@coinrithm/mcp-trading 0.7.15 → 0.7.16

package/dist/agent/setups.js

@@ -10,14 +10,15 @@
 //
 // Pure + stateless: no I/O, no model. Strategy-neutral — it reports the structure
 // and the trend-following bias; a contrarian agent fades the same facts.
+import { DEFAULT_SIGNAL_THRESHOLDS } from "./signals.js";
 // Thresholds tuned to FIRE readily on a normal moving market (the failure mode we
 // are fixing is under-firing). A genuinely flat tape still yields an empty list,
 // which is the correct "nothing to do" signal.
-const STRONG_MOVE_PCT = 2.0; // |24h %| that counts as a real directional push
-const LEAN_MOVE_PCT = 0.8; // smaller move that still confirms an EMA-stack trend
-const RSI_OVERSOLD = 35;
-const RSI_OVERBOUGHT = 68;
-const MIN_STRENGTH = 0.5; // below this we do not flag (avoid noise)
+// Defaults live in signals.ts (DEFAULT_SIGNAL_THRESHOLDS): |24h %| 2.0 for a
+// strong push, 0.8 for a move that still confirms an EMA-stack trend, RSI 35 /
+// 68, and 0.5 as the strength under which nothing is flagged. An agent may
+// declare its own (spec.signals), which changes both this shortlist and the
+// gate that decides whether the model is called.
 function pct(n) {
     return `${n >= 0 ? "+" : ""}${n.toFixed(1)}%`;
 }
