@coinrithm/mcp-trading 0.7.5 → 0.7.7

package/dist/agent/resolve.js

@@ -47,6 +47,32 @@ const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;
 // Optional prose files (markdown the LLM reads), in assembly order.
 const PROSE_FILES = ["character/thesis.md", "character/persona.md"];
+// Prose files carry an OPTIONAL YAML frontmatter block (type/title/description/
+// tags) that is authoring metadata, not doctrine — the model gains nothing from
+// `tags: [agent, persona, mean-reversion]`. It was being merged verbatim into
+// the system prompt: pure noise, and on the hosted path it also consumed the
+// 8,000-char strategy budget (measured 2026-08-19: ~1.0k chars across a
+// decomposed bundle's thesis/persona/journal). Skill files already strip theirs
+// (their frontmatter is parsed for the cap patch), and guards.md strips too —
+// this brings the remaining prose files in line. Files WITHOUT frontmatter are
+// returned unchanged.
+export const proseBody = (raw) => {
+    const src = raw.replace(/\r\n/g, "\n");
+    const m = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(src);
+    return (m ? m[1] : src).trim();
+};
+// First-class hard-guards file (2026-08-19, audit rank 7). User-authored
+// behavioral borders that machine caps cannot express ("never open a short
+// unless a qualifying pump preceded it") previously lived as an undocumented
+// "Hard borders" paragraph buried mid-persona — present in only 5 of 8
+// bundles and easy for a forker to miss. character/guards.md gets a dedicated
+// slot: loaded LAST so the block lands at the END of the strategy prose,
+// immediately adjacent to the system prompt's hard-caps section, wrapped in a
+// high-salience header plus an explicit guards-win-conflicts rule.
+export const GUARDS_FILE = "character/guards.md";
+export const GUARDS_HEADER = "## HARD BEHAVIORAL GUARDS — never violate these";
+export const GUARDS_FOOTER = "(These guards override every other instruction in this strategy. When a guard conflicts with an opportunity, the guard wins and the correct output is a skip that names the guard.)";
+export const wrapGuardsProse = (body) => `${GUARDS_HEADER}\n\n${body.trim()}\n\n${GUARDS_FOOTER}`;
 const FUNCTIONALITY_PIN = "functionality/coinrithm.yaml";
 // Enforced cap field names. sizing.yaml is SOFT guidance and must NOT contain
 // any of these (or a user could think a limit binds when it does not).
@@ -427,8 +453,9 @@ function resolveDirectory(dir) {
         const p = join(dir, pf);
         if (existsSync(p)) {
             const abs = safePath(ctx, pf, "prose");
-            if (abs)
-                proseParts.push({ source: pf, text: readHashed(ctx, abs) });
+            if (abs) {
+                proseParts.push({ source: pf, text: proseBody(readHashed(ctx, abs)) });
+            }
         }
     }
     proseParts.push(...skillProse);
@@ -437,13 +464,28 @@ function resolveDirectory(dir) {
     if (existsSync(journalPath)) {
         const abs = safePath(ctx, "journal/notes.md", "journal");
         if (abs) {
-            const full = readHashed(ctx, abs);
+            const full = proseBody(readHashed(ctx, abs));
             proseParts.push({
                 source: "journal/notes.md",
                 text: boundTail(full, JOURNAL_MAX_LINES, JOURNAL_MAX_BYTES),
             });
         }
     }
+    // Hard behavioral guards — see GUARDS_FILE above. Pushed AFTER the journal
+    // so the wrapped block is the final prose the model reads before the caps
+    // section. Frontmatter is optional and stripped (only the body is doctrine);
+    // an empty body contributes nothing.
+    const guardsAbsPath = join(dir, GUARDS_FILE);
+    if (existsSync(guardsAbsPath)) {
+        const abs = safePath(ctx, GUARDS_FILE, "guards");
+        if (abs) {
+            const raw = readHashed(ctx, abs);
+            const body = (raw.startsWith("---") ? parseFrontmatter(raw).body : raw).trim();
+            if (body) {
+                proseParts.push({ source: GUARDS_FILE, text: wrapGuardsProse(body) });
+            }
+        }
+    }
     // Optional API/tool contract pin. It is locked for reproducibility and stale
     // warnings, but it is not part of AgentSpec and is never sent to the model.
     const functionalityPath = join(dir, FUNCTIONALITY_PIN);
@@ -542,3 +584,40 @@ export function resolveAgent(inputPath) {
         { code: "input_invalid", message: "input must be a file or a directory" },
     ]);
 }
