@blockrun/franklin 3.8.8 → 3.8.10

package/dist/agent/error-classifier.js

@@ -96,6 +96,7 @@ export function classifyAgentError(message) {
         'workers are busy',
         'all workers are busy',
         'server busy',
+        'high demand',
         'capacity',
     ])) {
         return {

package/dist/agent/llm.d.ts

@@ -27,6 +27,13 @@ export interface LLMClientOptions {
     chain: Chain;
     debug?: boolean;
 }
+/**
+ * Extract the most human-readable message from an error body.
+ * Some gateways wrap provider errors multiple times, e.g.
+ * `{"error":{"message":"{\"error\":{\"message\":\"...\"}}"}}`.
+ * Peel those layers so the UI doesn't show raw nested JSON.
+ */
+export declare function extractApiErrorMessage(errorBody: string): string;
 /**
  * Apply Anthropic prompt caching using the `system_and_3` strategy.
  * Pattern from nousresearch/hermes-agent `agent/prompt_caching.py`.

package/dist/agent/llm.js

@@ -6,6 +6,53 @@
 import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import { USER_AGENT } from '../config.js';
 import { ThinkTagStripper } from './think-tag-stripper.js';
+/**
+ * Extract the most human-readable message from an error body.
+ * Some gateways wrap provider errors multiple times, e.g.
+ * `{"error":{"message":"{\"error\":{\"message\":\"...\"}}"}}`.
+ * Peel those layers so the UI doesn't show raw nested JSON.
+ */
+export function extractApiErrorMessage(errorBody) {
+    const visited = new Set();
+    const walk = (value, depth = 0) => {
+        // Some providers wrap the real message under error.message as a JSON
+        // string, which adds another object/string hop. Allow a few layers of
+        // nesting without risking runaway recursion.
+        if (depth > 8 || visited.has(value))
+            return null;
+        if (value && (typeof value === 'object' || typeof value === 'string')) {
+            visited.add(value);
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed) {
+                try {
+                    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+                        const parsed = JSON.parse(trimmed);
+                        const nested = walk(parsed, depth + 1);
+                        if (nested)
+                            return nested;
+                    }
+                }
+                catch { /* plain string — use as-is below */ }
+            }
+            return trimmed || null;
+        }
+        if (!value || typeof value !== 'object')
+            return null;
+        const obj = value;
+        for (const key of ['error', 'message', 'detail', 'reason']) {
+            if (key in obj) {
+                const nested = walk(obj[key], depth + 1);
+                if (nested)
+                    return nested;
+            }
+        }
+        return null;
+    };
+    const extracted = walk(errorBody) ?? errorBody;
+    return extracted.replace(/\s+/g, ' ').trim();
+}
 // ─── Anthropic Prompt Caching ─────────────────────────────────────────────
 /**
  * Apply Anthropic prompt caching using the `system_and_3` strategy.
@@ -265,13 +312,7 @@ export class ModelClient {
         }
         if (!response.ok) {
             const errorBody = await response.text().catch(() => 'unknown error');
-            // Extract human-readable message from JSON error bodies ({"error":{"message":"..."}})
-            let message = errorBody;
-            try {
-                const parsed = JSON.parse(errorBody);
-                message = parsed?.error?.message || parsed?.message || errorBody;
-            }
-            catch { /* not JSON — use raw text */ }
+            const message = extractApiErrorMessage(errorBody);
             yield {
                 kind: 'error',
                 payload: { status: response.status, message },

package/dist/agent/loop.js

@@ -13,6 +13,8 @@ import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS, getMaxOutputT
 import { classifyAgentError } from './error-classifier.js';
 import { SessionToolGuard } from './tool-guard.js';
 import { resetToolSessionState } from '../tools/index.js';
+import { CORE_TOOL_NAMES, dynamicToolsEnabled } from '../tools/tool-categories.js';
+import { createActivateToolCapability } from '../tools/activate.js';
 import { recordUsage } from '../stats/tracker.js';
 import { recordSessionUsage } from '../stats/session-tracker.js';
 import { appendAudit, extractLastUserPrompt } from '../stats/audit.js';
@@ -317,11 +319,36 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         chain: config.chain,
         debug: config.debug,
     });
