@finchagentic/mcp 4.0.0

package/dist/clink-input.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedupClinkInput = dedupClinkInput;
+// Deduplicates doubled input from a known Clink v1.7.6 terminal bug (garbled/
+// doubled keystrokes, e.g. "finch_sk_xxfinch_sk_xx" -> "finch_sk_xx"). Used by
+// every raw-input prompt in cli.ts (login, setup wizard provider/URL prompts)
+// before validating what the user typed.
+function dedupClinkInput(s) {
+    if (s.length > 0 && s.length % 2 === 0) {
+        const half = s.length / 2;
+        if (s.slice(0, half) === s.slice(half))
+            return s.slice(0, half);
+    }
+    return s;
+}

package/dist/config.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = env;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.getSavedToken = getSavedToken;
+exports.isApiKey = isApiKey;
+exports.hydrateEnvFromConfig = hydrateEnvFromConfig;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CONFIG_DIR = path.join(os.homedir(), ".finch");
+const LEGACY_DIR = path.join(os.homedir(), ".noelclaw");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const LEGACY_FILE = path.join(LEGACY_DIR, "config.json");
+/** Prefer FINCH_* env, fall back to legacy NOELCLAW_* during rebrand. */
+function env(name, legacy) {
+    const primary = process.env[name];
+    if (primary !== undefined && primary !== "")
+        return primary;
+    if (legacy) {
+        const v = process.env[legacy];
+        if (v !== undefined && v !== "")
+            return v;
+    }
+    // Auto-map FINCH_X → NOELCLAW_X when legacy not passed
+    if (name.startsWith("FINCH_")) {
+        const auto = "NOELCLAW_" + name.slice("FINCH_".length);
+        const v = process.env[auto];
+        if (v !== undefined && v !== "")
+            return v;
+    }
+    return undefined;
+}
+function readConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+        }
+        // migrate-read: still pick up old ~/.noelclaw/config.json
+        if (fs.existsSync(LEGACY_FILE)) {
+            return JSON.parse(fs.readFileSync(LEGACY_FILE, "utf8"));
+        }
+    }
+    catch {
+        // Missing/corrupt config file - treat as no saved config.
+    }
+    return {};
+}
+function writeConfig(patch) {
+    const current = readConfig();
+    const updated = { ...current, ...patch };
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), { mode: 0o600 });
+}
+function getSavedToken() {
+    // env var always wins over saved config
+    return env("FINCH_SESSION_TOKEN", "NOELCLAW_SESSION_TOKEN") ?? readConfig().sessionToken;
+}
+/** Accept finch_sk_* (new) and noel_sk_* (backend still issues these). */
+function isApiKey(value) {
+    if (!value)
+        return false;
+    return value.startsWith("finch_sk_") || value.startsWith("noel_sk_");
+}
+// Injects provider keys saved via `finch setup` into process.env, so both
+// the interactive CLI and the MCP server process (spawned fresh by Claude
+// Desktop/Cursor/etc, which never sees ~/.finch/config.json otherwise)
+// pick them up the same way. An env var already set by the parent process
+// always wins - this only fills gaps, never overrides.
+function hydrateEnvFromConfig() {
+    const cfg = readConfig();
+    if (!process.env.BANKR_API_KEY && cfg.bankrApiKey)
+        process.env.BANKR_API_KEY = cfg.bankrApiKey;
+    if (!process.env.ANTHROPIC_API_KEY && cfg.anthropicApiKey)
+        process.env.ANTHROPIC_API_KEY = cfg.anthropicApiKey;
+    if (!process.env.OPENAI_API_KEY && cfg.openaiApiKey)
+        process.env.OPENAI_API_KEY = cfg.openaiApiKey;
+    if (!process.env.OPENAI_BASE_URL && cfg.openaiBaseUrl)
+        process.env.OPENAI_BASE_URL = cfg.openaiBaseUrl;
+    // Bridge legacy env into FINCH_* so the rest of the codebase can read one name.
+    const bridges = [
+        ["FINCH_SESSION_TOKEN", "NOELCLAW_SESSION_TOKEN"],
+        ["FINCH_API_KEY", "NOELCLAW_API_KEY"],
+        ["FINCH_CONVEX_URL", "NOELCLAW_CONVEX_URL"],
+        ["FINCH_TOOLS", "NOELCLAW_TOOLS"],
+        ["FINCH_PROVIDER", "NOELCLAW_PROVIDER"],
+        ["FINCH_MODEL", "NOELCLAW_MODEL"],
+        ["FINCH_RPC_URL", "NOELCLAW_RPC_URL"],
+        ["FINCH_BROADCAST_RPC", "NOELCLAW_BROADCAST_RPC"],
+        ["FINCH_WALLET_PASSPHRASE", "NOELCLAW_WALLET_PASSPHRASE"],
+        ["FINCH_PAYMENT_HEADER", "NOELCLAW_PAYMENT_HEADER"],
+    ];
+    for (const [fin, leg] of bridges) {
+        if (!process.env[fin] && process.env[leg])
+            process.env[fin] = process.env[leg];
+    }
+}

