@coinrithm/mcp-trading 0.7.6 → 0.7.7

package/CHANGELOG.md

@@ -5,6 +5,57 @@ ships two binaries — `coinrithm-mcp` (the MCP server) and `coinrithm-agent` (t
 self-host agent runner) — versioned together. The CoinRithm **API contract** is
 versioned separately (see `openapi.yaml` `info.version`, currently `1.7.0`).
 
+## 0.7.7
+
+Reliability release. Every change here came from a live production failure, not
+from a roadmap. Additive: no tool renamed or removed, and the API **contract
+stays 1.7.0** because nothing on the documented surface changed.
+
+**Model requests are now built from a declared capability table, not
+assumptions.** `providerCapabilities.ts` states, per model family, which
+parameter carries the completion budget, whether a non-default temperature is
+allowed, and what extra body fields the family needs. Two failures this fixes:
+
+- **OpenAI's current models rejected our requests outright.** `gpt-5*` and
+  `o*` refuse `max_tokens` and any non-default `temperature`; they take
+  `max_completion_tokens`. The family is detected by MODEL id, not just the
+  provider name, so an OpenAI-compatible gateway serving `gpt-5` gets the same
+  shape. If you brought your own OpenAI key, this is why it now works.
+- **NVIDIA Nemotron models emitted a think-chain where the JSON decision
+  belonged**, which failed every cycle. The `chat_template_kwargs.enable_thinking=false`
+  switch and the "detailed thinking off" system hint are now encoded as data
+  rather than re-learned by failing.
+
+**New: `probeDecisionContract()`.** An HTTP 200 is not proof a route can run an
+agent. Both production failure modes returned 200s: a think-chain in the JSON
+slot, and an empty completion because a reasoning model spent its whole budget
+before answering. The probe sends a canned mini-observation through the REAL
+decision parser at a >=1024 completion allowance and classifies the result as
+`http`, `empty` or `parse`. Use it before adopting any model id; provider
+catalogs list ids that 404 on invoke.
+
+**Provider trouble no longer disables an agent.** A permanent-looking model
+error (404/410/decommissioned) used to disable the agent after a threshold. On
+2026-08-26 NVIDIA end-of-lifed an entire model line and 35 agents died on that
+path. The runner now reports a hold and keeps retrying each cadence, recovering
+by itself when the provider does. Disables remain for what deserves them:
+revoked credentials, drawdown, kill-switch, user action.
+
+**Failures carry structured metadata.** A failed `decide()` now returns
+`status` and, when the provider sends one, `retryAfterMs` (parsed from
+`Retry-After` in both delta-seconds and HTTP-date form, capped at an hour), so
+a caller can tell a 429 from a 5xx without parsing strings. Error text is
+unchanged.
+
+**`ClientConfig.extraHeaders`.** Headers attached to every request, spread
+before auth so they can never clobber it. Self-host has nothing to put here;
+it exists so CoinRithm's own hosted scheduler can present its attestation
+channel.
+
+**Model names corrected throughout.** The retired Llama 3.x line is gone from
+the README, the runtime defaults and the `quant-reference` example, which is
+relocked onto `nvidia/nemotron-3-nano-30b-a3b`.
+
 ## 0.7.6
 
 Agent capability release: universe discovery, first-class behavioral guards,

package/README.md

@@ -5,7 +5,8 @@
 spot, futures, and prediction markets on
 [CoinRithm](https://coinrithm.com/agentic-trading). No real money, no exchange,
 no risk — a proving ground to show an agent works *before* anything is on the
-line, with a public **Agent Arena** leaderboard ranked by realized paper PnL.
+line, with a public **Agent Arena** leaderboard using a versioned,
+confidence-weighted realized-PnL methodology.
 
 **Plus a free prediction-market data surface — no key at all.** The same server
 ships ten keyless `pm_data_*` tools serving CoinRithm's public cross-venue
@@ -22,7 +23,7 @@ Agents are **OKF bundles** — an open, model-agnostic folder of markdown + YAML
 
 - **Managed — nothing to install.** Build and deploy an agent in your browser
   with the **Agent Studio** (CoinRithm → My Agents → Studio): fork a house agent
-  or write one from scratch, and CoinRithm runs it **free on Llama 3.1 8B**
+  or write one from scratch, and CoinRithm runs it **free on Nemotron 3 Nano 30B**
   (NVIDIA NIM) on an always-on scheduler. The fastest path to a live agent.
 - **Self-host — this package.** Bring your own model key and run the
   `observe→decide→validate→act` loop on your machine, or wire the MCP server
@@ -83,6 +84,33 @@ key upstream. The Authorization header is **optional** on the hosted endpoint
 the ten keyless `pm_data_*` market-data tools work anonymously; every other
 tool requires it. See [`DEPLOY.md`](./DEPLOY.md).
 
+## Bring your own model key
+
+The hosted Agent Studio runs your agent free on a shared pool of NVIDIA-hosted
+models. That pool is a **fixed budget shared by every hosted agent**, so the
+scheduler floors how often a shared agent may run, and the floor stretches as
+more agents join. Bringing your own model key removes that floor entirely:
+your quota is yours, so there is nothing for us to ration.
+
+| | Shared free pool | Your own key |
+| --- | --- | --- |
+| Models | the free hosted picks | any model your provider serves |
+| Interval | floored by fleet size | exactly what you configure |
+| Rerouting | we may serve a live alternate when a model is rate-limited | never rerouted, your route is pinned |
+| Cost | free | you pay your provider, not CoinRithm |
+
+Providers accepted: `nvidia`, `openai`, `groq`, `anthropic`, and any
+`openai-compatible` endpoint (https base URL required). The key is validated by
+a **live decision probe before the agent is accepted** — a model that cannot
+return a parseable decision is rejected at deploy time rather than failing
+every scheduled cycle. Keys are encrypted at rest and never logged or echoed.
+
+Self-hosting through this package works the same way: set the provider's env
+var (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `NVIDIA_API_KEY`, `GROQ_API_KEY`
+or `MODEL_API_KEY`) and the runner builds the request in the shape that
+provider's model family actually accepts. A model key is **never** read from an
+agent file.
+
 ## Configure (stdio)
 
 | Env var | Required | Default | Notes |
@@ -278,13 +306,14 @@ least that long before retrying.
 
 ## Agent Arena
 
-Opted-in agents are publicly ranked by realized PnL — every agent with any
-decided (win/loss) trade is listed (a small-sample asterisk flags thin records;
-the live gate is surfaced as `minDecidedTrades` in the response) at
+Opted-in agents are publicly listed at
 [coinrithm.com](https://coinrithm.com/agentic-trading) — set `agentName` /
 `agentPublic` / `agentModel` on your key to join, then check your standing
-with `get_arena_leaderboard` / `get_arena_agent`. Pass `window: "7d" | "30d"`
-to `get_arena_leaderboard` for the weekly/monthly board (re-ranked by
-in-window PnL; the min-decided gate and badges stay all-time).
+with `get_arena_leaderboard` / `get_arena_agent`. Under `arena-ranking-v1`,
+five decided trades qualify an agent for normal ordering. Positive realized
+PnL is weighted by the 95% Wilson win-confidence lower bound; non-positive PnL
+is used directly. Agents below five remain listed after qualified agents, and
+fewer than 20 decided trades carries a separate small-sample warning. The API
+returns the full machine-readable `contract` with every board response.
 
 stdout is the MCP JSON-RPC channel; this server logs only to stderr.

package/dist/agent/client.d.ts

@@ -21,6 +21,7 @@ export interface ClientConfig {
     fetchFn?: typeof fetch;
     sleepFn?: (ms: number) => Promise<void>;
     maxRetries?: number;
+    extraHeaders?: Record<string, string>;
 }
 export declare class CoinRithmClient {
     private readonly apiKey;
@@ -28,6 +29,7 @@ export declare class CoinRithmClient {
     private readonly fetchFn;
     private readonly sleepFn;
     private readonly maxRetries;
+    private readonly extraHeaders?;
     rateLimitHits: number;
     constructor(cfg: ClientConfig);
     private request;

package/dist/agent/client.js

@@ -30,6 +30,7 @@ export class CoinRithmClient {
     fetchFn;
     sleepFn;
     maxRetries;
+    extraHeaders;
     // Every 429 seen this session (read or write, retried or not) — feeds the
     // rate-limit-pressure kill-switch, which a write-only counter would miss.
     rateLimitHits = 0;
@@ -39,6 +40,7 @@ export class CoinRithmClient {
         this.fetchFn = cfg.fetchFn ?? fetch;
         this.sleepFn = cfg.sleepFn ?? realSleep;
         this.maxRetries = cfg.maxRetries ?? 3;
+        this.extraHeaders = cfg.extraHeaders;
     }
     async request(method, path, opts = {}) {
         const url = new URL(this.baseUrl + path);
@@ -48,7 +50,9 @@ export class CoinRithmClient {
                     url.searchParams.set(k, String(v));
             }
         }
+        // extraHeaders first: auth, accept and trace can never be clobbered by it.
         const headers = {
+            ...this.extraHeaders,
             Authorization: `Bearer ${this.apiKey}`,
             Accept: "application/json",
             ...traceHeaders(opts.trace),

package/dist/agent/decisionProbe.d.ts

@@ -0,0 +1,17 @@
+import { ProviderName } from "./types.js";
+export interface ProbeRoute {
+    provider: ProviderName;
+    model: string;
+    baseUrl?: string | null;
+    key: string;
+}
+export type ProbeDecisionResult = {
+    ok: true;
+} | {
+    ok: false;
+    stage: "http" | "empty" | "parse";
+    error: string;
+    status?: number;
+    retryAfterMs?: number;
+};
+export declare function probeDecisionContract(route: ProbeRoute, fetchFn?: typeof fetch): Promise<ProbeDecisionResult>;

package/dist/agent/decisionProbe.js

@@ -0,0 +1,70 @@
+// Representative decision probe (reliability slice A, contract frozen on
+// Telegram 2026-08-26). An HTTP-200 chat ping is NOT proof a route can run an
+// agent: the 62f3a12 incident had 200s all round while every cycle failed with
+// "Unexpected token W" (think-chain in the JSON slot), and Codex's gpt-5-nano
+// probe at 256 completion tokens returned EMPTY content with a length finish
+// because reasoning consumed the budget. A route is eligible only when a real
+// call comes back parseable through the REAL decision parser with a non-empty
+// decision — using the exact request shape a cycle would send
+// (providerForRoute -> the same provider classes as the runner).
+//
+// Uses: boot eligibility of fallback-chain targets (slice B), circuit
+// half-open reopens, any future model migration (D18: probe before adopt).
+// The key is used for the one call and never logged; provider error text is
+// sanitized before it can reach any log or ledger row.
+import { providerForRoute } from "./providers.js";
+import { chatShapeFor } from "./providerCapabilities.js";
+import { parseDecision } from "./decision.js";
+// A canned mini-observation whose ONLY correct answer is a tiny skip decision.
+// Small enough to cost nothing, real enough to exercise the full JSON contract.
+const PROBE_SYSTEM = [
+    "You are a trading agent contract probe.",
+    'Reply with EXACTLY one JSON object: {"decision":"skip","reason":"contract probe"}.',
+    "No prose, no code fences, no additional keys.",
+].join(" ");
+const PROBE_USER = "Observation: BTC 24h change 0.0%. Confirm the decision contract.";
+const PROBE_TIMEOUT_MS = 30_000;
+/** Strip the key (and bearer echoes) out of any text a probe might surface. */
+function sanitize(text, key) {
+    let out = (text ?? "").slice(0, 400);
+    if (key)
+        out = out.split(key).join("***");
+    out = out.replace(/Bearer\s+[A-Za-z0-9._-]{8,}/g, "Bearer ***");
+    return out.slice(0, 200);
+}
+export async function probeDecisionContract(route, fetchFn = fetch) {
+    const shape = chatShapeFor(route.provider, route.model, route.baseUrl ?? undefined);
+    const provider = providerForRoute(route, route.key, fetchFn);
+    const res = await provider.decide({
+        system: PROBE_SYSTEM,
+        user: PROBE_USER,
+        // Reasoning models spend hidden tokens first — grant at least the family
+        // floor (1024) or the empty-with-length-finish false negative comes back.
+        maxTokens: Math.max(1024, shape.minProbeCompletionTokens),
+        timeoutMs: PROBE_TIMEOUT_MS,
+    });
+    if (!res.ok) {
+        const error = sanitize(res.error, route.key);
+        // Provider classes report empty 2xx content as "... returned empty content".
+        const stage = /returned empty content/i.test(res.error) ? "empty" : "http";
+        return {
+            ok: false,
+            stage,
+            error,
+            status: res.status,
+            retryAfterMs: res.retryAfterMs,
+        };
+    }
+    if (!res.text.trim()) {
+        return { ok: false, stage: "empty", error: "empty completion" };
+    }
+    const parsed = parseDecision(res.text);
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            stage: "parse",
+            error: sanitize(parsed.error, route.key),
+        };
+    }
+    return { ok: true };
+}

package/dist/agent/decisionValidator.js

@@ -36,6 +36,29 @@ export function validateAction(action, ctx) {
             }
         }
     }
+    // Direction constraint (2026-08-24): a strategy's side restriction is a HARD
+    // cap, not prose-obedience. Live incident: a short-only fade agent opened
+    // two momentum LONGS when the flagged-setups act-pressure outweighed its
+    // prose. Closes/SL-TP/cancels are never direction-gated — reducing or
+    // protecting an existing position is not a directional bet.
+    const direction = spec.risk.direction;
+    if (direction) {
+        if (action.type === "futures_open") {
+            if (direction === "short_only" && action.side !== "short") {
+                return fail("direction_constraint", `direction ${direction}: futures_open side must be "short", got "${action.side}"`);
+            }
+            if (direction === "long_only" && action.side !== "long") {
+                return fail("direction_constraint", `direction ${direction}: futures_open side must be "long", got "${action.side}"`);
+            }
+        }
+        // Spot buys are long exposure; a short_only agent must not accumulate
+        // them. Spot sells reduce a holding and stay allowed.
+        if (action.type === "spot_order" &&
+            direction === "short_only" &&
+            action.side === "buy") {
+            return fail("direction_constraint", `direction ${direction}: spot buys are long exposure`);
+        }
+    }
     if (action.type === "futures_open") {
         // Daily realized-loss stop: once today's loss hits the cap, open no new risk.
         if (spec.limits.maxDailyLossMusd > 0 &&

package/dist/agent/engine.d.ts

@@ -1,5 +1,8 @@
 export { runCycle, type RunnerDeps } from "./runner.js";
-export { selectProvider, type ProviderEnv, type Provider, } from "./providers.js";
+export { selectProvider, providerForRoute, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
+export { parseDecision } from "./decision.js";
+export { chatShapeFor, buildChatBody, type ChatShape, } from "./providerCapabilities.js";
+export { probeDecisionContract, type ProbeRoute, type ProbeDecisionResult, } from "./decisionProbe.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
 export { resolveAgent } from "./resolve.js";

package/dist/agent/engine.js

@@ -6,7 +6,13 @@
 // This barrel is the ONE import a host scheduler needs; it re-exports only the
 // stable engine pieces, never the CLI.
 export { runCycle } from "./runner.js";
-export { selectProvider, } from "./providers.js";
+export { selectProvider, providerForRoute, } from "./providers.js";
+export { parseDecision } from "./decision.js";
+// Reliability slice A: the declarative request-capability table and the
+// representative decision probe (route eligibility = a REAL parsed decision,
+// never a bare HTTP 200 — the 62f3a12 lesson).
+export { chatShapeFor, buildChatBody, } from "./providerCapabilities.js";
+export { probeDecisionContract, } from "./decisionProbe.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec } from "./skill.js";
 export { resolveAgent } from "./resolve.js";

package/dist/agent/observe.js

@@ -11,8 +11,26 @@ const INDICATOR_RANGE = "1D";
 // `universe_scan` bounds: how many top movers to pull, and how many of those
 // to fully resolve into tradable watch entries (each resolved row costs a
 // resolve + market [+ candles] call).
+//
+// RESOLVE_TOP 3 -> 6 on 2026-08-21. Only a resolved row carries indicators, and
+// therefore a `setups` flag; the unresolved remainder is bare symbol + 24h
+// change + price. At 3, a discovery-driven strategy could reason properly about
+// exactly three coins per cycle out of fifteen surfaced.
+//
+// That bit a real user case. A pump-fade agent identifies a candidate from a
+// `stretched`/`fade-short` setup (RSI14 >= 68) and then waits for exhaustion,
+// which by definition means RSI is NO LONGER extreme. Nothing persists between
+// cycles, so the candidate has to still be a resolved row at the moment the
+// exhaustion evidence appears. Discovery is gainers-ranked, so a retracing coin
+// slides down the list — at 3 it fell out almost immediately and went blind
+// exactly when the strategy needed to look at it.
+//
+// 6 roughly doubles how far a coin can slide before losing its indicators. Cost
+// is 3 extra market+candles calls per cycle against CoinRithm's own API (never
+// the model quota) and ~3 more watch entries in the prompt, and only for agents
+// that declare universe_scan.
 const UNIVERSE_SCAN_LIMIT = 15;
-const UNIVERSE_RESOLVE_TOP = 3;
+const UNIVERSE_RESOLVE_TOP = 6;
 // Watchlist symbols -> the coin NAMES prediction-market titles use, so an agent
 // discovers PM markets about the coins it actually has a price view on.
 const PM_COIN_NAMES = {

package/dist/agent/prompt.d.ts

@@ -6,4 +6,6 @@ export declare function buildSystemPrompt(spec: AgentSpec, mergedProse: string,
 export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     at: string;
     did: string;
-}>): string;
+}>, opts?: {
+    venues?: AgentSpec["venues"];
+}): string;

package/dist/agent/prompt.js

@@ -41,15 +41,28 @@ export function buildSystemPrompt(spec, mergedProse,
 opts = {}) {
     const r = spec.risk;
     const v = spec.venues;
-    const includeForecast = opts.includeForecast === true;
+    const hasFutures = v.includes("futures");
+    const hasSpot = v.includes("spot");
+    const hasPm = v.includes("pm");
+    const hasCoinVenue = hasFutures || hasSpot;
+    const coinVenueLabel = [
+        ...(hasSpot ? ["spot"] : []),
+        ...(hasFutures ? ["futures"] : []),
+    ].join(" + ");
+    const includeForecast = hasPm && opts.includeForecast === true;
+    const sizeKinds = [
+        ...(hasFutures ? ["futures margin"] : []),
+        ...(hasSpot ? ["spot buy notional"] : []),
+        ...(hasPm ? ["PM stake"] : []),
+    ];
     const actions = [];
-    if (v.includes("futures")) {
+    if (hasFutures) {
         actions.push('{"type":"futures_open","symbol","side":"long"|"short","leverage","marginMusd","stopLossPrice","takeProfitPrice","confidence":0..1}', '{"type":"futures_close","positionId","fraction"}', '{"type":"futures_set_sltp","positionId","stopLossPrice","takeProfitPrice"}', "FUTURES TRIGGER RULES (the server rejects the WHOLE open otherwise): a LONG's takeProfitPrice must be ABOVE the current mark and stopLossPrice BELOW it (and above liquidationPrice); a SHORT is inverted (TP below mark, SL above). Every open position in observation.openPositions shows entryPrice, markPrice, liquidationPrice, stopLossPrice, takeProfitPrice — read them and place triggers on the correct side. NEVER attach stopLossPrice/takeProfitPrice to a futures_open for a symbol you ALREADY hold (the server treats it as an add and rejects it) — adjust that position with futures_set_sltp on its positionId instead.");
     }
-    if (v.includes("spot")) {
+    if (hasSpot) {
         actions.push('{"type":"spot_order","symbol","side":"buy"|"sell","orderType":"market"|"limit"|"stop","quantity","limitPrice","stopPrice","confidence":0..1}', '{"type":"spot_cancel","orderId"}');
     }
-    if (v.includes("pm")) {
+    if (hasPm) {
         actions.push(`{"type":"pm_open","ref":"pmN","stakeMusd","confidence":0..1${includeForecast ? ',"forecastProbability":1..99' : ""}}  (set "ref" to one of the refs listed THIS cycle (pm1..pmN) — the \`ref\` of the ONE observation.pmMarkets entry you are betting, e.g. "pm3", copied EXACTLY; a ref NOT in this cycle's list is rejected as pm_ref_unknown and wastes the cycle; stakeMusd >= 10${includeForecast ? '; set "forecastProbability" to YOUR OWN probability 1-99 that this outcome wins — see the forecast rule below' : ""})`);
     }
     return [
@@ -61,25 +74,44 @@ opts = {}) {
         "",
         "## Hard caps the runner enforces (do not exceed; proposing over a cap wastes the cycle)",
         `- venues you may act in: ${v.join(", ")}`,
-        `- perTradeMarginMusd ${r.perTradeMarginMusd} is the per-trade SIZE cap (futures margin / spot buy notional / PM stake)`,
-        `- futures: maxLeverage ${r.maxLeverage}, maxConcurrentPositions ${r.maxConcurrentPositions}, requireStopLoss ${r.requireStopLoss} (long stop below entry, short stop above)`,
+        `- perTradeMarginMusd ${r.perTradeMarginMusd} is the per-trade SIZE cap (${sizeKinds.join(" / ")})`,
+        ...(hasFutures
+            ? [
+                `- futures: maxLeverage ${r.maxLeverage}, maxConcurrentPositions ${r.maxConcurrentPositions}, requireStopLoss ${r.requireStopLoss} (long stop below entry, short stop above)`,
+            ]
+            : []),
+        ...(r.direction
+            ? [
+                r.direction === "short_only"
+                    ? '- DIRECTION: SHORT ONLY — every futures_open MUST be side:"short" (and spot buys are forbidden: they are long exposure). A long is REJECTED by the runner no matter how strong the setup looks; a long-bias setup is never yours to take, only to fade when YOUR criteria are met.'
+                    : '- DIRECTION: LONG ONLY — every futures_open MUST be side:"long". A short is REJECTED by the runner no matter how strong the setup looks.',
+            ]
+            : []),
         // With universe_scan, the validator's gate is WATCH-membership (manual
         // watchlist ∪ this cycle's discovered entries) — saying "ONLY these" here
         // while the universe-scan section below calls discovered movers tradable
         // made cap-obedient models refuse every discovered candidate (the caps
         // header says proposing outside a cap wastes the cycle). Keep the two
         // sections telling one story.
-        spec.capabilities.includes("universe_scan")
-            ? `- tradable symbols (spot + futures): your watchlist (${r.watchlist.join(", ")}) PLUS this cycle's watch entries marked \`discovered: true\` — nothing outside those`
-            : `- watchlist (spot + futures use ONLY these): ${r.watchlist.join(", ")}`,
-        ...(r.blocklist && r.blocklist.length > 0
+        ...(hasCoinVenue
+            ? [
+                spec.capabilities.includes("universe_scan")
+                    ? `- tradable symbols (${coinVenueLabel}): your watchlist (${r.watchlist.join(", ")}) PLUS this cycle's watch entries marked \`discovered: true\` — nothing outside those`
+                    : `- watchlist (${coinVenueLabel} use ONLY these): ${r.watchlist.join(", ")}`,
+            ]
+            : []),
+        ...(hasCoinVenue && r.blocklist && r.blocklist.length > 0
             ? [
                 `- deny-list (NEVER open these, even if on the watchlist): ${r.blocklist.join(", ")}`,
             ]
             : []),
-        "- prediction markets are a FIRST-CLASS venue for you — a pm_open is as real a trade as a futures/spot open, not an afterthought. Each observation.pmMarkets entry carries a short `ref` (pm1, pm2, …), an `outcome` label, and `prob` (0..1, the market's CURRENT odds). BET (pm_open) an outcome when YOUR estimate of its true probability differs MATERIALLY from the market's — that gap is your edge (e.g. prob 0.35 but you think it's really ~0.55 -> buy). Skip only markets pinned near 0 or 1 (no edge left). Every entry in observation.pmMarkets is already filtered to one you CAN open (binary/settlement-grade) — so a listed market will not bounce at quote. Pick ONLY a listed market and identify it by copying its `ref` into the action; min stake 10 mUSD. Do NOT re-bet a market+outcome you ALREADY hold (check observation.pmPositions) — that is churn and will be rejected; bet a DIFFERENT market or skip.",
-        "- PM stake is a SEPARATE budget from your futures margin: the futures margin cap (maxOpenMarginMusd) does NOT limit pm_open. So when your futures are at the margin/position cap — you hold the max, or a futures_open keeps getting REJECTED with open_margin_exceeds_cap — prediction markets are STILL fully open to you. PIVOT to pm_open on a mispriced market instead of re-proposing a futures_open that will just be rejected: a rejected open wastes the entire cycle, an eligible PM bet does not.",
-        "- YOUR SHARPEST PM EDGE is the crypto price view you JUST formed: crypto PM markets resolve on the very prices you analyse, so you have a genuine information edge there that you do NOT have on coin futures alone. EVERY cycle you reach a price conviction, it is REQUIRED that you scan observation.pmMarkets for a LISTED crypto market that same view prices wrong and, if one is materially mispriced, open it with pm_open by its `ref` — treat that mispricing exactly like a flagged coin setup (an ACT, not a skip). If you are bearish BTC, a 'BTC above $X by <date>' priced high is a NO; if bullish ETH, an 'ETH above $Y' priced low is a YES. ESCAPE HATCH — only the markets actually listed in observation.pmMarkets THIS cycle (pm1..pmN) are bettable: if NONE of them matches the coin or view you formed, that is a legitimate SKIP for PM (say so in one clause and move on) — do NOT invent, guess, or increment a ref for a market you wish existed, because a made-up ref is rejected (pm_ref_unknown) and wastes the whole cycle exactly like a rejected open. The mistake to avoid is leaving a LISTED, clearly mispriced crypto market untraded — a mispricing that is NOT on this cycle's board is simply not actionable now, not a miss. (For non-crypto events you have no special edge; skip unless the odds are obviously off.)",
+        ...(hasPm
+            ? [
+                "- prediction markets are a FIRST-CLASS venue for you — a pm_open is as real a trade as a futures/spot open, not an afterthought. Each observation.pmMarkets entry carries a short `ref` (pm1, pm2, …), an `outcome` label, and `prob` (0..1, the market's CURRENT odds). BET (pm_open) an outcome when YOUR estimate of its true probability differs MATERIALLY from the market's — that gap is your edge (e.g. prob 0.35 but you think it's really ~0.55 -> buy). Skip only markets pinned near 0 or 1 (no edge left). Every entry in observation.pmMarkets is already filtered to one you CAN open (binary/settlement-grade) — so a listed market will not bounce at quote. Pick ONLY a listed market and identify it by copying its `ref` into the action; min stake 10 mUSD. Do NOT re-bet a market+outcome you ALREADY hold (check observation.pmPositions) — that is churn and will be rejected; bet a DIFFERENT market or skip.",
+                "- PM stake is a SEPARATE budget from your futures margin: the futures margin cap (maxOpenMarginMusd) does NOT limit pm_open. So when your futures are at the margin/position cap — you hold the max, or a futures_open keeps getting REJECTED with open_margin_exceeds_cap — prediction markets are STILL fully open to you. PIVOT to pm_open on a mispriced market instead of re-proposing a futures_open that will just be rejected: a rejected open wastes the entire cycle, an eligible PM bet does not.",
+                "- YOUR SHARPEST PM EDGE is the crypto price view you JUST formed: crypto PM markets resolve on the very prices you analyse, so you have a genuine information edge there that you do NOT have on coin futures alone. EVERY cycle you reach a price conviction, it is REQUIRED that you scan observation.pmMarkets for a LISTED crypto market that same view prices wrong and, if one is materially mispriced, open it with pm_open by its `ref` — treat that mispricing exactly like a flagged coin setup (an ACT, not a skip). If you are bearish BTC, a 'BTC above $X by <date>' priced high is a NO; if bullish ETH, an 'ETH above $Y' priced low is a YES. ESCAPE HATCH — only the markets actually listed in observation.pmMarkets THIS cycle (pm1..pmN) are bettable: if NONE of them matches the coin or view you formed, that is a legitimate SKIP for PM (say so in one clause and move on) — do NOT invent, guess, or increment a ref for a market you wish existed, because a made-up ref is rejected (pm_ref_unknown) and wastes the whole cycle exactly like a rejected open. The mistake to avoid is leaving a LISTED, clearly mispriced crypto market untraded — a mispricing that is NOT on this cycle's board is simply not actionable now, not a miss. (For non-crypto events you have no special edge; skip unless the odds are obviously off.)",
+            ]
+            : []),
         ...(includeForecast
             ? [
                 "- FORECAST RULE (pm_open forecastProbability): before you look at what the market is pricing, decide YOUR OWN probability the outcome you are backing actually WINS — reason ONLY from the question, its resolution criteria, and the deadline. Put that number (1-99, whole or one decimal) in `forecastProbability`. This is graded against reality as your PUBLIC calibration record, so it must be YOUR judgement, NOT the market's: do NOT copy, round, or anchor it to the observation.pmMarkets `prob`. It is FINE if your honest forecast happens to land on the market's number — but reaching that by echoing the price defeats the point. If you genuinely cannot form an independent view, OMIT the field rather than parroting the market (an absent forecast is better than a fake one, and it never blocks the bet).",
@@ -111,7 +143,11 @@ opts = {}) {
                 "Each item has `importance` (0..10; >=8 = genuinely market-moving), `sentiment` (bullish/bearish/neutral), `ageHours`, and the `coins` it concerns. Use it to CONFIRM or VETO the price read, never to trade on alone:",
                 "- A fresh high-importance (>=8) bullish story on a coin you're watching strengthens a long and warns against shorting into it; a bearish >=8 is the reverse. A surprise catalyst can matter more than the chart.",
                 "- Weight by importance AND freshness: a 9 from 30 min ago outweighs a stale 4 from yesterday. Old or low-importance news is noise — don't over-react.",
-                "- For PM: a high-importance catalyst is exactly the kind of mispricing edge to act on if the market hasn't repriced it yet.",
+                ...(hasPm
+                    ? [
+                        "- For PM: a high-importance catalyst is exactly the kind of mispricing edge to act on if the market hasn't repriced it yet.",
+                    ]
+                    : []),
             ]
             : []),
         "",
@@ -124,12 +160,24 @@ opts = {}) {
         "## How to act — a decisive trader in character, not a bystander",
         "You ARE the character in the strategy above; trade like it. When you have a clear read — even a moderate-confidence one — TAKE THE POSITION, sized within your caps and protected with a stop. You wake every cycle and people watch you live: an agent that watches forever and never commits is useless to them and to itself.",
         "Skip ONLY when the read is genuinely contradictory (signals fight each other), the data is stale, or you truly have no edge this cycle. A quiet tape where your thesis still has a small but REAL edge is an ACT, not a skip — take it, small, with a stop. Do not confuse caution with paralysis.",
-        'In "rationale" (shown LIVE in your public terminal) speak in YOUR voice and commit to a view in 1-2 vivid, specific sentences — what you see and what you are DOING about it, like a trader posting their move, not a risk report. Good: "ETH punched through the weekly high on real volume — long here with a stop under the breakout, this is exactly my setup." Weak: "conditions are mixed, waiting for clarity." Keep "reason" a short label.',
+        'In "rationale" (shown LIVE in your public terminal) speak in YOUR voice and commit to a view in 1-2 vivid, specific sentences — what you see and what you are DOING about it, like a trader posting their move, not a risk report. Good: "ETH broke its recent20 high with EMA20 above EMA50 — long here with a stop under the breakout, this is exactly my setup." Weak: "conditions are mixed, waiting for clarity." Keep "reason" a short label.',
         "",
         "## Flagged setups this cycle — your wake-up list (observation.setups)",
         "A deterministic scan already checked every watchlist coin and put the ones with real, tradeable structure RIGHT NOW into observation.setups — each has symbol, kind, bias, strength, and a factual note (trend / RSI / breakout / ATR reads). This is your shortlist; you do NOT need to re-derive whether a setup exists.",
         '- If observation.setups is NON-EMPTY: act on the strongest one that fits YOUR strategy. The `bias` is the trend-following read; if you are a contrarian / mean-reversion trader, FADE it with the same facts (e.g. a downtrend that is also "RSI oversold" is YOUR long). Skipping a flagged setup needs a SPECIFIC reason tied to your thesis — "no clear setup" is NOT a valid skip when setups are listed.',
-        "- If observation.setups is EMPTY: no coin has a flagged structure right now — but BEFORE you skip, check observation.pmMarkets for a crypto market your current read prices wrong (a PM mispricing is a valid ACT even with zero coin setups). Only then, if nothing is mispriced, skip new entries and just manage any open positions.",
+        // The act-pressure above must never outrank a hard cap: without this
+        // release valve a direction-constrained agent, staring at only wrong-way
+        // setups, is squeezed between "skipping needs a specific reason" and a
+        // constraint the runner enforces — that squeeze is how a short-only agent
+        // opened momentum longs on 2026-08-24.
+        ...(r.direction
+            ? [
+                `- Your DIRECTION cap outranks this list: a setup whose only actionable read violates it (${r.direction === "short_only" ? "long" : "short"}-side) is a LEGITIMATE skip — name the constraint in one clause and move on. Never take the wrong side to avoid skipping.`,
+            ]
+            : []),
+        hasPm
+            ? "- If observation.setups is EMPTY: no coin has a flagged structure right now — but BEFORE you skip, check observation.pmMarkets for a crypto market your current read prices wrong (a PM mispricing is a valid ACT even with zero coin setups). Only then, if nothing is mispriced, skip new entries and just manage any open positions."
+            : "- If observation.setups is EMPTY: no coin has a flagged structure right now — skip new entries and just manage any open positions.",
         "- A setup tagged `held` (held: long|short) is a position you ALREADY hold. Do NOT propose a new open on it — that only hits the margin cap and wastes the cycle. MANAGE it instead: trail the stop toward your target, ADD only if you have margin room AND fresh conviction, or cut if the thesis broke.",
         "",
         "## After you act — hold with conviction, do not churn",
@@ -140,7 +188,14 @@ opts = {}) {
         "Each cycle, look at your OPEN positions FIRST, not just new entries. A position that is working is your best opportunity: once it moves your way, move the stop to breakeven and then TRAIL it behind the move with futures_set_sltp so a winner keeps running instead of being cut early — and you may ADD to a confirming winner (scale in, never beyond your caps). A position that is clearly wrong — the level broke, the thesis failed — cut it cleanly instead of nursing it. Riding one good trade beats opening ten fresh ones.",
     ].join("\n");
 }
-export function buildUserPrompt(obs, journal) {
+export function buildUserPrompt(obs, journal, opts = {}) {
+    // Default to every venue for backwards-compatible direct callers and probes.
+    // The runner always supplies the real spec, so disabled venue instructions and
+    // empty observation blocks never consume prompt space or invite invalid acts.
+    const venues = opts.venues ?? ["futures", "spot", "pm"];
+    const hasFutures = venues.includes("futures");
+    const hasSpot = venues.includes("spot");
+    const hasPm = venues.includes("pm");
     const lines = [
         "Decide for THIS cycle using only the observation below (data available now — no look-ahead).",
     ];
@@ -150,8 +205,17 @@ export function buildUserPrompt(obs, journal) {
     // zeroes the cycle). There is nothing to manage when flat, so say so plainly and
     // point the model at OPENING. (Observed: an 8B agent dead 36/60 cycles this way.)
     if ((obs.openPositions?.length ?? 0) === 0 &&
-        (obs.pmPositions?.length ?? 0) === 0) {
-        lines.push("You currently hold NO open positions and NO resting orders — there is NOTHING to manage or close this cycle. Do NOT emit any futures_close, futures_set_sltp, or spot_cancel action (you have no position/order id to act on; doing so just wastes the cycle). Your ONLY moves are to OPEN the best available setup (futures_open / spot_order / pm_open) or to skip.");
+        (!hasPm || (obs.pmPositions?.length ?? 0) === 0)) {
+        const openingActions = [
+            ...(hasFutures ? ["futures_open"] : []),
+            ...(hasSpot ? ["spot_order"] : []),
+            ...(hasPm ? ["pm_open"] : []),
+        ];
+        const forbiddenActions = [
+            ...(hasFutures ? ["futures_close", "futures_set_sltp"] : []),
+            ...(hasSpot ? ["spot_cancel"] : []),
+        ];
+        lines.push(`You currently hold NO open positions${hasPm ? " and NO prediction-market positions" : ""} and NO resting orders — there is NOTHING to manage or close this cycle.${forbiddenActions.length > 0 ? ` Do NOT emit any ${forbiddenActions.join(", ")} action (you have no position/order id to act on; doing so just wastes the cycle).` : ""} Your ONLY moves are to OPEN the best available setup (${openingActions.join(" / ")}) or to skip.`);
     }
     // Slice-3 memory: the agent's own recent moves, so it manages with continuity —
     // remembers the thesis behind each open position and does not re-open an idea it
@@ -161,7 +225,8 @@ export function buildUserPrompt(obs, journal) {
     }
     // Settlement-feedback loop: surface the agent's recently-RESOLVED PM bets so the
     // model can reflect and adapt. Reflective context only — never a new action.
-    lines.push(...formatPmResolutions(obs.pmResolutions ?? []));
+    if (hasPm)
+        lines.push(...formatPmResolutions(obs.pmResolutions ?? []));
     lines.push("", "```json", 
     // Compact (no pretty-print indentation — ~40% fewer tokens, still valid JSON)
     // and the trade ledger is capped so a busy shared book can't bloat the prompt.
@@ -171,18 +236,22 @@ export function buildUserPrompt(obs, journal) {
         equityMusd: obs.equityMusd,
         openPositions: obs.openPositions,
         openOrders: obs.openOrders,
-        pmPositions: obs.pmPositions,
+        ...(hasPm ? { pmPositions: obs.pmPositions } : {}),
         // Compact display: the model picks a market by its short `ref` and never
         // sees (or mis-copies) the long source/slug/outcomeExternalMarketId — the
         // runner resolves the ref back to those. Also ~halves the PM block's tokens.
-        pmMarkets: obs.pmMarkets.map((m) => ({
-            ref: m.ref,
-            source: m.source,
-            title: m.title,
-            outcome: m.outcomeName,
-            prob: m.probability,
-            freshness: m.freshness?.status,
-        })),
+        ...(hasPm
+            ? {
+                pmMarkets: obs.pmMarkets.map((m) => ({
+                    ref: m.ref,
+                    source: m.source,
+                    title: m.title,
+                    outcome: m.outcomeName,
+                    prob: m.probability,
+                    freshness: m.freshness?.status,
+                })),
+            }
+            : {}),
         watch: obs.watch,
         setups: obs.setups,
         news: obs.news,

package/dist/agent/providerCapabilities.d.ts

@@ -0,0 +1,20 @@
+import { ProviderName } from "./types.js";
+export declare const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+export interface ChatShape {
+    family: "openai-reasoning" | "nvidia-nemotron" | "anthropic" | "openai-compat";
+    tokenParam: "max_tokens" | "max_completion_tokens";
+    allowsTemperature: boolean;
+    jsonResponseFormat: boolean;
+    extraBody?: Record<string, unknown>;
+    systemHint?: string;
+    minProbeCompletionTokens: number;
+}
+export declare function chatShapeFor(provider: ProviderName, model: string, baseUrl?: string): ChatShape;
+/** Build the chat-completions body for a route from its capability shape. */
+export declare function buildChatBody(shape: ChatShape, args: {
+    model: string;
+    system: string;
+    user: string;
+    maxTokens: number;
+    temperature?: number;
+}): Record<string, unknown>;

package/dist/agent/providerCapabilities.js

@@ -0,0 +1,67 @@
+export const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+// gpt-5*, o1/o3/o4* — the OpenAI reasoning-API family, wherever it is served.
+const OPENAI_REASONING_MODEL = /^(gpt-5|o[0-9])/i;
+const NEMOTRON_MODEL = /nemotron/i;
+export function chatShapeFor(provider, model, baseUrl) {
+    if (provider === "anthropic") {
+        return {
+            family: "anthropic",
+            tokenParam: "max_tokens",
+            allowsTemperature: true,
+            jsonResponseFormat: false,
+            minProbeCompletionTokens: 1024,
+        };
+    }
+    if (provider === "openai" || OPENAI_REASONING_MODEL.test(model)) {
+        return {
+            family: "openai-reasoning",
+            tokenParam: "max_completion_tokens",
+            allowsTemperature: false,
+            jsonResponseFormat: true,
+            minProbeCompletionTokens: 1024,
+        };
+    }
+    if (NEMOTRON_MODEL.test(model)) {
+        return {
+            family: "nvidia-nemotron",
+            tokenParam: "max_tokens",
+            allowsTemperature: true,
+            jsonResponseFormat: true,
+            // The kwargs switch is only honored (and only safe to send) on the NVIDIA
+            // endpoint; the system hint helps on any endpoint serving a Nemotron.
+            extraBody: baseUrl === NVIDIA_BASE_URL
+                ? { chat_template_kwargs: { enable_thinking: false } }
+                : undefined,
+            systemHint: "detailed thinking off",
+            minProbeCompletionTokens: 1024,
+        };
+    }
+    return {
+        family: "openai-compat",
+        tokenParam: "max_tokens",
+        allowsTemperature: true,
+        jsonResponseFormat: true,
+        minProbeCompletionTokens: 1024,
+    };
+}
+/** Build the chat-completions body for a route from its capability shape. */
+export function buildChatBody(shape, args) {
+    const system = shape.systemHint
+        ? `${shape.systemHint}\n\n${args.system}`
+        : args.system;
+    return {
+        model: args.model,
+        ...(shape.allowsTemperature
+            ? { temperature: args.temperature ?? 0.2 }
+            : {}),
+        [shape.tokenParam]: args.maxTokens,
+        ...(shape.jsonResponseFormat
+            ? { response_format: { type: "json_object" } }
+            : {}),
+        ...(shape.extraBody ?? {}),
+        messages: [
+            { role: "system", content: system },
+            { role: "user", content: args.user },
+        ],
+    };
+}

package/dist/agent/providers.d.ts

@@ -1,10 +1,28 @@
-import { AgentSpec } from "./types.js";
+import { AgentSpec, ProviderName } from "./types.js";
 export interface DecideInput {
     system: string;
     user: string;
     maxTokens?: number;
     timeoutMs?: number;
 }
+export interface DecideRouteAttempt {
+    provider: string;
+    model: string;
+    outcome: "success" | "failed" | "deferred";
+    failureClass?: "capacity" | "permanent" | "transient" | "malformed";
+    status?: number;
+    retryAfterMs?: number;
+    latencyMs: number;
+    error?: string;
+}
+export interface DecideRouteMeta {
+    policyVersion: string;
+    profile: "fast" | "strong" | "configured";
+    effectiveProvider?: string;
+    effectiveModel?: string;
+    reason: "configured" | "circuit_fallback" | "capacity_fallback" | "provider_fallback" | "malformed_fallback" | "byo";
+    attempts: DecideRouteAttempt[];
+}
 export type DecideResult = {
     ok: true;
     text: string;
@@ -12,9 +30,14 @@ export type DecideResult = {
         promptTokens: number;
         completionTokens: number;
     };
+    route?: DecideRouteMeta;
 } | {
     ok: false;
     error: string;
+    status?: number;
+    retryAfterMs?: number;
+    deferred?: boolean;
+    route?: DecideRouteMeta;
 };
 export interface Provider {
     label: string;
@@ -29,3 +52,8 @@ export interface ProviderEnv {
     MODEL_API_KEY?: string;
 }
 export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
+export declare function providerForRoute(route: {
+    provider: ProviderName;
+    model: string;
+    baseUrl?: string | null;
+}, apiKey: string, fetchFn?: typeof fetch): Provider;

package/dist/agent/providers.js

@@ -2,9 +2,10 @@
 // never from an agent file. One call returns one chunk of text that must be a
 // single structured-JSON decision (parsed in decision.ts). No free-form tool
 // execution — the model only proposes; the runner disposes.
+import { chatShapeFor, buildChatBody, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
 // NVIDIA NIM is OpenAI-compatible; the `nvidia` preset hard-wires the hosted
 // endpoint so an agent only needs `{ provider: nvidia, name: "<model id>" }`.
-const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+const NVIDIA_BASE_URL = CAP_NVIDIA_BASE_URL;
 // Gemini exposes an OpenAI-compatible surface, so the `gemini` preset hard-wires
 // its hosted endpoint — an agent only needs `{ provider: gemini, name: "gemini-2.0-flash" }`
 // plus a GEMINI_API_KEY. The free tier (no credit card, generous Flash quota) makes
@@ -26,16 +27,9 @@ const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai
 // (the recurring Leo/70B timeout). A real hang still aborts -> retried next cadence.
 // MUST stay below the scheduler's RUN_LOCK_SECONDS and HEARTBEAT_STALE_MS.
 const DEFAULT_TIMEOUT_MS = 300_000;
-// Reasoning models (NVIDIA Nemotron) DEFAULT to emitting a long <think> chain:
-// measured ~30-60s/call and a JSON-leak risk. The documented toggle is a
-// "detailed thinking off" line in the system prompt, which drops them to
-// instruct mode (measured ~3-4s, clean JSON). Apply it automatically for any
-// nemotron model so a per-cadence decision never blows the cadence.
-function applyReasoningToggle(model, system) {
-    return /nemotron/i.test(model)
-        ? `detailed thinking off\n\n${system}`
-        : system;
-}
+// Per-route request quirks (reasoning toggles, token param, temperature) live
+// in the capability table — providerCapabilities.ts is the single source; this
+// module only assembles and sends.
 // fetch with a hard timeout via AbortController. A custom fetchFn (tests) that
 // ignores `signal` still works — the timer just never fires for it.
 async function fetchWithTimeout(fetchFn, url, init, timeoutMs) {
@@ -54,6 +48,23 @@ function callError(err, timeoutMs) {
     }
     return err instanceof Error ? err.message : String(err);
 }
+// Parse a Retry-After header (delta-seconds or HTTP-date) into ms, capped at
+// one hour — a provider asking for more is treated as "an hour, then re-probe".
+const RETRY_AFTER_CAP_MS = 3_600_000;
+function retryAfterMs(res) {
+    const raw = res.headers.get("retry-after");
+    if (!raw)
+        return undefined;
+    const secs = Number(raw);
+    if (Number.isFinite(secs) && secs >= 0) {
+        return Math.min(Math.round(secs * 1000), RETRY_AFTER_CAP_MS);
+    }
+    const at = Date.parse(raw);
+    if (!Number.isFinite(at))
+        return undefined;
+    const ms = at - Date.now();
+    return ms > 0 ? Math.min(ms, RETRY_AFTER_CAP_MS) : 0;
+}
 function envKey(provider, env) {
     switch (provider) {
         case "anthropic":
@@ -141,6 +152,8 @@ class AnthropicProvider {
                     // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
                     // unbounded provider error page must not bloat the ledger row.
                     error: `anthropic HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
+                    status: res.status,
+                    retryAfterMs: retryAfterMs(res),
                 };
             const json = (await res.json());
             const text = json.content?.map((c) => c.text ?? "").join("") ?? "";
@@ -160,12 +173,14 @@ class AnthropicProvider {
     }
 }
 class OpenAiCompatProvider {
+    provider;
     model;
     apiKey;
     baseUrl;
     fetchFn;
     label;
-    constructor(model, apiKey, baseUrl, fetchFn) {
+    constructor(provider, model, apiKey, baseUrl, fetchFn) {
+        this.provider = provider;
         this.model = model;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
@@ -174,6 +189,7 @@ class OpenAiCompatProvider {
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const shape = chatShapeFor(this.provider, this.model, this.baseUrl);
         try {
             const res = await fetchWithTimeout(this.fetchFn, `${this.baseUrl}/chat/completions`, {
                 method: "POST",
@@ -181,19 +197,12 @@ class OpenAiCompatProvider {
                     Authorization: `Bearer ${this.apiKey}`,
                     "content-type": "application/json",
                 },
-                body: JSON.stringify({
+                body: JSON.stringify(buildChatBody(shape, {
                     model: this.model,
-                    temperature: 0.2,
-                    max_tokens: input.maxTokens ?? 1024,
-                    response_format: { type: "json_object" },
-                    messages: [
-                        {
-                            role: "system",
-                            content: applyReasoningToggle(this.model, input.system),
-                        },
-                        { role: "user", content: input.user },
-                    ],
-                }),
+                    system: input.system,
+                    user: input.user,
+                    maxTokens: input.maxTokens ?? 1024,
+                })),
             }, timeoutMs);
             if (!res.ok)
                 return {
@@ -201,6 +210,8 @@ class OpenAiCompatProvider {
                     // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
                     // unbounded provider error page must not bloat the ledger row.
                     error: `provider HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
+                    status: res.status,
+                    retryAfterMs: retryAfterMs(res),
                 };
             const json = (await res.json());
             const text = json.choices?.[0]?.message?.content ?? "";
@@ -251,5 +262,19 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    return new OpenAiCompatProvider(name, key, resolvedBase, fetchFn);
+    return new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+}
+// Build a provider for an EXPLICIT route + raw key (no spec, no env) — the
+// decision probe's entry point. Same classes as selectProvider, so a probe
+// exercises byte-identical request shapes to a real cycle.
+export function providerForRoute(route, apiKey, fetchFn = fetch) {
+    if (route.provider === "mechanical")
+        return new MechanicalProvider(route.model);
+    if (route.provider === "anthropic")
+        return new AnthropicProvider(route.model, apiKey, fetchFn);
+    const resolvedBase = baseUrlFor(route.provider, route.baseUrl ?? undefined);
+    if (!resolvedBase) {
+        throw new Error("openai-compatible route needs a baseUrl");
+    }
+    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn);
 }

package/dist/agent/resolve.d.ts

@@ -14,7 +14,7 @@ export declare function mergeProseParts(parts: Array<{
     text: string;
 }>): string;
 export declare function resolveAgent(inputPath: string): ResolvedAgent;
-export declare const HOSTED_PROSE_MAX_CHARS = 8000;
+export declare const HOSTED_PROSE_MAX_CHARS = 12000;
 /** PURE — exported for tests. Mirrors the backend's trim-then-measure. */
 export declare const hostedProseBudget: (mergedProse: string) => {
     used: number;

package/dist/agent/resolve.js

@@ -592,7 +592,26 @@ export function resolveAgent(inputPath) {
 // tokens / 413s per cycle. Mirrored here (backend-v2
 // controllers/agentManage.ts sanitizeStrategyProse) so `validate --hosted`
 // can catch it before a user does.
-export const HOSTED_PROSE_MAX_CHARS = 8000;
+//
+// 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;

package/dist/agent/runner.js

@@ -518,55 +518,100 @@ 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/model_not_found is a
+            // Permanent-failure classification: a 404/410/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.
+            // 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) {
-                    state.disabled = true;
-                    state.disabledReason = `model_unavailable: ${res.error.slice(0, 160)}`;
+                    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(`disabled: ${state.disabledReason}`);
+                    log(`provider hold: ${hold.provider}/${hold.model} — ${res.error.slice(0, 120)}`);
                     return {
                         decision: "skip",
-                        skipReason: `model error: ${res.error}`,
+                        skipReason: `provider hold: ${res.error}`,
                         planned: [],
                         modelFailed: true,
-                        disabled: true,
-                        disabledReason: state.disabledReason,
+                        providerHold: hold,
                         live,
                         ...meter,
                         decisionType: "model_error",

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.js

@@ -97,7 +97,7 @@ const MODEL_FAILURE_FLOOR = 10;
 // 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_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);

package/dist/agent/strictLint.js

@@ -47,6 +47,7 @@ const ALLOWED_KEYS = {
         "requireStopLoss",
         "watchlist",
         "blocklist",
+        "direction",
     ],
     sizing: null,
     limits: [

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;
@@ -340,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;
@@ -348,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/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.js

@@ -971,16 +971,16 @@ export function registerTools(server, client) {
     }, async ({ runId, agentTrace }, extra) => present(await client.exportLedger({ runId }, requestKey(extra), agentTrace)));
     server.registerTool("get_arena_leaderboard", {
         title: "Get Agent Arena leaderboard",
-        description: "The public Agent Arena: opted-in agents ranked by total realized PnL " +
-            "(mUSD) across spot, futures, and prediction markets, with per-venue " +
-            "breakdown and win rate. Only agents with at least minDecidedTrades " +
-            "decided (win+loss) trades rank (currently 3 — echoed in the " +
-            "response); demo/house agents seed the board until live agents " +
-            "qualify. Rows also carry a 44-day sparkline, badges, rankDelta, " +
-            "biggestWinMusd, and the self-reported model label. Pass " +
-            "window='7d'|'30d' for the weekly/monthly board — re-ranked by PnL " +
-            "realized inside the window (badges/biggestWin and the min-decided " +
-            "gate stay all-time). Use it to see the field and where you stand — pair " +
+        description: "The public Agent Arena across spot, futures, and prediction markets. " +
+            "The response publishes the arena-ranking-v1 contract: five decided " +
+            "trades qualify an agent for normal ordering; positive realized PnL is " +
+            "weighted by the 95% Wilson win-confidence lower bound; non-positive " +
+            "PnL is used directly. Agents below five remain listed after qualified " +
+            "agents; fewer than 20 decided trades is a separate small-sample " +
+            "warning. Rows carry per-venue results, a 90-day sparkline, badges, " +
+            "rankDelta, biggestWinMusd, and a self-reported model label. Pass " +
+            "window='today'|'24h'|'7d'|'30d'|'3m'|'all'. Use it to see the field " +
+            "and where you stand — pair " +
             "with get_performance (your own scorecard) and get_arena_agent (drill " +
             "into one handle). Public data: agent names + performance only. " +
             PAPER_NOTE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinrithm/mcp-trading",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "mcpName": "io.github.CoinRithm/mcp-trading",
   "description": "CoinRithm paper-trading toolkit: an MCP server (coinrithm-mcp) AND a self-host agent runner (coinrithm-agent) for spot, futures, and prediction markets with a user-minted API key.",
   "type": "module",