+    // ── Dynamic tool visibility ──
+    // Register ActivateTool before building the capability map so the agent
+    // can always reach the meta-tool. When FRANKLIN_DYNAMIC_TOOLS=0 is set,
+    // `activeTools` is seeded with every registered name — behaves as the
+    // pre-3.8.9 static registry.
     const capabilityMap = new Map();
     for (const cap of config.capabilities) {
         capabilityMap.set(cap.spec.name, cap);
     }
-    const toolDefs = config.capabilities.map((c) => c.spec);
+    const activeTools = new Set();
+    const dynamicTools = dynamicToolsEnabled();
+    if (dynamicTools) {
+        for (const name of CORE_TOOL_NAMES) {
+            if (capabilityMap.has(name))
+                activeTools.add(name);
+        }
+    }
+    else {
+        for (const cap of config.capabilities)
+            activeTools.add(cap.spec.name);
+    }
+    const activateToolCap = createActivateToolCapability({ activeTools, allTools: capabilityMap });
+    capabilityMap.set(activateToolCap.spec.name, activateToolCap);
+    if (dynamicTools)
+        activeTools.add(activateToolCap.spec.name);
+    const allToolDefs = [...capabilityMap.values()].map(c => c.spec);
+    const buildCallToolDefs = () => dynamicTools ? allToolDefs.filter(t => activeTools.has(t.name)) : allToolDefs;
+    const buildActiveCapabilityMap = () => dynamicTools
+        ? new Map([...capabilityMap.entries()].filter(([name]) => activeTools.has(name)))
+        : capabilityMap;
     const maxTurns = config.maxTurns ?? 15;
     const workDir = config.workingDir ?? process.cwd();
     const permissions = new PermissionManager(config.permissionMode ?? 'default', config.permissionPromptFn);
@@ -576,6 +603,20 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     '4. Think step by step — show your reasoning explicitly when it adds value\n' +
                     'Prioritize correctness and thoroughness over speed.');
             }
+            // ── Dynamic tool visibility hint ──
+            // When the core/on-demand split is active, tell every model up front
+            // that its tool list is intentionally small and that extras can be
+            // pulled via ActivateTool. Kept byte-stable across turns (no tool
+            // names inlined) so the prompt cache still holds.
+            if (dynamicTools && allToolDefs.length > activeTools.size) {
+                systemParts.push('# Tool Inventory\n' +
+                    'Your current tool list is intentionally minimal. Additional tools ' +
+                    '(web search, image/video/music generation, trading, content, brain ' +
+                    'recall, etc.) are available on demand. Call `ActivateTool()` with ' +
+                    'no arguments to see what is available, then call `ActivateTool({ ' +
+                    '"names": ["<name>"] })` to enable the ones you need. Activated ' +
+                    'tools become visible on the next turn.');
+            }
             // ── Context awareness injection ──
             // Tell the model how full its context window is so it can self-regulate.
             // At high usage, nudge it to be concise and avoid unnecessary tool calls.
@@ -611,8 +652,9 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             let usage;
             let stopReason;
             // Create streaming executor for concurrent tool execution
+            const activeCapabilityMap = buildActiveCapabilityMap();
             const streamExec = new StreamingExecutor({
-                handlers: capabilityMap,
+                handlers: activeCapabilityMap,
                 scope: {
                     workingDir: workDir,
                     abortSignal: abort.signal,
@@ -669,7 +711,10 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             }
             // Build per-call tool defs, max_tokens, and system prompt
             // (planning calls get no tools + short output + planning prompt)
-            let callToolDefs = toolDefs;
+            // Dynamic visibility: `buildCallToolDefs()` returns only the active set
+            // (core + any the agent pulled via ActivateTool). Re-evaluated every
+            // turn so newly activated tools take effect immediately.
+            let callToolDefs = buildCallToolDefs();
             let callMaxTokens = maxTokens;
             let callSystemPrompt = systemPrompt;
             if (planActive && loopCount === 1) {
@@ -918,6 +963,24 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             const opusCost = (inputTokens / 1_000_000) * OPUS_PRICING.input
                 + (usage.outputTokens / 1_000_000) * OPUS_PRICING.output;
             sessionSavedVsOpus += Math.max(0, opusCost - costEstimate);
+            // ── Max-spend guard ──
+            // Session-level cost ceiling. Cron/daily drivers pass this to bound a
+            // single run ("spend at most $0.50 for today's digest"); interactive
+            // users can pass it to feel safe walking away. Hits as soon as accumulated
+            // cost crosses the cap — the last call that tipped us over still runs,
+            // but no further API calls are made.
+            const maxSpend = config.maxSpendUsd;
+            if (typeof maxSpend === 'number' && Number.isFinite(maxSpend) && maxSpend > 0 &&
+                sessionCostUsd >= maxSpend) {
+                onEvent({
+                    kind: 'text_delta',
+                    text: `\n\n_Max-spend reached: $${sessionCostUsd.toFixed(4)} ≥ cap $${maxSpend.toFixed(2)}. ` +
+                        `Stopping session — further calls would exceed the budget._\n`,
+                });
+                persistSessionMeta();
+                onEvent({ kind: 'turn_done', reason: 'budget' });
+                return history;
+            }
             // ── Max output tokens recovery ──
             if (stopReason === 'max_tokens' && recoveryAttempts < MAX_RECOVERY_ATTEMPTS) {
                 recoveryAttempts++;

package/dist/agent/permissions.js

@@ -33,10 +33,10 @@ function isCommonDevCommand(cmd) {
     return COMMON_DEV_PATTERNS.some(p => p.test(trimmed));
 }
 // ─── Default Rules ─────────────────────────────────────────────────────────
-const READ_ONLY_TOOLS = new Set(['Read', 'Glob', 'Grep', 'WebSearch', 'Task', 'AskUser', 'ImageGen', 'TradingSignal', 'TradingMarket', 'SearchX']);
+const READ_ONLY_TOOLS = new Set(['Read', 'Glob', 'Grep', 'WebSearch', 'Task', 'AskUser', 'ActivateTool', 'ImageGen', 'TradingSignal', 'TradingMarket', 'SearchX']);
 const DESTRUCTIVE_TOOLS = new Set(['Write', 'Edit', 'Bash']);
 const DEFAULT_RULES = {
-    allow: ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task', 'AskUser', 'ImageGen', 'TradingSignal', 'TradingMarket', 'SearchX'],
+    allow: ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task', 'AskUser', 'ActivateTool', 'ImageGen', 'TradingSignal', 'TradingMarket', 'SearchX'],
     deny: [],
     ask: ['Write', 'Edit', 'Bash', 'Agent', 'PostToX'],
 };

package/dist/agent/types.d.ts

@@ -155,4 +155,11 @@ export interface AgentConfig {
      * unset. Format: "<driver>:<owner-or-chat-id>", e.g. "telegram:12345".
      */
     sessionChannel?: string;
+    /**
+     * Hard cap on total USD spend for this session. When accumulated API cost
+     * crosses the cap, the loop stops with `reason: 'budget'`. Zero/negative
+     * values disable the cap. Primary use case: cron/daily drivers that must
+     * bound a single run to keep autonomous execution inside a known envelope.
+     */
+    maxSpendUsd?: number;
 }

package/dist/banner.js

@@ -82,6 +82,21 @@ function padVisible(s, targetWidth) {
     return s + '\x1b[0m' + ' '.repeat(targetWidth - current);
 }
 export function printBanner(version) {
+    const style = process.env.FRANKLIN_BANNER?.toLowerCase();
+    if (style === 'full' || style === 'legacy') {
+        printLegacyBanner(version);
+        return;
+    }
+    printCompactBanner(version);
+}
+function printCompactBanner(version) {
+    const title = chalk.bold.hex(GOLD_START)('FRANKLIN');
+    const meta = chalk.dim(`  ·  blockrun.ai  ·  v${version}`);
+    console.log(`${title}${meta}`);
+    console.log(chalk.dim('The AI agent with a wallet'));
+    console.log('');
+}
+function printLegacyBanner(version) {
     const termWidth = process.stdout.columns ?? 80;
     const useSideBySide = termWidth >= MIN_WIDTH_FOR_PORTRAIT;
     if (useSideBySide) {

package/dist/commands/start.d.ts

@@ -7,6 +7,10 @@ interface StartOptions {
     resume?: string | boolean | 'picker';
     /** Continue: resume most recent session matching the current working directory */
     continue?: boolean;
+    /** Hard USD cap on total session spend. Stops the loop when exceeded. */
+    maxSpend?: string | number;
+    /** Run a single prompt non-interactively, then exit. For cron/scripted use. */
+    prompt?: string;
 }
 export declare function startCommand(options: StartOptions): Promise<void>;
 export {};

package/dist/commands/start.js

@@ -74,6 +74,49 @@ export async function startCommand(options) {
         // Default: free NVIDIA model — zero wallet charges until user explicitly switches
         model = 'nvidia/nemotron-ultra-253b';
     }
+    const workDir = process.cwd();
+    // --prompt batch mode: skip all interactive startup UI/side effects so
+    // stdout stays clean for cron/scripts. Keep the capability surface to the
+    // built-ins only — no panel, no MCP autoconnect, no wallet/banner chatter.
+    if (options.prompt) {
+        if (options.resume === true || options.resume === 'picker') {
+            console.error(chalk.red('`--prompt` requires `--resume` to include an explicit session id.'));
+            process.exitCode = 1;
+            return;
+        }
+        const systemInstructions = assembleInstructions(workDir, model);
+        const subAgent = createSubAgentCapability(apiUrl, chain, allCapabilities, model);
+        const { registerMoAConfig } = await import('../tools/moa.js');
+        registerMoAConfig(apiUrl, chain, model);
+        const capabilities = [...allCapabilities, subAgent];
+        if (options.debug) {
+            const issues = validateToolDescriptions(capabilities);
+            for (const issue of issues) {
+                console.error(`[validate] ${issue.severity}: ${issue.toolName} — ${issue.issue}`);
+            }
+        }
+        const agentConfig = {
+            model,
+            apiUrl,
+            chain,
+            systemInstructions,
+            capabilities,
+            maxTurns: 100,
+            workingDir: workDir,
+            permissionMode: 'trust',
+            debug: options.debug,
+            resumeSessionId: (typeof options.resume === 'string' && options.resume !== 'picker')
+                ? options.resume
+                : continueResolvedId,
+            ...(options.maxSpend != null
+                ? { maxSpendUsd: Number(options.maxSpend) }
+                : {}),
+        };
+        const exitCode = await runOneShot(agentConfig, options.prompt);
+        flushStats();
+        process.exitCode = exitCode;
+        return;
+    }
     // Warn when a paid model is active so users know they'll be charged
     const FREE_MODELS = new Set([
         'nvidia/nemotron-ultra-253b',
@@ -114,7 +157,6 @@ export async function startCommand(options) {
         catch { /* migration is optional */ }
     }
     printBanner(version);
-    const workDir = process.cwd();
     // Auto-start panel in background unless explicitly disabled.
     // Binds loopback-only (wallet secrets on /api/wallet/secret — never expose on LAN).
     let panelUrl;
@@ -240,9 +282,13 @@ export async function startCommand(options) {
         workingDir: workDir,
         // Non-TTY (piped) input = scripted mode → trust all tools automatically.
         // Interactive TTY = default mode (prompts for Bash/Write/Edit).
-        permissionMode: (options.trust || !process.stdin.isTTY) ? 'trust' : 'default',
+        // --prompt is also scripted; the cron driver never sees a TTY.
+        permissionMode: (options.trust || options.prompt || !process.stdin.isTTY) ? 'trust' : 'default',
         debug: options.debug,
         resumeSessionId,
+        ...(options.maxSpend != null
+            ? { maxSpendUsd: Number(options.maxSpend) }
+            : {}),
     };
     // Bootstrap learnings from existing CLAUDE.md on first run (async, non-blocking)
     Promise.all([
@@ -262,6 +308,30 @@ export async function startCommand(options) {
         await runWithBasicUI(agentConfig, model, workDir);
     }
 }
+// ─── One-shot mode (franklin --prompt "...") ──────────────────────────────
+// Used by cron drivers. Non-interactive, prints text deltas to stdout as
+// they stream, honors --max-spend, exits 0 on completion / 1 on error.
+async function runOneShot(agentConfig, prompt) {
+    let delivered = false;
+    let exitCode = 0;
+    const getInput = async () => {
+        if (delivered)
+            return null;
+        delivered = true;
+        return prompt;
+    };
+    await interactiveSession(agentConfig, getInput, (event) => {
+        if (event.kind === 'text_delta') {
+            process.stdout.write(event.text);
+        }
+        else if (event.kind === 'turn_done') {
+            if (event.reason === 'error')
+                exitCode = 1;
+            process.stdout.write('\n');
+        }
+    });
+    return exitCode;
+}
 // ─── Ink UI (interactive terminal) ─────────────────────────────────────────
 async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, onBalanceReady, fetchBalance) {
     const startSnapshot = snapshotStats();

package/dist/index.js

@@ -43,6 +43,8 @@ program
     .option('--trust', 'Trust mode — skip permission prompts for all tools')
     .option('-r, --resume [sessionId]', 'Resume a session by ID (or show picker if omitted)')
     .option('-c, --continue', 'Continue the most recent session in this directory')
+    .option('--max-spend <usd>', 'Hard USD cap on total session API spend — session stops when exceeded')
+    .option('-p, --prompt <text>', 'Run a single prompt non-interactively (for cron/scripted use)')
     .action((options) => startCommand({ ...options, version }));
 program
     .command('resume [sessionId]')
@@ -209,7 +211,7 @@ const args = process.argv.slice(2);
 const firstArg = args[0];
 const HELP_FLAGS = new Set(['-h', '--help']);
 const VERSION_FLAGS = new Set(['-V', '--version']);
-const START_ONLY_FLAGS = new Set(['--trust', '--debug', '-m', '--model', '-r', '--resume', '-c', '--continue']);
+const START_ONLY_FLAGS = new Set(['--trust', '--debug', '-m', '--model', '-r', '--resume', '-c', '--continue', '-p', '--prompt', '--max-spend']);
 function hasAnyFlag(argv, flags) {
     return argv.some(arg => flags.has(arg));
 }
@@ -227,6 +229,12 @@ function parseStartFlags(argv, startIdx = 0) {
         else if ((arg === '-m' || arg === '--model') && argv[i + 1]) {
             opts.model = argv[++i];
         }
+        else if ((arg === '-p' || arg === '--prompt') && argv[i + 1]) {
+            opts.prompt = argv[++i];
+        }
+        else if (arg === '--max-spend' && argv[i + 1]) {
+            opts.maxSpend = argv[++i];
+        }
         else if (arg === '-c' || arg === '--continue') {
             opts.continue = true;
         }
@@ -257,7 +265,7 @@ if (firstArg === 'solana' || firstArg === 'base') {
     saveChain(firstArg);
     const startOpts = parseStartFlags(args, 1);
     await startCommand(startOpts);
-    process.exit(0);
+    process.exit(process.exitCode ?? 0);
 }
 else if (!firstArg || firstArg.startsWith('-')) {
     if (hasAnyFlag(args, HELP_FLAGS) && hasStartOnlyFlag(args)) {
@@ -273,7 +281,7 @@ else if (!firstArg || firstArg.startsWith('-')) {
     // No subcommand or only flags — treat as 'start' with flags
     const startOpts = parseStartFlags(args, 0);
     await startCommand(startOpts);
-    process.exit(0);
+    process.exit(process.exitCode ?? 0);
 }
 else {
     program.parse();

package/dist/panel/html.js

@@ -371,14 +371,14 @@ a:hover { text-decoration:underline; }
       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12V7H5a2 2 0 0 1 0-4h14v4"/><path d="M3 5v14a2 2 0 0 0 2 2h16v-5"/><path d="M18 12a2 2 0 0 0 0 4h4v-4z"/></svg>
       Wallet
     </button>
+    <button class="nav-item" data-tab="markets">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 3v18h18"/><path d="M7 14l4-4 4 4 5-5"/></svg>
+      Markets
+    </button>
     <button class="nav-item" data-tab="sessions">
       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg>
       Sessions
     </button>
-    <button class="nav-item" data-tab="social">
-      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 4l11.733 16h4.267l-11.733-16z"/><path d="M4 20l6.768-6.768M15.232 11.232L20 4"/></svg>
-      Social
-    </button>
     <button class="nav-item" data-tab="learnings">
       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"/><path d="M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"/></svg>
       Learnings
@@ -542,16 +542,34 @@ a:hover { text-decoration:underline; }
     <div class="session-detail" id="session-detail" style="display:none"></div>
   </div>
 
-  <!-- Social -->
-  <div class="tab" id="tab-social">
+  <!-- Markets -->
+  <div class="tab" id="tab-markets">
     <div class="content-header">
-      <h2>Social</h2>
-      <p>X/Twitter engagement stats</p>
+      <h2>Markets</h2>
+      <p>How Franklin gets trading data — and what it costs.</p>
     </div>
-    <div class="grid grid-4" id="social-stats"></div>
-    <div class="card" style="margin-top:12px">
-      <h3>Recent Activity</h3>
-      <div id="social-feed" class="empty">No social activity yet</div>
+
+    <div class="grid grid-4">
+      <div class="card"><h3>Calls today</h3><div class="metric" id="mk-calls">&mdash;</div></div>
+      <div class="card"><h3>Spend today</h3><div class="metric gold" id="mk-spend">&mdash;</div></div>
+      <div class="card"><h3>p50 latency</h3><div class="metric" id="mk-p50">&mdash;</div></div>
+      <div class="card"><h3>Payment chain</h3><div class="metric" id="mk-chain">&mdash;</div></div>
+    </div>
+
+    <div style="display:grid;grid-template-columns:1.1fr 1fr;gap:14px;margin-top:14px">
+      <div class="card">
+        <h3>Data pipeline</h3>
+        <p style="color:var(--text-dim);font-size:12px;margin:4px 0 14px">
+          Each asset class routes through the provider registry to the active upstream.
+        </p>
+        <div id="mk-pipeline" style="font-family:var(--mono);font-size:12px;line-height:1.75"></div>
+      </div>
+      <div class="card">
+        <h3>Providers</h3>
+        <div id="mk-providers" style="margin-top:6px"></div>
+        <h3 style="margin-top:18px">Recent paid calls</h3>
+        <div id="mk-paid" class="empty" style="margin-top:6px">No paid calls yet</div>
+      </div>
     </div>
   </div>
 
@@ -588,6 +606,7 @@ a:hover { text-decoration:underline; }
     </div>
     <div id="audit-list" style="font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:12px;"></div>
   </div>
+
 </div>
 
 <script>
@@ -716,14 +735,84 @@ document.getElementById('session-search').addEventListener('input', (e) => {
   }, 300);
 });
 
-async function loadSocial() {
-  const social = await api('social');
-  if (!social) return;
-  document.getElementById('social-stats').innerHTML =
-    '<div class="card"><h3>Posted</h3><div class="metric success">' + (social.posted || 0) + '</div></div>' +
-    '<div class="card"><h3>Drafted</h3><div class="metric">' + (social.drafted || 0) + '</div></div>' +
-    '<div class="card"><h3>Skipped</h3><div class="metric">' + (social.skipped || 0) + '</div></div>' +
-    '<div class="card"><h3>Social Cost</h3><div class="metric gold">' + usd(social.totalCost || 0) + '</div></div>';
+async function loadMarkets() {
+  const data = await api('markets');
+  if (!data) return;
+
+  const calls = (data.totals && data.totals.callsToday) || 0;
+  const spend = (data.totals && data.totals.spendUsdToday) || 0;
+  const p50 = data.totals && data.totals.p50LatencyMs;
+  document.getElementById('mk-calls').textContent = String(calls);
+  document.getElementById('mk-spend').textContent = usd(spend);
+  document.getElementById('mk-p50').textContent = (p50 == null) ? '—' : (p50 + ' ms');
+  document.getElementById('mk-chain').textContent = (data.chain || 'base').toUpperCase();
+
+  // Pipeline: Franklin → registry → per-asset-class provider → endpoint
+  const rows = (data.wiring || []).filter(function(r){ return r.kind === 'price'; });
+  const singletonRows = (data.wiring || []).filter(function(r){ return r.kind !== 'price'; });
+  const providerLabel = function(name) {
+    if (name === 'coingecko') return '<span style="color:var(--success)">CoinGecko</span>';
+    if (name === 'blockrun') return '<span style="color:var(--gold)">BlockRun Gateway</span>';
+    return esc(name);
+  };
+  const pipeLines = [
+    '<div>Franklin agent</div>',
+    '<div style="color:var(--text-dim);padding-left:8px">↓</div>',
+    '<div>Provider registry</div>',
+    '<div style="color:var(--text-dim);padding-left:8px">↓</div>',
+  ];
+  rows.forEach(function(r, i){
+    const last = i === rows.length - 1;
+    const branch = last ? '└' : '├';
+    const paid = r.paid ? ' <span style="color:var(--gold);font-size:10px">◆ x402</span>' : '';
+    pipeLines.push(
+      '<div>&nbsp;' + branch + '─ ' + esc(r.assetClass).padEnd(9, ' ') +
+      ' → ' + providerLabel(r.provider) + paid + '</div>'
+    );
+  });
+  pipeLines.push('<div style="margin-top:10px;color:var(--text-dim);font-size:11px">Other singleton kinds:</div>');
+  singletonRows.forEach(function(r){
+    pipeLines.push(
+      '<div style="color:var(--text-dim);font-size:11px">&nbsp;&nbsp;' +
+      esc(r.kind) + ' → ' + providerLabel(r.provider) + '</div>'
+    );
+  });
+  document.getElementById('mk-pipeline').innerHTML = pipeLines.join('');
+
+  // Providers health
+  const statusChip = function(s){
+    if (s === 'ok')       return '<span class="dot on"></span> <span style="color:var(--success)">OK</span>';
+    if (s === 'degraded') return '<span class="dot off"></span> <span style="color:var(--danger)">degraded</span>';
+    return '<span class="dot" style="background:var(--text-dim)"></span> <span style="color:var(--text-dim)">cold</span>';
+  };
+  const providers = data.providers || [];
+  document.getElementById('mk-providers').innerHTML = providers.length === 0 ? '<div class="empty">No calls recorded yet.</div>' : providers.map(function(p){
+    const since = p.lastOkAt ? Math.round((Date.now() - p.lastOkAt) / 1000) + 's ago' : '—';
+    return '<div style="display:flex;justify-content:space-between;align-items:center;padding:7px 0;border-bottom:1px solid var(--border);font-size:12px">' +
+      '<span>' + statusChip(p.status) + ' &nbsp;<strong>' + esc(p.name) + '</strong></span>' +
+      '<span style="color:var(--text-dim);font-family:var(--mono);font-size:11px">' +
+        p.calls + ' calls · p50 ' + (p.p50LatencyMs == null ? '—' : p.p50LatencyMs + 'ms') + ' · last ' + since +
+      '</span>' +
+    '</div>';
+  }).join('');
+
+  // Recent paid calls
+  const paid = data.recentPaidCalls || [];
+  const paidBox = document.getElementById('mk-paid');
+  if (paid.length === 0) {
+    paidBox.className = 'empty';
+    paidBox.textContent = 'No paid calls yet — stocks ship in the next release.';
+  } else {
+    paidBox.className = '';
+    paidBox.innerHTML = paid.map(function(r){
+      const age = Math.round((Date.now() - r.ts) / 1000) + 's ago';
+      return '<div style="display:flex;justify-content:space-between;padding:4px 0;font-family:var(--mono);font-size:12px">' +
+        '<span>' + esc(r.endpoint) + '</span>' +
+        '<span class="gold">' + usd(r.costUsd) + '</span>' +
+        '<span style="color:var(--text-dim)">' + age + '</span>' +
+      '</div>';
+    }).join('');
+  }
 }
 
 async function loadLearnings() {
@@ -909,9 +998,10 @@ document.querySelector('[data-tab="audit"]')?.addEventListener('click', loadAudi
 
 loadOverview();
 loadSessions();
-loadSocial();
+loadMarkets();
 loadLearnings();
 loadWallet();
+document.querySelector('[data-tab="markets"]')?.addEventListener('click', loadMarkets);
 setInterval(() => api('wallet').then(w => {
   if (w) {
     document.getElementById('balance').textContent = usdBig(w.balance) + ' USDC';

package/dist/panel/server.js

@@ -13,7 +13,8 @@ import { listSessions, loadSessionHistory } from '../session/storage.js';
 import { searchSessions } from '../session/search.js';
 import { loadLearnings } from '../learnings/store.js';
 import { readAudit } from '../stats/audit.js';
-import { getStats as getSocialStats } from '../social/db.js';
+import { snapshot as marketsSnapshot } from '../trading/providers/telemetry.js';
+import { describeWiring } from '../trading/providers/registry.js';
 import { getHTML } from './html.js';
 const sseClients = new Set();
 function json(res, data, status = 200) {
@@ -312,9 +313,19 @@ export function createPanelServer(port) {
                     }
                     return;
                 }
-                if (p === '/api/social') {
-                    const stats = getSocialStats();
-                    json(res, stats);
+                if (p === '/api/markets') {
+                    // Snapshot of every active data provider for the Markets panel:
+                    // pipeline wiring (which endpoint serves which asset class), live
+                    // health + latency per provider, and today's paid-call ledger.
+                    const snap = marketsSnapshot();
+                    const wiring = describeWiring();
+                    json(res, {
+                        chain: loadChain(),
+                        wiring,
+                        providers: snap.providers,
+                        totals: snap.totals,
+                        recentPaidCalls: snap.recentPaidCalls,
+                    });
                     return;
                 }
                 if (p === '/api/learnings') {