package/dist/convex.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentRequiredError = exports.CONVEX_SITE = void 0;
+exports.buildPaymentHeader = buildPaymentHeader;
+exports.callConvex = callConvex;
+exports.callConvexRaw = callConvexRaw;
+exports.notifyTelegram = notifyTelegram;
+const wallet_js_1 = require("./wallet.js");
+const config_js_1 = require("./config.js");
+exports.CONVEX_SITE = process.env.FINCH_CONVEX_URL ?? "https://befitting-porcupine-276.convex.site";
+const RETRY_STATUSES = new Set([429, 500, 502, 503, 504]);
+const RETRY_DELAYS = [500, 1000, 2000];
+class PaymentRequiredError extends Error {
+    constructor(details) {
+        super("Payment required");
+        this.name = "PaymentRequiredError";
+        this.details = details;
+    }
+}
+exports.PaymentRequiredError = PaymentRequiredError;
+function buildPaymentHeader(txHash, requestId) {
+    return Buffer.from(`${txHash}:${requestId}`).toString("base64");
+}
+async function attemptConvex(url, method, headers, body, timeoutMs = 30000) {
+    return fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+}
+async function callConvex(path, method, body, toolName = "unknown", timeoutMs = 30000) {
+    const url = `${exports.CONVEX_SITE}${path}`;
+    const headers = { "Content-Type": "application/json" };
+    const apiKey = process.env.FINCH_API_KEY;
+    const sessionToken = (0, config_js_1.getSavedToken)(); // env var → saved config fallback
+    // Prefer session token (resolved by backend) over API key for Convex API calls
+    const authHeader = sessionToken
+        ? `Bearer ${sessionToken}`
+        : apiKey
+            ? `Bearer ${apiKey}`
+            : null;
+    if (authHeader) {
+        headers["Authorization"] = authHeader;
+    }
+    else {
+        try {
+            const { address, signature, timestamp } = await (0, wallet_js_1.signRequest)(toolName);
+            headers["X-Wallet-Address"] = address;
+            headers["X-Wallet-Signature"] = signature;
+            headers["X-Wallet-Timestamp"] = timestamp;
+        }
+        catch {
+            // continue without wallet headers - server will respond with 401/402
+        }
+    }
+    const paymentHeader = process.env.FINCH_PAYMENT_HEADER;
+    if (paymentHeader)
+        headers["X-Payment"] = paymentHeader;
+    // BYOK headers - user pays for their own AI/service costs
+    if (process.env.ANTHROPIC_API_KEY)
+        headers["X-User-Anthropic-Key"] = process.env.ANTHROPIC_API_KEY;
+    if (process.env.OPENAI_API_KEY)
+        headers["X-User-OpenAI-Key"] = process.env.OPENAI_API_KEY;
+    if (process.env.GROK_API_KEY)
+        headers["X-User-Grok-Key"] = process.env.GROK_API_KEY;
+    if (process.env.BANKR_API_KEY)
+        headers["X-User-Bankr-Key"] = process.env.BANKR_API_KEY;
+    if (process.env.TELEGRAM_BOT_TOKEN)
+        headers["X-User-Telegram-Token"] = process.env.TELEGRAM_BOT_TOKEN;
+    if (process.env.TELEGRAM_CHAT_ID)
+        headers["X-User-Telegram-Chat"] = process.env.TELEGRAM_CHAT_ID;
+    let lastError = null;
+    for (let attempt = 0; attempt < RETRY_DELAYS.length; attempt++) {
+        if (attempt > 0) {
+            await new Promise((r) => setTimeout(r, RETRY_DELAYS[attempt - 1]));
+        }
+        let res;
+        try {
+            res = await attemptConvex(url, method, headers, body, timeoutMs);
+        }
+        catch (err) {
+            lastError = err;
+            continue;
+        }
+        if (res.status === 402) {
+            const b = await res.json().catch(() => ({}));
+            throw new PaymentRequiredError(b);
+        }
+        if (res.status === 401) {
+            const b = await res.json().catch(() => ({}));
+            throw new Error(`🔑 ${b.message || "Authentication required"}\n\n` +
+                `→ Sign in at: ${b.url || "https://finchagentic.com"}\n\n` +
+                `Hint: ${b.hint || 'Add FINCH_SESSION_TOKEN=… to the env block in your MCP config'}\n\n` +
+                `${b.alternative ? `Alternative: ${b.alternative}` : ""}`);
+        }
+        if (RETRY_STATUSES.has(res.status) && attempt < RETRY_DELAYS.length) {
+            lastError = new Error(`Finch API error: ${res.status}`);
+            continue;
+        }
+        if (!res.ok)
+            throw new Error(`Finch API error: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    throw lastError ?? new Error("Request failed after retries");
+}
+// Variant that returns the response body as raw text. Used for endpoints
+// that stream non-JSON content like /vault/blob (large vault entries that
+// were offloaded to Convex File Storage).
+async function callConvexRaw(path, toolName = "unknown", timeoutMs = 60000) {
+    const url = `${exports.CONVEX_SITE}${path}`;
+    const headers = {};
+    const apiKey = process.env.FINCH_API_KEY;
+    const sessionToken = (0, config_js_1.getSavedToken)();
+    const authHeader = apiKey
+        ? `Bearer ${apiKey}`
+        : sessionToken
+            ? `Bearer ${sessionToken}`
+            : null;
+    if (authHeader) {
+        headers["Authorization"] = authHeader;
+    }
+    else {
+        try {
+            const { address, signature, timestamp } = await (0, wallet_js_1.signRequest)(toolName);
+            headers["X-Wallet-Address"] = address;
+            headers["X-Wallet-Signature"] = signature;
+            headers["X-Wallet-Timestamp"] = timestamp;
+        }
+        catch {
+            // No local wallet available to sign with - continue without wallet
+            // headers, server will respond with 401/402 if auth was required.
+        }
+    }
+    const res = await fetch(url, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok)
+        throw new Error(`Finch API error: ${res.status}`);
+    return res.text();
+}
+async function notifyTelegram(userId, message) {
+    try {
+        return await callConvex("/user/telegram/notify", "POST", { userId, message }, "set_telegram");
+    }
+    catch (error) {
+        return { sent: false, reason: error.message ?? String(error) };
+    }
+}

package/dist/dex-pair.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Pick the DexScreener pair whose numbers actually describe the token asked for.
+ *
+ * `priceUsd`, `marketCap`, `fdv`, `priceChange` and `txns` on a pair all describe
+ * the BASE token. Taking the deepest pair regardless of side therefore reports a
+ * different token entirely, and does it convincingly — the caller's own contract
+ * address is still printed alongside. Two real cases:
+ *
+ *   - Canonical USDC on Base. Its deepest pair is `AERO/USDC`, so asking for
+ *     USDC returned Aerodrome at $0.4332 with an $840M FDV.
+ *   - NVDA on Robinhood Chain. Its deepest pair is `AI/NVDA`, so it reported AI
+ *     at $0.0063 as though that were NVDA at $205 — and that price fed the
+ *     take-profit and stop-loss triggers.
+ *
+ * Base-side pairs are preferred by depth. When a token only ever appears as the
+ * quote, its price is still derivable as `basePriceUsd / basePriceInOurToken`,
+ * so the pair is rebuilt with the sides swapped and the fields that describe the
+ * other token's flow dropped rather than passed off as ours.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickTokenPair = pickTokenPair;
+const depth = (p) => p.liquidity?.usd ?? 0;
+function pickTokenPair(pairs, tokenAddress) {
+    const want = tokenAddress.toLowerCase();
+    const all = pairs ?? [];
+    const baseSide = all
+        .filter((p) => p.baseToken?.address?.toLowerCase() === want)
+        .sort((a, b) => depth(b) - depth(a));
+    if (baseSide.length)
+        return baseSide[0];
+    const q = all
+        .filter((p) => p.quoteToken?.address?.toLowerCase() === want)
+        .sort((a, b) => depth(b) - depth(a))[0];
+    if (!q)
+        return null;
+    const baseUsd = Number(q.priceUsd);
+    const baseInOurs = Number(q.priceNative);
+    if (!isFinite(baseUsd) || !isFinite(baseInOurs) || baseInOurs <= 0)
+        return null;
+    return {
+        ...q,
+        baseToken: q.quoteToken,
+        quoteToken: q.baseToken,
+        priceUsd: String(baseUsd / baseInOurs),
+        priceNative: undefined,
+        // Supply-based and direction-based figures belong to the other token.
+        marketCap: undefined,
+        fdv: undefined,
+        txns: undefined,
+        priceChange: undefined,
+        derivedFromQuoteSide: true,
+    };
+}

package/dist/enrichment-router.js

@@ -0,0 +1,315 @@
+"use strict";
+// Generalized enrichment router for deep_research synthesis.
+//
+// Old behavior: Firecrawl scraped 5–10 pages and the LLM synthesized. When
+// pages were thin or outdated, the LLM filled gaps with plausible fiction.
+//
+// New behavior: detect the topic domain and hit primary-source APIs in
+// parallel before synthesis. Inject results as "AUTHORITATIVE LIVE DATA"
+// the LLM is instructed to lead with.
+//
+// All APIs used here are free, public, no auth required:
+//   - DefiLlama, CoinGecko (crypto)
+//   - HackerNews Algolia (tech news, ~real-time)
+//   - GitHub search (repos, no auth needed for public read)
+//   - arXiv (academic papers)
+//   - Wikipedia REST (foundational facts)
+//
+// All calls are best-effort with short timeouts - if any fail, the
+// synthesis runs without that block.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichQuery = enrichQuery;
+exports.todayContext = todayContext;
+// ─── Topic detection ──────────────────────────────────────────────────────────
+const CRYPTO_RE = /\b(tvl|apy|yield|vault|defi|stablecoin|usdc|usdt|eth|btc|sol|bitcoin|ethereum|solana|base|aerodrome|uniswap|morpho|moonwell|aave|lido|ethena|pendle|curve|gauntlet|steakhouse|base chain|arbitrum|optimism|polygon|onchain|on-chain|wallet|swap|amm|perpetual|perp|liquid staking)\b/i;
+const TECH_RE = /\b(ai|llm|gpt|claude|anthropic|openai|gemini|machine learning|deep learning|neural|transformer|frontier model|agent|mcp|api|framework|library|sdk|github|repo|repository|startup|y combinator|yc|saas|vc|funding round|seed|series [a-d]|launches|launched|release|shipped|build|launch)\b/i;
+const ACADEMIC_RE = /\b(paper|research paper|arxiv|study|publication|preprint|peer.review|citation|abstract|methodology|hypothesis|empirical|experiment|finding[s]?|literature review|systematic review|meta.analysis|theorem|proof)\b/i;
+const FACTUAL_RE = /\b(history of|founded|established|definition|what is|who is|when did|where is|biography|encyclopedia|background|origin|first invented)\b/i;
+function detectDomains(query) {
+    const q = query.toLowerCase();
+    const domains = [];
+    if (CRYPTO_RE.test(q))
+        domains.push("crypto");
+    if (TECH_RE.test(q))
+        domains.push("tech");
+    if (ACADEMIC_RE.test(q))
+        domains.push("academic");
+    if (FACTUAL_RE.test(q))
+        domains.push("general");
+    return domains;
+}
+// ─── Formatting helpers ──────────────────────────────────────────────────────
+function formatUsd(n) {
+    if (typeof n !== "number" || !isFinite(n))
+        return "n/a";
+    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(2)}K`;
+    return `$${n.toFixed(2)}`;
+}
+function clipText(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+function ageInDays(iso) {
+    return Math.floor((Date.now() - new Date(iso).getTime()) / 86400000);
+}
+// ─── Crypto enrichment (DefiLlama + CoinGecko) ────────────────────────────────
+const DEFI_PROTOCOLS = [
+    "aerodrome", "uniswap", "morpho", "moonwell", "aave", "compound", "lido",
+    "rocket pool", "rocketpool", "ethena", "pendle", "curve", "balancer",
+    "convex", "frax", "spark", "fluid", "kamino", "marginfi", "jupiter",
+    "raydium", "orca", "drift", "gmx", "synthetix", "dydx", "vertex",
+    "hyperliquid", "yearn", "gauntlet", "steakhouse",
+];
+const CHAIN_KEYWORDS = [
+    "ethereum", "base", "arbitrum", "optimism", "polygon", "solana", "avalanche",
+    "blast", "sonic", "linea", "scroll", "zksync", "berachain", "monad",
+];
+const TOP_TOKENS = [
+    "btc", "bitcoin", "eth", "ethereum", "usdc", "usdt", "dai", "weth",
+    "sol", "solana", "matic", "avax", "link", "uni", "aave", "ldo",
+];
+async function cryptoEnrich(query) {
+    const q = query.toLowerCase();
+    const protocols = DEFI_PROTOCOLS.filter((p) => q.includes(p));
+    const chains = CHAIN_KEYWORDS.filter((c) => q.includes(c));
+    const tokens = TOP_TOKENS.filter((t) => new RegExp(`\\b${t}\\b`, "i").test(q));
+    const blocks = [];
+    // Protocol TVL
+    if (protocols.length > 0) {
+        try {
+            const slug = protocols[0].toLowerCase().replace(/\s+/g, "-");
+            const res = await fetch(`https://api.llama.fi/protocol/${slug}`, { signal: AbortSignal.timeout(8000) });
+            if (res.ok) {
+                const d = (await res.json());
+                if (d?.name) {
+                    const chainBreakdown = d.currentChainTvls
+                        ? Object.entries(d.currentChainTvls)
+                            .sort(([, a], [, b]) => b - a)
+                            .slice(0, 5)
+                            .map(([c, v]) => `${c}: ${formatUsd(v)}`)
+                            .join(" · ")
+                        : "";
+                    blocks.push([
+                        `### 📊 DefiLlama - ${d.name}`,
+                        `- TVL: **${formatUsd(d.tvl)}** | 24h: ${d.change_1d?.toFixed(2) ?? "n/a"}% | 7d: ${d.change_7d?.toFixed(2) ?? "n/a"}%`,
+                        d.mcap ? `- Market cap: ${formatUsd(d.mcap)}` : "",
+                        chainBreakdown ? `- Top chains: ${chainBreakdown}` : "",
+                        `- Source: https://defillama.com/protocol/${slug}`,
+                    ].filter(Boolean).join("\n"));
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // Yields
+    if (q.match(/\b(yield|vault|apy|lp)\b/)) {
+        try {
+            const res = await fetch("https://yields.llama.fi/pools", { signal: AbortSignal.timeout(8000) });
+            if (res.ok) {
+                const d = (await res.json());
+                let pools = (d?.data ?? []);
+                if (chains[0])
+                    pools = pools.filter((p) => (p.chain ?? "").toLowerCase() === chains[0]);
+                if (tokens[0])
+                    pools = pools.filter((p) => (p.symbol ?? "").toLowerCase().includes(tokens[0]));
+                pools = pools.filter((p) => (p.tvlUsd ?? 0) > 1000000 && (p.apy ?? 0) < 100);
+                pools = pools.sort((a, b) => (b.tvlUsd ?? 0) - (a.tvlUsd ?? 0)).slice(0, 8);
+                if (pools.length > 0) {
+                    const rows = pools.map((p) => `- **${p.project}** ${p.symbol} on ${p.chain}: ${(p.apy ?? 0).toFixed(2)}% APY · TVL ${formatUsd(p.tvlUsd)}`).join("\n");
+                    blocks.push(`### 💰 DefiLlama Yields (TVL > $1M)\n${rows}\n- Source: https://yields.llama.fi/`);
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // Prices
+    if (tokens.length > 0) {
+        try {
+            const idMap = {
+                btc: "bitcoin", eth: "ethereum", sol: "solana", matic: "matic-network",
+                usdc: "usd-coin", usdt: "tether", dai: "dai", weth: "weth",
+                avax: "avalanche-2", link: "chainlink", uni: "uniswap", aave: "aave",
+                ldo: "lido-dao",
+            };
+            const ids = tokens.map((t) => idMap[t.toLowerCase()] ?? t.toLowerCase()).join(",");
+            const res = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true`, { signal: AbortSignal.timeout(8000) });
+            if (res.ok) {
+                const d = (await res.json());
+                const rows = Object.entries(d).map(([id, p]) => {
+                    const change = typeof p.usd_24h_change === "number"
+                        ? ` (${p.usd_24h_change >= 0 ? "+" : ""}${p.usd_24h_change.toFixed(2)}% 24h)`
+                        : "";
+                    const mcap = p.usd_market_cap ? ` · mcap ${formatUsd(p.usd_market_cap)}` : "";
+                    return `- **${id}**: $${(p.usd ?? 0).toLocaleString()}${change}${mcap}`;
+                }).join("\n");
+                if (rows)
+                    blocks.push(`### 💵 CoinGecko\n${rows}\n- Source: https://www.coingecko.com/`);
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return blocks.length > 0 ? blocks.join("\n\n") : null;
+}
+// ─── Tech enrichment (HackerNews Algolia + GitHub search) ────────────────────
+async function techEnrich(query) {
+    const blocks = [];
+    // HackerNews - last 30 days, sorted by relevance + popularity
+    try {
+        const since = Math.floor((Date.now() - 30 * 86400000) / 1000);
+        const url = `https://hn.algolia.com/api/v1/search?query=${encodeURIComponent(query)}&numericFilters=created_at_i>${since}&hitsPerPage=8`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
+        if (res.ok) {
+            const d = (await res.json());
+            const hits = (d?.hits ?? []);
+            if (hits.length > 0) {
+                const rows = hits.slice(0, 6).map((h) => {
+                    const title = h.title ?? h.story_title ?? "(no title)";
+                    const points = h.points != null ? `${h.points} pts` : "";
+                    const comments = h.num_comments != null ? `${h.num_comments} comments` : "";
+                    const age = h.created_at ? `${ageInDays(h.created_at)}d ago` : "";
+                    const meta = [points, comments, age].filter(Boolean).join(" · ");
+                    const link = h.url ?? `https://news.ycombinator.com/item?id=${h.objectID}`;
+                    return `- **${clipText(title, 140)}** · ${meta}\n  ${link}`;
+                }).join("\n");
+                blocks.push(`### 📰 HackerNews (last 30d, top hits)\n${rows}\n- Source: https://hn.algolia.com/`);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    // GitHub search - public repos matching query
+    try {
+        const url = `https://api.github.com/search/repositories?q=${encodeURIComponent(query)}&sort=stars&order=desc&per_page=6`;
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(8000),
+            headers: { Accept: "application/vnd.github+json", "User-Agent": "finch-mcp" },
+        });
+        if (res.ok) {
+            const d = (await res.json());
+            const repos = (d?.items ?? []);
+            if (repos.length > 0) {
+                const rows = repos.slice(0, 5).map((r) => {
+                    const stars = r.stargazers_count?.toLocaleString() ?? "?";
+                    const desc = clipText(r.description ?? "", 100);
+                    return `- **${r.full_name}** (★${stars}) - ${desc}\n  ${r.html_url}`;
+                }).join("\n");
+                blocks.push(`### 🐙 GitHub (top repos by stars)\n${rows}\n- Source: https://github.com/search?q=${encodeURIComponent(query)}`);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return blocks.length > 0 ? blocks.join("\n\n") : null;
+}
+// ─── Academic enrichment (arXiv) ─────────────────────────────────────────────
+async function academicEnrich(query) {
+    try {
+        const url = `http://export.arxiv.org/api/query?search_query=all:${encodeURIComponent(query)}&start=0&max_results=5&sortBy=submittedDate&sortOrder=descending`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
+        if (!res.ok)
+            return null;
+        const xml = await res.text();
+        const entries = xml.match(/<entry>[\s\S]*?<\/entry>/g) ?? [];
+        if (entries.length === 0)
+            return null;
+        const rows = entries.slice(0, 5).map((e) => {
+            const title = (e.match(/<title>([\s\S]*?)<\/title>/)?.[1] ?? "").replace(/\s+/g, " ").trim();
+            const summary = (e.match(/<summary>([\s\S]*?)<\/summary>/)?.[1] ?? "").replace(/\s+/g, " ").trim();
+            const published = e.match(/<published>([\s\S]*?)<\/published>/)?.[1] ?? "";
+            const link = e.match(/<id>([\s\S]*?)<\/id>/)?.[1] ?? "";
+            const date = published ? `${published.slice(0, 10)} (${ageInDays(published)}d ago)` : "";
+            return `- **${clipText(title, 140)}** · ${date}\n  ${clipText(summary, 200)}\n  ${link}`;
+        }).join("\n\n");
+        return `### 📚 arXiv (recent papers)\n${rows}\n- Source: https://arxiv.org/`;
+    }
+    catch {
+        return null;
+    }
+}
+// ─── General enrichment (Wikipedia REST) ─────────────────────────────────────
+async function generalEnrich(query) {
+    try {
+        // Wikipedia search - find best matching article
+        const searchRes = await fetch(`https://en.wikipedia.org/w/api.php?action=opensearch&format=json&search=${encodeURIComponent(query)}&limit=3`, { signal: AbortSignal.timeout(6000) });
+        if (!searchRes.ok)
+            return null;
+        const [, titles, descs, urls] = (await searchRes.json());
+        if (!titles || titles.length === 0)
+            return null;
+        // Fetch summary for top hit
+        const top = titles[0];
+        const sumRes = await fetch(`https://en.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(top)}`, { signal: AbortSignal.timeout(6000) });
+        if (!sumRes.ok)
+            return null;
+        const summary = (await sumRes.json());
+        const lines = [
+            `### 🌐 Wikipedia - ${summary.title ?? top}`,
+            summary.extract ? clipText(summary.extract, 600) : descs[0] ?? "",
+            `- Source: ${urls[0] ?? `https://en.wikipedia.org/wiki/${encodeURIComponent(top)}`}`,
+        ];
+        return lines.filter(Boolean).join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Public entry point ──────────────────────────────────────────────────────
+/**
+ * Run enrichment in parallel for all detected domains. Pure best-effort: if
+ * no domain matches or all APIs fail, returns hasData=false and synthesis
+ * runs normally.
+ */
+async function enrichQuery(query) {
+    const domains = detectDomains(query);
+    if (domains.length === 0) {
+        return { context: "", authoritative: [], hasData: false, domains: [] };
+    }
+    const promises = [];
+    if (domains.includes("crypto"))
+        promises.push(cryptoEnrich(query));
+    if (domains.includes("tech"))
+        promises.push(techEnrich(query));
+    if (domains.includes("academic"))
+        promises.push(academicEnrich(query));
+    if (domains.includes("general"))
+        promises.push(generalEnrich(query));
+    const results = await Promise.all(promises);
+    const blocks = results.filter((b) => !!b);
+    if (blocks.length === 0) {
+        return { context: "", authoritative: [], hasData: false, domains };
+    }
+    const authoritative = [];
+    if (domains.includes("crypto"))
+        authoritative.push("defillama.com", "coingecko.com");
+    if (domains.includes("tech"))
+        authoritative.push("news.ycombinator.com", "github.com");
+    if (domains.includes("academic"))
+        authoritative.push("arxiv.org");
+    if (domains.includes("general"))
+        authoritative.push("wikipedia.org");
+    const todayISO = new Date().toISOString().slice(0, 10);
+    const context = [
+        `---`,
+        `## 🔒 AUTHORITATIVE LIVE DATA - fetched ${todayISO}`,
+        ``,
+        `The blocks below come from primary-source APIs called at query time. Treat as ground truth. When figures here conflict with the scraped sources below, prefer these and cite them by source name (e.g. \`[DefiLlama]\`, \`[HackerNews]\`, \`[arXiv]\`, \`[GitHub]\`, \`[Wikipedia]\`).`,
+        ``,
+        blocks.join("\n\n"),
+        `---`,
+    ].join("\n");
+    return { context, authoritative, hasData: true, domains };
+}
+/**
+ * Returns the current date in ISO format. Used by the synthesis prompt to
+ * anchor the LLM in time - prevents "Q2 2026 catalysts in July" style
+ * calendar hallucinations.
+ */
+function todayContext() {
+    const now = new Date();
+    const iso = now.toISOString().slice(0, 10);
+    const weekday = now.toLocaleDateString("en-US", { weekday: "long" });
+    const quarter = `Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
+    return `Today is ${weekday}, ${iso}. This is ${quarter} ${now.getUTCFullYear()}. Treat any date after today as a future/projected event, not a confirmed one.`;
+}