@keelage/mcp 0.1.1

package/lib/x-meta.mjs

@@ -0,0 +1,214 @@
+// x-meta.mjs - what X is saying about a token, as CONTEXT on a verdict.
+//
+// Display only. Never a gate, never a rank key. This module states MEASURED facts: posts and accounts
+// in the last 24h, how much of it is copy-paste, which large profiles posted and whether their post is
+// even about this chain's token, the views, and one model-written line on what the chatter is about.
+//
+// Sources: SocialData (SOCIALDATA_API_KEY) for the posts; xAI grok-4-fast without tools (XAI_API_KEY) for
+// the one-line gist over the posts already fetched. No key = that half is null; the card still renders.
+// Cache: <state>/x-meta-cache.json per token, X_META_TTL_H (6h); failures are never cached.
+// Import-safe: no network at import, no top-level await, no argv reads.
+import { io } from './io.mjs';
+import { statePath } from './state.mjs';
+
+export const X_META_TTL_H = Number(process.env.X_META_TTL_H || 6);
+export const BIG_FOLLOWERS = Number(process.env.X_META_BIG_FOLLOWERS || 10_000); // "large profile" bar
+const SD_BASE = 'https://api.socialdata.tools';
+const PAGES_MAX = 3;          // 3 x ~20 posts covers a 24h window on a memecoin cashtag
+const WINDOW_H = 24;
+const GIST_POSTS = 25;        // posts handed to the model for the gist
+const BIG_SHOWN = 3;          // large profiles named on the card
+const CASHTAG_RE = /^[A-Za-z0-9]{2,15}$/;        // a symbol X indexes as a cashtag
+const NAME_RE = /^[\p{L}\p{N}]{1,15}$/u;           // letters/digits in any script: searchable as a word plus the chain
+const CHAIN_WORD = { robinhood: 'robinhood', solana: 'solana', bsc: 'bnb', ethereum: 'ethereum', base: 'base' };
+const CHAIN_WORDS = {
+  robinhood: /\b(robinhood|rh chain|on rh|\$hood|hood chain|robinhood chain)\b/i,
+  solana: /\b(solana|sol|pump\.?fun|pumpswap|raydium|jupiter)\b/i,
+  bsc: /\b(bsc|bnb|binance smart chain|pancakeswap|four\.meme)\b/i,
+  ethereum: /\b(ethereum|eth mainnet|uniswap on eth)\b/i,
+  base: /\b(on base|base chain|basechain)\b/i,
+};
+const SOL_MINT_IN_TEXT = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/;
+const EVM_ADDR_IN_TEXT = /\b0x[0-9a-fA-F]{40}\b/;
+
+// How to search X for a symbol: an ASCII symbol is a cashtag ($NAME); a non-Latin symbol is searched as
+// the word plus the chain; an emoji or empty symbol is unsearchable. Returns {query, mode} or null.
+export function queryFor(symbol, chain) {
+  const sym = String(symbol || '').replace(/^\$/, '').trim();
+  if (CASHTAG_RE.test(sym)) return { query: '$' + sym, mode: 'cashtag' };
+  if (NAME_RE.test(sym)) return { query: `${sym} ${CHAIN_WORD[chain] || chain || ''}`.trim(), mode: 'name+chain' };
+  return null;
+}
+
+const keyOf = (c) => `${c.chain}:${String(c.address || '').toLowerCase()}`;
+const readCache = () => { try { return JSON.parse(io.read(statePath('x-meta-cache.json'))); } catch { return {}; } };
+const writeCache = (v) => { try { io.write(statePath('x-meta-cache.json'), JSON.stringify(v, null, 1)); } catch {} };
+const normText = (s) => String(s || '').toLowerCase().replace(/https?:\/\/\S+/g, '').replace(/\s+/g, ' ').trim().slice(0, 80);
+
+// Which chain a post is talking about, from its own words: a mint or contract in the text beats chain
+// words. Returns the chain name, or null when the post names none (most posts). `ours` is the token's chain.
+export function postChain(text, ours) {
+  const t = String(text || '');
+  if (SOL_MINT_IN_TEXT.test(t.replace(/\$\w+/g, ''))) return 'solana';
+  if (EVM_ADDR_IN_TEXT.test(t)) return ours === 'robinhood' || ours === 'base' || ours === 'ethereum' || ours === 'bsc' ? ours : 'evm';
+  for (const [chain, re] of Object.entries(CHAIN_WORDS)) if (re.test(t)) return chain;
+  return null;
+}
+
+// Pure: turn a SocialData tweet list into the card's facts.
+export function summariseTweets(tweets, { symbol, chain, now = Date.now() } = {}) {
+  const since = now - WINDOW_H * 3600_000;
+  const rows = (Array.isArray(tweets) ? tweets : []).filter((t) => {
+    const ts = Date.parse(t.tweet_created_at || t.created_at || '');
+    return Number.isFinite(ts) && ts >= since && ts <= now + 300_000;
+  });
+  const originals = rows.filter((t) => !t.retweeted_status);
+  const byAuthor = new Map();
+  const textCount = new Map();
+  let views = 0, likes = 0, replies = 0, chainHits = 0, otherChainHits = 0;
+  for (const t of originals) {
+    const u = t.user || {};
+    const a = u.screen_name || '?';
+    const text = t.full_text || t.text || '';
+    const pc = postChain(text, chain);
+    const d = byAuthor.get(a) || { handle: a, followers: Number(u.followers_count) || 0, verified: !!u.verified, posts: 0, views: 0, chains: new Set(), sample: '' };
+    d.posts++; d.views += Number(t.views_count) || 0; if (pc) d.chains.add(pc); if (!d.sample) d.sample = text.replace(/\s+/g, ' ').slice(0, 140);
+    byAuthor.set(a, d);
+    views += Number(t.views_count) || 0;
+    likes += Number(t.favorite_count) || 0;
+    replies += Number(t.reply_count) || 0;
+    if (pc === chain) chainHits++; else if (pc) otherChainHits++;
+    const n = normText(text); textCount.set(n, (textCount.get(n) || 0) + 1);
+  }
+  const posts24 = originals.length;
+  const authors = [...byAuthor.values()];
+  const top = authors.slice().sort((a, b) => b.posts - a.posts)[0] || null;
+  // Copy-paste share: posts whose link-stripped, 80-char text appears more than once, i.e. a template being pushed.
+  const copyPaste = [...textCount.values()].filter((c) => c > 1).reduce((s, c) => s + c, 0);
+  const copyPasteShare = posts24 ? Math.round((copyPaste / posts24) * 100) : null;
+  const followers = authors.map((a) => a.followers).sort((a, b) => a - b);
+  const bigAccounts = authors.filter((a) => a.followers >= BIG_FOLLOWERS).sort((a, b) => b.followers - a.followers)
+    .map((a) => ({ handle: a.handle, followers: a.followers, posts: a.posts, views: a.views, verified: a.verified,
+      otherChain: [...a.chains].find((x) => x !== chain) || null, sample: a.sample }));
+  const forGist = originals.slice()
+    .sort((a, b) => ((postChain(b.full_text || '', chain) === chain) - (postChain(a.full_text || '', chain) === chain))
+      || ((Number(b.user?.followers_count) || 0) - (Number(a.user?.followers_count) || 0)))
+    .slice(0, GIST_POSTS)
+    .map((t) => `[@${t.user?.screen_name || '?'} ${Number(t.user?.followers_count) || 0} followers] ${String(t.full_text || t.text || '').replace(/\s+/g, ' ').slice(0, 220)}`);
+  return {
+    symbol, chain, posts24, rts24: rows.length - originals.length, accounts24: byAuthor.size,
+    topAccount: top ? top.handle : null, topShare: top && posts24 ? Math.round((top.posts / posts24) * 100) : null,
+    views24: views, likes24: likes, replies24: replies,
+    chainMentions: chainHits,            // posts that name THIS chain (or carry its contract)
+    otherChainMentions: otherChainHits,  // posts that name a different chain: the same cashtag elsewhere
+    copyPasteShare,                       // % of posts that are a repeated template
+    accountsBig: bigAccounts.length, bigAccounts, medianFollowers: followers.length ? followers[Math.floor(followers.length / 2)] : null,
+    sample: forGist,
+  };
+}
+
+// Measured tone word from the copy-paste share. Not an opinion: 40%+ of posts being one template is a campaign.
+export function toneOf(s) {
+  if (!s || s.posts24 == null || s.posts24 < 4 || s.copyPasteShare == null) return null;
+  return s.copyPasteShare >= 40 ? 'campaign' : s.copyPasteShare < 20 ? 'organic' : 'mixed';
+}
+
+async function fetchTweets(query, key, log) {
+  const out = [];
+  let cursor = null;
+  for (let p = 0; p < PAGES_MAX; p++) {
+    const url = `${SD_BASE}/twitter/search?query=${encodeURIComponent(query)}&type=Latest${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ''}`;
+    const r = await fetch(url, { headers: { Authorization: `Bearer ${key}`, Accept: 'application/json' }, signal: AbortSignal.timeout(15_000) });
+    if (!r.ok) { log(`[x-meta] socialdata ${r.status} for "${query}"`); return out.length ? out : null; }
+    const j = await r.json();
+    const tw = Array.isArray(j.tweets) ? j.tweets : [];
+    out.push(...tw);
+    const oldest = tw.length ? Math.min(...tw.map((t) => Date.parse(t.tweet_created_at || t.created_at || '') || Infinity)) : Infinity;
+    cursor = j.next_cursor || null;
+    if (!cursor || !tw.length || oldest < Date.now() - WINDOW_H * 3600_000) break;
+  }
+  return out;
+}
+
+// One line on what the chatter is about, from the posts already fetched. The measured facts go in so the
+// line explains them (which big account said what, whether the campaign is a listing vote or a raid).
+export async function gistFor(summary, key, log) {
+  if (!key || !summary || !summary.sample.length) return null;
+  try {
+    const facts = `${summary.posts24} posts from ${summary.accounts24} accounts in 24h; ${summary.copyPasteShare ?? '?'}% are a repeated template; ${summary.accountsBig} account(s) with ${BIG_FOLLOWERS.toLocaleString('en-US')}+ followers${summary.bigAccounts.length ? ` (${summary.bigAccounts.slice(0, 5).map((b) => `@${b.handle} ${b.followers.toLocaleString('en-US')}${b.otherChain ? ` - posting about the ${b.otherChain} token` : ''}`).join(', ')})` : ''}; ${summary.chainMentions} name ${summary.chain}, ${summary.otherChainMentions} name another chain.`;
+    const r = await fetch('https://api.x.ai/v1/responses', {
+      method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${key}` },
+      body: JSON.stringify({
+        model: 'grok-4-fast',
+        input: `${/^[A-Za-z0-9]+$/.test(summary.symbol) ? `Cashtag $${summary.symbol}` : `Token "${summary.symbol}" (searched by name + chain, not as a cashtag - unrelated uses of the word may appear)`}, a memecoin on the ${summary.chain} chain (the same cashtag may exist on other chains - posts carrying a Solana mint or naming another chain are NOT about this coin).\nMeasured: ${facts}\n\nLast-24h posts (author, followers, text):\n`
+          + summary.sample.map((s, i) => `${i + 1}. ${s}`).join('\n')
+          + `\n\nReply ONLY with JSON: {"meta": "<max 100 chars, plain words: the narrative / catalyst / campaign the ${summary.chain} posts are pushing, or 'no clear meta'>", "chain": "<${summary.chain}|other|mixed|unclear - which chain's token MOST posts are about>", "big": "<max 80 chars: what the largest accounts actually said about THIS coin, or 'none about this coin'>"}`,
+      }),
+      signal: AbortSignal.timeout(25_000),
+    });
+    const j = await r.json();
+    const txt = (j.output || []).filter((o) => o.type === 'message').flatMap((o) => (o.content || []).map((x) => x.text || '')).join(' ');
+    const m = /\{[\s\S]*\}/.exec(txt);
+    if (!m) return null;
+    const g = JSON.parse(m[0]);
+    return { meta: String(g.meta || '').slice(0, 120), chain: String(g.chain || 'unclear').slice(0, 12), big: String(g.big || '').slice(0, 100) };
+  } catch (e) { log(`[x-meta] gist ${summary.symbol}: ${e.message}`); return null; }
+}
+
+// The fresh cache entry for a token, or null.
+export function cachedMeta(c) {
+  const hit = readCache()[keyOf(c)];
+  return hit && hit.v === 2 && Date.now() - Date.parse(hit.at || 0) < X_META_TTL_H * 3600_000 ? hit : null;
+}
+
+// The X facts for one token, cached X_META_TTL_H. null when there is no key; a note when the symbol is unsearchable.
+export async function xMeta(c, { log = console.error, force = false } = {}) {
+  const sdKey = process.env.SOCIALDATA_API_KEY;
+  if (!sdKey) return null;
+  const symbol = String(c.symbol || '').replace(/^\$/, '').trim();
+  const q = queryFor(symbol, c.chain);
+  if (!q) return { symbol, posts24: null, note: symbol ? `symbol "${symbol}" is not a searchable cashtag` : 'no symbol to search' };
+  const key = keyOf(c);
+  const cache = readCache();
+  const hit = cache[key];
+  if (!force && hit && hit.v === 2 && Date.now() - Date.parse(hit.at || 0) < X_META_TTL_H * 3600_000) return hit;
+  let tweets;
+  try { tweets = await fetchTweets(q.query, sdKey, log); } catch (e) { log(`[x-meta] "${q.query}": ${e.message}`); return hit || null; }
+  if (tweets === null) return hit || null; // provider error: never cached, keep the stale read if any
+  const s = summariseTweets(tweets, { symbol, chain: c.chain });
+  const gist = await gistFor(s, process.env.XAI_API_KEY, log);
+  const out = {
+    v: 2, at: new Date().toISOString(), source: 'socialdata', symbol, chain: c.chain, query: q.query, queryMode: q.mode,
+    posts24: s.posts24, rts24: s.rts24, accounts24: s.accounts24, topAccount: s.topAccount, topShare: s.topShare,
+    views24: s.views24, likes24: s.likes24, replies24: s.replies24, chainMentions: s.chainMentions, otherChainMentions: s.otherChainMentions,
+    copyPasteShare: s.copyPasteShare, tone: toneOf(s), accountsBig: s.accountsBig, medianFollowers: s.medianFollowers,
+    bigAccounts: s.bigAccounts.slice(0, 8).map(({ sample, ...b }) => b),
+    meta: gist ? gist.meta : null, metaChain: gist ? gist.chain : null, big: gist ? gist.big : null,
+  };
+  const fresh = readCache(); fresh[key] = out; writeCache(fresh);
+  return out;
+}
+
+const kFollowers = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+
+// The card lines. Pure; `esc` is an optional output escaper (identity for plain text).
+//   X 24h: 60 posts | 47 accounts (3 with 10k+) | 8k views | 65% copy-paste (campaign) | 21 name robinhood, 4 another chain
+//   big: @handle 32k (solana), @handle 28k
+//   meta: listing-vote campaign
+export function xLine(x, esc = (s) => String(s ?? '')) {
+  if (!x) return null;
+  if (x.posts24 == null) return x.note ? `X: ${esc(x.note)}` : null;
+  const k = kFollowers;
+  const parts = [`X 24h${x.queryMode === 'name+chain' ? ` (searched "${esc(x.query)}")` : ''}: ${x.posts24} posts`];
+  if (x.accounts24 != null) parts.push(`${x.accounts24} accounts${x.accountsBig ? ` (${x.accountsBig} with ${kFollowers(BIG_FOLLOWERS)}+)` : ''}${x.topShare != null && x.posts24 >= 4 && x.topShare >= 40 ? ` (one posts ${x.topShare}%)` : ''}`);
+  if (x.views24) parts.push(`${k(x.views24)} views`);
+  if (x.copyPasteShare != null && x.posts24 >= 4) parts.push(`${x.copyPasteShare}% copy-paste${x.tone ? ` (${x.tone})` : ''}`);
+  if (x.chainMentions != null && x.posts24) parts.push(`${x.chainMentions} name ${x.chain}${x.otherChainMentions ? `, ${x.otherChainMentions} another chain` : ''}`);
+  const lines = [parts.join(' | ')];
+  if (x.bigAccounts && x.bigAccounts.length) {
+    lines.push(`big: ${x.bigAccounts.slice(0, BIG_SHOWN).map((b) => `@${esc(b.handle)} ${kFollowers(b.followers)}${b.otherChain ? ` (${esc(b.otherChain)})` : ''}${b.posts > 1 ? ` x${b.posts}` : ''}`).join(', ')}${x.bigAccounts.length > BIG_SHOWN ? ` +${x.bigAccounts.length - BIG_SHOWN} more` : ''}${x.big && !/^none/i.test(x.big) ? ` - ${esc(x.big)}` : ''}`);
+  }
+  if (x.meta) lines.push(`meta: ${esc(x.meta)}${x.metaChain && x.metaChain !== x.chain && x.metaChain !== 'unclear' ? ` (most posts read as ${esc(x.metaChain)}-chain)` : ''}`);
+  else if (x.posts24 === 0) lines[0] += ' - quiet';
+  return lines.join('\n');
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@keelage/mcp",
+  "version": "0.1.1",
+  "description": "Token intelligence for Robinhood Chain, as an MCP server. Structural verdicts, holder maps, launcher templates and a published track record. Research only, not financial advice.",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://keelage.ai",
+  "bin": {
+    "keelage": "bin/keelage.mjs"
+  },
+  "exports": {
+    ".": "./lib/gate.mjs",
+    "./render": "./lib/render.mjs",
+    "./holders": "./lib/holders.mjs",
+    "./template": "./lib/template.mjs",
+    "./record": "./lib/record.mjs",
+    "./server": "./server/mcp.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "server",
+    "data",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/keelage.mjs",
+    "test": "node test/pure.mjs",
+    "test:live": "node test/reference.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "mcp",
+    "robinhood-chain",
+    "token",
+    "research",
+    "model-context-protocol"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/server/core.mjs

@@ -0,0 +1,114 @@
+// core.mjs - the Model Context Protocol server, transport-free. No dependencies.
+//
+// Transport: newline-delimited JSON-RPC 2.0 on stdin/stdout. Logs go to stderr only; stdout carries protocol
+// frames and nothing else. Read-only: no wallet, no key, nothing here can spend.
+import { scanOne } from '../lib/gate.mjs';
+import { renderScanJson } from '../lib/render.mjs';
+import { holdersFor } from '../lib/holders.mjs';
+import { templateFor } from '../lib/template.mjs';
+import { trackRecord } from '../lib/record.mjs';
+import { knownRulesets, THRESHOLDS } from '../lib/calc.mjs';
+
+export const SERVER_INFO = { name: 'keelage', title: 'Keelage', version: '0.1.0' };
+const SUPPORTED = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
+const ADDRESS_SCHEMA = { type: 'string', description: 'Token contract address on Robinhood Chain (0x + 40 hex characters).', pattern: '^0x[0-9a-fA-F]{40}$' };
+// The ruleset the verdict is computed under: a preset by name, or the default with some lines replaced.
+const RULESET_SCHEMA = {
+  description: `Which ruleset the verdict is computed under. A preset name (${knownRulesets().join(', ')}; "default" is short for keelage-default), or { lines: [{ key, value }] } to replace lines of keelage-default. Keys are the ones in keelage_record's rules: ${THRESHOLDS.lines.map((l) => l.key).join(', ')}. The facts never change; only the policy over them does. Omitted: keelage-default.`,
+  oneOf: [
+    { type: 'string', enum: [...knownRulesets(), 'default'] },
+    {
+      type: 'object',
+      properties: { lines: { type: 'array', minItems: 1, items: { type: 'object', properties: { key: { type: 'string' }, value: { description: 'A number, or for a band line an array of numbers of the same length as the default.' } }, required: ['key', 'value'] } } },
+      required: ['lines'],
+    },
+  ],
+};
+
+export const TOOLS = [
+  {
+    name: 'keelage_scan',
+    title: 'Scan a token',
+    description: 'Full structural verdict for one Robinhood Chain token: verified source, launcher template, owner privileges, transfer-tax code, honeypot flags, sells clearing, holder concentration tier, ATH drawdown and 30-day-low band, entry test and size rule, plus Jev probabilities as context when TYPESAFE_API_KEY is set. Four verdict states: ELIGIBLE, NOT_ELIGIBLE, FAIL, UNVERIFIED, computed under a named, dated ruleset (the optional ruleset argument; the answer names it under verdict.ruleset) and marked beta; the facts themselves are measured from the chain and timestamped. Research only, not financial advice.',
+    inputSchema: { type: 'object', properties: { address: ADDRESS_SCHEMA, ruleset: RULESET_SCHEMA }, required: ['address'] },
+    annotations: { readOnlyHint: true, openWorldHint: true, idempotentHint: true },
+  },
+  {
+    name: 'keelage_holders',
+    title: 'Holder map',
+    description: 'Top wallets for one token with pools, contracts and burn addresses labeled, top-10 share excluding pools and contracts, burn share, and the share held by EIP-7702 smart accounts (how the Robinhood app wallet reads).',
+    inputSchema: { type: 'object', properties: { address: ADDRESS_SCHEMA, smartAccounts: { type: 'boolean', description: 'Check each listed wallet for EIP-7702 delegation (one RPC call per wallet). Default true.' } }, required: ['address'] },
+    annotations: { readOnlyHint: true, openWorldHint: true, idempotentHint: true },
+  },
+  {
+    name: 'keelage_template',
+    title: 'Launcher template',
+    description: 'Which launcher template a contract came from (Pons, LaunchToken, Doppler, UERC20, tokenized stock, or unregistered), with the template verdict, the ABI privileges and the transfer-tax identifier count read from verified source.',
+    inputSchema: { type: 'object', properties: { address: ADDRESS_SCHEMA }, required: ['address'] },
+    annotations: { readOnlyHint: true, openWorldHint: true, idempotentHint: true },
+  },
+  {
+    name: 'keelage_record',
+    title: 'Track record',
+    description: 'The published track record behind the verdicts: dated studies with sample sizes (gate policy outcomes, template census, base-band outcomes, probability calibration). Optionally one study by key.',
+    inputSchema: { type: 'object', properties: { study: { type: 'string', description: 'Study key, e.g. gate-policy-review, template-census, base-band-outcomes, jev-halve-calibration. Omit for all.' } } },
+    annotations: { readOnlyHint: true, openWorldHint: false, idempotentHint: true },
+  },
+];
+
+export async function callTool(name, args = {}) {
+  switch (name) {
+    case 'keelage_scan': return renderScanJson(await scanOne(args.address, { log: (...a) => console.error(...a), ruleset: args.ruleset ?? 'default' }));
+    case 'keelage_holders': return holdersFor(args.address, { withSmartAccounts: args.smartAccounts !== false });
+    case 'keelage_template': return templateFor(args.address);
+    case 'keelage_record': return trackRecord({ study: args.study || null });
+    default: throw Object.assign(new Error(`unknown tool ${name}`), { code: -32602 });
+  }
+}
+
+// Prices per call in USDG on Robinhood Chain, as published on keelage.ai/#pricing. Free tools are never counted.
+export const TOOL_PRICES = { keelage_scan: '0.05', keelage_holders: '0.03' };
+export const FREE_TOOLS = ['keelage_record', 'keelage_template'];
+export const FREE_CALLS_PER_DAY = 20;
+export { SUPPORTED };
+
+const ok = (id, result) => ({ jsonrpc: '2.0', id, result });
+const err = (id, code, message, data) => ({ jsonrpc: '2.0', id, error: { code, message, ...(data ? { data } : {}) } });
+
+// One JSON-RPC message in, one response object out (undefined for a notification). Transports write it.
+export async function dispatch(msg) {
+  const { id, method, params = {} } = msg;
+  const isNotification = id === undefined || id === null;
+  try {
+    switch (method) {
+      case 'initialize': {
+        const asked = String(params.protocolVersion || '');
+        const protocolVersion = SUPPORTED.includes(asked) ? asked : SUPPORTED[0];
+        return ok(id, { protocolVersion, capabilities: { tools: { listChanged: false } }, serverInfo: SERVER_INFO,
+          instructions: 'Keelage reads Robinhood Chain tokens from the chain and answers with a structural verdict, a holder map, a launcher template and the published track record. Every answer is research only, not financial advice. Unknown facts are null, never zero.' });
+      }
+      case 'notifications/initialized': return;
+      case 'notifications/cancelled': return;
+      case 'ping': return ok(id, {});
+      case 'tools/list': return ok(id, { tools: TOOLS });
+      case 'tools/call': {
+        const name = params.name, args = params.arguments || {};
+        if (!TOOLS.some((t) => t.name === name)) return err(id, -32602, `unknown tool ${name}`);
+        try {
+          const result = await callTool(name, args);
+          return ok(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], structuredContent: result, isError: result && result.ok === false });
+        } catch (e) {
+          return ok(id, { content: [{ type: 'text', text: `error: ${e.message}` }], isError: true });
+        }
+      }
+      case 'resources/list': return ok(id, { resources: [] });
+      case 'prompts/list': return ok(id, { prompts: [] });
+      default:
+        if (isNotification) return;
+        return err(id, -32601, `method not found: ${method}`);
+    }
+  } catch (e) {
+    if (!isNotification) return err(id, -32603, e.message);
+  }
+}
+

package/server/hosted-io.mjs

@@ -0,0 +1,9 @@
+// hosted-io.mjs - storage for a bundled, filesystem-free runtime (the hosted server on Cloudflare Pages).
+// Import this module FIRST: it installs the in-memory store before calc.mjs reads thresholds.json at load.
+// The data files are embedded at bundle time; caches live in memory for the life of the isolate.
+import { setIO, memoryIO } from '../lib/io.mjs';
+import thresholds from '../data/thresholds.json' with { type: 'json' };
+import trackRecord from '../data/track-record.json' with { type: 'json' };
+import templates from '../lib/templates.json' with { type: 'json' };
+
+setIO(memoryIO({ 'data/thresholds.json': thresholds, 'data/track-record.json': trackRecord, 'lib/templates.json': templates }));

package/server/mcp.mjs

@@ -0,0 +1,25 @@
+// mcp.mjs - the Model Context Protocol server over stdio. No dependencies.
+// Transport: newline-delimited JSON-RPC 2.0 on stdin/stdout. Logs go to stderr only; stdout carries protocol
+// messages and nothing else. The protocol itself lives in core.mjs and is shared with the hosted server.
+import { createInterface } from 'readline';
+import { dispatch } from './core.mjs';
+export { SERVER_INFO, TOOLS, callTool, dispatch, TOOL_PRICES, FREE_TOOLS, FREE_CALLS_PER_DAY } from './core.mjs';
+
+export async function handle(msg) {
+  const out = await dispatch(msg);
+  if (out !== undefined) process.stdout.write(JSON.stringify(out) + '\n');
+}
+
+export function serve() {
+  const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  rl.on('line', (line) => {
+    const s = line.trim();
+    if (!s) return;
+    let msg;
+    try { msg = JSON.parse(s); } catch { return fail(null, -32700, 'parse error'); }
+    if (Array.isArray(msg)) { for (const m of msg) handle(m); return; }
+    handle(msg);
+  });
+  rl.on('close', () => process.exit(0));
+  process.stdin.on('end', () => process.exit(0));
+}