+// ── Hosted strategy-prose budget ───────────────────────────────────────────
+// The managed (Studio) deploy/edit API caps the merged strategy prose and
+// reverts the save past the cap; the self-host runner has NO such limit. The
+// cap is not arbitrary — the merged prose becomes the system prompt, and an
+// oversized prompt is what previously pushed small free-tier models to ~69k
+// tokens / 413s per cycle. Mirrored here (backend-v2
+// controllers/agentManage.ts sanitizeStrategyProse) so `validate --hosted`
+// can catch it before a user does.
+//
+// RAISED 8,000 -> 12,000 on 2026-08-21, from measurement rather than feel.
+// 8,000 made the product's core promise impossible: forking a house template
+// starts you at 7,967 (Olivia) / 7,931 (Carl) / 7,839 (Mia), so a user had
+// 33 to 161 characters to write their own rules in. "Fork a template and make
+// it yours" could not be done.
+//
+// The cap was justified by hosted inference cost. Measured over 8,060 LLM
+// cycles in 24h on prod: average input is 9,038 tokens, of which the prose is
+// only 12.6-40.2% (median ~25%) — the OBSERVATION is the other ~75%. Inputs
+// already reached 17,065 tokens on Llama 3.1 8B and 16,437 on Nemotron 49B
+// (measured on the since-retired NIM line; Nemotron 3 successors match), with
+// ZERO rate-limit errors and estimated_cost_usd of 0.0000 (free NIM tier).
+// +4,000 characters is ~+1,000 tokens/cycle (+11%), landing average input near
+// 10,038 — still below what the fleet already handles at peak today.
+//
+// Self-host is deliberately NOT capped (runner.ts/prompt.ts enforce nothing):
+// those agents run on the user's own model key, so their prompt size costs us
+// nothing. This limit exists only where WE pay for the inference.
+export const HOSTED_PROSE_MAX_CHARS = 12000;
+/** PURE — exported for tests. Mirrors the backend's trim-then-measure. */
+export const hostedProseBudget = (mergedProse) => {
+    const used = mergedProse.replace(/\r\n/g, "\n").trim().length;
+    return {
+        used,
+        over: Math.max(0, used - HOSTED_PROSE_MAX_CHARS),
+        fits: used <= HOSTED_PROSE_MAX_CHARS,
+    };
+};

package/dist/agent/runner.js

