@coinrithm/mcp-trading 0.7.7 → 0.7.8

package/dist/agent/prompt.d.ts

@@ -1,4 +1,12 @@
-import { AgentSpec, Observation, PmResolution } from "./types.js";
+import { AgentSpec, Observation, PmResolution, RunState } from "./types.js";
+export interface DailyRiskBudget {
+    version: "coinrithm.daily-risk-budget.v1";
+    utcDay: string;
+    limit: number | null;
+    used: number;
+    remaining: number | null;
+}
+export declare function buildDailyRiskBudget(spec: AgentSpec, state: Pick<RunState, "dayKey" | "riskIncreasesToday">): DailyRiskBudget;
 export declare function formatPmResolutions(resolutions: PmResolution[]): string[];
 export declare function buildSystemPrompt(spec: AgentSpec, mergedProse: string, opts?: {
     includeForecast?: boolean;
@@ -8,4 +16,6 @@ export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     did: string;
 }>, opts?: {
     venues?: AgentSpec["venues"];
+    dailyRiskBudget?: DailyRiskBudget;
+    capitalSizing?: AgentSpec["capitalSizing"];
 }): string;

package/dist/agent/prompt.js

@@ -2,6 +2,23 @@
 // static character (cached prefix); the user prompt is the fresh observation.
 // The model only PROPOSES — the runner re-checks every action against the caps,
 // so the prompt states the caps but never relies on the model to honor them.
+import { pmQualityOf, pmDecisionSupportOf } from "./pmContext.js";
+import { usesCapitalSizing } from "./capitalSizing.js";
+// The runner has already called rollDay. Use the same counter as validation,
+// including conservative legacy-state migration; never infer it from writes,
+// model calls, or the number of positions that remain open.
+export function buildDailyRiskBudget(spec, state) {
+    const limit = spec.limits.maxTradesPerDay > 0 ? spec.limits.maxTradesPerDay : null;
+    return {
+        version: "coinrithm.daily-risk-budget.v1",
+        utcDay: state.dayKey,
+        limit,
+        used: state.riskIncreasesToday,
+        remaining: limit === null ? null : Math.max(0, limit - state.riskIncreasesToday),
+    };
+}
+// Whole-dollar rendering for the compact PM rows (tokens, not precision).
+const roundUsd = (v) => typeof v === "number" && Number.isFinite(v) ? Math.round(v) : undefined;
 // Format the settlement-feedback block: a concise, natural-language recap of the
 // agent's OWN PM bets that resolved since the last cycle, so the model can REFLECT
 // (reinforce what worked, avoid what didn't). Capped + compact — this is context,
@@ -55,15 +72,22 @@ opts = {}) {
         ...(hasSpot ? ["spot buy notional"] : []),
         ...(hasPm ? ["PM stake"] : []),
     ];
+    const openKinds = [
+        ...(hasFutures ? ["futures_open"] : []),
+        ...(hasSpot ? ["spot_order"] : []),
+        ...(hasPm ? ["pm_open"] : []),
+    ];
+    const hasIndicators = spec.capabilities.includes("indicators");
+    const hasNews = spec.capabilities.includes("news");
     const actions = [];
     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.");
+        actions.push('{"type":"futures_open","symbol","side":"long"|"short","leverage","marginMusd","stopLossPrice","takeProfitPrice","confidence":0..1,"thesis":{"summary","invalidation":{"priceBelow"|"priceAbove","maxHoldMinutes","catalyst"}}}', '{"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 (hasSpot) {
-        actions.push('{"type":"spot_order","symbol","side":"buy"|"sell","orderType":"market"|"limit"|"stop","quantity","limitPrice","stopPrice","confidence":0..1}', '{"type":"spot_cancel","orderId"}');
+        actions.push('{"type":"spot_order","symbol","side":"buy"|"sell","orderType":"market"|"limit"|"stop","quantity","limitPrice","stopPrice","confidence":0..1,"thesis":{"summary","invalidation":{"priceBelow"|"priceAbove","maxHoldMinutes","catalyst"}}}', '{"type":"spot_cancel","orderId"}');
     }
     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' : ""})`);
