@wzrd_sol/eliza-plugin 0.1.2 → 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/claim.d.ts

@@ -1,9 +1,6 @@
 /**
- * ELIZA Action: WZRD_CLAIM — claim accrued CCM via gasless relay (auth).
- *
- * Agents can check current APR before deciding whether to claim or hold:
- *   WzrdClient.getMarketApr(marketId) — projected_total_apr_bps shows current yield rate.
- *   WzrdClient.getMarketPreview(marketId) — projected_multiplier_bps for live attention signal.
+ * WZRD_CLAIM — Claim accrued CCM via gasless relay.
+ * Server pays all transaction fees. Agent needs 0 SOL.
  */
 import type { Action } from '@elizaos/core';
 export declare const claimAction: Action;

package/dist/actions/claim.js

@@ -1,45 +1,48 @@
-import { getWzrdClient } from '../client.js';
+import { getWzrdClient } from '../client-factory.js';
 export const claimAction = {
     name: 'WZRD_CLAIM',
-    similes: ['WZRD_HARVEST', 'CLAIM_CCM', 'COLLECT_YIELD'],
-    description: 'Claim accrued CCM tokens via gasless relay. Server pays tx fees.',
-    examples: [[
+    similes: ['WZRD_HARVEST', 'CLAIM_CCM', 'COLLECT_REWARDS'],
+    description: 'Claim accrued CCM tokens via gasless relay. Server pays tx fees — agent needs 0 SOL.',
+    examples: [
+        [
             { name: '{{user1}}', content: { text: 'Claim my WZRD rewards' } },
-            { name: '{{agentName}}', content: { text: 'Claimed CCM via gasless relay. Tx: 5S7L...' } },
-        ]],
+            { name: '{{agentName}}', content: { text: 'Claimed 142.5 CCM via gasless relay. Tx: 5S7L...' } },
+        ],
+    ],
     validate: async () => true,
     handler: async (runtime, _msg, _state, _opt, callback) => {
         const client = getWzrdClient(runtime);
-        let claims;
         try {
-            claims = await client.getClaims();
+            // Check if there's anything to claim
+            const status = await client.getClaimStatus();
+            if (status.claimable <= 0) {
+                const text = `No CCM to claim right now.\n` +
+                    `Cumulative: ${(status.cumulative_total / 1e9).toFixed(2)} CCM\n` +
+                    `Already claimed: ${(status.claimed_total / 1e9).toFixed(2)} CCM\n` +
+                    `Run WZRD_EARN first to accrue rewards.`;
+                await callback?.({ text });
+                return { success: true, data: status };
+            }
+            const result = await client.claimRelay();
+            if (result.status === 'already_claimed') {
+                await callback?.({ text: `Already claimed through root ${result.root_seq}.` });
+                return { success: true, data: result };
+            }
+            const text = `Claimed CCM via gasless relay.\n` +
+                `Amount: ${(result.cumulative_total / 1e9).toFixed(2)} CCM (cumulative)\n` +
+                `Root: ${result.root_seq}\n` +
+                `Tx: ${result.tx_sig?.slice(0, 20)}...`;
+            await callback?.({ text });
+            return { success: true, data: result };
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (msg.includes('404')) {
-                const text = 'No claims found. Deposit into a market first to start accruing CCM.';
-                await callback?.({ text });
-                return { success: true, text };
+                await callback?.({ text: 'No claims found yet. Run WZRD_EARN to start accruing CCM.' });
+                return { success: true, data: {} };
             }
-            const text = `Failed to fetch claims: ${msg}`;
-            await callback?.({ text });
-            return { success: false, error: text };
-        }
-        const claimable = claims.cumulative_total - claims.claimed_total;
-        if (claimable <= 0) {
-            const text = `No CCM to claim. Cumulative: ${claims.cumulative_total}, claimed: ${claims.claimed_total}.`;
-            await callback?.({ text });
-            return { success: true, text, data: claims };
-        }
-        const result = await client.claimRelay();
-        if (result.status === 'already_claimed') {
-            const text = `Already claimed through root ${result.root_seq}.`;
-            await callback?.({ text });
-            return { success: true, text, data: result };
+            await callback?.({ text: `Claim failed: ${msg}` });
+            return { success: false, error: msg };
         }
-        const text = `Claimed CCM via relay. Cumulative: ${(result.cumulative_total / 1e6).toFixed(4)} CCM. ` +
-            `Root: ${result.root_seq}. Tx: ${result.tx_sig?.slice(0, 16)}...`;
-        await callback?.({ text });
-        return { success: true, text, data: result };
     },
 };

