@coinrithm/mcp-trading 0.7.4 → 0.7.6

package/dist/agent/runner.js

@@ -14,9 +14,10 @@ import { validateAction } from "./decisionValidator.js";
 import { resolvePmRef } from "./resolvePm.js";
 import { fetchQuote, executeAction } from "./act.js";
 import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
-import { rollDay, checkKillSwitch, accrueRealized, saveState, } from "./state.js";
+import { rollDay, checkKillSwitch, accrueRealized, saveState, isPermanentModelError, isAuthFailureSkip, PERMANENT_MODEL_ERROR_THRESHOLD, AUTH_FAILURE_THRESHOLD, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
 import { parseCadenceMs, sleep } from "./util.js";
+import { buildObservationReceipt } from "./observationReceipt.js";
 // Independent-forecast kill-switch. Default ON: the fleet elicits + submits its
 // OWN forecastProbability on PM opens. Set HOUSE_AGENT_FORECAST_ENABLED to
 // "false"/"0"/"no"/"off" to ship pm/open requests WITHOUT the field, byte-identical
@@ -371,6 +372,10 @@ export async function runCycle(deps) {
     // OBSERVE
     const obs = await observe(client, spec, state, baseTrace);
     const observation = obs.observation;
+    const observationReceipt = buildObservationReceipt(observation);
+    // Reads build the observation, so its hash cannot exist before they finish.
+    // From this point every durable write carries the exact decision-input receipt.
+    Object.assign(baseTrace, observationReceipt);
     accrueRealized(state, observation.newClosedTrades);
     state.cursor = observation.syncCursor;
     for (const t of observation.newClosedTrades) {
@@ -419,14 +424,46 @@ export async function runCycle(deps) {
             disabled: true,
             disabledReason: state.disabledReason,
             live,
+            ...observationReceipt,
         };
     }
     if (obs.skip) {
         state.consecutiveRejectCycles += 1;
+        // Permanent-failure classification: a revoked/invalid CoinRithm key
+        // answers 401 deterministically — after the threshold, disable with the
+        // machine-readable 'key_invalid' prefix the scheduler's self-heal exempts
+        // (the old path revived such agents into ~1,500 guaranteed-dead
+        // cycles/day). A transient rotation blip stays under the threshold.
+        if (isAuthFailureSkip(obs.skip)) {
+            state.consecutiveAuthFailures = (state.consecutiveAuthFailures ?? 0) + 1;
+            if (state.consecutiveAuthFailures >= AUTH_FAILURE_THRESHOLD) {
+                state.disabled = true;
+                state.disabledReason = `key_invalid: CoinRithm key rejected (HTTP 401) on ${state.consecutiveAuthFailures} consecutive cycles`;
+                saveState(stateFile, state);
+                log(`disabled: ${state.disabledReason}`);
+                return {
+                    decision: "skip",
+                    skipReason: obs.skip,
+                    planned: [],
+                    disabled: true,
+                    disabledReason: state.disabledReason,
+                    live,
+                    ...observationReceipt,
+                };
+            }
+        }
         saveState(stateFile, state);
         log(`skip: ${obs.skip}`);
-        return { decision: "skip", skipReason: obs.skip, planned: [], live };
+        return {
+            decision: "skip",
+            skipReason: obs.skip,
+            planned: [],
+            live,
+            ...observationReceipt,
+        };
     }
+    // A full observation implies /me succeeded — the auth-failure streak is over.
+    state.consecutiveAuthFailures = 0;
     // GATE (slice 2): only SPEND an LLM call when a deterministic trigger fires — a
     // flagged entry setup or an open position to manage. No trigger => a cheap
     // heartbeat (zero tokens). A heartbeat is neither a model reject nor a failure,
@@ -451,6 +488,7 @@ export async function runCycle(deps) {
             estimatedCostUsd: 0,
             writeAttempted: 0,
             writeAccepted: 0,
+            ...observationReceipt,
         };
     }
     // DECIDE. Two paths share the same downstream validate+act loop:
@@ -507,6 +545,40 @@ export async function runCycle(deps) {
         };
         if (!res.ok) {
             state.consecutiveModelFailures += 1;
+            // Permanent-failure classification: a 404/model_not_found is a
+            // DECOMMISSIONED or misconfigured model that will fail every cycle
+            // forever (live-measured: 93% of one agent's cycles for days, revived
+            // 7x in 3h). Three consecutive occurrences rules out a routing fluke;
+            // then disable with the 'model_unavailable' prefix the scheduler's
+            // self-heal exempts. Transient errors reset the permanent streak.
+            if (isPermanentModelError(res.error)) {
+                state.consecutivePermanentModelErrors =
+                    (state.consecutivePermanentModelErrors ?? 0) + 1;
+                if (state.consecutivePermanentModelErrors >=
+                    PERMANENT_MODEL_ERROR_THRESHOLD) {
+                    state.disabled = true;
+                    state.disabledReason = `model_unavailable: ${res.error.slice(0, 160)}`;
+                    saveState(stateFile, state);
+                    log(`disabled: ${state.disabledReason}`);
+                    return {
+                        decision: "skip",
+                        skipReason: `model error: ${res.error}`,
+                        planned: [],
+                        modelFailed: true,
+                        disabled: true,
+                        disabledReason: state.disabledReason,
+                        live,
+                        ...meter,
+                        decisionType: "model_error",
+                        writeAttempted: 0,
+                        writeAccepted: 0,
+                        ...observationReceipt,
+                    };
+                }
+            }
+            else {
+                state.consecutivePermanentModelErrors = 0;
+            }
             saveState(stateFile, state);
             log(`model error: ${res.error}`);
             return {
@@ -519,6 +591,7 @@ export async function runCycle(deps) {
                 decisionType: "model_error",
                 writeAttempted: 0,
                 writeAccepted: 0,
+                ...observationReceipt,
             };
         }
         const parsed = parseDecision(res.text);
@@ -539,9 +612,11 @@ export async function runCycle(deps) {
                 decisionType: "model_error",
                 writeAttempted: 0,
                 writeAccepted: 0,
+                ...observationReceipt,
             };
         }
         state.consecutiveModelFailures = 0;
+        state.consecutivePermanentModelErrors = 0;
         decision = parsed.decision;
     }
     // Reasoning captured for the Arena terminal (keystone transparency): the