@@ -14,7 +14,7 @@ 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";
@@ -429,6 +429,29 @@ export async function runCycle(deps) {
     }
     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 {
@@ -439,6 +462,8 @@ export async function runCycle(deps) {
             ...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,
@@ -493,33 +518,112 @@ export async function runCycle(deps) {
         };
     }
     else {
-        noteLlmCall(state, gate.codes, nowMs);
         const system = buildSystemPrompt(spec, mergedProse, {
             includeForecast: forecastEnabled,
         });
-        const user = buildUserPrompt(observation, state.journal);
+        const user = buildUserPrompt(observation, state.journal, {
+            venues: spec.venues,
+        });
         const tokensInEst = Math.round((system.length + user.length) / 4);
         // Prompt-size + trigger visibility in the live terminal.
         log(`prompt ~${tokensInEst} tok ` +
             `(pm ${observation.pmMarkets.length}, trades ${observation.newClosedTrades.length}, watch ${observation.watch.length}, setups ${observation.setups.length}, triggers ${gate.codes.join("|") || "none"})`);
         const res = await provider.decide({ system, user });
+        const route = res.route;
+        const actualCallMade = route
+            ? route.attempts.some((attempt) => attempt.outcome !== "deferred")
+            : true;
+        // Capacity deferral made no provider call, so it must not consume the
+        // runner's debounce/LLM budget or delay recovery after capacity returns.
+        if (actualCallMade)
+            noteLlmCall(state, gate.codes, nowMs);
+        const effectiveProvider = actualCallMade
+            ? (route?.effectiveProvider ?? providerName)
+            : undefined;
         // Metering: prefer provider-reported usage; fall back to a chars/4 estimate.
-        const tokensIn = res.ok
-            ? (res.usage?.promptTokens ?? tokensInEst)
-            : tokensInEst;
+        const tokensIn = !actualCallMade
+            ? 0
+            : res.ok
+                ? (res.usage?.promptTokens ?? tokensInEst)
+                : tokensInEst;
         const tokensOut = res.ok
             ? (res.usage?.completionTokens ?? Math.round(res.text.length / 4))
             : 0;
-        const estimatedCostUsd = estimateCostUsd(providerName, tokensIn, tokensOut);
+        const estimatedCostUsd = estimateCostUsd(effectiveProvider ?? providerName, tokensIn, tokensOut);
         meter = {
             triggerCodes: gate.codes,
-            llmCallMade: true,
+            llmCallMade: actualCallMade,
             tokensIn,
             tokensOut,
             estimatedCostUsd,
+            effectiveProvider,
+            effectiveModel: actualCallMade
+                ? (route?.effectiveModel ?? spec.model?.name)
+                : undefined,
+            routeReason: route?.reason,
+            routeAttempts: route?.attempts,
         };
         if (!res.ok) {
+            if (res.deferred || !actualCallMade) {
+                saveState(stateFile, state);
+                log(`capacity deferred: ${res.error}`);
+                return {
+                    decision: "skip",
+                    skipReason: "provider capacity deferred",
+                    planned: [],
+                    modelFailed: false,
+                    live,
+                    ...meter,
+                    decisionType: "gate_skip",
+                    writeAttempted: 0,
+                    writeAccepted: 0,
+                    ...observationReceipt,
+                };
+            }
             state.consecutiveModelFailures += 1;
+            // Permanent-failure classification: a 404/410/model_not_found is a
+            // DECOMMISSIONED or misconfigured model that will fail every cycle
+            // until something changes (live-measured 2026-08-26: NVIDIA EOL'd the
+            // whole Llama 3.x line and 35 agents died on the old disable path).
+            // Reliability slice 1: this class must NEVER disable the agent —
+            // provider failures are the PLATFORM's problem, not the user's. Three
+            // consecutive occurrences (rules out a routing fluke) now emit a
+            // providerHold: hosted, the scheduler folds holds into a fleet-wide
+            // (provider, model) circuit that skip-claims matching agents with
+            // backoff probes; self-host, the runner simply keeps retrying each
+            // cadence and recovers the moment the provider does. Disables remain
+            // for what deserves them: revoked credentials, drawdown, kill-switch,
+            // user action. Transient errors reset the permanent streak.
+            if (isPermanentModelError(res.error)) {
+                state.consecutivePermanentModelErrors =
+                    (state.consecutivePermanentModelErrors ?? 0) + 1;
+                if (state.consecutivePermanentModelErrors >=
+                    PERMANENT_MODEL_ERROR_THRESHOLD) {
+                    const hold = {
+                        provider: route?.effectiveProvider ?? spec.model?.provider ?? "unknown",
+                        model: route?.effectiveModel ?? spec.model?.name ?? "unknown",
+                        error: res.error.slice(0, 200),
+                    };
+                    saveState(stateFile, state);
+                    log(`provider hold: ${hold.provider}/${hold.model} — ${res.error.slice(0, 120)}`);
+                    return {
+                        decision: "skip",
+                        skipReason: `provider hold: ${res.error}`,
+                        planned: [],
+                        modelFailed: true,
+                        providerHold: hold,
+                        live,
+                        ...meter,
+                        decisionType: "model_error",
+                        writeAttempted: 0,
+                        writeAccepted: 0,
+                        ...observationReceipt,
+                    };
+                }
+            }
+            else {
+                state.consecutivePermanentModelErrors = 0;
+            }
             saveState(stateFile, state);
             log(`model error: ${res.error}`);
             return {
@@ -557,6 +661,7 @@ export async function runCycle(deps) {
             };
         }
         state.consecutiveModelFailures = 0;
+        state.consecutivePermanentModelErrors = 0;
         decision = parsed.decision;
     }
     // Reasoning captured for the Arena terminal (keystone transparency): the

package/dist/agent/skill.js

@@ -92,6 +92,12 @@ export function buildSpec(raw) {
             requireStopLoss: bool(risk.requireStopLoss, true),
             watchlist: strArr(risk.watchlist),
             blocklist: strArr(risk.blocklist),
+            // Only the two exact values pass; anything else stays undefined here and
+            // FAILS validation (skillValidator) — a typo like "shorts_only" must
+            // never silently mean "unrestricted".
+            direction: risk.direction === "long_only" || risk.direction === "short_only"
+                ? risk.direction
+                : undefined,
         },
         limits: {
             maxTradesPerDay: normalizeTradeCap(num(limits.maxTradesPerDay, DEFAULT_LIMITS.maxTradesPerDay)),

package/dist/agent/skillValidator.js

@@ -53,6 +53,13 @@ export function validateSkill(parsed, mode = "self-host") {
             add("skill_risk_sl", "risk.requireStopLoss must be true or false");
         if (!Array.isArray(r.watchlist) || r.watchlist.length === 0)
             add("skill_risk_watchlist", "risk.watchlist must be a non-empty list of symbols");
+        // Fail-closed on the side restriction: a typo ("shorts_only") must never
+        // silently mean "unrestricted" — that is exactly how a prose-only
+        // constraint failed live on 2026-08-24.
+        if (r.direction !== undefined &&
+            r.direction !== "long_only" &&
+            r.direction !== "short_only")
+            add("skill_risk_direction", 'risk.direction must be "long_only" or "short_only" (omit for both)');
     }
     // Model
     if (raw.model === undefined) {

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|\b410\b|reached (?:its )?end of life|no longer available|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",
@@ -35,6 +47,7 @@ const ALLOWED_KEYS = {
         "requireStopLoss",
         "watchlist",
         "blocklist",
+        "direction",
     ],
     sizing: null,
     limits: [
@@ -107,6 +120,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

@@ -31,6 +31,7 @@ export interface RiskConfig {
     requireStopLoss: boolean;
     watchlist: string[];
     blocklist?: string[];
+    direction?: "long_only" | "short_only";
 }
 export interface LimitsConfig {
     maxTradesPerDay: number;
@@ -61,7 +62,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 +107,7 @@ export interface WatchEntry {
     sentimentBullishPct?: number;
     freshness?: Freshness;
     indicators?: IndicatorSet;
+    discovered?: boolean;
 }
 export interface OpenPosition {
     venue: Venue;
@@ -197,6 +199,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 +298,8 @@ export interface RunState {
     llmCallTimestamps?: number[];
     lastLlmCallAt?: number;
     lastTriggerFingerprint?: string;
+    consecutivePermanentModelErrors?: number;
+    consecutiveAuthFailures?: number;
     journal?: Array<{
         at: string;
         did: string;
@@ -331,6 +341,16 @@ export interface CycleResult {
     modelFailed?: boolean;
     disabled?: boolean;
     disabledReason?: string;
+    /** Reliability slice 1 (2026-08-26): a PERMANENT provider/model failure
+     * (404/410/decommission class) no longer disables the agent. The runner
+     * reports the hold; the scheduler aggregates holds into a fleet-wide
+     * provider circuit (skip-claiming + backoff probes). User pauses, revoked
+     * credentials, drawdown and safety stops keep using `disabled`. */
+    providerHold?: {
+        provider: string;
+        model: string;
+        error: string;
+    };
     live: boolean;
     observationHash?: string;
     indicatorVersion?: string;
@@ -339,6 +359,19 @@ export interface CycleResult {
     tokensIn?: number;
     tokensOut?: number;
     estimatedCostUsd?: number;
+    effectiveProvider?: string;
+    effectiveModel?: string;
+    routeReason?: string;
+    routeAttempts?: Array<{
+        provider: string;
+        model: string;
+        outcome: "success" | "failed" | "deferred";
+        failureClass?: "capacity" | "permanent" | "transient" | "malformed";
+        status?: number;
+        retryAfterMs?: number;
+        latencyMs: number;
+        error?: string;
+    }>;
     decisionType?: "act" | "skip" | "gate_skip" | "model_error";
     writeAttempted?: number;
     writeAccepted?: 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

@@ -83,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

@@ -236,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/http.js

@@ -79,6 +79,27 @@ async function main() {
             },
         });
     });
+    // robots.txt for THIS host. robots.txt is per-HOST, so www.coinrithm.com's
+    // file never governed mcp.coinrithm.com — a separate origin that had no
+    // route of its own. The origin 404'd and Cloudflare answered with its
+    // managed content-signals boilerplate: 1,248 bytes of comments carrying ZERO
+    // User-agent/Disallow/Allow lines, which a crawler reads as "crawl
+    // everything". That is the identical failure that cost api.coinrithm.com
+    // 15.4% of the site's 90-day crawl budget (4,468 of 29,100 GSC requests)
+    // before it was closed on 2026-08-20.
+    //
+    // Nothing here is indexable: GET / is a JSON service descriptor, GET /mcp is
+    // a 405, and the real surface is POST-only streamable HTTP. The human-facing
+    // documentation crawlers should index lives on www.coinrithm.com
+    // (/en/agentic-trading, /en/prediction-markets/api), which links here.
+    //
+    // SAFE FOR MCP CLIENTS AND REGISTRIES: robots.txt is advisory to CRAWLERS
+    // only. MCP clients, Smithery and the MCP registry POST /mcp or GET /healthz
+    // directly and never consult robots.txt, so this cannot gate discovery,
+    // initialization or tool listing. Do not "fix" a registry problem here.
+    app.get("/robots.txt", (_req, res) => {
+        res.type("text/plain").send("User-agent: *\nDisallow: /\n");
+    });
     app.get("/mcp", (_req, res) => {
         res.status(405).json({
             error: "method_not_allowed",

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,