@coinrithm/mcp-trading 0.7.15 → 0.7.17

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

@@ -75,6 +75,15 @@ function buildCapitalSizing(raw) {
         totalCapitalPct: num(policy.totalCapitalPct, Number.NaN),
         cashReservePct: num(policy.cashReservePct, Number.NaN),
         minRewardRisk: num(policy.minRewardRisk, Number.NaN),
+        ...(policy.highConviction !== undefined
+            ? {
+                highConviction: {
+                    minConfidence: num(obj(policy.highConviction).minConfidence, Number.NaN),
+                    perTicketCapitalPct: num(obj(policy.highConviction).perTicketCapitalPct, Number.NaN),
+                    futuresRiskPct: num(obj(policy.highConviction).futuresRiskPct, Number.NaN),
+                },
+            }
+            : {}),
     };
 }
 // Coerce raw frontmatter into a best-effort AgentSpec. This NEVER throws on bad
@@ -118,6 +127,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 +190,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;
@@ -26,6 +28,7 @@ export function validateCapitalSizingPolicy(value) {
         ...percentKeys,
         "cashReservePct",
         "minRewardRisk",
+        "highConviction",
     ]);
     for (const key of Object.keys(p)) {
         if (!allowedKeys.has(key))
@@ -55,6 +58,28 @@ export function validateCapitalSizingPolicy(value) {
         p.totalCapitalPct + p.cashReservePct > 100) {
         add("skill_capital_sizing_total_reserve", "capitalSizing.totalCapitalPct + cashReservePct cannot exceed 100");
     }
+    if (p.highConviction !== undefined) {
+        const hc = p.highConviction;
+        if (!isObj(hc)) {
+            add("skill_capital_sizing_high_conviction", "capitalSizing.highConviction must be an object");
+        }
+        else {
+            for (const key of Object.keys(hc)) {
+                if (!["minConfidence", "perTicketCapitalPct", "futuresRiskPct"].includes(key))
+                    add("skill_capital_sizing_unknown_key", `unknown capitalSizing.highConviction key "${key}"`);
+            }
+            if (!isPosNum(hc.minConfidence) || hc.minConfidence > 1)
+                add("skill_capital_sizing_high_conviction", "capitalSizing.highConviction.minConfidence must be a finite number in (0, 1]");
+            for (const key of ["perTicketCapitalPct", "futuresRiskPct"]) {
+                if (!isPosNum(hc[key]) || hc[key] > 100)
+                    add("skill_capital_sizing_percent", `capitalSizing.highConviction.${key} must be a finite number in (0, 100]`);
+            }
+            if (isPosNum(hc.perTicketCapitalPct) &&
+                isPosNum(p.totalCapitalPct) &&
+                hc.perTicketCapitalPct > p.totalCapitalPct)
+                add("skill_capital_sizing_ticket_cap", "capitalSizing.highConviction.perTicketCapitalPct cannot exceed totalCapitalPct");
+        }
+    }
     return issues;
 }
 export function validateSkill(parsed, mode = "self-host") {
@@ -88,6 +113,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 +146,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: [
@@ -61,6 +87,7 @@ const ALLOWED_KEYS = {
         "totalCapitalPct",
         "cashReservePct",
         "minRewardRisk",
+        "highConviction",
     ],
     limits: [
         "maxTradesPerDay",
@@ -141,6 +168,9 @@ export function strictLint(raw) {
         "sync",
         "killSwitch",
         "objective",
+        "signals",
+        "data",
+        "universe",
     ]) {
         if (isObj(raw[block]))
             lintKeys(block, raw[block], issues);

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

@@ -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;
@@ -52,6 +58,15 @@ export interface CapitalSizingPolicy {
     totalCapitalPct: number;
     cashReservePct: number;
     minRewardRisk: number;
+    /** Opt-in (owner 2026-10-08): a futures_open the model rates at or above
+     * minConfidence uses these larger ticket and stop-risk limits instead of
+     * the base ones. Every other cap (total, reserve, open margin, R:R) holds. */
+    highConviction?: CapitalHighConviction;
+}
+export interface CapitalHighConviction {
+    minConfidence: number;
+    perTicketCapitalPct: number;
+    futuresRiskPct: number;
 }
 export type CapitalBook = {
     status: "unavailable";
@@ -116,6 +131,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 +170,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 +184,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 +299,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 +367,8 @@ export interface PmPosition {
     entryProbability?: number;
     currentProbability?: number;
     openedAt?: string;
+    coins?: string[];
+    endDate?: string;
     thesis?: ThesisView;
 }
 export interface PmResolution {
@@ -250,6 +392,7 @@ export interface PmMarket {
     volumeUsd?: number;
     endDate?: string;
     liquidityUsd?: number;
+    coins?: string[];
     quality?: PmQuality;
     decisionSupport?: PmDecisionSupport;
     consensus?: PmConsensus | null;
@@ -322,6 +465,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 +559,8 @@ export interface Observation {
         label: string;
         fetchedAt?: string;
     };
+    macro?: MacroContext;
+    stablecoinSupply?: StablecoinSupplyContext;
     syncCursor: string | null;
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
@@ -549,6 +696,8 @@ export interface FuturesFundingQuoteEvidence {
     annualizedRate?: number;
 }
 export interface RunState {
+    /** Exact checkpointed v2 request; validated before replay, never model-controlled. */
+    pmPaperV2Pending?: unknown;
     runId: string;
     cyclesRun: number;
     writesToday: number;
@@ -580,6 +729,13 @@ export interface RunState {
         did: string;
     }>;
     theses?: Record<string, PositionThesis>;
+    lastRejections?: LastRejection[];
+}
+export interface LastRejection {
+    at: string;
+    action: string;
+    code: string;
+    reason?: string;
 }
 export interface AgentTrace {
     runId?: string;
@@ -605,8 +761,21 @@ export interface PlannedAction {
     reason?: string;
     quote?: QuoteEvidence;
     executed?: boolean;
+    /** V2 close accepted but exposure remains open; accounting is separate. */
+    executionPending?: boolean;
+    executionReplayed?: boolean;
+    /** A newly accepted v2 intent/fill consumes write budget; replay does not. */
+    writeRecorded?: boolean;
     result?: unknown;
     capitalSizing?: CapitalSizingAdjustment;
+    /** Set when the runner replaced the model's futures take-profit; persisted
+     * with the cycle so the requested target is never lost. */
+    takeProfitRepair?: TakeProfitRepair;
+}
+export interface TakeProfitRepair {
+    requestedTakeProfitPrice: number | null;
+    appliedTakeProfitPrice: number;
+    reason: "missing" | "wrong_side" | "below_reward_risk_floor";
 }
 export interface CycleResult {
     /** Private non-enumerable evidence. Never forward through AgentTrace/public APIs. */
@@ -638,19 +807,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;