@@ -578,6 +653,7 @@ export async function runCycle(deps) {
             writeAttempted: decision.actions.length,
             writeAccepted: 0,
             ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+            ...observationReceipt,
         };
     }
     // VALIDATE (+ ACT when live). Quote evidence is fetched by the runner.
@@ -778,13 +854,16 @@ export async function runCycle(deps) {
         const seq = state.intentSeq[intentKey] ?? 0;
         const idem = `${runId}:${intentKey}:${seq}`;
         const meta = action;
-        const trace = makeTrace(runId, decisionId, spec, meta.confidence ?? decision.confidence, 
-        // The trade's "why" on the Arena live floor. Prefer the model's per-action
-        // summary; else the decision rationale, but kept HONEST about this action's
-        // market (a multi-action decision's rationale can be about a DIFFERENT market
-        // than a secondary trade — see rationaleForAction). Sanitized short reasoning
-        // only — never raw chain-of-thought.
-        rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length));
+        const trace = {
+            ...makeTrace(runId, decisionId, spec, meta.confidence ?? decision.confidence, 
+            // The trade's "why" on the Arena live floor. Prefer the model's per-action
+            // summary; else the decision rationale, but kept HONEST about this action's
+            // market (a multi-action decision's rationale can be about a DIFFERENT market
+            // than a secondary trade — see rationaleForAction). Sanitized short reasoning
+            // only — never raw chain-of-thought.
+            rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length)),
+            ...observationReceipt,
+        };
         const r = await executeAction(client, action, observation, trace, idem, provenance);
         planned.push({
             action,
@@ -868,6 +947,7 @@ export async function runCycle(deps) {
         writeAttempted: decision.actions.length,
         writeAccepted: planned.filter((p) => p.accepted).length,
         ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+        ...observationReceipt,
     };
 }
 export async function runLoop(deps, opts = {}) {

package/dist/agent/state.d.ts

@@ -4,4 +4,9 @@ export declare function loadState(file: string | undefined, runId: string): RunS
 export declare function saveState(file: string | undefined, state: RunState): void;
 export declare function rollDay(state: RunState): RunState;
 export declare function accrueRealized(state: RunState, closedTrades: Record<string, unknown>[]): void;
+export declare const PERMANENT_MODEL_ERROR_RE: RegExp;
+export declare const PERMANENT_MODEL_ERROR_THRESHOLD = 3;
+export declare const AUTH_FAILURE_THRESHOLD = 10;
+export declare const isPermanentModelError: (error: string) => boolean;
+export declare const isAuthFailureSkip: (skipReason: string) => boolean;
 export declare function checkKillSwitch(spec: AgentSpec, state: RunState): string | null;

package/dist/agent/state.js

@@ -84,6 +84,26 @@ export function accrueRealized(state, closedTrades) {
 // floored at this many consecutive failures regardless of an agent's own (lower)
 // setting. The scheduler additionally auto-revives any model-failure disable.
 const MODEL_FAILURE_FLOOR = 10;
+// ── Permanent-failure classification (2026-08-19) ───────────────────────────
+// The generic kill-switch treats every failure as transient — correct for
+// timeouts/blips, catastrophic for DETERMINISTIC failures. Live-measured: one
+// agent spent 93% of 782 cycles/24h on a Groq 404 (model decommissioned),
+// revived 7 times in 3h by the self-heal; four others burned ~1,500 cycles/day
+// on a revoked CoinRithm key (HTTP 401). These classifiers give such failures
+// a fast, NON-revivable disable with a machine-readable reason prefix the
+// scheduler's self-heal exempts ('model_unavailable' / 'key_invalid').
+//
+// Permanent model errors are deterministic, so the threshold is small — 3
+// consecutive occurrences rules out a one-off routing fluke without burning a
+// day. Auth failures get 10: a key rotation/propagation blip should not kill
+// an agent, but nothing recovers from an actually-revoked key.
+export const PERMANENT_MODEL_ERROR_RE = /model_not_found|model[_ ]decommissioned|has been decommissioned|\b404\b|does not exist or you do not have access/i;
+export const PERMANENT_MODEL_ERROR_THRESHOLD = 3;
+export const AUTH_FAILURE_THRESHOLD = 10;
+export const isPermanentModelError = (error) => PERMANENT_MODEL_ERROR_RE.test(error);
+// The observe phase folds a rejected key into its required-reads skip reason
+// as "... (HTTP 401)".
+export const isAuthFailureSkip = (skipReason) => /HTTP 401/.test(skipReason);
 // Returns a disable reason if any kill-switch condition is tripped, else null.
 export function checkKillSwitch(spec, state) {
     const ks = spec.killSwitch;

package/dist/agent/strictLint.js

@@ -25,8 +25,20 @@ const ALLOWED_KEYS = {
         "capabilities",
         "include",
         "watchlist",
+        // Load-bearing since OKF v2 (skill.ts builds the full TriggerPolicy from
+        // it) but was missing here, so any bundle actually SETTING it got an
+        // unknown_key lint — the knob existed and was unreachable (audit rank 10).
+        "triggerPolicy",
     ],
     trigger: ["cadence", "timezone", "events"],
+    triggerPolicy: [
+        "mode",
+        "skipLlmWhenNoTrigger",
+        "alwaysManageOpenPositions",
+        "maxLlmCallsPerHour",
+        "debounceMinutes",
+        "pmEvalCooldownMinutes",
+    ],
     model: ["provider", "name", "baseUrl"],
     risk: [
         "maxLeverage",
@@ -107,6 +119,7 @@ export function strictLint(raw) {
     lintKeys("$root", raw, issues);
     for (const block of [
         "trigger",
+        "triggerPolicy",
         "model",
         "risk",
         "limits",

package/dist/agent/templates.js

@@ -91,6 +91,12 @@ export function buildAgentObject(name, preset) {
         trigger: { cadence: p.cadence, timezone: "UTC" },
         model: { provider: "anthropic", name: "claude-sonnet-4-6" },
         venues: ["futures"],
+        // Without `indicators` the event_driven gate has no setups to fire on and
+        // a fresh flat agent heartbeats forever with ZERO model calls (audit
+        // 2026-08-19: every scaffold was born dormant). Optional extras a user
+        // can add: "universe_scan" (top-movers discovery beyond the watchlist)
+        // and "news" (catalyst context for its coins).
+        capabilities: ["indicators"],
         risk: {
             maxLeverage: p.leverage,
             perTradeMarginMusd: p.margin,

package/dist/agent/types.d.ts

@@ -61,7 +61,7 @@ export interface ObjectiveConfig {
     secondary: string[];
     horizon?: string;
 }
-export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news"];
+export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan"];
 export type Capability = (typeof ALLOWED_CAPABILITIES)[number];
 export interface AgentSpec {
     name: string;
@@ -106,6 +106,7 @@ export interface WatchEntry {
     sentimentBullishPct?: number;
     freshness?: Freshness;
     indicators?: IndicatorSet;
+    discovered?: boolean;
 }
 export interface OpenPosition {
     venue: Venue;
@@ -197,6 +198,12 @@ export interface Observation {
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
     news?: NewsItem[];
+    universeMovers?: Array<{
+        symbol: string;
+        name?: string;
+        change24hPct?: number;
+        priceUsd?: number;
+    }>;
 }
 export type ProposedAction = {
     type: "futures_open";
@@ -290,6 +297,8 @@ export interface RunState {
     llmCallTimestamps?: number[];
     lastLlmCallAt?: number;
     lastTriggerFingerprint?: string;
+    consecutivePermanentModelErrors?: number;
+    consecutiveAuthFailures?: number;
     journal?: Array<{
         at: string;
         did: string;
@@ -301,6 +310,8 @@ export interface AgentTrace {
     strategyLabel?: string;
     confidence?: number;
     rationaleSummary?: string;
+    observationHash?: string;
+    indicatorVersion?: string;
 }
 export interface ApiResult {
     ok: boolean;
@@ -330,6 +341,8 @@ export interface CycleResult {
     disabled?: boolean;
     disabledReason?: string;
     live: boolean;
+    observationHash?: string;
+    indicatorVersion?: string;
     triggerCodes?: string[];
     llmCallMade?: boolean;
     tokensIn?: number;

package/dist/agent/types.js

@@ -50,10 +50,20 @@ export const OBJECTIVE_PRIMARIES = [
 // slice. `websearch` = external lookups (an injection surface + a cost — it can
 // inform reasoning but NEVER widen a cap, since caps live in the runner);
 // `indicators` = runner-computed RSI/MACD/etc. fed into the observation.
+// `universe_scan` (2026-08-18, direct user request): each cycle the runner
+// pulls the top 24h movers across CoinRithm's tracked coin universe, resolves
+// the top few into FULL watch entries (price, sentiment, indicators when that
+// capability is also on) and appends them to the observation marked
+// `discovered: true`. Downstream is unchanged by design: a discovered entry
+// passes through the exact same risk gates as a watchlist symbol (blocklist
+// still wins, caps/SL rules unchanged) — the capability widens the CANDIDATE
+// SET for one cycle, never any cap. Off by default; without it the universe
+// is invisible and only manual watchlist pairs are analyzed.
 export const ALLOWED_CAPABILITIES = [
     "websearch",
     "indicators",
     "news",
+    "universe_scan",
 ];
 export const ok = () => ({ valid: true });
 export const fail = (code, reason) => ({

package/dist/agent/version.d.ts

@@ -5,7 +5,7 @@ export declare const COINRITHM_API: {
     readonly kind: "coinrithm-agent-api";
     readonly baseUrl: "https://api.coinrithm.com";
     readonly mcpUrl: "https://mcp.coinrithm.com/mcp";
-    readonly openapiVersion: "1.6.0";
+    readonly openapiVersion: "1.7.0";
     readonly mcpPackage: "@coinrithm/mcp-trading";
     readonly mcpVersion: string;
 };

package/dist/agent/version.js

@@ -20,7 +20,7 @@ export const COINRITHM_API = {
     mcpUrl: "https://mcp.coinrithm.com/mcp",
     // The API CONTRACT version (openapi.yaml info.version). Versioned independently
     // from the npm package below — hand-bump this when the OpenAPI contract changes.
-    openapiVersion: "1.6.0",
+    openapiVersion: "1.7.0",
     mcpPackage: "@coinrithm/mcp-trading",
     mcpVersion: PACKAGE_VERSION,
 };

package/dist/client.d.ts

@@ -48,6 +48,10 @@ export declare class CoinRithmClient {
     getPublicPmOverview(query?: {
         fiat?: string;
     }): Promise<ApiResult>;
+    getPublicPmSources(query?: {
+        fiat?: string;
+    }): Promise<ApiResult>;
+    getPublicPmSourcesHealth(): Promise<ApiResult>;
     listPublicPmEvents(query?: {
         q?: string;
         source?: string;
@@ -79,6 +83,7 @@ export declare class CoinRithmClient {
     }): Promise<ApiResult>;
     getPublicPmCanonicalDetail(key: string): Promise<ApiResult>;
     getPublicPmVolumeHistory(): Promise<ApiResult>;
+    getPublicCryptoMovers(direction: "gainers" | "losers", limit?: number): Promise<ApiResult>;
     whoami(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     getPortfolio(query?: {
         fiat?: string;

package/dist/client.js

@@ -203,6 +203,12 @@ export class CoinRithmClient {
     getPublicPmOverview(query) {
         return this.publicRequest("/api/prediction-markets/overview", query);
     }
+    getPublicPmSources(query) {
+        return this.publicRequest("/api/prediction-markets/sources", query);
+    }
+    getPublicPmSourcesHealth() {
+        return this.publicRequest("/api/prediction-markets/sources/health");
+    }
     listPublicPmEvents(query) {
         return this.publicRequest("/api/prediction-markets/events", query);
     }
@@ -230,6 +236,16 @@ export class CoinRithmClient {
     getPublicPmVolumeHistory() {
         return this.publicRequest("/api/prediction-markets/volume-history");
     }
+    // ---- public crypto data (no key required) ----
+    // Top 24h movers across the tracked coin universe (user feature request,
+    // 2026-08-18: agents previously could only analyze manually-added pairs).
+    // Backend caps limit at 100; rows are {ucid, symbol, name, slug, change24h,
+    // currentPrice} ordered by 24h change.
+    getPublicCryptoMovers(direction, limit) {
+        return this.publicRequest(direction === "losers"
+            ? "/api/coins/top-losers"
+            : "/api/coins/top-gainers", { limit });
+    }
     // Every method takes an optional trailing `apiKey` (the per-request key for
     // the multi-user HTTP path). When omitted, the constructor key (stdio) is used.
     // ---- reads (scope: read) ----

package/dist/tools.d.ts

@@ -14,6 +14,7 @@ export declare function compactPublicPmEvents(data: unknown): unknown;
  */
 export declare function compactPublicPmEvent(data: unknown): unknown;
 export declare function compactPublicPmWhales(data: unknown, limit: number): unknown;
+export declare function compactPublicCryptoMovers(data: unknown): unknown;
 /**
  * Keep cross-venue disagreement clusters small enough for an agent context
  * window: each event is reduced to eventSummary (drops descriptions, images,

package/dist/tools.js

@@ -492,6 +492,34 @@ export function compactPublicPmWhales(data, limit) {
         : data.trades;
     return { ...data, trades };
 }
+// Crypto movers rows arrive as {ucid, symbol, name, slug, change24h,
+// currentPrice} with the numerics as STRINGS (backend SQL fn passthrough).
+// Coerce so a brain never string-compares "9.5" > "12"; drop the internal
+// ucid. A row that fails coercion passes through untouched — honesty over
+// polish, same rule as every other compactor here.
+export function compactPublicCryptoMovers(data) {
+    if (!Array.isArray(data))
+        return data;
+    return data.map((row) => {
+        if (!isJsonRecord(row))
+            return row;
+        const change = Number(row.change24h);
+        const price = Number(row.currentPrice);
+        return {
+            // coinId IS the ucid the rest of the tool surface takes (get_candles,
+            // get_market_context, the futures quote/open path). Carrying it through
+            // is not cosmetic: without it the caller has to re-derive the coin from
+            // the SYMBOL via resolve_symbol, and symbols collide across listings —
+            // the round-trip can land on a different coin than the one that moved.
+            coinId: row.ucid,
+            symbol: row.symbol,
+            name: row.name,
+            slug: row.slug,
+            change24hPct: Number.isFinite(change) ? change : row.change24h,
+            priceUsd: Number.isFinite(price) ? price : row.currentPrice,
+        };
+    });
+}
 const MATCH_PAIR_FIELDS = [
     "matchId",
     "confidence",
@@ -1426,8 +1454,8 @@ export function registerTools(server, client) {
         title: "Cross-venue prediction-market statistics",
         description: "Free public cross-venue prediction-market statistics: total/open/" +
             "closed market counts, total volume, 24h volume, and liquidity " +
-            "aggregated across all 11 venues (Polymarket, Kalshi, Rothera, " +
-            "Limitless, Smarkets, Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx), plus market " +
+            "aggregated across all 12 venues (Polymarket, Kalshi, Rothera, " +
+            "Limitless, Smarkets, Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx, Gemini), plus market " +
             "highlights in a compact discovery shape. Use pm_data_event for full " +
             "event evidence. Freshness is SOURCE-AWARE — each venue ingests " +
             "independently; per-venue health (freshness tier, lag, stale reason) " +
@@ -1445,11 +1473,40 @@ export function registerTools(server, client) {
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Cross-venue prediction-market statistics"),
     }, async ({ fiat }) => present(mapSuccessfulBody(await client.getPublicPmOverview({ fiat }), compactPublicPmOverview)));
+    server.registerTool("pm_data_sources", {
+        title: "Prediction-market venue methodology and coverage",
+        description: "Free public methodology and comparable coverage for every CoinRithm " +
+            "prediction-market venue: source kind, supported metrics, market counts, " +
+            "explicit 24h/cumulative volume bases, currency basis, comparability, " +
+            "and as-of timestamps. Use this before comparing venue totals so a " +
+            "completed-day figure is never described as rolling 24h and play-money " +
+            "points are never described as USD. No API key required.",
+        inputSchema: {
+            fiat: z
+                .string()
+                .optional()
+                .describe("Fiat currency code for monetary figures (default usd)."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Prediction-market venue methodology and coverage"),
+    }, async ({ fiat }) => present(await client.getPublicPmSources({ fiat })));
+    server.registerTool("pm_data_sources_health", {
+        title: "Prediction-market venue freshness and health",
+        description: "Free public per-venue ingest health across all CoinRithm sources: " +
+            "freshness tier, observed lag, stale/degraded reason, coverage counts, " +
+            "and current health timestamps. Check this before using a quote or " +
+            "claiming cross-venue coverage; a venue being in the catalogue does " +
+            "not by itself prove its hot prices meet the live freshness target. " +
+            "No API key required.",
+        inputSchema: {},
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Prediction-market venue freshness and health"),
+    }, async () => present(await client.getPublicPmSourcesHealth()));
     server.registerTool("pm_data_events", {
         title: "Search prediction markets across all venues",
-        description: "Free public search over prediction-market events across ALL 11 " +
+        description: "Free public search over prediction-market events across ALL 12 " +
             "venues (Polymarket, Kalshi, Rothera, Limitless, Smarkets, " +
-            "Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx) — broader than discover_pm_markets, which is " +
+            "Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx, Gemini) — broader than discover_pm_markets, which is " +
             "scoped to the paper-tradeable venues. Returns titles, probabilities, " +
             "volume/liquidity, status, and source per event, plus " +
             "the five highest-probability outcomes and the full outcome count. " +
@@ -1468,7 +1525,7 @@ export function registerTools(server, client) {
                 .string()
                 .optional()
                 .describe("Optional venue filter: polymarket, kalshi, rothera, limitless, " +
-                "smarkets, manifold, metaculus, predictit, futuur, myriad, or forecastex."),
+                "smarkets, manifold, metaculus, predictit, futuur, myriad, forecastex, or gemini."),
             status: z
                 .string()
                 .optional()
@@ -1525,7 +1582,7 @@ export function registerTools(server, client) {
             source: z
                 .string()
                 .describe("Venue slug: polymarket, kalshi, rothera, limitless, smarkets, " +
-                "manifold, metaculus, predictit, futuur, myriad, or forecastex."),
+                "manifold, metaculus, predictit, futuur, myriad, forecastex, or gemini."),
             slug: z.string().describe("Event slug on that venue."),
             fiat: z
                 .string()
@@ -1728,4 +1785,32 @@ export function registerTools(server, client) {
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Global prediction-market volume trend"),
     }, async () => present(await client.getPublicPmVolumeHistory()));
+    server.registerTool("get_crypto_movers", {
+        title: "Top 24h crypto movers (universe scan)",
+        description: "Free public scan of CoinRithm's tracked crypto universe for the " +
+            "biggest 24h price moves — top gainers or top losers, ordered by " +
+            "24h change percent. Use this to DISCOVER candidates beyond your " +
+            "watchlist (abnormal rapid moves), then deep-analyze each candidate " +
+            "with get_candles (OHLC + indicators) and get_market_context " +
+            "(sentiment, news) before any trade decision. Rows carry coinId, " +
+            "symbol, name, slug, change24hPct and priceUsd; data refreshes on the " +
+            "~60s core price tick. Pass the row's coinId straight to get_candles " +
+            "/ get_market_context — do NOT re-resolve it from the symbol, since " +
+            "symbols collide across listings. No API key required.",
+        inputSchema: {
+            direction: z
+                .enum(["gainers", "losers"])
+                .optional()
+                .describe("Scan direction (default gainers)."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("Rows to return, 1-100 (default 20)."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Top 24h crypto movers"),
+    }, async ({ direction, limit }) => present(mapSuccessfulBody(await client.getPublicCryptoMovers(direction ?? "gainers", limit ?? 20), compactPublicCryptoMovers)));
 }