package/dist/actions/earn.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WZRD_EARN — Full earn cycle: infer → report → check rewards.
+ *
+ * Single action that runs the complete server-witnessed earn loop.
+ * For agents that want one-shot earning without managing execution_ids.
+ */
+import type { Action } from '@elizaos/core';
+export declare const earnAction: Action;

package/dist/actions/earn.js

@@ -0,0 +1,83 @@
+import { getWzrdClient } from '../client-factory.js';
+const EVAL_PROMPTS = {
+    code: [
+        'Write a Python function that checks if a binary tree is balanced. Include time complexity analysis.',
+        'Implement a thread-safe LRU cache in Rust with O(1) get and put operations.',
+        'Write a TypeScript generic function that deep-merges two objects, handling arrays and nested objects.',
+    ],
+    chat: [
+        'Explain the difference between TCP and UDP to someone who has never programmed before.',
+        'What are the tradeoffs between microservices and monolithic architecture?',
+        'Describe how consensus works in proof-of-stake blockchains.',
+    ],
+    reasoning: [
+        'A farmer has a fox, a chicken, and a bag of grain. He must cross a river in a boat that can only carry him and one item. How does he do it?',
+        'If it takes 5 machines 5 minutes to make 5 widgets, how long does it take 100 machines to make 100 widgets?',
+        'Three people check into a hotel room that costs $30. They each pay $10. The manager realizes the room should cost $25 and gives $5 to the bellboy to return. The bellboy keeps $2 and gives $1 back to each person. So each person paid $9 (total $27) plus the bellboy kept $2 (total $29). Where is the missing dollar?',
+    ],
+};
+function pickPrompt(taskType) {
+    const prompts = EVAL_PROMPTS[taskType] || EVAL_PROMPTS.chat;
+    return prompts[Math.floor(Math.random() * prompts.length)];
+}
+export const earnAction = {
+    name: 'WZRD_EARN',
+    similes: ['WZRD_EARN_CCM', 'EARN_REWARDS', 'RUN_EARN_LOOP'],
+    description: 'Run the full WZRD earn cycle: pick a prompt, run server-witnessed inference, ' +
+        'report the outcome, and check pending rewards. One action, complete loop.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Earn some CCM on WZRD' } },
+            {
+                name: '{{agentName}}',
+                content: {
+                    text: 'Earn cycle complete. Model: gemini-2.5-flash, quality: 0.85, verified. Pending: 142.5 CCM.',
+                },
+            },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = message.content;
+        const taskType = content.task_type || 'code';
+        const prompt = content.prompt || pickPrompt(taskType);
+        const client = getWzrdClient(runtime);
+        const steps = [];
+        try {
+            // Step 1: Pick model + Infer
+            steps.push('→ Picking model from leaderboard...');
+            const model = await client.pickModel(taskType);
+            steps.push(`→ Running inference: ${model} (${taskType})...`);
+            const infer = await client.infer(prompt, model, taskType);
+            steps.push(`✓ Inference: ${infer.executed_model} (${infer.provider}), quality ${infer.quality_score.toFixed(2)}, ${infer.latency_ms}ms`);
+            // Step 2: Report with execution_id
+            steps.push('→ Reporting outcome...');
+            const report = await client.report({
+                model_id: infer.requested_model,
+                execution_id: infer.execution_id,
+                task_type: taskType,
+                quality_score: infer.quality_score,
+                latency_ms: infer.latency_ms,
+            });
+            steps.push(`✓ Reported: ${report.verification_state}, contribution #${report.contribution_id}, pending ${(report.pending_ccm / 1e9).toFixed(2)} CCM`);
+            // Step 3: Check rewards
+            steps.push('→ Checking rewards...');
+            const rewards = await client.getRewards();
+            steps.push(`✓ Rewards: ${(rewards.pending_ccm / 1e9).toFixed(2)} CCM pending, ` +
+                `${(rewards.total_rewarded_ccm / 1e9).toFixed(2)} CCM lifetime` +
+                (rewards.rank ? `, rank #${rewards.rank}` : ''));
+            const text = `Earn cycle complete:\n${steps.join('\n')}`;
+            await callback?.({ text });
+            return {
+                success: true,
+                data: { infer, report, rewards },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            steps.push(`✗ Failed: ${msg}`);
+            await callback?.({ text: `Earn cycle failed:\n${steps.join('\n')}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/infer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WZRD_INFER — Server-witnessed inference through WZRD.
+ *
+ * WZRD calls the AI provider (Gemini/Nous/OpenRouter), grades the response,
+ * and returns an execution_id receipt. Pass this to WZRD_REPORT for verified rewards.
+ */
+import type { Action } from '@elizaos/core';
+export declare const inferAction: Action;

package/dist/actions/infer.js

@@ -0,0 +1,41 @@
+import { getWzrdClient } from '../client-factory.js';
+export const inferAction = {
+    name: 'WZRD_INFER',
+    similes: ['WZRD_RUN_INFERENCE', 'ASK_MODEL', 'RUN_MODEL'],
+    description: 'Run inference through WZRD. The server calls the AI provider, grades quality, ' +
+        'and returns an execution receipt. Use the execution_id with WZRD_REPORT to earn CCM.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Run inference through WZRD: explain quicksort in Python' } },
+            { name: '{{agentName}}', content: { text: 'Inference complete. Model: gemini-2.5-flash, quality: 0.85. execution_id: abc-123...' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = message.content;
+        const prompt = content.prompt || content.text || '';
+        if (!prompt) {
+            await callback?.({ text: 'No prompt provided. Include a prompt or text to run inference.' });
+            return { success: false, error: 'No prompt' };
+        }
+        const taskType = content.task_type || 'chat';
+        const model = content.model;
+        const client = getWzrdClient(runtime);
+        try {
+            const result = await client.infer(prompt, model, taskType);
+            const text = `Inference complete.\n` +
+                `Model: ${result.executed_model} (${result.provider})\n` +
+                `Quality: ${result.quality_score.toFixed(2)}\n` +
+                `Latency: ${result.latency_ms}ms\n` +
+                `execution_id: ${result.execution_id}\n\n` +
+                `Response: ${result.response_preview}`;
+            await callback?.({ text });
+            return { success: true, data: result };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Inference failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

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/report.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WZRD_REPORT — Report a model pick with execution receipt for verified CCM rewards.
+ *
+ * Must be called after WZRD_INFER. Pass the execution_id from the infer result
+ * to get server-verified status and quality-weighted rewards.
+ */
+import type { Action } from '@elizaos/core';
+export declare const reportAction: Action;

package/dist/actions/report.js

@@ -0,0 +1,45 @@
+import { getWzrdClient } from '../client-factory.js';
+export const reportAction = {
+    name: 'WZRD_REPORT',
+    similes: ['WZRD_REPORT_OUTCOME', 'REPORT_MODEL_PICK', 'SUBMIT_SIGNAL'],
+    description: 'Report a model pick to WZRD with an execution_id from WZRD_INFER. ' +
+        'Verified reports earn CCM rewards with quality multiplier.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Report the inference result to earn CCM' } },
+            { name: '{{agentName}}', content: { text: 'Reported. Verification: verified, contribution #4521.' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = message.content;
+        if (!content.execution_id || !content.model_id) {
+            await callback?.({
+                text: 'Missing required: execution_id and model_id. Run WZRD_INFER first to get an execution receipt.',
+            });
+            return { success: false, error: 'Missing execution_id or model_id' };
+        }
+        const client = getWzrdClient(runtime);
+        try {
+            const result = await client.report({
+                model_id: content.model_id,
+                execution_id: content.execution_id,
+                task_type: content.task_type,
+                quality_score: content.quality_score,
+                latency_ms: content.latency_ms,
+            });
+            const text = `Reported to WZRD.\n` +
+                `Verification: ${result.verification_state}\n` +
+                `Contribution: #${result.contribution_id}\n` +
+                `Pending CCM: ${(result.pending_ccm / 1e9).toFixed(2)}\n` +
+                `Pipeline: ${result.pipeline_state}`;
+            await callback?.({ text });
+            return { success: true, data: result };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Report failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/rewards.d.ts

@@ -0,0 +1,5 @@
+/**
+ * WZRD_REWARDS — Check pending and lifetime CCM rewards.
+ */
+import type { Action } from '@elizaos/core';
+export declare const rewardsAction: Action;