@@ -34,7 +35,7 @@ export function baseSymbol(s) {
 // signal — the same structure is a momentum trade to a trend-follower and a
 // mean-reversion trade to a contrarian, so we surface both and let each agent pick
 // the one matching its style (fixes contrarians skipping "no setup fits me").
-function classify(w, openPositions) {
+function classify(w, openPositions, t) {
     const ind = w.indicators;
     if (!ind)
         return [];
@@ -42,8 +43,8 @@ function classify(w, openPositions) {
     const rsi = ind.rsi14;
     const up = ind.ema20AboveEma50 === true && ind.aboveEma20 === true;
     const down = ind.ema20AboveEma50 === false && ind.aboveEma20 === false;
-    const oversold = rsi != null && rsi <= RSI_OVERSOLD;
-    const overbought = rsi != null && rsi >= RSI_OVERBOUGHT;
+    const oversold = rsi != null && rsi <= t.rsiOversold;
+    const overbought = rsi != null && rsi >= t.rsiOverbought;
     // Compact, factual note the model reads (no interpretation — just the structure).
     const facts = [`${pct(ch)} 24h`];
     if (up)
@@ -79,21 +80,21 @@ function classify(w, openPositions) {
             note,
         });
     }
-    else if (up && ch >= LEAN_MOVE_PCT) {
+    else if (up && ch >= t.leanMovePct) {
         out.push({
             symbol: w.symbol,
             kind: "uptrend",
             bias: "long",
-            strength: ch >= STRONG_MOVE_PCT ? 0.75 : 0.6,
+            strength: ch >= t.strongMovePct ? 0.75 : 0.6,
             note,
         });
     }
-    else if (down && ch <= -LEAN_MOVE_PCT) {
+    else if (down && ch <= -t.leanMovePct) {
         out.push({
             symbol: w.symbol,
             kind: "downtrend",
             bias: "short",
-            strength: ch <= -STRONG_MOVE_PCT ? 0.75 : 0.6,
+            strength: ch <= -t.strongMovePct ? 0.75 : 0.6,
             note,
         });
     }
@@ -115,7 +116,7 @@ function classify(w, openPositions) {
             note,
         });
     }
-    else if (Math.abs(ch) >= STRONG_MOVE_PCT) {
+    else if (Math.abs(ch) >= t.strongMovePct) {
         // A strong move with no clean EMA stack — still tradeable momentum.
         out.push({
             symbol: w.symbol,
@@ -170,11 +171,11 @@ function classify(w, openPositions) {
 // Scan the whole watchlist, return the flagged setups strongest-first. An empty
 // list = a flat tape = a legitimate reason to skip new entries this cycle. Setups
 // on a symbol we already hold are tagged `held` (manage, don't re-open).
-export function scanSetups(watch, openPositions = []) {
+export function scanSetups(watch, openPositions = [], thresholds = DEFAULT_SIGNAL_THRESHOLDS) {
     const out = [];
     for (const w of watch) {
-        for (const s of classify(w, openPositions))
-            if (s.strength >= MIN_STRENGTH)
+        for (const s of classify(w, openPositions, thresholds))
+            if (s.strength >= thresholds.minStrength)
                 out.push(s);
     }
     return out.sort((a, b) => b.strength - a.strength);

package/dist/agent/signals.d.ts

@@ -0,0 +1,33 @@
+import type { AgentSpec } from "./types.js";
+export interface SignalThresholds {
+    rsiOversold: number;
+    rsiOverbought: number;
+    strongMovePct: number;
+    leanMovePct: number;
+    minStrength: number;
+}
+export declare const DEFAULT_SIGNAL_THRESHOLDS: SignalThresholds;
+/** Candle range -> bar interval, as GET /api/agent/market/:id/candles serves. */
+export declare const INDICATOR_RANGES: {
+    readonly "1D": 300;
+    readonly "1W": 900;
+    readonly "1M": 3600;
+    readonly "3M": 14400;
+};
+export type IndicatorRange = keyof typeof INDICATOR_RANGES;
+export declare const DEFAULT_INDICATOR_RANGE: IndicatorRange;
+/** Effective thresholds: declared values over the defaults. */
+export declare function signalThresholdsOf(spec: {
+    signals?: Partial<SignalThresholds>;
+}): SignalThresholds;
+export declare function indicatorRangeOf(spec: {
+    data?: {
+        indicatorRange?: IndicatorRange;
+    };
+}): IndicatorRange;
+/** "5-minute", "15-minute", "1-hour", "4-hour". */
+export declare function barLabel(range: IndicatorRange): string;
+/** Validation issues for raw `signals` / `data` blocks ([] when valid). */
+export declare function signalIssues(rawSignals: unknown, rawData: unknown): Array<[string, string]>;
+/** Type guard used where only the spec shape is known. */
+export type SignalSpec = Pick<AgentSpec, "signals" | "data">;

package/dist/agent/signals.js

@@ -0,0 +1,89 @@
+// What counts as a signal, per agent (owner 2026-10-07, Telegram 56624: show
+// that personality changes trade handling; audit: setup thresholds and the
+// indicator window were hard-coded for every agent).
+//
+//   signals:                 # optional; absent = the platform defaults below
+//     rsiOversold: 30        # RSI at or under this flags an oversold fade
+//     rsiOverbought: 72      # RSI at or over this flags an overbought fade
+//     strongMovePct: 3       # |24h %| that counts as a strong push
+//     leanMovePct: 1         # smaller move that still confirms a trend stack
+//     minStrength: 0.6       # flags under this are not raised at all
+//   data:
+//     indicatorRange: 1W     # 1D = 5m bars, 1W = 15m, 1M = 1h, 3M = 4h
+//
+// The flags feed both the prompt's setup shortlist AND the deterministic gate
+// that decides whether a cycle calls the model at all, so these numbers change
+// what the agent notices and when it thinks, not just what it is told.
+export const DEFAULT_SIGNAL_THRESHOLDS = {
+    rsiOversold: 35,
+    rsiOverbought: 68,
+    strongMovePct: 2.0,
+    leanMovePct: 0.8,
+    minStrength: 0.5,
+};
+/** Candle range -> bar interval, as GET /api/agent/market/:id/candles serves. */
+export const INDICATOR_RANGES = {
+    "1D": 300,
+    "1W": 900,
+    "1M": 3_600,
+    "3M": 14_400,
+};
+export const DEFAULT_INDICATOR_RANGE = "1D";
+/** Effective thresholds: declared values over the defaults. */
+export function signalThresholdsOf(spec) {
+    return { ...DEFAULT_SIGNAL_THRESHOLDS, ...(spec.signals ?? {}) };
+}
+export function indicatorRangeOf(spec) {
+    return spec.data?.indicatorRange ?? DEFAULT_INDICATOR_RANGE;
+}
+/** "5-minute", "15-minute", "1-hour", "4-hour". */
+export function barLabel(range) {
+    const s = INDICATOR_RANGES[range];
+    return s < 3_600 ? `${s / 60}-minute` : `${s / 3_600}-hour`;
+}
+const BOUNDS = {
+    rsiOversold: [5, 50],
+    rsiOverbought: [50, 95],
+    strongMovePct: [0.1, 50],
+    leanMovePct: [0.05, 20],
+    minStrength: [0, 1],
+};
+/** Validation issues for raw `signals` / `data` blocks ([] when valid). */
+export function signalIssues(rawSignals, rawData) {
+    const issues = [];
+    const add = (code, reason) => issues.push([code, reason]);
+    const isMap = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    if (rawSignals !== undefined) {
+        if (!isMap(rawSignals)) {
+            add("skill_signals", "signals must be a mapping");
+        }
+        else {
+            for (const [key, [lo, hi]] of Object.entries(BOUNDS)) {
+                const v = rawSignals[key];
+                if (v === undefined)
+                    continue;
+                if (typeof v !== "number" || !Number.isFinite(v) || v < lo || v > hi)
+                    add("skill_signals_range", `signals.${key} must be a number between ${lo} and ${hi}`);
+            }
+            const t = signalThresholdsOf({
+                signals: rawSignals,
+            });
+            if (t.rsiOversold >= t.rsiOverbought)
+                add("skill_signals_rsi", "signals.rsiOversold must be below signals.rsiOverbought");
+            if (t.leanMovePct > t.strongMovePct)
+                add("skill_signals_moves", "signals.leanMovePct must not exceed signals.strongMovePct");
+        }
+    }
+    if (rawData !== undefined) {
+        if (!isMap(rawData)) {
+            add("skill_data", "data must be a mapping");
+        }
+        else if (rawData.indicatorRange !== undefined &&
+            // A real string only: String(['1W']) is "1W" and must not pass.
+            (typeof rawData.indicatorRange !== "string" ||
+                !Object.hasOwn(INDICATOR_RANGES, rawData.indicatorRange))) {
+            add("skill_data_range", `data.indicatorRange must be one of ${Object.keys(INDICATOR_RANGES).join(", ")}`);
+        }
+    }
+    return issues;
+}

package/dist/agent/skill.js

@@ -118,6 +118,32 @@ export function buildSpec(raw) {
                     pmMinEntryProbabilityPct: risk.pmMinEntryProbabilityPct,
                 }
                 : {}),
+            // The three PM policy dials follow the same as-written rule.
+            ...(risk.pmMinEdgeGapPct !== undefined
+                ? {
+                    pmMinEdgeGapPct: risk.pmMinEdgeGapPct,
+                }
+                : {}),
+            ...(risk.pmMaxEdgePoints !== undefined
+                ? {
+                    pmMaxEdgePoints: risk.pmMaxEdgePoints,
+                }
+                : {}),
+            ...(risk.pmMaxOpenPerEvent !== undefined
+                ? {
+                    pmMaxOpenPerEvent: risk.pmMaxOpenPerEvent,
+                }
+                : {}),
+            ...(risk.pmMaxOpenPerCoinHorizon !== undefined
+                ? {
+                    pmMaxOpenPerCoinHorizon: risk.pmMaxOpenPerCoinHorizon,
+                }
+                : {}),
+            ...(risk.pmMinMinutesToClose !== undefined
+                ? {
+                    pmMinMinutesToClose: risk.pmMinMinutesToClose,
+                }
+                : {}),
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),
@@ -155,6 +181,17 @@ export function buildSpec(raw) {
         },
         objective: buildObjective(raw.objective),
         capabilities: strArr(raw.capabilities).filter((c) => ALLOWED_CAPABILITIES.includes(c)),
+        // Signal thresholds and data diet: carried AS WRITTEN so skillValidator
+        // fails closed on a malformed block instead of a typo meaning "defaults".
+        ...(raw.signals !== undefined
+            ? { signals: raw.signals }
+            : {}),
+        ...(raw.data !== undefined ? { data: raw.data } : {}),
+        // Market boundaries: carried AS WRITTEN (an object) so skillValidator can
+        // fail closed on a malformed block instead of a typo meaning "no limits".
+        ...(raw.universe !== undefined
+            ? { universe: raw.universe }
+            : {}),
         // OKF v2 (load-bearing): the gate reads this; omitted -> DEFAULT_TRIGGER_POLICY.
         // This is the agent's INTENT — the platform deployment overlay may tighten it
         // server-side, and it can never widen a hard cap (caps live in the runner).

package/dist/agent/skillValidator.js

@@ -1,5 +1,7 @@
 import { fail, VENUES, PROVIDERS, SPEC_VERSION, OBJECTIVE_PRIMARIES, ALLOWED_CAPABILITIES, } from "./types.js";
+import { universeIssues } from "./universe.js";
 import { parseCadenceMs, scanForSecrets } from "./util.js";
+import { signalIssues } from "./signals.js";
 import { entryPredicateIssues } from "./entryPredicates.js";
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isPosNum = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
@@ -88,6 +90,12 @@ export function validateSkill(parsed, mode = "self-host") {
                 add("skill_venue_unknown", `unknown venue "${String(v)}" (allowed: ${VENUES.join(", ")})`);
         }
     }
+    // Signal thresholds and data diet (optional).
+    for (const [code, reason] of signalIssues(raw.signals, raw.data))
+        add(code, reason);
+    // Market boundaries (optional).
+    for (const [code, reason] of universeIssues(raw.universe))
+        add(code, reason);
     // Risk — always required
     if (!isObj(raw.risk)) {
         add("skill_risk", "risk block is required (the caps the agent runs under)");
@@ -115,6 +123,31 @@ export function validateSkill(parsed, mode = "self-host") {
             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)");
         }
+        if (r.pmMinEdgeGapPct !== undefined) {
+            const g = r.pmMinEdgeGapPct;
+            if (typeof g !== "number" || !Number.isFinite(g) || g < 0 || g > 100)
+                add("skill_risk_pm_edge_gap", "risk.pmMinEdgeGapPct must be a number between 0 and 100 (% of the gap to 100; omit for the global minimum edge only)");
+        }
+        if (r.pmMaxEdgePoints !== undefined) {
+            const m = r.pmMaxEdgePoints;
+            if (typeof m !== "number" || !Number.isFinite(m) || m < 0 || m > 100)
+                add("skill_risk_pm_max_edge", "risk.pmMaxEdgePoints must be a number between 0 and 100 (points over cost; omit for no cap)");
+        }
+        if (r.pmMaxOpenPerEvent !== undefined) {
+            const n = r.pmMaxOpenPerEvent;
+            if (typeof n !== "number" || !Number.isInteger(n) || n < 1 || n > 50)
+                add("skill_risk_pm_per_event", "risk.pmMaxOpenPerEvent must be a whole number between 1 and 50 (omit for no per-event cap)");
+        }
+        if (r.pmMaxOpenPerCoinHorizon !== undefined) {
+            const n = r.pmMaxOpenPerCoinHorizon;
+            if (typeof n !== "number" || !Number.isInteger(n) || n < 1 || n > 50)
+                add("skill_risk_pm_coin_horizon", "risk.pmMaxOpenPerCoinHorizon must be a whole number between 1 and 50 (omit for no per-coin-horizon cap)");
+        }
+        if (r.pmMinMinutesToClose !== undefined) {
+            const m = r.pmMinMinutesToClose;
+            if (typeof m !== "number" || !Number.isFinite(m) || m < 0 || m > 10_080)
+                add("skill_risk_pm_close_cutoff", "risk.pmMinMinutesToClose must be a number of minutes between 0 and 10080 (omit for no cutoff)");
+        }
         // 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.

package/dist/agent/strictLint.js

@@ -30,8 +30,29 @@ const ALLOWED_KEYS = {
         // it) but was missing here, so any bundle actually SETTING it got an
         // unknown_key lint — the knob existed and was unreachable (audit rank 10).
         "triggerPolicy",
+        "signals",
+        "data",
+        "universe",
     ],
     trigger: ["cadence", "timezone", "events"],
+    signals: [
+        "rsiOversold",
+        "rsiOverbought",
+        "strongMovePct",
+        "leanMovePct",
+        "minStrength",
+    ],
+    data: ["indicatorRange"],
+    universe: [
+        "rank",
+        "minVolume24hUsd",
+        "excludeStablecoins",
+        "includeSectors",
+        "excludeSectors",
+        "sort",
+        "resolveTop",
+        "scanLimit",
+    ],
     triggerPolicy: [
         "mode",
         "skipLlmWhenNoTrigger",
@@ -51,6 +72,11 @@ const ALLOWED_KEYS = {
         "direction",
         "entryPredicates",
         "pmMinEntryProbabilityPct",
+        "pmMinEdgeGapPct",
+        "pmMaxEdgePoints",
+        "pmMaxOpenPerEvent",
+        "pmMaxOpenPerCoinHorizon",
+        "pmMinMinutesToClose",
     ],
     sizing: null,
     capitalSizing: [
@@ -141,6 +167,9 @@ export function strictLint(raw) {
         "sync",
         "killSwitch",
         "objective",
+        "signals",
+        "data",
+        "universe",
     ]) {
         if (isObj(raw[block]))
             lintKeys(block, raw[block], issues);

package/dist/agent/types.d.ts

@@ -1,6 +1,7 @@
 import type { FuturesEntryEligibility } from "./futuresEligibility.js";
 import { IndicatorSet } from "./indicators.js";
 import type { DecisionInputRecord } from "./decisionReceipt.js";
+import type { DecideRouteAttempt } from "./providers.js";
 export declare const SPEC_VERSION = "coinrithm.agent.v1";
 export type Venue = "spot" | "futures" | "pm";
 export declare const VENUES: readonly Venue[];
@@ -36,6 +37,11 @@ export interface RiskConfig {
     blocklist?: string[];
     direction?: "long_only" | "short_only";
     pmMinEntryProbabilityPct?: number;
+    pmMinEdgeGapPct?: number;
+    pmMaxEdgePoints?: number;
+    pmMaxOpenPerEvent?: number;
+    pmMaxOpenPerCoinHorizon?: number;
+    pmMinMinutesToClose?: number;
 }
 export interface LimitsConfig {
     maxTradesPerDay: number;
@@ -116,6 +122,25 @@ export interface AgentSpec {
     objective?: ObjectiveConfig;
     capabilities: Capability[];
     triggerPolicy?: TriggerPolicy;
+    signals?: Partial<import("./signals.js").SignalThresholds>;
+    data?: {
+        indicatorRange?: import("./signals.js").IndicatorRange;
+    };
+    universe?: UniverseConfig;
+}
+/** Declared market boundaries; see universe.ts for semantics and defaults. */
+export interface UniverseConfig {
+    rank?: {
+        min?: number;
+        max?: number;
+    };
+    minVolume24hUsd?: number;
+    excludeStablecoins?: boolean;
+    includeSectors?: string[];
+    excludeSectors?: string[];
+    sort?: "gainers_24h" | "losers_24h" | "abs_change_24h" | "abs_change_1h" | "volume_24h" | "rank";
+    resolveTop?: number;
+    scanLimit?: number;
 }
 export interface ParsedSkill {
     spec: AgentSpec;
@@ -136,8 +161,8 @@ export interface Freshness {
     basis?: string;
 }
 export interface IndicatorContext {
-    range: "1D";
-    nominalIntervalSeconds: 300;
+    range: import("./signals.js").IndicatorRange;
+    nominalIntervalSeconds: number;
     barCount: number;
     timestampedBarCount: number;
     checkedIntervalCount: number;
@@ -150,6 +175,105 @@ export interface IndicatorContext {
         intervalStatus: "regular" | "irregular" | "unknown";
     };
 }
+export interface OpenInterestContext {
+    totalUsd: number;
+    venues: string[];
+    change1hPct: number | null;
+    change1hVenues: string[];
+    change24hPct: number | null;
+    change24hVenues: string[];
+    asOf: string;
+    stale: boolean;
+}
+export interface DatedValue {
+    value: number;
+    asOf: string;
+    stale: boolean;
+}
+export interface PositioningContext {
+    venue: string;
+    symbol: string;
+    longShortAccountRatio?: DatedValue;
+    longAccountPct?: DatedValue;
+    topTraderPositionRatio?: DatedValue;
+    takerBuySellRatio?: DatedValue;
+}
+export interface LiquidationWindow {
+    longLiquidatedUsdt: number;
+    shortLiquidatedUsdt: number;
+    events: number;
+    capturedPct: number;
+}
+export interface LiquidationContext {
+    venue: string;
+    instId: string;
+    last1h: LiquidationWindow;
+    last24h: LiquidationWindow;
+    lastEventAt: string | null;
+}
+export interface MacroQuote {
+    symbol: string;
+    label: string;
+    kind: string;
+    price: number;
+    change24hPct: number | null;
+    asOf: string;
+    stale: boolean;
+}
+export interface MacroContext {
+    note: string;
+    quotes: MacroQuote[];
+}
+export interface ChainTvlContext {
+    chain: string;
+    tvlUsd: number;
+    publishedAt: string | null;
+    fetchedAt: string | null;
+    sourceObservedAt: null;
+    stale: boolean;
+    dayAt: string | null;
+    change1dPct: number | null;
+    change7dPct: number | null;
+}
+export interface StablecoinSupplyContext {
+    totalUsd: number;
+    dayAt: string;
+    change1dPct: number | null;
+    change7dPct: number | null;
+    stale: boolean;
+}
+export interface DepthSideContext {
+    usd: number;
+    reachPct: number;
+    levels: number;
+    complete: boolean;
+}
+export interface DepthContext {
+    venue: string;
+    bid: DepthSideContext | null;
+    ask: DepthSideContext | null;
+    asOf: string;
+    stale: boolean;
+}
+export interface FundingVenueRate {
+    role: "settlement_reference" | "context_only";
+    venue: string;
+    symbol: string;
+    source: "paper_futures_reference" | "hyperliquid_predicted_fundings";
+    rateFraction: number;
+    intervalHours: number | null;
+    hourlyEquivalentFraction: number | null;
+    nextFundingTime: string | null;
+    fetchedAt: string;
+    sourceAt: null;
+    ageSeconds: number;
+    stale: boolean;
+    freshnessBasis: "collection_time";
+}
+export interface FundingByVenueContext {
+    rates: FundingVenueRate[];
+    sameTime: false;
+}
 export interface WatchEntry {
     symbol: string;
     coinId: string | null;
@@ -166,8 +290,15 @@ export interface WatchEntry {
     indicators?: IndicatorSet;
     indicatorContext?: IndicatorContext;
     discovered?: boolean;
+    withinBoundaries?: boolean;
     slug?: string;
     fundamentals?: CoinFundamentals;
+    openInterest?: OpenInterestContext;
+    positioning?: PositioningContext;
+    liquidations?: LiquidationContext;
+    chainTvl?: ChainTvlContext;
+    depth?: DepthContext;
+    fundingByVenue?: FundingByVenueContext;
     futuresEntryEligibility?: FuturesEntryEligibility;
 }
 export interface CoinFundamentals {
@@ -227,6 +358,8 @@ export interface PmPosition {
     entryProbability?: number;
     currentProbability?: number;
     openedAt?: string;
+    coins?: string[];
+    endDate?: string;
     thesis?: ThesisView;
 }
 export interface PmResolution {
@@ -250,6 +383,7 @@ export interface PmMarket {
     volumeUsd?: number;
     endDate?: string;
     liquidityUsd?: number;
+    coins?: string[];
     quality?: PmQuality;
     decisionSupport?: PmDecisionSupport;
     consensus?: PmConsensus | null;
@@ -322,6 +456,8 @@ export interface NewsItem {
     ageHours?: number;
     publishedAt?: string;
     coins?: string[];
+    url?: string;
+    category?: string;
 }
 export type WhaleContextStatus = "available" | "partial" | "unavailable";
 export type WhaleContextFailure = "timeout" | "network_error" | "http_error" | "invalid_payload";
@@ -414,6 +550,8 @@ export interface Observation {
         label: string;
         fetchedAt?: string;
     };
+    macro?: MacroContext;
+    stablecoinSupply?: StablecoinSupplyContext;
     syncCursor: string | null;
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
@@ -638,19 +776,18 @@ export interface CycleResult {
     tokensIn?: number;
     tokensOut?: number;
     estimatedCostUsd?: number;
+    providerUsage?: {
+        promptTokens: number;
+        completionTokens: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        cacheWrite5mTokens?: number;
+        cacheWrite1hTokens?: 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;
-    }>;
+    routeAttempts?: DecideRouteAttempt[];
     decisionType?: "act" | "skip" | "gate_skip" | "model_error";
     writeAttempted?: number;
     writeAccepted?: number;