@coinrithm/mcp-trading 0.7.12 → 0.7.14

package/dist/agent/observe.js

@@ -6,10 +6,10 @@ import { computeIndicators } from "./indicators.js";
 import { scanSetups } from "./setups.js";
 import { freshnessOf, pmQualityOf, pmDecisionSupportOf } from "./pmContext.js";
 import { deriveCapitalBook, usesCapitalSizing } from "./capitalSizing.js";
-// Candle granularity feeding the indicators: the 1D range = 5-minute candles
-// (~5-min fresh, ~288 bars — ample for EMA50/RSI14/Bollinger20), which suits the
-// short cadence the hosted house agents run on. Probe-verified 2026-06-17.
+// The 1D endpoint nominally returns 288 five-minute bars. Timestamps and gaps
+// are checked separately; requesting this range does not establish freshness.
 const INDICATOR_RANGE = "1D";
+const INDICATOR_INTERVAL_SECONDS = 300;
 // `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).
@@ -73,6 +73,49 @@ const PM_CALIBRATION_CHURN_RE = /(updown|up-or-down|-5-?min|-5m-|-15m|15m(?:-|$)
 export function isCalibrationChurnMarket(market) {
     return PM_CALIBRATION_CHURN_RE.test(`${market.slug ?? ""} ${market.title ?? ""}`);
 }
+// The live endpoint's t is Unix seconds. Missing/malformed values (including
+// millisecond epochs) stay unknown; never substitute retrieval time.
+function candleTimestamp(value) {
+    return typeof value === "number" &&
+        Number.isInteger(value) &&
+        value > 0 &&
+        value <= 253_402_300_799
+        ? value
+        : undefined;
+}
+function candleIntervals(times) {
+    let timestampedBarCount = 0;
+    let checkedIntervalCount = 0;
+    let irregularIntervalCount = 0;
+    let maxGapSeconds;
+    for (let i = 0; i < times.length; i++) {
+        const current = times[i];
+        if (current === undefined)
+            continue;
+        timestampedBarCount++;
+        const previous = times[i - 1];
+        if (previous === undefined)
+            continue;
+        const gap = current - previous;
+        checkedIntervalCount++;
+        if (gap !== INDICATOR_INTERVAL_SECONDS)
+            irregularIntervalCount++;
+        maxGapSeconds = Math.max(maxGapSeconds ?? 0, gap);
+    }
+    const intervalStatus = irregularIntervalCount > 0
+        ? "irregular"
+        : times.length < 2 || timestampedBarCount !== times.length
+            ? "unknown"
+            : "regular";
+    return {
+        barCount: times.length,
+        timestampedBarCount,
+        checkedIntervalCount,
+        irregularIntervalCount,
+        intervalStatus,
+        ...(maxGapSeconds === undefined ? {} : { maxGapSeconds }),
+    };
+}
 // Fetch candles for one coin and reduce them to a compact indicator bundle plus
 // the 24h volume. Tolerant by design: any failure (HTTP error, malformed/sparse
 // candles) yields null indicators so the cycle proceeds with price-only context
@@ -90,8 +133,11 @@ async function fetchCandleContext(client, coinId, trace) {
     }
     if (!cr.ok)
         return { indicators: null };
-    // Endpoint shape: { candles: [{ t, o, h, l, c, v }] } ascending (oldest first).
+    // Endpoint shape: { candles: [{ t, o, h, l, c, v, vm }] } ascending (oldest first).
     const candles = [];
+    const times = [];
+    let latestVolume;
+    let latestVolumeMissingVenues;
     for (const raw of asArr(asObj(cr.data).candles)) {
         const c = asObj(raw);
         const open = asNum(c.o);
@@ -100,12 +146,37 @@ async function fetchCandleContext(client, coinId, trace) {
         const close = asNum(c.c);
         if (open == null || high == null || low == null || close == null)
             continue;
-        candles.push({ open, high, low, close, volume: asNum(c.v) ?? undefined });
+        const volume = asNum(c.v);
+        candles.push({ open, high, low, close, volume: volume ?? undefined });
+        times.push(candleTimestamp(c.t));
+        latestVolume = volume != null && volume >= 0 ? volume : undefined;
+        const coverage = asNum(c.vm);
+        latestVolumeMissingVenues =
+            latestVolume != null &&
+                coverage != null &&
+                Number.isInteger(coverage) &&
+                coverage >= 0
+                ? coverage
+                : undefined;
     }
-    const lastVolume = candles.length > 0 ? candles[candles.length - 1].volume : undefined;
+    const latestTime = times.at(-1);
+    const recent = candleIntervals(times.slice(-15));
     return {
         indicators: computeIndicators(candles),
-        volume24hUsd: typeof lastVolume === "number" && lastVolume > 0 ? lastVolume : undefined,
+        indicatorContext: {
+            range: INDICATOR_RANGE,
+            nominalIntervalSeconds: INDICATOR_INTERVAL_SECONDS,
+            ...candleIntervals(times),
+            ...(latestTime === undefined
+                ? {}
+                : { asOf: new Date(latestTime * 1000).toISOString() }),
+            recent15: {
+                barCount: recent.barCount,
+                intervalStatus: recent.intervalStatus,
+            },
+        },
+        volume24hUsd: latestVolume,
+        volumeMissingVenues: latestVolumeMissingVenues,
     };
 }
 // The fundamentals leg of a watch entry, read from the /market context the
@@ -135,12 +206,20 @@ async function enrichFromCandles(client, entry, coinId, trace) {
     const cc = await fetchCandleContext(client, coinId, trace);
     if (cc.indicators)
         entry.indicators = cc.indicators;
+    if (cc.indicatorContext)
+        entry.indicatorContext = cc.indicatorContext;
     if (cc.volume24hUsd != null) {
         entry.fundamentals = {
             ...(entry.fundamentals ?? {}),
             volume24hUsd: cc.volume24hUsd,
         };
     }
+    if (cc.volumeMissingVenues != null) {
+        entry.fundamentals = {
+            ...(entry.fundamentals ?? {}),
+            volumeMissingVenues: cc.volumeMissingVenues,
+        };
+    }
 }
 const HEADLINES_PER_COIN = 3;
 const HEADLINE_TITLE_CHARS = 110;
@@ -316,6 +395,14 @@ export async function observe(client, spec, state, trace) {
         // and could not tell a winner from a small loser before a manual close.
         // Tolerant fallbacks keep older/mocked shapes working.
         const coin = asObj(p.coin);
+        const fundingPaidMusd = Object.prototype.hasOwnProperty.call(p, "fundingPaidMusd")
+            ? (asNum(p.fundingPaidMusd) ??
+                (p.fundingPaidMusd === null ? null : undefined))
+            : undefined;
+        const fundingAppliedThrough = Object.prototype.hasOwnProperty.call(p, "fundingAppliedThrough")
+            ? (asStr(p.fundingAppliedThrough) ??
+                (p.fundingAppliedThrough === null ? null : undefined))
+            : undefined;
         return {
             venue: "futures",
             id: Number(asNum(p.id) ?? p.id),
@@ -327,6 +414,10 @@ export async function observe(client, spec, state, trace) {
             leverage: asNum(p.leverage),
             marginMusd: asNum(p.marginMusd),
             unrealizedPnlMusd: asNum(p.unrealizedPnlMusd),
+            ...(fundingPaidMusd !== undefined ? { fundingPaidMusd } : {}),
+            ...(fundingAppliedThrough !== undefined
+                ? { fundingAppliedThrough }
+                : {}),
             entryPrice: asNum(p.entryPrice),
             markPrice: asNum(p.markPrice),
             liquidationPrice: asNum(p.liquidationPrice),

package/dist/agent/prompt.js

@@ -147,6 +147,11 @@ opts = {}) {
                 "- 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 && typeof r.pmMinEntryProbabilityPct === "number"
+            ? [
+                `- PM ENTRY FLOOR: pm_open on an outcome whose market probability is below ${r.pmMinEntryProbabilityPct} points is REJECTED by the runner (the chosen outcome's own price; fees are not counted). Do not propose cheaper longshots; look for edge on outcomes priced at or above the floor.`,
+            ]
+            : []),
         ...(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). A forecast you DO give is enforced: if it is not above what the outcome currently costs, the open is rejected, because buying something you price below the market is a losing trade by your own numbers.",
@@ -156,7 +161,8 @@ opts = {}) {
         ...(spec.capabilities.includes("indicators")
             ? [
                 "",
-                "## Signals — each watch entry may carry `indicators` (computed from 5-minute candles)",
+                "## Signals — each watch entry may carry `indicators` (nominal five-minute candles)",
+                "- `indicatorContext` reports accepted candle counts, source `asOf` and intervalStatus (regular/irregular/unknown); compare its asOf with observation.asOf for age. /market freshness is separate. nominalIntervalSeconds=300 does not prove fresh, continuous candles. Missing timestamps are unknown; stale, future-dated or irregular candles do not establish a current five-minute signal. `recent15` describes only recent spacing; Wilder atr14 also retains earlier history, so recent regularity does not erase older gaps.",
                 "- rsi14: momentum (>70 overbought, <30 oversold); ema20 & ema50: trend; atr14: volatility (size stops off it); bollinger {upper,mid,lower}; recent20 {high,low}: breakout levels.",
                 "- boolean reads: aboveEma20, ema20AboveEma50 (uptrend when both true), brokeRecentHigh (breakout), brokeRecentLow (breakdown).",
                 "- a null field = not enough data; ignore it. These INFORM your decision; they never widen a cap.",
@@ -338,6 +344,10 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     if (brokenTheses.length > 0) {
         lines.push("", "## Positions whose thesis is INVALIDATED this cycle", ...brokenTheses.map((b) => `- ${b}`));
     }
+    if (obs.openPositions.some((p) => p.fundingPaidMusd !== undefined ||
+        p.fundingAppliedThrough !== undefined)) {
+        lines.push("Futures funding shown in the position is already reflected in margin and balances; do not deduct it again when judging available capital or PnL.");
+    }
     // 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.
     if (hasPm)

package/dist/agent/providers.d.ts

@@ -52,6 +52,10 @@ export interface ProviderEnv {
     GEMINI_API_KEY?: string;
     MODEL_API_KEY?: string;
 }
+/** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
+export declare function classifyProviderFailure(result: Extract<DecideResult, {
+    ok: false;
+}>): "capacity" | "permanent" | "transient";
 export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
 export declare function providerForRoute(route: {
     provider: ProviderName;

package/dist/agent/providers.js

@@ -29,6 +29,16 @@ const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai
 // MUST stay below the scheduler's RUN_LOCK_SECONDS and HEARTBEAT_STALE_MS.
 const DEFAULT_TIMEOUT_MS = 300_000;
 const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
+/** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
+export function classifyProviderFailure(result) {
+    if (result.status === 429 ||
+        (result.status === 503 &&
+            /resourceexhausted|worker local total request limit/i.test(result.error ?? "")))
+        return "capacity";
+    if (result.status === 404 || result.status === 410)
+        return "permanent";
+    return "transient";
+}
 // 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.
@@ -332,15 +342,11 @@ class SameModelRetryProvider {
                     error: res.error,
                     status: res.status,
                     retryAfterMs: res.retryAfterMs,
-                    ...(res.status !== undefined
-                        ? {
-                            failureClass: res.status === 429
-                                ? "capacity"
-                                : res.status >= 500
-                                    ? "transient"
-                                    : "permanent",
-                        }
-                        : {}),
+                    failureClass: classifyProviderFailure(res) === "capacity"
+                        ? "capacity"
+                        : res.status !== undefined && res.status < 500
+                            ? "permanent"
+                            : "transient",
                 }
                 : {}),
         });
@@ -350,7 +356,7 @@ class SameModelRetryProvider {
             // or a certificate that returned text passed the trading-decision parser.
             ...result,
             route: {
-                policyVersion: "coinrithm.configured-same-model-retry.v1",
+                policyVersion: "coinrithm.configured-same-model-retry.v2",
                 profile: "configured",
                 effectiveProvider: this.provider,
                 effectiveModel: this.model,

package/dist/agent/resolve.js

@@ -47,7 +47,14 @@ const CONFIG_BLOCKS = [
 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"];
+const PROSE_FILES = [
+    "character/thesis.md",
+    "character/persona.md",
+    "character/entries.md",
+    "character/exits.md",
+    "character/sizing.md",
+    "character/research.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

package/dist/agent/runner.js

@@ -2,6 +2,7 @@
 // spot, futures, and prediction markets. Dry-run never writes. Live uses
 // idempotency keys + agentTrace and exports run evidence. The client + provider
 // are injected so the loop is fully unit-testable with no network/model calls.
+import { classifyProviderFailure } from "./providers.js";
 import { COINRITHM_API } from "./version.js";
 import { spotBuyCost, DEFAULT_TRIGGER_POLICY, } from "./types.js";
 import { usesCapitalSizing, prepareCapitalAction, validateCapitalAction, capitalCashCost, } from "./capitalSizing.js";
@@ -424,6 +425,12 @@ async function runCycleCore(deps, capture) {
     const provenance = buildRunnerProvenance(spec);
     state.cyclesRun += 1;
     rollDay(state);
+    // Old state did not identify which route failed. Carrying that count into
+    // a replacement model can request a hold on its very first error.
+    if (state.consecutivePermanentModelErrors &&
+        !state.permanentModelErrorRoute) {
+        state.consecutivePermanentModelErrors = 0;
+    }
     const runId = state.runId;
     const decisionId = makeDecisionId(state.cyclesRun);
     const captureBase = { runId, decisionId, spec, mergedProse, state };
@@ -580,7 +587,7 @@ async function runCycleCore(deps, capture) {
             ...makeTrace(runId, decisionId, spec, undefined, `Thesis exit: ${why}`),
             ...observationReceipt,
         };
-        const r = await executeAction(client, action, observation, trace, idem, provenance);
+        const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
         exitPlanned.push({
             action,
             accepted: true,
@@ -727,7 +734,7 @@ async function runCycleCore(deps, capture) {
             // only capacity failures. Treat that exactly like a local capacity defer:
             // no action, no fallback invented here, and no model-failure streak that
             // could stop an otherwise healthy agent after repeated quota pressure.
-            const capacityOnlyFailure = (!route && res.status === 429) ||
+            const capacityOnlyFailure = (!route && classifyProviderFailure(res) === "capacity") ||
                 (!!route?.attempts?.length &&
                     route.attempts.every((attempt) => attempt.failureClass === "capacity"));
             if (res.deferred || !actualCallMade || capacityOnlyFailure) {
@@ -763,13 +770,34 @@ async function runCycleCore(deps, capture) {
             // for what deserves them: revoked credentials, drawdown, kill-switch,
             // user action. Transient errors reset the permanent streak.
             if (isPermanentModelError(res.error)) {
+                // The router retains the last non-capacity failure even when a later
+                // fallback returns 429. Its effective route still describes the last
+                // actual call for metering, not necessarily the error returned here.
+                const failureAttempt = route?.attempts
+                    .slice()
+                    .reverse()
+                    .find((attempt) => attempt.outcome === "failed" &&
+                    attempt.failureClass !== "capacity" &&
+                    attempt.error === res.error);
+                const failureRoute = {
+                    provider: failureAttempt?.provider ??
+                        route?.effectiveProvider ??
+                        providerName,
+                    model: failureAttempt?.model ??
+                        route?.effectiveModel ??
+                        spec.model?.name ??
+                        "unknown",
+                };
+                const previousRoute = state.permanentModelErrorRoute;
+                const sameRoute = previousRoute?.provider === failureRoute.provider &&
+                    previousRoute?.model === failureRoute.model;
                 state.consecutivePermanentModelErrors =
-                    (state.consecutivePermanentModelErrors ?? 0) + 1;
+                    (sameRoute ? (state.consecutivePermanentModelErrors ?? 0) : 0) + 1;
+                state.permanentModelErrorRoute = failureRoute;
                 if (state.consecutivePermanentModelErrors >=
                     PERMANENT_MODEL_ERROR_THRESHOLD) {
                     const hold = {
-                        provider: route?.effectiveProvider ?? spec.model?.provider ?? "unknown",
-                        model: route?.effectiveModel ?? spec.model?.name ?? "unknown",
+                        ...failureRoute,
                         error: res.error.slice(0, 200),
                     };
                     saveState(stateFile, state);
@@ -791,6 +819,7 @@ async function runCycleCore(deps, capture) {
             }
             else {
                 state.consecutivePermanentModelErrors = 0;
+                delete state.permanentModelErrorRoute;
             }
             saveState(stateFile, state);
             log(`model error: ${res.error}`);
@@ -807,6 +836,10 @@ async function runCycleCore(deps, capture) {
                 ...observationReceipt,
             };
         }
+        // A returned model response proves availability even if its decision JSON
+        // is invalid. Output validation keeps its own failure counter below.
+        state.consecutivePermanentModelErrors = 0;
+        delete state.permanentModelErrorRoute;
         const parsed = parseDecision(res.text);
         if (!parsed.ok) {
             state.consecutiveModelFailures += 1;
@@ -829,7 +862,6 @@ async function runCycleCore(deps, capture) {
             };
         }
         state.consecutiveModelFailures = 0;
-        state.consecutivePermanentModelErrors = 0;
         decision = parsed.decision;
     }
     // Reasoning captured for the Arena terminal (keystone transparency): the
@@ -1026,7 +1058,9 @@ async function runCycleCore(deps, capture) {
                 }
             }
         }
-        const quote = await fetchQuote(client, action, observation, baseTrace);
+        const quote = await fetchQuote(client, action, observation, baseTrace, {
+            pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct,
+        });
         // Early PM skip: the quote's openBlocked preview tells us a pm/open right now
         // would be rejected 422 by the open-time quality gate (distinct from the
         // eligible/blockReasons SHAPE gate the validator checks). Bail here with a clear
@@ -1149,7 +1183,7 @@ async function runCycleCore(deps, capture) {
             rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length)),
             ...observationReceipt,
         };
-        const r = await executeAction(client, action, observation, trace, idem, provenance);
+        const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
         planned.push({
             action,
             accepted: true,

package/dist/agent/skill.js

@@ -109,6 +109,15 @@ export function buildSpec(raw) {
                     entryPredicates: risk.entryPredicates,
                 }
                 : {}),
+            // Optional PM entry floor: an absent key stays absent (no floor); an
+            // explicit value is carried AS WRITTEN, malformed or not, so hosted
+            // validation fails closed instead of a typo silently meaning "no floor"
+            // (the same rule entryPredicates follow).
+            ...(risk.pmMinEntryProbabilityPct !== undefined
+                ? {
+                    pmMinEntryProbabilityPct: risk.pmMinEntryProbabilityPct,
+                }
+                : {}),
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),

package/dist/agent/skillValidator.js

@@ -108,6 +108,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");
+        // Optional PM entry floor: absent means no floor; present must be a finite
+        // number of probability points in [0, 100].
+        if (r.pmMinEntryProbabilityPct !== undefined) {
+            const f = r.pmMinEntryProbabilityPct;
+            if (typeof f !== "number" || !Number.isFinite(f) || f < 0 || f > 100)
+                add("skill_risk_pm_entry_floor", "risk.pmMinEntryProbabilityPct must be a number between 0 and 100 (points; omit for no floor)");
+        }
         // 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.
@@ -171,8 +178,10 @@ export function validateSkill(parsed, mode = "self-host") {
                 add("skill_limits_trades", "limits.maxTradesPerDay must be a number >= 0 (0 = unlimited daily trades)");
             if (!isPosNum(l.maxWritesPerCycle))
                 add("skill_limits_writes", "limits.maxWritesPerCycle must be a positive number");
-            if (!isPosNum(l.maxDailyLossMusd))
-                add("skill_limits_loss", "limits.maxDailyLossMusd must be a positive number");
+            // 0 = no daily loss cap: the runner only enforces a positive value and
+            // the hosted API already accepts 0..50,000, so hosted validation must too.
+            if (!isNonNegNum(l.maxDailyLossMusd))
+                add("skill_limits_loss", "limits.maxDailyLossMusd must be a number >= 0 (0 = no daily loss cap)");
             if (!isPosNum(l.maxOpenMarginMusd))
                 add("skill_limits_open", "limits.maxOpenMarginMusd must be a positive number");
         }

package/dist/agent/strictLint.js

@@ -50,6 +50,7 @@ const ALLOWED_KEYS = {
         "blocklist",
         "direction",
         "entryPredicates",
+        "pmMinEntryProbabilityPct",
     ],
     sizing: null,
     capitalSizing: [

package/dist/agent/templates.js

@@ -50,37 +50,37 @@ const PRESETS = {
         modelFail: 5,
     },
 };
-const THESIS_BODY = `# Momentum Futures — strategy
-
-You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
-Everything here is simulated; it is not financial advice and never touches real
-money. Edit this prose freely (any language) — it is your agent's borders.
-
-## Each cycle
-
-1. Ground yourself: read your portfolio and open positions first. Never assume
-   balances or what is already open.
-2. Scan the watchlist. A candidate is a coin whose short and medium momentum
-   agree (both up, or both down) and is not already an open position.
-3. Pick the strongest candidate and commit when the read is clear — even a
-   moderate-confidence one — sized small with a stop. Skip only when the signals
-   contradict or the data is stale; a quiet tape where your edge is still real
-   is an act, not a skip.
-4. Quote before you open. Read the liquidation price and confirm it is sane. If
-   the quote is not eligible, relay the reason and stop.
-5. Open small and protected: enter in the trend direction and set a stop-loss at
-   open. Place the take-profit a touch wider than the stop.
-6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
-   fired while you were not looking, and react to what actually happened.
-
-The hard caps (leverage, margin, watchlist) live in the config blocks above and
+const THESIS_BODY = `# Momentum Futures — strategy
+
+You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
+Everything here is simulated; it is not financial advice and never touches real
+money. Edit this prose freely (any language) — it is your agent's borders.
+
+## Each cycle
+
+1. Ground yourself: read your portfolio and open positions first. Never assume
+   balances or what is already open.
+2. Scan the watchlist. A candidate is a coin whose short and medium momentum
+   agree (both up, or both down) and is not already an open position.
+3. Pick the strongest candidate and commit when the read is clear — even a
+   moderate-confidence one — sized small with a stop. Skip only when the signals
+   contradict or the data is stale; a quiet tape where your edge is still real
+   is an act, not a skip.
+4. Quote before you open. Read the liquidation price and confirm it is sane. If
+   the quote is not eligible, relay the reason and stop.
+5. Open small and protected: enter in the trend direction and set a stop-loss at
+   open. Place the take-profit a touch wider than the stop.
+6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
+   fired while you were not looking, and react to what actually happened.
+
+The hard caps (leverage, margin, watchlist) live in the config blocks above and
 are enforced by the runner — change them there, not in this prose.`;
-const PERSONA_STUB = `# Persona
-
-Decisive and in character. Acts on a clear read — even a moderate-confidence one
-— sized small and protected with a stop, and skips only when the read is
-contradictory or the data is stale. States its reasoning plainly in its own
-voice, and never frames paper results as real-money advice.
+const PERSONA_STUB = `# Persona
+
+Decisive and in character. Acts on a clear read — even a moderate-confidence one
+— sized small and protected with a stop, and skips only when the read is
+contradictory or the data is stale. States its reasoning plainly in its own
+voice, and never frames paper results as real-money advice.
 `;
 export function buildAgentObject(name, preset) {
     const p = PRESETS[preset];

package/dist/agent/types.d.ts

@@ -34,6 +34,7 @@ export interface RiskConfig {
     watchlist: string[];
     blocklist?: string[];
     direction?: "long_only" | "short_only";
+    pmMinEntryProbabilityPct?: number;
 }
 export interface LimitsConfig {
     maxTradesPerDay: number;
@@ -133,6 +134,21 @@ export interface Freshness {
     asOf?: string;
     basis?: string;
 }
+export interface IndicatorContext {
+    range: "1D";
+    nominalIntervalSeconds: 300;
+    barCount: number;
+    timestampedBarCount: number;
+    checkedIntervalCount: number;
+    irregularIntervalCount: number;
+    intervalStatus: "regular" | "irregular" | "unknown";
+    maxGapSeconds?: number;
+    asOf?: string;
+    recent15: {
+        barCount: number;
+        intervalStatus: "regular" | "irregular" | "unknown";
+    };
+}
 export interface WatchEntry {
     symbol: string;
     coinId: string | null;
@@ -144,6 +160,7 @@ export interface WatchEntry {
     sentimentBullishPct?: number;
     freshness?: Freshness;
     indicators?: IndicatorSet;
+    indicatorContext?: IndicatorContext;
     discovered?: boolean;
     slug?: string;
     fundamentals?: CoinFundamentals;
@@ -153,6 +170,7 @@ export interface CoinFundamentals {
     marketCapRank?: number;
     marketCapUsd?: number;
     volume24hUsd?: number;
+    volumeMissingVenues?: number;
     headlines?: Array<{
         title: string;
         at?: string;
@@ -171,6 +189,8 @@ export interface OpenPosition {
     leverage?: number;
     marginMusd?: number;
     unrealizedPnlMusd?: number;
+    fundingPaidMusd?: number | null;
+    fundingAppliedThrough?: string | null;
     entryPrice?: number;
     markPrice?: number;
     liquidationPrice?: number;
@@ -397,10 +417,21 @@ export interface QuoteEvidence {
     futuresFeeBps?: number;
     estimatedEntryFeeMusd?: number;
     cashRequiredMusd?: number;
+    funding?: FuturesFundingQuoteEvidence | null;
     freshness?: Freshness;
     openBlocked?: boolean;
     openBlockReasons?: unknown;
 }
+export interface FuturesFundingQuoteEvidence {
+    venue?: string;
+    symbol?: string;
+    rate?: number;
+    intervalHours?: number;
+    nextFundingTime?: string;
+    asOf?: string;
+    estimatedPerIntervalMusd?: number | null;
+    annualizedRate?: number;
+}
 export interface RunState {
     runId: string;
     cyclesRun: number;
@@ -423,6 +454,10 @@ export interface RunState {
     lastLlmCallAt?: number;
     lastTriggerFingerprint?: string;
     consecutivePermanentModelErrors?: number;
+    permanentModelErrorRoute?: {
+        provider: string;
+        model: string;
+    };
     consecutiveAuthFailures?: number;
     journal?: Array<{
         at: string;

package/dist/client.d.ts

@@ -64,7 +64,11 @@ export declare class CoinRithmClient {
     getPublicPmEvent(source: string, slug: string, query?: {
         fiat?: string;
     }): Promise<ApiResult>;
+    /** Best-effort anonymous interest marker for an explicitly viewed open event. */
+    markPublicPmEventViewed(source: string, slug: string): Promise<ApiResult>;
     getPublicPmWhales(): Promise<ApiResult>;
+    getPublicPmWhaleWallets(window?: "7d" | "30d", source?: "polymarket" | "limitless" | "myriad"): Promise<ApiResult>;
+    getPublicPmWhaleWallet(source: string, wallet: string): Promise<ApiResult>;
     getPublicPmMatches(query?: {
         limit?: number;
         offset?: number;
@@ -168,6 +172,9 @@ export declare class CoinRithmClient {
         outcomeExternalMarketId: string;
         side?: "yes" | "no";
         stakeMusd: number;
+        forecastProbability?: number;
+        bankrollMusd?: number;
+        minEntryProbabilityPct?: number;
     } & {
         agentTrace?: AgentTrace;
     }, apiKey?: string): Promise<ApiResult>;
@@ -215,6 +222,8 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         idempotencyKey: string;
         forecastProbability?: number;
+        minEntryProbabilityPct?: number;
+        thesis?: string;
         provenance?: ProvenanceReport;
     }>, apiKey?: string): Promise<ApiResult>;
     reportPmOpportunity(body: TraceableBody<{