+        actions.push(`{"type":"pm_open","ref":"pmN","stakeMusd","confidence":0..1${includeForecast ? ',"forecastProbability":1..99' : ""},"thesis":{"summary","invalidation":{"probabilityBelow"|"probabilityAbove","maxHoldMinutes","catalyst"}}}  (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 [
         "You operate a CoinRithm PAPER-TRADING agent (simulated 50,000 mUSD; not real money, not financial advice).",
@@ -73,8 +97,14 @@ opts = {}) {
         mergedProse.trim() || "(no strategy prose provided)",
         "",
         "## Hard caps the runner enforces (do not exceed; proposing over a cap wastes the cycle)",
+        "- When supplied, the user prompt's dailyRiskBudget is the remaining UTC-day entry/add allowance. It outranks setup/entry pressure: exhaustion is a legitimate skip for new risk, never a reason to skip otherwise-valid closes or protection. All other caps still apply, even when this daily count is unlimited.",
         `- venues you may act in: ${v.join(", ")}`,
         `- perTradeMarginMusd ${r.perTradeMarginMusd} is the per-trade SIZE cap (${sizeKinds.join(" / ")})`,
+        ...(usesCapitalSizing(spec)
+            ? [
+                `- Opt-in paper capital policy ${spec.capitalSizing?.version ?? "invalid"}: the runner REPLACES proposed futures margins and PM stakes using current owned-book evidence, stops and fixed policy limits; it does not treat your confidence or the nominal starting grant as a sizing instruction. Choose the market, direction and meaningful protection; invalid policy, quoted costs, shared allocation and cash reserve can still reject an entry.`,
+            ]
+            : []),
         ...(hasFutures
             ? [
                 `- futures: maxLeverage ${r.maxLeverage}, maxConcurrentPositions ${r.maxConcurrentPositions}, requireStopLoss ${r.requireStopLoss} (long stop below entry, short stop above)`,
@@ -107,14 +137,14 @@ opts = {}) {
             : []),
         ...(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.",
+                "- prediction markets are a FIRST-CLASS venue for you. 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) when your independently formed estimate differs materially from the market's, after costs. Discovery filters known ineligible candidates but is NOT an execution promise: fresh quote and open-time guards still apply. `quality` contains eligibility and warning evidence; `decisionSupport` describes liquidity/activity/structure, NOT winning probability or forecast accuracy. Missing quality is unknown, not approval. Check warning reasons, freshness age and flags before deciding. Pick ONLY a listed market by its `ref`; min stake 10 mUSD. Do NOT re-bet a market+outcome already held (check observation.pmPositions); choose 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).",
+                "- 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.",
             ]
             : []),
         `- abstention.minConfidence ${spec.abstention.minConfidence}: opens below this are rejected, so act with genuine conviction — but routine caution is no reason to sit out a clear setup`,
@@ -151,12 +181,53 @@ opts = {}) {
             ]
             : []),
         "",
+        `## Fundamentals (observation.watch[].fundamentals${hasPm ? ", observation.pmMarkets" : ""}): the fundamental leg of every decision`,
+        ...(hasCoinVenue
+            ? [
+                `Each watch entry carries \`fundamentals\`: \`categories\` (sector tags), \`marketCapRank\`, \`marketCapUsd\`${hasIndicators ? ", `volume24hUsd` (24h volume on the tracked exchanges)" : ""}${hasNews ? ", and `headlines` (up to 3 recent stories about that coin, each with an `at` timestamp, `importance` 0..10 and `sentiment`)" : ""}. Next to \`change24h\` / \`change7d\` this is your fundamental read; it GRADES the trade, it never replaces your technical rules:`,
+                "- A fresh, high-importance headline that explains the move is what turns a B-grade setup into A-grade size; a big move with no headline and thin volume is more often exhaustion than a beginning.",
+                "- Rank and volume set the size ceiling: a top-20 coin with deep volume can take your full per-trade margin; a rank-300 name on thin volume gets half at most, a wider stop and a shorter time stop.",
+                "- Categories tell you what else moves with it: a sector-wide story (an L2 narrative, an exchange listing wave, a regulatory hit) applies to peers on your watchlist too; a coin whose only story is its own pump has no fundamental leg.",
+            ]
+            : []),
+        ...(hasPm
+            ? [
+                "- Each pmMarkets row carries `end` (resolution date), `vol24h` and `liq` (USD): thin liquidity means a smaller stake and a wider required edge; your time stop must sit before `end`; a probability that moved on heavy volume is information, one that moved on none is noise.",
+            ]
+            : []),
+        "",
         "## Output contract — return ONLY this JSON object, nothing else:",
-        '{"decision":"skip"|"act","confidence":0..1,"reason":"short","rationale":"1-2 sentences","actions":[]}',
+        '{"decision":"skip"|"act","confidence":0..1,"reason":"brief label","rationale":"1-2 sentences","actions":[]}',
+        'Decision/action consistency is mandatory: decision="act" requires at least one complete action object; decision="skip" requires actions=[]. Never describe entering or managing a trade while returning an empty actions array.',
         "Each action is one of:",
         ...actions.map((a) => `- ${a}`),
         `Set each opening action's "confidence" (0..1) to your honest conviction — the runner REJECTS any open below abstention.minConfidence (${spec.abstention.minConfidence}). The decision-level "confidence" is the fallback when an action omits its own.`,
         "",
+        "## Thesis on every open, and thesis exits (the runner enforces the exit)",
+        `Every opening action (${openKinds.join(" / ")}) MUST carry a \`thesis\`: \`summary\` = one sentence with the edge and why NOW; \`invalidation\` = what proves it wrong, with at least ONE machine-checkable condition:`,
+        ...(hasCoinVenue
+            ? [
+                "- coins: `priceBelow` for a long or `priceAbove` for a short = the level at which the idea is dead (a real structure level inside your stop-loss); and/or `maxHoldMinutes` = a time stop (minimum 60, at most 43200) after which an idea that has not worked is closed.",
+            ]
+            : []),
+        ...(hasPm
+            ? [
+                "- prediction markets: `probabilityBelow` for a YES or `probabilityAbove` for a NO, in 0..100 points of the outcome's market probability (the `currentProbability` shown on the position) = the odds at which your read is wrong; and/or `maxHoldMinutes`. Never set a time stop past the market's `end` date.",
+            ]
+            : []),
+        '- `catalyst`: free text naming the event whose outcome kills the idea (e.g. "CPI prints hot", "the ETF decision slips"). The runner never evaluates it; YOU re-judge it every cycle you manage the position.',
+        ...(hasFutures
+            ? [
+                "The runner re-checks every open futures position each cycle: when its price level or time stop is breached, the position is CLOSED automatically (logged as a thesis exit) on top of your stop-loss / take-profit. A wrong-side level (a long's priceBelow above entry) is dropped at open, so place it properly.",
+            ]
+            : []),
+        ...(hasPm
+            ? [
+                "Prediction-market positions cannot be closed before settlement: an invalidated PM thesis is shown to you so you do not add to it.",
+            ]
+            : []),
+        "Each open position shows its `thesis` with `status` (intact | invalidated), `holdMinutes` and, when broken, `invalidatedBy`. While the status is intact, HOLD: a discretionary close must name the broken condition or the resolved catalyst in its `rationaleSummary`. A small loss, an early profit below your target or a wiggle against you is not an exit. A position with no thesis (opened before this rule) is managed by its stop and target only.",
+        "",
         "## 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.",
@@ -185,7 +256,7 @@ opts = {}) {
         "Place each stop at a real structural level with ROOM to breathe — past the swing or extreme by a sensible margin — and size the position DOWN to keep the risk small. A stop hugging your entry gets clipped by normal volatility and bleeds you a cut at a time. After a stop-out, do not immediately re-enter the same name and direction (that level is hot — wait for a genuinely fresh setup). Decisive entries, patient holds.",
         "",
         "## Manage your open positions — ride winners, cut losers",
-        "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.",
+        "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 (its `thesis.status` reads invalidated, the level broke, the catalyst resolved against you) is cut cleanly instead of nursed; a position whose thesis is intact is held. Riding one good trade beats opening ten fresh ones.",
     ].join("\n");
 }
 export function buildUserPrompt(obs, journal, opts = {}) {
@@ -199,6 +270,29 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     const lines = [
         "Decide for THIS cycle using only the observation below (data available now — no look-ahead).",
     ];
+    if (opts.capitalSizing) {
+        lines.push("capitalSizingPolicy is the opt-in paper sizing policy (percent fields use percentage points). capitalBook is captured owned-book collateral plus marked spot, reduced only by negative futures/PM marks on its walletId; positive open-position gains are excluded, so this is NOT complete marked equity. Positions on other walletIds remain visible for management but their collateral, marks and close proceeds do not fund this book. Missing/unavailable capitalBook means no new entries; otherwise-valid closes, protection, cancellations and spot sells remain available.");
+    }
+    if (opts.dailyRiskBudget) {
+        const entryActions = [
+            ...(hasFutures ? ["futures_open (including adds)"] : []),
+            ...(hasSpot ? ["spot_order buys"] : []),
+            ...(hasPm ? ["pm_open"] : []),
+        ];
+        const protectiveActions = [
+            ...(hasFutures ? ["futures_close", "futures_set_sltp"] : []),
+            ...(hasSpot ? ["spot_order sells", "spot_cancel"] : []),
+        ];
+        lines.push(`dailyRiskBudget below is a runtime-state snapshot: each successful ${entryActions.join(" / ")} uses one slot. It is NOT a model-call, API-call or total-write budget. Multiple entries/adds in one decision share the remaining slots; propose no more than remain. Closing does not restore a used slot. A null limit/remaining means no daily count cap; other risk caps still apply.`, ...(protectiveActions.length > 0
+            ? [
+                `Otherwise-valid ${protectiveActions.join(" / ")} do not consume these slots and remain available when the entry/add budget is exhausted.`,
+            ]
+            : []), ...(opts.dailyRiskBudget.remaining === 0
+            ? [
+                "Today's entry/add budget is EXHAUSTED until the next UTC day: propose no new entries or adds. Manage/protect existing positions and orders where valid, or skip; a flagged setup does not override this budget.",
+            ]
+            : []));
+    }
     // Flat-state steer: when the agent holds NOTHING, weaker models (Llama 3.1 8B)
     // still emit futures_close / futures_set_sltp / spot_cancel with a hallucinated
     // positionId/orderId — which fails the whole cycle's strict parse (one bad id
@@ -223,6 +317,22 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     if (journal && journal.length > 0) {
         lines.push("", "## Your recent moves (memory, newest last) — manage these with continuity; do NOT churn by re-opening an idea you just acted on:", ...journal.slice(-6).map((j) => `- ${j.did}`));
     }
+    // Slice 2: name the positions whose stated thesis broke this cycle. On a live
+    // run the runner has already closed the futures ones (they are no longer in
+    // openPositions); whatever is listed here is for the MODEL to act on.
+    const brokenTheses = [
+        ...obs.openPositions
+            .filter((p) => p.thesis?.status === "invalidated")
+            .map((p) => `futures pos#${p.id} ${p.side ?? ""} ${p.symbol ?? ""}: ${p.thesis?.invalidatedBy ?? "invalidated"} (close it with futures_close)`),
+        ...(hasPm
+            ? (obs.pmPositions ?? [])
+                .filter((p) => p.thesis?.status === "invalidated")
+                .map((p) => `PM pos#${p.id} "${(p.title ?? p.slug ?? "").slice(0, 50)}": ${p.thesis?.invalidatedBy ?? "invalidated"} (no close endpoint: do NOT add, let it settle)`)
+            : []),
+    ];
+    if (brokenTheses.length > 0) {
+        lines.push("", "## Positions whose thesis is INVALIDATED this cycle", ...brokenTheses.map((b) => `- ${b}`));
+    }
     // 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)
@@ -232,8 +342,17 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     // and the trade ledger is capped so a busy shared book can't bloat the prompt.
     JSON.stringify({
         asOf: obs.asOf,
+        ...(opts.dailyRiskBudget
+            ? { dailyRiskBudget: opts.dailyRiskBudget }
+            : {}),
         cashAvailableMusd: obs.cashAvailableMusd,
         equityMusd: obs.equityMusd,
+        ...(opts.capitalSizing
+            ? {
+                capitalSizingPolicy: opts.capitalSizing,
+                ...(obs.capitalBook ? { capitalBook: obs.capitalBook } : {}),
+            }
+            : {}),
         openPositions: obs.openPositions,
         openOrders: obs.openOrders,
         ...(hasPm ? { pmPositions: obs.pmPositions } : {}),
@@ -249,6 +368,15 @@ export function buildUserPrompt(obs, journal, opts = {}) {
                     outcome: m.outcomeName,
                     prob: m.probability,
                     freshness: m.freshness?.status,
+                    ageSeconds: m.freshness?.ageSeconds,
+                    sourceAsOf: m.freshness?.asOf,
+                    freshnessBasis: m.freshness?.basis,
+                    quality: pmQualityOf(m.quality),
+                    decisionSupport: pmDecisionSupportOf(m.decisionSupport),
+                    // Slice 2 fundamentals: resolution date, 24h volume, liquidity.
+                    end: m.endDate,
+                    vol24h: roundUsd(m.volumeUsd),
+                    liq: roundUsd(m.liquidityUsd),
                 })),
             }
             : {}),

