@blockrun/franklin 3.15.69 → 3.15.71

package/dist/agent/context.js

@@ -336,12 +336,16 @@ Your training data is frozen in the past. Live-world questions MUST be answered
 
 If you find yourself about to emit one of these, stop and call the tool instead. If you don't know which ticker the user means, call ExaSearch or AskUser — never deflect.
 
-**Prediction markets (PredictionMarket).** When the user asks about real-world odds — elections, "will X happen by year-end", "Polymarket on Y", "Kalshi market for Z", "what are the odds of recession" — use **PredictionMarket** instead of guessing. Four actions:
-- \`searchPolymarket\` (\$0.001) and \`searchKalshi\` (\$0.001) — search markets by keyword. Run them **in parallel** when the user wants the current odds; comparing implied probability across two venues is the high-value answer.
-- \`crossPlatform\` (\$0.005) — pre-matched pairs of equivalent markets across Polymarket and Kalshi. Use when the user wants arbitrage candidates or wants to know "where does the consensus disagree".
-- \`smartMoney\` (\$0.005) — top-wallet flow on a specific Polymarket \`condition_id\`. Get the \`condition_id\` from a prior \`searchPolymarket\` call.
-
-NEVER answer "what are the odds of X" from training-data memory — these are live markets that move every minute. NEVER claim "Polymarket doesn't have a market on this" without running \`searchPolymarket\` first. If both Polymarket and Kalshi return zero markets, say so explicitly with the searches you tried, then offer to broaden the query.
+**Prediction markets (PredictionMarket).** When the user asks about real-world odds — elections, "will X happen by year-end", "Polymarket on Y", "Kalshi market for Z", "what are the odds of recession" — use **PredictionMarket** instead of guessing. Eight actions, route by intent:
+- "is there a market on X anywhere?" / unknown which platform → \`searchAll\` (\$0.005) — single call across Polymarket+Kalshi+Limitless+Opinion+Predict.Fun.
+- "what are the odds on Polymarket / Kalshi specifically" → \`searchPolymarket\` (\$0.001) and \`searchKalshi\` (\$0.001) **in parallel**; comparing implied probability across the two venues is the high-value answer.
+- "where do Polymarket and Kalshi disagree / arbitrage" → \`crossPlatform\` (\$0.005) returns pre-matched pairs.
+- "who's profitable / top traders / who should I follow on Polymarket" → \`leaderboard\` (\$0.001) — global top wallets by P&L.
+- "how is wallet 0xabc doing / show this trader's P&L / are they profitable" → \`walletProfile\` (\$0.005) with \`wallets="<address>"\` (comma-separated for batch).
+- "what are smart traders betting on right now / smart money flow across markets" → \`smartActivity\` (\$0.005) — markets where high-P&L wallets are positioning.
+- "show smart money on this specific Polymarket market / this condition_id" → \`smartMoney\` (\$0.005) with \`conditionId="<condition_id>"\`.
+
+NEVER answer "what are the odds of X" from training-data memory — these are live markets that move every minute. NEVER claim "no market on this" without running \`searchAll\` (or at least \`searchPolymarket\`) first. If a search returns zero, say so with the query you tried and offer to broaden.
 
 **Trading verdicts (TradingSignal).** When the user asks "how does $TICKER look" / "should I buy X" / "is BTC overbought":
 - Run **TradingSignal** with default lookback (90d). Lower values leave MACD undefined.

package/dist/agent/loop.js

@@ -939,10 +939,20 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             // never approached its 1M-token compaction threshold. Compact here
             // when the turn has accumulated lots of tool calls AND real spend,
             // even though the context window isn't close to full.
+            //
+            // Thresholds tightened in 3.15.71. Original 3.15.69 used
+            // (>30 calls AND >$0.05) — verified too loose against a real
+            // franklin-shorts edit session: 16 deepseek-v4-pro calls for
+            // $0.055 ended naturally before the trigger fired, even though
+            // by call #4 the per-call input was already 13K tokens (worth
+            // compacting). Lowering to (>15 AND >$0.03) catches sessions
+            // where input-replay tax has clearly started biting; the
+            // fire-once-per-turn flag still bounds the worst case at one
+            // extra summary call (~$0.005).
             if (!bloatCompactedThisTurn &&
                 compactFailures < 3 &&
-                turnToolCalls > 30 &&
-                turnCostUsd > 0.05) {
+                turnToolCalls > 15 &&
+                turnCostUsd > 0.03) {
                 try {
                     const beforeTokens = estimateHistoryTokens(history);
                     const { history: compacted, compacted: didCompact } = await forceCompact(history, config.model, client, config.debug);

package/dist/panel/html.js

@@ -650,7 +650,7 @@ a:hover { text-decoration:underline; }
   <div class="tab" id="tab-markets">
     <div class="content-header">
       <h2>Markets</h2>
-      <p>How Franklin gets trading data — and what it costs.</p>
+      <p>How Franklin gets trading + prediction-market data — and what it costs.</p>
     </div>
 
     <div class="grid grid-4">

package/dist/stats/audit.js

@@ -114,7 +114,18 @@ export function extractLastUserPrompt(history) {
         const text = flattenContent(msg.content);
         if (!text)
             continue;
-        return text.replace(/\s+/g, ' ').trim();
+        const cleaned = text.replace(/\s+/g, ' ').trim();
+        // Anthropic's message format puts harness-injected context, guardrail
+        // warnings, and grounding-retry feedback under role:"user" too. Walking
+        // back blindly returns those synthetic strings instead of the real user
+        // intent — verified 2026-05-06 in the audit log: 403 entries showed
+        // "[FRANKLIN HARNESS PREFETCH] CRCL price..." and 18 showed
+        // "[GROUNDING CHECK FAILED] ..." instead of the user's actual question.
+        // Skip any message whose first non-whitespace block is a SCREAMING-CASE
+        // bracketed label and keep walking back to the real user turn.
+        if (/^\[[A-Z][A-Z _-]+\]/.test(cleaned))
+            continue;
+        return cleaned;
     }
     return undefined;
 }

package/dist/tools/prediction.d.ts

@@ -1,7 +1,8 @@
 /**
- * PredictionMarket — unified access to Polymarket / Kalshi / cross-platform
- * matching / smart-money endpoints via the BlockRun gateway. Each call
- * settles via x402 against the user's USDC wallet.
+ * PredictionMarket — unified access to Polymarket / Kalshi / Limitless /
+ * Opinion / Predict.Fun / cross-platform / smart-money / wallet endpoints
+ * via the BlockRun gateway. Each call settles via x402 against the user's
+ * USDC wallet.
  *
  * Powered server-side by Predexon; surfaced to the agent as a single
  * action-dispatched tool so the inventory stays small. Keep one cohesive
@@ -9,12 +10,19 @@
  * one-shot capabilities, otherwise weak models start hallucinating tool
  * names.
  *
+ *   searchAll          $0.005  search markets across Polymarket+Kalshi+
+ *                              Limitless+Opinion+Predict.Fun in one call
  *   searchPolymarket   $0.001  query Polymarket markets (event filter, sort)
  *   searchKalshi       $0.001  query Kalshi markets
  *   crossPlatform      $0.005  matching market pairs across Polymarket+Kalshi
  *                              (the arbitrage / consensus signal)
+ *   leaderboard        $0.001  global Polymarket leaderboard — top wallets by P&L
+ *   walletProfile      $0.005  batch profile lookup for one or more Polymarket
+ *                              wallets — P&L, positions, identity
+ *   smartActivity      $0.005  discover markets where high-performing wallets
+ *                              are active right now
  *   smartMoney         $0.005  smart-money positioning on one Polymarket
- *                              condition_id (top wallet flow + side bias)
+ *                              condition_id (per-market drill-down)
  *
  * Output is filtered + truncated on the way back so a single call never
  * dumps 100 markets into the agent's context. Default 20 rows; agents that

package/dist/tools/prediction.js

@@ -1,7 +1,8 @@
 /**
- * PredictionMarket — unified access to Polymarket / Kalshi / cross-platform
- * matching / smart-money endpoints via the BlockRun gateway. Each call
- * settles via x402 against the user's USDC wallet.
+ * PredictionMarket — unified access to Polymarket / Kalshi / Limitless /
+ * Opinion / Predict.Fun / cross-platform / smart-money / wallet endpoints
+ * via the BlockRun gateway. Each call settles via x402 against the user's
+ * USDC wallet.
  *
  * Powered server-side by Predexon; surfaced to the agent as a single
  * action-dispatched tool so the inventory stays small. Keep one cohesive
@@ -9,12 +10,19 @@
  * one-shot capabilities, otherwise weak models start hallucinating tool
  * names.
  *
+ *   searchAll          $0.005  search markets across Polymarket+Kalshi+
+ *                              Limitless+Opinion+Predict.Fun in one call
  *   searchPolymarket   $0.001  query Polymarket markets (event filter, sort)
  *   searchKalshi       $0.001  query Kalshi markets
  *   crossPlatform      $0.005  matching market pairs across Polymarket+Kalshi
  *                              (the arbitrage / consensus signal)
+ *   leaderboard        $0.001  global Polymarket leaderboard — top wallets by P&L
+ *   walletProfile      $0.005  batch profile lookup for one or more Polymarket
+ *                              wallets — P&L, positions, identity
+ *   smartActivity      $0.005  discover markets where high-performing wallets
+ *                              are active right now
  *   smartMoney         $0.005  smart-money positioning on one Polymarket
- *                              condition_id (top wallet flow + side bias)
+ *                              condition_id (per-market drill-down)
  *
  * Output is filtered + truncated on the way back so a single call never
  * dumps 100 markets into the agent's context. Default 20 rows; agents that
@@ -23,9 +31,31 @@
 import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import { loadChain, API_URLS, VERSION } from '../config.js';
 import { logger } from '../logger.js';
+import { recordFetch } from '../trading/providers/telemetry.js';
 const TIMEOUT_MS = 30_000;
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 50;
+// Per-action price table — mirrors the Predexon openapi.json. Used to feed
+// the Markets-tab telemetry ring buffer so prediction-market spend appears
+// in "Calls today / Spend today / Recent paid calls" alongside trading calls.
+// If a path isn't here we don't record cost — we still record the fetch
+// (success/latency) so panel health stays accurate.
+const PATH_PRICES = [
+    { pattern: /\/v1\/pm\/markets\/search$/, usd: 0.005 },
+    { pattern: /\/v1\/pm\/matching-markets/, usd: 0.005 },
+    { pattern: /\/v1\/pm\/polymarket\/wallets\//, usd: 0.005 },
+    { pattern: /\/v1\/pm\/polymarket\/wallet\//, usd: 0.005 },
+    { pattern: /\/v1\/pm\/polymarket\/market\/[^/]+\/smart-money$/, usd: 0.005 },
+    { pattern: /\/v1\/pm\/polymarket\/markets\/smart-activity$/, usd: 0.005 },
+    { pattern: /\/v1\/pm\/.+/, usd: 0.001 },
+];
+function priceForPath(path) {
+    for (const { pattern, usd } of PATH_PRICES) {
+        if (pattern.test(path))
+            return usd;
+    }
+    return 0;
+}
 // ─── Shared GET-with-x402 flow ────────────────────────────────────────────
 async function getWithPayment(path, query, ctx) {
     const chain = loadChain();
@@ -46,6 +76,8 @@ async function getWithPayment(path, query, ctx) {
     const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
     const onAbort = () => controller.abort();
     ctx.abortSignal.addEventListener('abort', onAbort, { once: true });
+    const startedAt = Date.now();
+    let costRecorded = 0;
     try {
         let response = await fetch(endpoint, { method: 'GET', signal: controller.signal, headers });
         if (response.status === 402) {
@@ -58,11 +90,23 @@ async function getWithPayment(path, query, ctx) {
                 signal: controller.signal,
                 headers: { ...headers, ...paymentHeaders },
             });
+            // Only record cost on the post-402 settlement; the initial 402
+            // response is free and counting it would double-charge the panel.
+            costRecorded = priceForPath(path);
         }
         if (!response.ok) {
             const errText = await response.text().catch(() => '');
+            // Surface failed paid calls in the Markets-tab health summary.
+            recordFetch({ provider: 'blockrun', endpoint: path, ok: false, latencyMs: Date.now() - startedAt });
             throw new Error(`PredictionMarket ${path} failed (${response.status}): ${errText.slice(0, 200)}`);
         }
+        recordFetch({
+            provider: 'blockrun',
+            endpoint: path,
+            ok: true,
+            latencyMs: Date.now() - startedAt,
+            costUsd: costRecorded > 0 ? costRecorded : undefined,
+        });
         return (await response.json());
     }
     finally {
@@ -120,21 +164,33 @@ async function extractPaymentReq(response) {
     return header;
 }
 // ─── Formatting helpers ────────────────────────────────────────────────────
+function asNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const n = Number(value);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return null;
+}
 function formatUsd(value) {
-    if (value == null || !Number.isFinite(value))
+    const n = asNumber(value);
+    if (n == null)
         return 'n/a';
-    if (value >= 1e9)
-        return `$${(value / 1e9).toFixed(2)}B`;
-    if (value >= 1e6)
-        return `$${(value / 1e6).toFixed(2)}M`;
-    if (value >= 1e3)
-        return `$${(value / 1e3).toFixed(1)}K`;
-    return `$${value.toFixed(2)}`;
+    if (n >= 1e9)
+        return `$${(n / 1e9).toFixed(2)}B`;
+    if (n >= 1e6)
+        return `$${(n / 1e6).toFixed(2)}M`;
+    if (n >= 1e3)
+        return `$${(n / 1e3).toFixed(1)}K`;
+    return `$${n.toFixed(2)}`;
 }
 function formatPct(value, digits = 1) {
-    if (value == null || !Number.isFinite(value))
+    const n = asNumber(value);
+    if (n == null)
         return 'n/a';
-    return `${(value * 100).toFixed(digits)}%`;
+    return `${(n * 100).toFixed(digits)}%`;
 }
 // API responses sometimes come wrapped as `{data: [...], pagination: ...}`,
 // other times as a bare array. Normalise to an array.
@@ -155,13 +211,242 @@ function unwrapList(raw) {
     return [];
 }
 async function execute(input, ctx) {
-    const { action, search, status, sort, limit, conditionId } = input;
+    const { action, search, status, sort, limit, conditionId, wallets } = input;
     const cappedLimit = Math.min(Math.max(1, limit ?? DEFAULT_LIMIT), MAX_LIMIT);
     if (!action) {
-        return { output: 'Error: action is required (searchPolymarket | searchKalshi | crossPlatform | smartMoney)', isError: true };
+        return {
+            output: 'Error: action is required (searchAll | searchPolymarket | searchKalshi | crossPlatform | leaderboard | walletProfile | smartActivity | smartMoney)',
+            isError: true,
+        };
     }
     try {
         switch (action) {
+            case 'searchAll': {
+                // One $0.005 call across 5 platforms — Polymarket, Kalshi, Limitless,
+                // Opinion, Predict.Fun. The right entry point for "is there a market
+                // on X anywhere?" — beats firing per-platform searches in parallel.
+                const raw = await getWithPayment('/v1/pm/markets/search', {
+                    search,
+                    status,
+                    sort,
+                    limit: cappedLimit,
+                }, ctx);
+                // Predexon returns either a flat list or per-platform buckets.
+                // Try the bucket shape first; fall back to a flat list.
+                const lines = [
+                    `## Cross-platform market search` + (search ? ` · "${search}"` : ''),
+                    '_Searched Polymarket, Kalshi, Limitless, Opinion, Predict.Fun in one call._',
+                    '',
+                ];
+                if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+                    const obj = raw;
+                    const platforms = ['polymarket', 'kalshi', 'limitless', 'opinion', 'predictfun', 'predict_fun'];
+                    let totalShown = 0;
+                    for (const p of platforms) {
+                        const list = unwrapList(obj[p]);
+                        if (list.length === 0)
+                            continue;
+                        const remaining = cappedLimit - totalShown;
+                        if (remaining <= 0)
+                            break;
+                        const shown = list.slice(0, Math.min(5, remaining));
+                        lines.push(`### ${p}`);
+                        shown.forEach((m, i) => {
+                            const title = (m.title || m.question || m.market_slug || m.ticker || 'untitled');
+                            const id = (m.condition_id || m.ticker || m.id);
+                            const idTag = id ? ` · \`${String(id).slice(0, 18)}…\`` : '';
+                            const vol = m.volume != null ? ` · vol ${formatUsd(m.volume)}` : '';
+                            lines.push(`${i + 1}. ${title}${idTag}${vol}`);
+                            totalShown++;
+                        });
+                        lines.push('');
+                    }
+                    if (totalShown === 0) {
+                        // Bucket shape but empty — fall back to flat-list interpretation.
+                        const flat = unwrapList(raw);
+                        if (flat.length === 0) {
+                            return { output: 'No markets matched across any platform.' };
+                        }
+                        flat.slice(0, cappedLimit).forEach((m, i) => {
+                            const title = (m.title || m.question || m.market_slug || m.ticker || 'untitled');
+                            const platform = (m.platform || m.source || 'unknown');
+                            lines.push(`${i + 1}. **[${platform}]** ${title}`);
+                        });
+                    }
+                }
+                else {
+                    const flat = unwrapList(raw);
+                    if (flat.length === 0) {
+                        return { output: 'No markets matched across any platform.' };
+                    }
+                    flat.slice(0, cappedLimit).forEach((m, i) => {
+                        const title = (m.title || m.question || m.market_slug || m.ticker || 'untitled');
+                        const platform = (m.platform || m.source || 'unknown');
+                        lines.push(`${i + 1}. **[${platform}]** ${title}`);
+                    });
+                }
+                lines.push(`_$0.005 paid via x402._`);
+                return { output: lines.join('\n') };
+            }
+            case 'leaderboard': {
+                // Global top-wallet ranking. Cheap ($0.001) — the right answer to
+                // "who's making money on Polymarket" / "who should I follow".
+                const raw = await getWithPayment('/v1/pm/polymarket/leaderboard', {
+                    limit: cappedLimit,
+                    sort,
+                }, ctx);
+                const rows = unwrapList(raw);
+                if (rows.length === 0) {
+                    return { output: 'No leaderboard data returned.' };
+                }
+                const lines = [
+                    `## Polymarket leaderboard — top ${rows.length} wallet${rows.length === 1 ? '' : 's'}`,
+                    '',
+                ];
+                rows.forEach((r, i) => {
+                    const wallet = (r.wallet || r.address || r.proxy_wallet || 'unknown');
+                    const w = wallet.length > 12
+                        ? `${wallet.slice(0, 8)}…${wallet.slice(-4)}`
+                        : wallet;
+                    const pnl = r.pnl ?? r.realized_pnl ?? r.total_pnl;
+                    const volume = r.volume ?? r.total_volume;
+                    const winRate = r.win_rate ?? r.winRate;
+                    const name = (r.name || r.handle || r.username);
+                    const handle = name ? ` (${name})` : '';
+                    const parts = [];
+                    if (pnl != null)
+                        parts.push(`P&L ${formatUsd(pnl)}`);
+                    if (volume != null)
+                        parts.push(`vol ${formatUsd(volume)}`);
+                    if (winRate != null)
+                        parts.push(`win ${formatPct(winRate, 0)}`);
+                    lines.push(`${i + 1}. \`${w}\`${handle}` + (parts.length > 0 ? ` — ${parts.join(' · ')}` : ''));
+                });
+                lines.push('', `_$0.001 paid via x402._`);
+                return { output: lines.join('\n') };
+            }
+            case 'walletProfile': {
+                if (!wallets || !wallets.trim()) {
+                    return {
+                        output: 'Error: `wallets` is required for walletProfile (single address or comma-separated list of Polymarket wallet addresses)',
+                        isError: true,
+                    };
+                }
+                // Predexon's batch endpoint accepts multiple wallets; we forward
+                // verbatim. Single wallet works too — caller passes one address.
+                const raw = await getWithPayment('/v1/pm/polymarket/wallets/profiles', {
+                    wallets: wallets.trim(),
+                }, ctx);
+                const profiles = unwrapList(raw);
+                if (profiles.length === 0) {
+                    return { output: `No profile data returned for: ${wallets}` };
+                }
+                const lines = [
+                    `## Polymarket wallet profile${profiles.length === 1 ? '' : 's'} — ${profiles.length}`,
+                    '',
+                ];
+                profiles.forEach((p, i) => {
+                    const wallet = (p.wallet || p.address || p.proxy_wallet || 'unknown');
+                    const w = wallet.length > 12
+                        ? `${wallet.slice(0, 8)}…${wallet.slice(-4)}`
+                        : wallet;
+                    const name = (p.name || p.handle || p.username);
+                    const pnl = p.pnl ?? p.realized_pnl ?? p.total_pnl;
+                    const unrealized = p.unrealized_pnl;
+                    const volume = p.volume ?? p.total_volume;
+                    const positions = p.positions_count ?? p.open_positions;
+                    const winRate = p.win_rate ?? p.winRate;
+                    lines.push(`${i + 1}. \`${w}\`` + (name ? ` (${name})` : ''));
+                    const stats = [];
+                    if (pnl != null)
+                        stats.push(`P&L ${formatUsd(pnl)}`);
+                    if (unrealized != null)
+                        stats.push(`unrealized ${formatUsd(unrealized)}`);
+                    if (volume != null)
+                        stats.push(`vol ${formatUsd(volume)}`);
+                    if (positions != null)
+                        stats.push(`${positions} open`);
+                    if (winRate != null)
+                        stats.push(`win ${formatPct(winRate, 0)}`);
+                    if (stats.length > 0)
+                        lines.push(`   ${stats.join(' · ')}`);
+                });
+                lines.push('', `_$0.005 paid via x402._`);
+                return { output: lines.join('\n') };
+            }
+            case 'smartActivity': {
+                // "Discover markets where high-performing wallets are active right now."
+                // Replaces the old `smartMoney` action (which hit a non-existent path
+                // /v1/pm/polymarket/market/<id>/smart-money — silently 404'd from
+                // launch). Verified 2026-05-05 against blockrun.ai/openapi.json.
+                const raw = await getWithPayment('/v1/pm/polymarket/markets/smart-activity', {
+                    limit: cappedLimit,
+                    search,
+                }, ctx);
+                const rows = unwrapList(raw);
+                if (rows.length === 0) {
+                    return { output: 'No smart-money activity recorded right now.' };
+                }
+                const lines = [
+                    `## Smart-money activity — ${rows.length} market${rows.length === 1 ? '' : 's'}`,
+                    '_Markets where high-P&L Polymarket wallets are positioning right now._',
+                    '',
+                ];
+                rows.forEach((r, i) => {
+                    const title = (r.question || r.title || r.market_slug || 'untitled');
+                    const cid = (r.condition_id || r.id);
+                    const cidTag = cid ? ` · \`${String(cid).slice(0, 14)}…\`` : '';
+                    const smartCount = r.smart_wallets_count ?? r.wallet_count;
+                    const netFlow = r.net_size ?? r.net_yes_size;
+                    const stats = [];
+                    if (smartCount != null)
+                        stats.push(`${smartCount} smart wallet${smartCount === 1 ? '' : 's'}`);
+                    if (netFlow != null)
+                        stats.push(`net ${formatUsd(netFlow)}`);
+                    lines.push(`${i + 1}. **${title}**${cidTag}` + (stats.length > 0 ? `\n   ${stats.join(' · ')}` : ''));
+                });
+                lines.push('', `_$0.005 paid via x402._`);
+                return { output: lines.join('\n') };
+            }
+            case 'smartMoney': {
+                if (!conditionId) {
+                    return {
+                        output: 'Error: conditionId is required for smartMoney (Polymarket condition_id from a prior searchPolymarket or smartActivity call)',
+                        isError: true,
+                    };
+                }
+                // Per-market drill-down. Official live registry:
+                // /api/v1/pm/polymarket/market/:condition_id/smart-money
+                const path = `/v1/pm/polymarket/market/${encodeURIComponent(conditionId)}/smart-money`;
+                const data = await getWithPayment(path, {}, ctx);
+                const buyers = (data.buyers ?? []).slice(0, 5);
+                const sellers = (data.sellers ?? []).slice(0, 5);
+                const lines = [
+                    `## Smart money — \`${conditionId.slice(0, 14)}…\``,
+                ];
+                if (data.net_yes_size != null || data.net_no_size != null) {
+                    lines.push(`**Net flow:** YES ${formatUsd(data.net_yes_size)} / NO ${formatUsd(data.net_no_size)}`);
+                }
+                if (buyers.length > 0) {
+                    lines.push('', '**Top buyers**');
+                    buyers.forEach((b, i) => {
+                        const w = b.wallet ? `${b.wallet.slice(0, 8)}…${b.wallet.slice(-4)}` : 'unknown';
+                        lines.push(`${i + 1}. ${w} — ${formatUsd(b.size)} on ${b.outcome ?? 'unknown side'}`);
+                    });
+                }
+                if (sellers.length > 0) {
+                    lines.push('', '**Top sellers**');
+                    sellers.forEach((s, i) => {
+                        const w = s.wallet ? `${s.wallet.slice(0, 8)}…${s.wallet.slice(-4)}` : 'unknown';
+                        lines.push(`${i + 1}. ${w} — ${formatUsd(s.size)} on ${s.outcome ?? 'unknown side'}`);
+                    });
+                }
+                if (buyers.length === 0 && sellers.length === 0) {
+                    lines.push('No smart-money flow recorded for this market yet.');
+                }
+                lines.push('', `_$0.005 paid via x402._`);
+                return { output: lines.join('\n') };
+            }
             case 'searchPolymarket': {
                 const raw = await getWithPayment('/v1/pm/polymarket/markets', {
                     search,
@@ -245,45 +530,9 @@ async function execute(input, ctx) {
                 lines.push('', `_$0.005 paid via x402._`);
                 return { output: lines.join('\n') };
             }
-            case 'smartMoney': {
-                if (!conditionId) {
-                    return { output: 'Error: conditionId is required for smartMoney (Polymarket condition_id from a prior searchPolymarket call)', isError: true };
-                }
-                const path = `/v1/pm/polymarket/market/${encodeURIComponent(conditionId)}/smart-money`;
-                const data = await getWithPayment(path, {}, ctx);
-                const buyers = (data.buyers ?? []).slice(0, 5);
-                const sellers = (data.sellers ?? []).slice(0, 5);
-                const lines = [
-                    `## Smart money — \`${conditionId.slice(0, 14)}…\``,
-                ];
-                if (data.net_yes_size != null || data.net_no_size != null) {
-                    const yesSize = formatUsd(data.net_yes_size);
-                    const noSize = formatUsd(data.net_no_size);
-                    lines.push(`**Net flow:** YES ${yesSize} / NO ${noSize}`);
-                }
-                if (buyers.length > 0) {
-                    lines.push('', '**Top buyers**');
-                    buyers.forEach((b, i) => {
-                        const w = b.wallet ? `${b.wallet.slice(0, 8)}…${b.wallet.slice(-4)}` : 'unknown';
-                        lines.push(`${i + 1}. ${w} — ${formatUsd(b.size)} on ${b.outcome ?? 'unknown side'}`);
-                    });
-                }
-                if (sellers.length > 0) {
-                    lines.push('', '**Top sellers**');
-                    sellers.forEach((s, i) => {
-                        const w = s.wallet ? `${s.wallet.slice(0, 8)}…${s.wallet.slice(-4)}` : 'unknown';
-                        lines.push(`${i + 1}. ${w} — ${formatUsd(s.size)} on ${s.outcome ?? 'unknown side'}`);
-                    });
-                }
-                if (buyers.length === 0 && sellers.length === 0) {
-                    lines.push('No smart-money flow recorded for this market yet.');
-                }
-                lines.push('', `_$0.005 paid via x402._`);
-                return { output: lines.join('\n') };
-            }
             default:
                 return {
-                    output: `Error: unknown action "${action}". Use: searchPolymarket, searchKalshi, crossPlatform, smartMoney`,
+                    output: `Error: unknown action "${action}". Use: searchAll, searchPolymarket, searchKalshi, crossPlatform, leaderboard, walletProfile, smartActivity, smartMoney`,
                     isError: true,
                 };
         }
@@ -295,41 +544,63 @@ async function execute(input, ctx) {
 export const predictionMarketCapability = {
     spec: {
         name: 'PredictionMarket',
-        description: 'Real prediction market data via the BlockRun gateway (powered by Predexon). Use for any "what are the odds of X" / "Polymarket on Y" / "Kalshi market for Z" question. ' +
+        description: 'Real prediction market data via the BlockRun gateway (powered by Predexon). Use for any "what are the odds of X" / "Polymarket on Y" / "is there a market on Z" / "follow this trader" question. ' +
             'Actions: ' +
-            '`searchPolymarket` (search Polymarket markets — $0.001), ' +
-            '`searchKalshi` (search Kalshi markets — $0.001), ' +
-            '`crossPlatform` (matched pairs across Polymarket+Kalshi for arbitrage / consensus — $0.005), ' +
-            '`smartMoney` (smart-money positioning on a Polymarket condition_id — $0.005). ' +
-            'Polymarket and Kalshi are the two largest legit prediction markets; cross-platform matching is unique to BlockRun. ' +
-            'For "should I bet on X" / "what does the market price imply": run searchPolymarket AND searchKalshi in parallel and compare implied probabilities — divergence is the signal.',
+            '`searchAll` (search markets across Polymarket+Kalshi+Limitless+Opinion+Predict.Fun in one call — $0.005), ' +
+            '`searchPolymarket` (Polymarket only, supports sort+status — $0.001), ' +
+            '`searchKalshi` (Kalshi only, supports sort+status — $0.001), ' +
+            '`crossPlatform` (matched market pairs across Polymarket+Kalshi for arbitrage / consensus — $0.005), ' +
+            '`leaderboard` (global top wallets by P&L on Polymarket — $0.001), ' +
+            '`walletProfile` (P&L + positions for one or more Polymarket wallets — $0.005), ' +
+            '`smartActivity` (markets where high-P&L wallets are positioning right now — $0.005), ' +
+            '`smartMoney` (smart-money positioning on one Polymarket condition_id — $0.005). ' +
+            'Default routing: ' +
+            '"is there a market on X anywhere" → searchAll. ' +
+            '"top wallets / who is profitable / who should I follow on Polymarket" → leaderboard. ' +
+            '"how is wallet 0xabc doing / show me their P&L" → walletProfile with that address. ' +
+            '"what are smart traders betting on right now" → smartActivity. ' +
+            '"show smart money on this specific Polymarket market" → smartMoney with conditionId. ' +
+            '"should I bet on X" → run searchPolymarket + searchKalshi in parallel and compare implied probabilities — divergence is the signal.',
         input_schema: {
             type: 'object',
             properties: {
                 action: {
                     type: 'string',
-                    enum: ['searchPolymarket', 'searchKalshi', 'crossPlatform', 'smartMoney'],
+                    enum: [
+                        'searchAll',
+                        'searchPolymarket',
+                        'searchKalshi',
+                        'crossPlatform',
+                        'leaderboard',
+                        'walletProfile',
+                        'smartActivity',
+                        'smartMoney',
+                    ],
                     description: 'Which prediction-market query to run. See tool description for cost per action.',
                 },
                 search: {
                     type: 'string',
-                    description: 'Search query (3-100 chars). Used by searchPolymarket / searchKalshi. Skip for crossPlatform/smartMoney.',
+                    description: 'Search query. Used by searchAll / searchPolymarket / searchKalshi / smartActivity. Optional for crossPlatform/leaderboard/walletProfile/smartMoney.',
                 },
                 status: {
                     type: 'string',
-                    description: 'Polymarket: active | closed | archived (default active). Kalshi: open | closed (default open).',
+                    description: 'Polymarket: active | closed | archived (default active). Kalshi: open | closed (default open). Forwarded to searchAll where supported.',
                 },
                 sort: {
                     type: 'string',
-                    description: 'Polymarket: volume | liquidity | created (default volume). Kalshi: volume | open_interest | price_desc | price_asc | close_time (default volume).',
+                    description: 'Polymarket: volume | liquidity | created (default volume). Kalshi: volume | open_interest | price_desc | price_asc | close_time (default volume). leaderboard: pnl | volume | win_rate (gateway-defined).',
                 },
                 limit: {
                     type: 'number',
                     description: `Max results (default ${DEFAULT_LIMIT}, hard cap ${MAX_LIMIT}).`,
                 },
+                wallets: {
+                    type: 'string',
+                    description: 'For walletProfile: a single Polymarket wallet address, or a comma-separated list of addresses for batch lookup.',
+                },
                 conditionId: {
                     type: 'string',
-                    description: 'Polymarket condition_id. Required for smartMoney. Get one from a prior searchPolymarket call.',
+                    description: 'For smartMoney: Polymarket condition_id from searchPolymarket or smartActivity.',
                 },
             },
             required: ['action'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.15.69",
+  "version": "3.15.71",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {