@blockrun/franklin 3.8.8 → 3.8.9

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,33 @@ 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 maxTurns = config.maxTurns ?? 15;
     const workDir = config.workingDir ?? process.cwd();
     const permissions = new PermissionManager(config.permissionMode ?? 'default', config.permissionPromptFn);
@@ -576,6 +600,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.
@@ -669,7 +707,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 +959,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/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;
         }

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') {

package/dist/tools/activate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ActivateTool — meta-capability that lets the agent pull on-demand tools
+ * into the active toolset per session.
+ *
+ * Pattern borrowed from OpenBB MCP server's per-session tool visibility:
+ * a weak model confronted with 25+ tool definitions starts inventing names
+ * or emits role-play "[TOOLCALL]" fragments. Register only the core file/
+ * shell tools by default and let the model explicitly opt in to the rest.
+ *
+ * Contract:
+ *   - `ActivateTool()` with no args → lists every inactive tool with a
+ *     one-line description so the model knows what's available.
+ *   - `ActivateTool({ names: ["ExaSearch", "ExaReadUrls"] })` → adds the
+ *     named tools to the session's active set; subsequent turns include
+ *     their full schemas. Returns a concise confirmation.
+ *
+ * The factory captures the shared `activeTools` Set that the loop filters
+ * against and the full `allTools` map used for name resolution. Both live
+ * in the session — activation is not durable across restarts on purpose,
+ * since the model can always re-activate on the next turn if it needs to.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export interface ActivateToolDeps {
+    /** Mutable set of tool names currently visible to the model. */
+    activeTools: Set<string>;
+    /** Map of every registered capability, keyed by name. */
+    allTools: Map<string, CapabilityHandler>;
+}
+export declare function createActivateToolCapability(deps: ActivateToolDeps): CapabilityHandler;

package/dist/tools/activate.js

@@ -0,0 +1,96 @@
+/**
+ * ActivateTool — meta-capability that lets the agent pull on-demand tools
+ * into the active toolset per session.
+ *
+ * Pattern borrowed from OpenBB MCP server's per-session tool visibility:
+ * a weak model confronted with 25+ tool definitions starts inventing names
+ * or emits role-play "[TOOLCALL]" fragments. Register only the core file/
+ * shell tools by default and let the model explicitly opt in to the rest.
+ *
+ * Contract:
+ *   - `ActivateTool()` with no args → lists every inactive tool with a
+ *     one-line description so the model knows what's available.
+ *   - `ActivateTool({ names: ["ExaSearch", "ExaReadUrls"] })` → adds the
+ *     named tools to the session's active set; subsequent turns include
+ *     their full schemas. Returns a concise confirmation.
+ *
+ * The factory captures the shared `activeTools` Set that the loop filters
+ * against and the full `allTools` map used for name resolution. Both live
+ * in the session — activation is not durable across restarts on purpose,
+ * since the model can always re-activate on the next turn if it needs to.
+ */
+function shortDesc(desc) {
+    // First sentence or first 120 chars, whichever is shorter.
+    const firstSentence = desc.split(/[.\n]/)[0]?.trim() ?? '';
+    if (firstSentence && firstSentence.length <= 120)
+        return firstSentence;
+    const trimmed = desc.replace(/\s+/g, ' ').trim();
+    return trimmed.length <= 120 ? trimmed : trimmed.slice(0, 117) + '...';
+}
+export function createActivateToolCapability(deps) {
+    const { activeTools, allTools } = deps;
+    return {
+        spec: {
+            name: 'ActivateTool',
+            description: 'Activate additional tools for this session. Most tools are hidden by default to keep your tool inventory small. ' +
+                'Call with no arguments to see what is available. Call with { "names": ["ToolA", "ToolB"] } to enable specific tools — ' +
+                'they become visible in your tool list on the next turn. Activate only what you need; extra tools crowd the inventory.',
+            input_schema: {
+                type: 'object',
+                properties: {
+                    names: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of tool names to activate. Omit to list what is available.',
+                    },
+                },
+            },
+        },
+        concurrent: false,
+        async execute(input) {
+            const raw = input.names;
+            const names = Array.isArray(raw) ? raw.filter((n) => typeof n === 'string') : undefined;
+            // No args → catalog the inactive tools so the model knows what's there.
+            if (!names || names.length === 0) {
+                const inactive = [...allTools.values()]
+                    .filter(t => !activeTools.has(t.spec.name))
+                    .sort((a, b) => a.spec.name.localeCompare(b.spec.name));
+                if (inactive.length === 0) {
+                    return { output: 'All registered tools are already active.' };
+                }
+                const lines = inactive.map(t => `- ${t.spec.name}: ${shortDesc(t.spec.description)}`);
+                return {
+                    output: `Available on-demand tools (${inactive.length}). Activate with ` +
+                        `ActivateTool({ "names": ["<name>", ...] }):\n` +
+                        lines.join('\n'),
+                };
+            }
+            // Activate each named tool.
+            const activated = [];
+            const alreadyActive = [];
+            const unknown = [];
+            for (const name of names) {
+                if (!allTools.has(name)) {
+                    unknown.push(name);
+                }
+                else if (activeTools.has(name)) {
+                    alreadyActive.push(name);
+                }
+                else {
+                    activeTools.add(name);
+                    activated.push(name);
+                }
+            }
+            const parts = [];
+            if (activated.length)
+                parts.push(`Activated: ${activated.join(', ')}`);
+            if (alreadyActive.length)
+                parts.push(`Already active: ${alreadyActive.join(', ')}`);
+            if (unknown.length)
+                parts.push(`Unknown (not registered): ${unknown.join(', ')}`);
+            const output = parts.length ? parts.join('. ') + '.' : 'No change.';
+            const isError = activated.length === 0 && unknown.length > 0;
+            return { output, isError };
+        },
+    };
+}

package/dist/tools/index.js

@@ -22,6 +22,7 @@ import { tradingSignalCapability, tradingMarketCapability } from './trading.js';
 import { searchXCapability } from './searchx.js';
 import { postToXCapability } from './posttox.js';
 import { moaCapability } from './moa.js';
+import { webhookPostCapability } from './webhook.js';
 import { createTradingCapabilities } from './trading-execute.js';
 import { Portfolio } from '../trading/portfolio.js';
 import { RiskEngine } from '../trading/risk.js';
@@ -138,6 +139,7 @@ export const allCapabilities = [
     searchXCapability,
     postToXCapability,
     moaCapability,
+    webhookPostCapability,
 ];
 export { readCapability, writeCapability, editCapability, bashCapability, globCapability, grepCapability, webFetchCapability, webSearchCapability, taskCapability, };
 export { createSubAgentCapability } from './subagent.js';