package/dist/agent/providerCapabilities.d.ts

@@ -1,10 +1,13 @@
 import { ProviderName } from "./types.js";
 export declare const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+export declare const DECISION_TOOL_NAME = "submit_trading_decision";
 export interface ChatShape {
     family: "openai-reasoning" | "nvidia-nemotron" | "anthropic" | "openai-compat";
     tokenParam: "max_tokens" | "max_completion_tokens";
     allowsTemperature: boolean;
     jsonResponseFormat: boolean;
+    jsonSchema?: Record<string, unknown>;
+    jsonSchemaTransport?: "tool_call" | "response_format";
     extraBody?: Record<string, unknown>;
     systemHint?: string;
     minProbeCompletionTokens: number;

package/dist/agent/providerCapabilities.js

@@ -1,4 +1,6 @@
+import { DECISION_JSON_SCHEMA } from "./decision.js";
 export const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+export const DECISION_TOOL_NAME = "submit_trading_decision";
 // 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;
@@ -22,14 +24,22 @@ export function chatShapeFor(provider, model, baseUrl) {
         };
     }
     if (NEMOTRON_MODEL.test(model)) {
+        const isNvidiaEndpoint = baseUrl === NVIDIA_BASE_URL;
         return {
             family: "nvidia-nemotron",
             tokenParam: "max_tokens",
             allowsTemperature: true,
             jsonResponseFormat: true,
+            jsonSchema: isNvidiaEndpoint
+                ? DECISION_JSON_SCHEMA
+                : undefined,
+            // integrate.api.nvidia.com currently ignores both response_format
+            // json_schema and guided_json for these hosted models. Its forced tool
+            // call path is the live-probed contract-enforcing transport.
+            jsonSchemaTransport: isNvidiaEndpoint ? "tool_call" : undefined,
             // 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
+            extraBody: isNvidiaEndpoint
                 ? { chat_template_kwargs: { enable_thinking: false } }
                 : undefined,
             systemHint: "detailed thinking off",
@@ -55,8 +65,36 @@ export function buildChatBody(shape, args) {
             ? { temperature: args.temperature ?? 0.2 }
             : {}),
         [shape.tokenParam]: args.maxTokens,
-        ...(shape.jsonResponseFormat
-            ? { response_format: { type: "json_object" } }
+        ...(shape.jsonSchema && shape.jsonSchemaTransport === "tool_call"
+            ? {
+                tools: [
+                    {
+                        type: "function",
+                        function: {
+                            name: DECISION_TOOL_NAME,
+                            description: "Submit the complete CoinRithm paper-trading decision for this cycle.",
+                            parameters: shape.jsonSchema,
+                        },
+                    },
+                ],
+                tool_choice: {
+                    type: "function",
+                    function: { name: DECISION_TOOL_NAME },
+                },
+            }
+            : {}),
+        ...(shape.jsonResponseFormat && shape.jsonSchemaTransport !== "tool_call"
+            ? {
+                response_format: shape.jsonSchema
+                    ? {
+                        type: "json_schema",
+                        json_schema: {
+                            name: "coinrithm_trading_decision",
+                            schema: shape.jsonSchema,
+                        },
+                    }
+                    : { type: "json_object" },
+            }
             : {}),
         ...(shape.extraBody ?? {}),
         messages: [

package/dist/agent/providers.js

@@ -2,7 +2,7 @@
 // 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";
+import { chatShapeFor, buildChatBody, DECISION_TOOL_NAME, 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 = CAP_NVIDIA_BASE_URL;
@@ -30,13 +30,23 @@ const DEFAULT_TIMEOUT_MS = 300_000;
 // 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) {
+// One deadline covers both headers AND response-body consumption. fetch resolves
+// at headers, so clearing a fetch-only timer there leaves text/json unbounded.
+// Abort native I/O and race the deadline as well: an injected implementation that
+// ignores AbortSignal must still release the caller rather than its run lock.
+async function withProviderTimeout(timeoutMs, operation) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(Object.assign(new Error("model deadline exceeded"), {
+                name: "AbortError",
+            }));
+            controller.abort();
+        }, timeoutMs);
+    });
     try {
-        return await fetchFn(url, { ...init, signal: controller.signal });
+        return await Promise.race([operation(controller.signal), deadline]);
     }
     finally {
         clearTimeout(timer);
@@ -131,44 +141,61 @@ class AnthropicProvider {
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        let failureResponse;
         try {
-            const res = await fetchWithTimeout(this.fetchFn, "https://api.anthropic.com/v1/messages", {
-                method: "POST",
-                headers: {
-                    "x-api-key": this.apiKey,
-                    "anthropic-version": "2023-06-01",
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                    model: this.model,
-                    max_tokens: input.maxTokens ?? 1024,
-                    system: input.system,
-                    messages: [{ role: "user", content: input.user }],
-                }),
-            }, timeoutMs);
-            if (!res.ok)
-                return {
-                    ok: false,
-                    // 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("") ?? "";
-            const usage = json.usage
-                ? {
-                    promptTokens: json.usage.input_tokens ?? 0,
-                    completionTokens: json.usage.output_tokens ?? 0,
+            return await withProviderTimeout(timeoutMs, async (signal) => {
+                const res = await this.fetchFn("https://api.anthropic.com/v1/messages", {
+                    method: "POST",
+                    signal,
+                    headers: {
+                        "x-api-key": this.apiKey,
+                        "anthropic-version": "2023-06-01",
+                        "content-type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        model: this.model,
+                        max_tokens: input.maxTokens ?? 1024,
+                        system: input.system,
+                        messages: [{ role: "user", content: input.user }],
+                    }),
+                });
+                if (!res.ok) {
+                    failureResponse = res;
+                    return {
+                        ok: false,
+                        // 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),
+                    };
                 }
-                : undefined;
-            return text
-                ? { ok: true, text, usage }
-                : { ok: false, error: "anthropic returned empty content" };
+                const json = (await res.json());
+                const text = json.content?.map((c) => c.text ?? "").join("") ?? "";
+                const usage = json.usage
+                    ? {
+                        promptTokens: json.usage.input_tokens ?? 0,
+                        completionTokens: json.usage.output_tokens ?? 0,
+                    }
+                    : undefined;
+                return text
+                    ? { ok: true, text, usage }
+                    : { ok: false, error: "anthropic returned empty content" };
+            });
         }
         catch (err) {
-            return { ok: false, error: callError(err, timeoutMs) };
+            return {
+                ok: false,
+                error: failureResponse
+                    ? `anthropic HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
+                    : callError(err, timeoutMs),
+                ...(failureResponse
+                    ? {
+                        status: failureResponse.status,
+                        retryAfterMs: retryAfterMs(failureResponse),
+                    }
+                    : {}),
+            };
         }
     }
 }
@@ -190,43 +217,62 @@ class OpenAiCompatProvider {
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const shape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        let failureResponse;
         try {
-            const res = await fetchWithTimeout(this.fetchFn, `${this.baseUrl}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify(buildChatBody(shape, {
-                    model: this.model,
-                    system: input.system,
-                    user: input.user,
-                    maxTokens: input.maxTokens ?? 1024,
-                })),
-            }, timeoutMs);
-            if (!res.ok)
-                return {
-                    ok: false,
-                    // 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 ?? "";
-            const usage = json.usage
-                ? {
-                    promptTokens: json.usage.prompt_tokens ?? 0,
-                    completionTokens: json.usage.completion_tokens ?? 0,
+            return await withProviderTimeout(timeoutMs, async (signal) => {
+                const res = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+                    method: "POST",
+                    signal,
+                    headers: {
+                        Authorization: `Bearer ${this.apiKey}`,
+                        "content-type": "application/json",
+                    },
+                    body: JSON.stringify(buildChatBody(shape, {
+                        model: this.model,
+                        system: input.system,
+                        user: input.user,
+                        maxTokens: input.maxTokens ?? 1024,
+                    })),
+                });
+                if (!res.ok) {
+                    failureResponse = res;
+                    return {
+                        ok: false,
+                        // 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),
+                    };
                 }
-                : undefined;
-            return text
-                ? { ok: true, text, usage }
-                : { ok: false, error: "provider returned empty content" };
+                const json = (await res.json());
+                const message = json.choices?.[0]?.message;
+                const decisionArguments = message?.tool_calls?.find((call) => call.function?.name === DECISION_TOOL_NAME)?.function?.arguments;
+                const text = decisionArguments ?? message?.content ?? "";
+                const usage = json.usage
+                    ? {
+                        promptTokens: json.usage.prompt_tokens ?? 0,
+                        completionTokens: json.usage.completion_tokens ?? 0,
+                    }
+                    : undefined;
+                return text
+                    ? { ok: true, text, usage }
+                    : { ok: false, error: "provider returned empty content" };
+            });
         }
         catch (err) {
-            return { ok: false, error: callError(err, timeoutMs) };
+            return {
+                ok: false,
+                error: failureResponse
+                    ? `provider HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
+                    : callError(err, timeoutMs),
+                ...(failureResponse
+                    ? {
+                        status: failureResponse.status,
+                        retryAfterMs: retryAfterMs(failureResponse),
+                    }
+                    : {}),
+            };
         }
     }
 }

package/dist/agent/resolve.js

@@ -36,6 +36,7 @@ const CONFIG_BLOCKS = [
     "venues",
     "risk",
     "sizing",
+    "capitalSizing",
     "limits",
     "abstention",
     "sync",

package/dist/agent/runner.d.ts

@@ -1,6 +1,7 @@
 import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { Provider } from "./providers.js";
 import { AgentSpec, RunState, CycleResult, Decision, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence } from "./types.js";
+import { type DecisionInputRecord } from "./decisionReceipt.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
     provider: Provider;
@@ -10,13 +11,15 @@ export interface RunnerDeps {
     live: boolean;
     stateFile?: string;
     log?: (line: string) => void;
+    /** Optional private storage hook. Its failure never changes cycle execution. */
+    onDecisionInputRecord?: (record: DecisionInputRecord) => void;
 }
 export declare function houseAgentForecastEnabled(): boolean;
 export declare function agentOpportunityCaptureEnabled(): boolean;
 export declare function runnerRuntimeKind(): ProvenanceReport["runtimeKind"];
 export declare function buildRunnerProvenance(spec: AgentSpec): ProvenanceReport;
 export declare function sanitizeForecastProbability(raw: unknown): number | undefined;
-export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence): {
+export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence, capitalMinimumRewardRisk?: number): {
     action: ProposedAction;
     repaired: boolean;
 };