@coinrithm/mcp-trading 0.7.15 → 0.7.17

package/dist/agent/prompt.js

@@ -4,8 +4,14 @@
 // prefix stable and avoiding balances or counts in the system prompt.
 // 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 { barLabel, indicatorRangeOf, signalThresholdsOf } from "./signals.js";
+import { describeUniverse, scansUniverse } from "./universe.js";
 import { pmQualityOf, pmDecisionSupportOf } from "./pmContext.js";
 import { usesCapitalSizing } from "./capitalSizing.js";
+import { serializePromptObservation } from "./promptTables.js";
+import { TRIGGER_PRICE_EPS } from "./decisionValidator.js";
+import { futuresEntryChoices } from "./futuresEligibility.js";
+import { baseSymbol } from "./setups.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.
@@ -69,6 +75,23 @@ export function formatPmResolutions(resolutions) {
         `Resolved since last cycle: ${items.join("; ")}.`,
     ];
 }
+// The agent's declared objective (spec.objective.primary), stated to the
+// model as how to weigh trade-offs (Studio audit, root 56825: the Studio
+// promised the objective "shapes how it weighs risk vs return", but nothing
+// read it). Guidance only: the hard caps below still decide what executes.
+export const OBJECTIVE_GUIDANCE = {
+    realized_pnl: "realized PnL after fees. Prefer setups with clear reward over risk; closing winners and cutting losers counts as much as entries.",
+    risk_adjusted: "return per unit of risk. Prefer fewer, cleaner setups with a meaningful stop; when the risk is unclear, skip.",
+    drawdown_control: "preserving capital and keeping drawdowns small, within your declared strategy and the existing risk limits.",
+    calibration: "honest, evidence-based probabilities. Report what the evidence supports and keep your uncertainty visible; a forecast is valid without a trade, and a trade needs adequate edge, otherwise skip it.",
+};
+export function objectiveLine(spec) {
+    const primary = spec.objective?.primary;
+    return primary &&
+        Object.prototype.hasOwnProperty.call(OBJECTIVE_GUIDANCE, primary)
+        ? `Optimise for ${OBJECTIVE_GUIDANCE[primary]} This is how to weigh trade-offs within your strategy; it never overrides a hard cap.`
+        : null;
+}
 export function buildSystemPrompt(spec, mergedProse, 
 // includeForecast (default OFF here; the runner passes the house-agent flag):
 // when true, pm_open asks for a market-aware forecastProbability (1..99):
@@ -128,6 +151,9 @@ opts = {}) {
         "## Your strategy (your borders)",
         mergedProse.trim() || "(no strategy prose provided)",
         "",
+        ...(objectiveLine(spec)
+            ? ["## Your objective", objectiveLine(spec), ""]
+            : []),
         "## 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(", ")}`,
@@ -135,6 +161,11 @@ opts = {}) {
         ...(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.`,
+                ...(spec.capitalSizing?.highConviction
+                    ? [
+                        `- HIGH-CONVICTION exception: a futures_open with confidence >= ${spec.capitalSizing.highConviction.minConfidence} is sized with the larger limits (ticket up to ${spec.capitalSizing.highConviction.perTicketCapitalPct}% of equity, stop risk up to ${spec.capitalSizing.highConviction.futuresRiskPct}%). Rate a setup that high ONLY when it is your best opportunity in days: its stop-out costs far more. Everything else stays at the base size.`,
+                    ]
+                    : []),
             ]
             : []),
         ...(hasFutures
@@ -162,7 +193,7 @@ opts = {}) {
         // sections telling one story.
         ...(hasCoinVenue
             ? [
-                spec.capabilities.includes("universe_scan")
+                scansUniverse(spec)
                     ? `- tradable symbols (${coinVenueLabel}): your watchlist (${r.watchlist.join(", ")}) PLUS this cycle's watch entries marked \`discovered: true\` — nothing outside those`
                     : `- watchlist (${coinVenueLabel} use ONLY these): ${r.watchlist.join(", ")}`,
             ]
@@ -184,6 +215,31 @@ opts = {}) {
                 `- PM ENTRY FLOOR: pm_open on an outcome whose market probability is below ${r.pmMinEntryProbabilityPct} points is REJECTED by the runner (the chosen outcome's own price; fees are not counted). Do not propose cheaper longshots; look for edge on outcomes priced at or above the floor.`,
             ]
             : []),
+        ...(hasPm && typeof r.pmMinEdgeGapPct === "number"
+            ? [
+                `- PM EDGE RULE: every pm_open MUST carry forecastProbability, and it must beat the fee-inclusive cost by ${r.pmMinEdgeGapPct}% of the room left to 100 (cost 50 needs ${(50 + (r.pmMinEdgeGapPct / 100) * 50).toFixed(1)}, cost 70 needs ${(70 + (r.pmMinEdgeGapPct / 100) * 30).toFixed(1)}). The runner REJECTS an open without a forecast or under this bar.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMaxEdgePoints === "number"
+            ? [
+                `- PM OVERCONFIDENCE CAP: every pm_open MUST carry forecastProbability, and it may beat the fee-inclusive cost by at most ${r.pmMaxEdgePoints} points. Base the forecast on current evidence. Do not alter a forecast to pass this cap: skip the trade if your evidence-based forecast falls outside the permitted range. Opens over the cap are REJECTED.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMaxOpenPerEvent === "number"
+            ? [
+                `- PM PER-EVENT CAP: at most ${r.pmMaxOpenPerEvent} open bet(s) per event (same market slug, counting bets you already hold). Extra opens are REJECTED.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMaxOpenPerCoinHorizon === "number"
+            ? [
+                `- PM COIN-HORIZON CAP: at most ${r.pmMaxOpenPerCoinHorizon} open bet(s) on the same coin whose events end within 24 h of each other, across DIFFERENT events (counting bets you already hold; uses each market's linked coins and end date). Extra opens are REJECTED.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMinMinutesToClose === "number"
+            ? [
+                `- PM CLOSE CUTOFF: a market whose \`end\` is less than ${r.pmMinMinutesToClose} minutes away when the runner validates your action is REJECTED; the price already knows.`,
+            ]
+            : []),
         ...(includeForecast
             ? [
                 "- FORECAST RULE (pm_open forecastProbability): the current market probability is already included in this request, so this is a market-aware estimate, not a blinded forecast. Form your own evidence-based probability that the outcome you are backing actually WINS, using the question, its resolution criteria, deadline, and available evidence. Put that number (1-99, whole or one decimal) in `forecastProbability`. This is graded against reality as your PUBLIC calibration record, so it must reflect your judgement: do NOT mechanically copy or round observation.pmMarkets `prob` to produce a forecast. 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 evidence-based 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.",
@@ -192,20 +248,37 @@ opts = {}) {
         `- 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`,
         ...(hasCoinVenue
             ? [
+                "- Open interest (watch[].openInterest) is single-side perpetual exposure in USD across the named venues, not the entire market. Each contract has both a long and a short: OI with price alone cannot establish who opened, closed, or was liquidated. USD OI can also move as price changes without contract counts changing. Treat long/short-covering interpretations as hypotheses requiring other evidence, never as a standalone trade signal. Read each change WITH its change1hVenues/change24hVenues: only matching venue-contracts contribute, and that set may differ from the total's venues. Null changes are unknown; a reported zero total is valid. Ignore stale or missing readings and check asOf against the current observation clock.",
+                "- Positioning (watch[].positioning, Binance, top coins by open interest only) counts ACCOUNTS (longShortAccountRatio, longAccountPct) or top-trader POSITIONS (topTraderPositionRatio); takerBuySellRatio is taker buy over sell volume for the last CLOSED 15-minute period. Each value has its own asOf. They describe who is positioned, not where price goes: a crowded side is a hypothesis, never a standalone signal. Ignore stale values.",
+                "- Funding venues (watch[].fundingByVenue): rateFraction is a fraction per intervalHours, not a percent. hourlyEquivalentFraction = rateFraction / intervalHours is simple normalization, not realized performance, APR or forecast return; an unknown interval stays null. Venues are collected independently, not at the same time. Read each fetchedAt/ageSeconds/stale; sourceAt=null means provider observation time and delay are unknown. context_only does not replace the paper settlement reference or entry gate. Ignore stale or missing values and do not treat a funding difference alone as a trade signal.",
+                "- Depth: watch[].depth is ONE venue's visible order book (Hyperliquid, at most 20 price levels per side), NOT total market liquidity and NOT an executable fill. bid/ask each give usd (resting USD in the visible levels), reachPct (how far from the mid those levels reach, often well under 1%), levels and complete. complete=false means liquidity beyond reachPct was not returned and remains unknown, never zero; null is unknown. Resting orders can be cancelled at any time; treat a bid/ask imbalance as a weak hint, never a standalone signal. Ignore stale values.",
+                "- DeFi: watch[].chainTvl is the value locked on the chain associated with that asset by DefiLlama (an association, not proof it is the chain's native token), NOT the coin's market value; change1dPct/change7dPct compare the provider's dated daily points (dayAt). The current TVL has no observation time (sourceObservedAt null): publishedAt is when the provider published the response and fetchedAt is when we collected it; neither dates the TVL itself. observation.stablecoinSupply is total stablecoin supply market-wide with 1d/7d changes. Both are slow structural context, never a short-term trade trigger; a stale value or a null change is unknown.",
+                "- Macro (observation.macro): Hyperliquid xyz perpetuals that track the S&P 500, Nasdaq-100, Nikkei, KOSPI, gold, silver, oil, gas, copper, EUR/USD, GBP/USD, USD/JPY and TLT around the clock: PROXIES, not exchange quotes, each with its own asOf. Use them as risk-on/risk-off context only; a stale quote is unknown.",
+                "- Liquidations (watch[].liquidations, OKX USDT swaps only): long/short liquidated USDT notional over the last 1h / 24h, read WITH capturedPct, which is a LOWER BOUND of OUR capture uptime for the window (at least that share was captured), not exchange completeness. Low capturedPct means unknown, never 'no liquidations'. Other venues are not included.",
                 "- Community sentiment is a dated sample: read sentimentBullishPct WITH sentimentTotalVotes and sentimentDayUtc. A tiny or old cohort is weak evidence, not current market consensus. sentimentUpdatedAt is the cohort's write time. Missing counts/dates are unknown; price freshness does not date sentiment. marketMood.fetchedAt is Fear & Greed collection time, not its provider observation time. Compare each clock with observation.asOf; never invent currentness from a missing date.",
             ]
             : []),
         ...(spec.capabilities.includes("indicators")
             ? [
                 "",
-                "## Signals — each watch entry may carry `indicators` (nominal five-minute candles)",
-                "- `indicatorContext` reports accepted candle counts, source `asOf` and intervalStatus (regular/irregular/unknown); compare its asOf with observation.asOf for age. /market freshness is separate. nominalIntervalSeconds=300 does not prove fresh, continuous candles. Missing timestamps are unknown; stale, future-dated or irregular candles do not establish a current five-minute signal. `recent15` describes only recent spacing; Wilder atr14 also retains earlier history, so recent regularity does not erase older gaps.",
-                "- rsi14: momentum (>70 overbought, <30 oversold); ema20 & ema50: trend; atr14: volatility (size stops off it); bollinger {upper,mid,lower}; recent20 {high,low}: breakout levels.",
+                `## Signals — each watch entry may carry \`indicators\` (nominal ${barLabel(indicatorRangeOf(spec))} candles)`,
+                "- `indicatorContext` reports accepted candle counts, source `asOf` and intervalStatus (regular/irregular/unknown); compare its asOf with observation.asOf for age. /market freshness is separate. nominalIntervalSeconds does not prove fresh, continuous candles. Missing timestamps are unknown; stale, future-dated or irregular candles do not establish a current signal. `recent15` describes only recent spacing; Wilder atr14 also retains earlier history, so recent regularity does not erase older gaps.",
+                `- rsi14: momentum (this agent flags overbought at ${signalThresholdsOf(spec).rsiOverbought} and oversold at ${signalThresholdsOf(spec).rsiOversold}); ema20 & ema50: trend; atr14: volatility (size stops off it); bollinger {upper,mid,lower}; recent20 {high,low}: breakout levels.`,
                 "- boolean reads: aboveEma20, ema20AboveEma50 (uptrend when both true), brokeRecentHigh (breakout), brokeRecentLow (breakdown).",
                 "- a null field = not enough data; ignore it. These INFORM your decision; they never widen a cap.",
             ]
             : []),
-        ...(spec.capabilities.includes("universe_scan")
+        ...(spec.universe
+            ? [
+                "",
+                "## Your market (declared boundaries) — candidates beyond your watchlist",
+                `Each cycle the runner scans the market inside YOUR boundaries: ${describeUniverse(spec.universe)}. Watch entries with \`discovered: true\` are the top rows of that scan, resolved with the same price/sentiment (and indicators) data as your watchlist. observation.universeMovers lists further rows as symbol + 24h change only (context — you cannot trade those directly this cycle). Nothing outside these boundaries is shown to you or tradable.`,
+                "- Treat a discovered candidate like any other symbol: analyze it for catalysts, exhaustion and reversal BEFORE acting. A big move is as often a top as a beginning — chasing candles blind is how discovery loses money.",
+                "- All your normal risk rules apply unchanged: caps, stops, blocklist, confidence floor. Discovery widens what you can SEE, never what you may risk.",
+                "- Your boundaries also bind your watchlist: a watch entry with `withinBoundaries: false` (or no withinBoundaries and not discovered) is context only. You may close or sell an existing position in it, but a new entry is REJECTED (outside_universe).",
+            ]
+            : []),
+        ...(!spec.universe && spec.capabilities.includes("universe_scan")
             ? [
                 "",
                 "## Universe scan (discovered movers) — candidates beyond your watchlist",
@@ -339,6 +412,39 @@ opts = {}) {
         `Each cycle, look at your OPEN positions FIRST, not just new entries. A position that is working is your best opportunity: once it moves your way, move the stop to breakeven and then TRAIL it behind the move with futures_set_sltp so a winner keeps running instead of being cut early${futuresOpenWithheld ? "" : " — 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");
 }
+/**
+ * Per-position stop-loss side of the mark for futures_set_sltp. Live
+ * 2026-10-08: 473 stop_loss_not_above/below_mark refusals in 24 h, nearly all
+ * agents moving a short's stop to its entry price or trailing it when the
+ * mark was already at or past that level. States only the observed-mark
+ * constraint the validator applies (pos.markPrice, TRIGGER_PRICE_EPS); the
+ * take-profit side, liquidation and every other check stay authoritative.
+ * Prices print unrounded so the text never contradicts the validator.
+ */
+export function stopBoundLines(positions) {
+    const out = [];
+    for (const p of positions) {
+        const mark = p.markPrice;
+        const side = (p.side ?? "").toLowerCase();
+        if (typeof mark !== "number" || !Number.isFinite(mark) || mark <= 0)
+            continue;
+        if (side !== "long" && side !== "short")
+            continue;
+        const isShort = side === "short";
+        let line = `- pos#${p.id} ${side} ${p.symbol ?? ""}: observed mark ${String(mark)}; a new stopLossPrice must be ${isShort ? "ABOVE" : "BELOW"} it.`;
+        const entry = p.entryPrice;
+        if (typeof entry === "number" && Number.isFinite(entry) && entry > 0) {
+            const entrySideOk = isShort
+                ? entry > mark + TRIGGER_PRICE_EPS
+                : entry < mark - TRIGGER_PRICE_EPS;
+            line += entrySideOk
+                ? ` A stop at the entry price ${String(entry)} is on the allowed side of the mark.`
+                : ` A stop at the entry price ${String(entry)} is on the wrong side of the mark and would be refused; keep the current stop, or close the position if the thesis broke.`;
+        }
+        out.push(line);
+    }
+    return out;
+}
 export function buildUserPrompt(obs, journal, opts = {}) {
     // Default to every venue for backwards-compatible direct callers and probes.
     // The runner always supplies the real spec, so disabled venue instructions and
@@ -348,9 +454,36 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     const futuresOpenWithheld = hasFutures && opts.excludeActionTypes?.includes("futures_open") === true;
     const hasSpot = venues.includes("spot");
     const hasPm = venues.includes("pm");
+    const entryChoices = hasFutures ? futuresEntryChoices(obs) : undefined;
+    const blockedFutures = new Set(entryChoices?.blocked.map((entry) => baseSymbol(entry.symbol)));
+    // Structural signals remain in the observation/receipt. Only the model's
+    // action shortlist changes: an unsupported NEW futures entry is not an
+    // actionable futures setup. Spot and held-position context remain visible.
+    const promptSetups = (obs.setups ?? []).flatMap((setup) => {
+        if (!blockedFutures.has(baseSymbol(setup.symbol)))
+            return [setup];
+        return hasSpot
+            ? [
+                {
+                    ...setup,
+                    note: `${setup.note} [NEW FUTURES ENTRY BLOCKED: consider spot only if independently allowed, or skip]`,
+                },
+            ]
+            : [];
+    });
+    const noFuturesEntryCandidates = entryChoices !== undefined &&
+        entryChoices.blocked.length > 0 &&
+        entryChoices.candidates.length === 0;
     const lines = [
         "Decide for THIS cycle using only the observation below (data available now — no look-ahead).",
     ];
+    if (entryChoices && entryChoices.blocked.length > 0) {
+        lines.push(`NEW FUTURES ENTRY AVAILABILITY: ${entryChoices.blocked.map((entry) => `${entry.symbol} (${entry.code})`).join(", ")} cannot be used for a NEW futures_open this cycle. A strong move or flagged structure does not override this block.`, "If futures_open is otherwise available, choose a new futures entry only from futuresEntryChoices.candidates below; this list checks perpetual-reference availability only, not other caps, universe boundaries, direction or quote/execution rules. reference=unknown is NOT eligibility: it still needs validation at quote time. held_position means the existing add/manage exception, under the unchanged add rules; it is not a fresh entry recommendation.", `Blocked coins remain in watch for market context${hasSpot ? " and otherwise-valid spot decisions" : ""}. Existing futures_close, futures_set_sltp and valid adds remain governed by their existing rules. ${hasSpot ? "Blocked setup notes apply only to NEW futures entries; do not force a spot trade to avoid skipping." : "Their unheld entry setups are omitted from this prompt's shortlist; the underlying market evidence remains visible."}`, ...(noFuturesEntryCandidates
+            ? [
+                "There are NO new futures entry candidates this cycle. Manage/protect existing positions where valid, or skip. Unavailable futures entries are a valid reason to skip; do not invent an alternative trade.",
+            ]
+            : []));
+    }
     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.");
     }
@@ -391,6 +524,31 @@ export function buildUserPrompt(obs, journal, opts = {}) {
                 ]
                 : []));
     }
+    // Futures entry rules the runner enforces, stated with THIS agent's numbers.
+    // The weekly house report (2026-09-30..10-07) found the two largest refusal
+    // classes were opens below the fee-inclusive reward:risk floor
+    // (capital_quote_reward_risk_too_low) and SL/TP on an add
+    // (add_cannot_carry_sltp). Wording only: the validators are unchanged.
+    if (hasFutures && !futuresOpenWithheld) {
+        const held = Array.from(new Set(obs.openPositions
+            .filter((p) => p.venue === "futures" &&
+            (p.status ?? "open") === "open" &&
+            typeof p.symbol === "string" &&
+            p.symbol.length > 0)
+            .map((p) => p.symbol.toUpperCase())));
+        const minRewardRisk = opts.capitalSizing?.minRewardRisk;
+        if (typeof minRewardRisk === "number" &&
+            Number.isFinite(minRewardRisk) &&
+            minRewardRisk >= 1) {
+            lines.push(`REWARD:RISK FLOOR ${minRewardRisk} (your capitalSizing.minRewardRisk, enforced with fees; a correct-side take-profit inside it is widened by the runner to the floor, never narrowed, and an open that still cannot meet it is rejected as capital_quote_reward_risk_too_low): the take-profit's distance from entry, minus the entry and exit fees, must be at least ${minRewardRisk}x the stop's distance from entry plus those fees. A target exactly ${minRewardRisk}x the stop distance FAILS once fees are counted, so leave room. If the setup cannot offer such a target, do not open it.`);
+        }
+        if (held.length > 0) {
+            const list = held.join(", ");
+            lines.push(opts.capitalSizing
+                ? `You already hold futures on ${list}. Under your capital policy you cannot ADD to them: every futures_open needs its own stopLossPrice and takeProfitPrice for sizing, and the server refuses SL/TP on an add (add_cannot_carry_sltp). Propose NO futures_open on ${list}; manage them with futures_set_sltp or futures_close on their positionId.`
+                : `You already hold futures on ${list}. A futures_open on any of them is an ADD and must carry NO stopLossPrice or takeProfitPrice (the whole open is rejected as add_cannot_carry_sltp); adjust protection with futures_set_sltp on the positionId instead.`);
+        }
+    }
     // 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
@@ -399,7 +557,9 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     if ((obs.openPositions?.length ?? 0) === 0 &&
         (!hasPm || (obs.pmPositions?.length ?? 0) === 0)) {
         const openingActions = [
-            ...(hasFutures && !futuresOpenWithheld ? ["futures_open"] : []),
+            ...(hasFutures && !futuresOpenWithheld && !noFuturesEntryCandidates
+                ? ["futures_open"]
+                : []),
             ...(hasSpot ? ["spot_order"] : []),
             ...(hasPm ? ["pm_open"] : []),
         ];
@@ -415,6 +575,16 @@ 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}`));
     }
+    // Persisted state is read back defensively: only well-formed entries render.
+    const rejections = (Array.isArray(opts.lastRejections) ? opts.lastRejections : [])
+        .filter((r) => r &&
+        typeof r.action === "string" &&
+        typeof r.code === "string" &&
+        r.code.length > 0)
+        .slice(0, 5);
+    if (rejections.length > 0) {
+        lines.push("", "## Your last decision's REJECTED actions (refused, nothing happened) - do NOT resubmit them unchanged; fix the cause shown or choose differently:", ...rejections.map((r) => `- ${r.action.replace(/\s+/g, " ").slice(0, 200)}: ${r.code.replace(/\s+/g, " ").slice(0, 80)}${typeof r.reason === "string" && r.reason ? ` - ${r.reason.replace(/\s+/g, " ").slice(0, 200)}` : ""}`));
+    }
     // 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.
@@ -431,6 +601,10 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     if (brokenTheses.length > 0) {
         lines.push("", "## Positions whose thesis is INVALIDATED this cycle", ...brokenTheses.map((b) => `- ${b}`));
     }
+    const stopBounds = stopBoundLines(obs.openPositions);
+    if (stopBounds.length > 0) {
+        lines.push("", "## Stop-loss side of the mark for futures_set_sltp (a stop on the wrong side is refused; take-profit side, liquidation and the other trigger checks still apply)", ...stopBounds);
+    }
     if (obs.openPositions.some((p) => p.fundingPaidMusd !== undefined ||
         p.fundingAppliedThrough !== undefined)) {
         lines.push("Futures funding shown in the position is already reflected in margin and balances; do not deduct it again when judging available capital or PnL.");
@@ -442,7 +616,7 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     lines.push("", "```json", 
     // Compact (no pretty-print indentation — ~40% fewer tokens, still valid JSON)
     // and the trade ledger is capped so a busy shared book can't bloat the prompt.
-    JSON.stringify({
+    serializePromptObservation({
         asOf: obs.asOf,
         ...(opts.dailyRiskBudget
             ? { dailyRiskBudget: opts.dailyRiskBudget }
@@ -500,13 +674,17 @@ export function buildUserPrompt(obs, journal, opts = {}) {
             ? { pmCalibration: obs.pmCalibration }
             : {}),
         watch: obs.watch,
-        setups: obs.setups,
+        ...(entryChoices && entryChoices.blocked.length > 0
+            ? { futuresEntryChoices: entryChoices }
+            : {}),
+        setups: promptSetups,
         news: obs.news,
         universeMovers: obs.universeMovers,
         whaleContext: obs.whaleContext,
         marketMood: obs.marketMood,
+        ...(obs.macro ? { macro: obs.macro } : {}),
         newClosedTrades: obs.newClosedTrades.slice(0, 20),
         polledBeforeWrite: obs.polledBeforeWrite,
-    }), "```", "", "Return ONLY the JSON decision object.");
+    }, opts.compactTables), "```", "", "Return ONLY the JSON decision object.");
     return lines.join("\n");
 }

package/dist/agent/promptTables.d.ts

@@ -0,0 +1 @@
+export declare function serializePromptObservation(value: unknown, compact?: boolean): string;

package/dist/agent/promptTables.js

@@ -0,0 +1,33 @@
+const row = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+// Keep market refs and per-outcome settlement rules in their proven object
+// representation. A provider probe mis-associated an optional rule with a ref.
+const TABLE_FIELDS = ["watch", "pmPositions", "newClosedTrades"];
+const FORMAT = "Tabular lists use columns and rows: each row's values map to the columns in order. Every row remains a separate item; nested objects keep their field names. References such as watch[].priceUsd refer to the reconstructed row. Only lists with identical fields use tables. Market refs and settlement rules remain objects. Return the normal decision JSON with actions as an array of objects.";
+export function serializePromptObservation(value, compact = false) {
+    const original = JSON.stringify(value);
+    if (!compact)
+        return original;
+    const data = JSON.parse(original);
+    let changed = false;
+    for (const field of TABLE_FIELDS) {
+        const list = data[field];
+        if (!Array.isArray(list) || list.length < 3 || !list.every(row))
+            continue;
+        const columns = Object.keys(list[0]).filter((k) => list.every((r) => Object.hasOwn(r, k)));
+        if (columns.length < 3 ||
+            list.some((r) => Object.keys(r).length !== columns.length))
+            continue;
+        const table = {
+            columns,
+            rows: list.map((r) => columns.map((k) => r[k])),
+        };
+        if (JSON.stringify(list).length - JSON.stringify(table).length < 512)
+            continue;
+        data[field] = table;
+        changed = true;
+    }
+    if (!changed)
+        return original;
+    const result = JSON.stringify({ tableFormat: FORMAT, ...data });
+    return result.length < original.length ? result : original;
+}

package/dist/agent/providerCapabilities.d.ts

@@ -1,6 +1,11 @@
 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 declare function canRetrySuperToolOutput(route: {
+    provider: string;
+    model: string;
+    baseUrl?: string | null;
+}, responseSource: string | undefined, actionsStringDiagnostic: string | undefined): boolean;
 export interface ChatShape {
     family: "openai-reasoning" | "nvidia-nemotron" | "anthropic" | "openai-compat";
     tokenParam: "max_tokens" | "max_completion_tokens";
@@ -13,6 +18,7 @@ export interface ChatShape {
     minProbeCompletionTokens: number;
 }
 export declare function chatShapeFor(provider: ProviderName, model: string, baseUrl?: string): ChatShape;
+export declare function withJsonContentTransport(shape: ChatShape): ChatShape;
 export type DecisionActionExclusion = "futures_open";
 export declare function restrictDecisionSchema(schema: Record<string, unknown>, exclude: readonly DecisionActionExclusion[] | undefined): Record<string, unknown>;
 /** Build the chat-completions body for a route from its capability shape. */
@@ -23,4 +29,5 @@ export declare function buildChatBody(shape: ChatShape, args: {
     maxTokens: number;
     temperature?: number;
     excludeActionTypes?: readonly DecisionActionExclusion[];
+    decisionContract?: "pm_paper_v2";
 }): Record<string, unknown>;

package/dist/agent/providerCapabilities.js

@@ -1,6 +1,17 @@
+import { PM_PAPER_DECISION_JSON_SCHEMA } from "./pmPaperDecision.js";
 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";
+// A retry changes transport only after the strict parser has rejected a known
+// Super tool-argument encoding failure. Valid responses and other routes keep
+// their original request shape. A custom endpoint is deliberately excluded.
+export function canRetrySuperToolOutput(route, responseSource, actionsStringDiagnostic) {
+    return (route.provider === "nvidia" &&
+        route.model === "nvidia/nemotron-3-super-120b-a12b" &&
+        (route.baseUrl == null || route.baseUrl === NVIDIA_BASE_URL) &&
+        responseSource === "tool_call" &&
+        actionsStringDiagnostic !== undefined);
+}
 // 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;
@@ -54,6 +65,19 @@ export function chatShapeFor(provider, model, baseUrl) {
         minProbeCompletionTokens: 1024,
     };
 }
+// Opt-in alternative for a hosted Nemotron route: plain JSON content
+// (`response_format: json_object`) instead of the forced decision tool call.
+// Hosted Super has returned the forced tool call with `actions` as a string
+// (519 of 533 malformed attempts in a 24h sample, 2026-10-05). In an 8-call
+// synthetic smoke pilot the tool-call arms failed 0/4 with the same coarse
+// string shape and the JSON-content arm parsed 2/2; that is not a rate
+// measurement and the exact serialization cause is not established. Only the
+// request transport changes: parseDecision still validates the full contract.
+export function withJsonContentTransport(shape) {
+    if (shape.family !== "nvidia-nemotron")
+        return shape;
+    return { ...shape, jsonSchema: undefined, jsonSchemaTransport: undefined };
+}
 // Transport-only restriction: drop the excluded variants from the action oneOf
 // a route decodes against. parseDecision keeps validating the FULL contract, so
 // a route that does not enforce a schema can still propose the action and the
@@ -87,7 +111,9 @@ export function buildChatBody(shape, args) {
         ? `${shape.systemHint}\n\n${args.system}`
         : args.system;
     const jsonSchema = shape.jsonSchema
-        ? restrictDecisionSchema(shape.jsonSchema, args.excludeActionTypes)
+        ? args.decisionContract === "pm_paper_v2"
+            ? PM_PAPER_DECISION_JSON_SCHEMA
+            : restrictDecisionSchema(shape.jsonSchema, args.excludeActionTypes)
         : undefined;
     return {
         model: args.model,

package/dist/agent/providers.d.ts

@@ -1,11 +1,24 @@
 import { AgentSpec, ProviderName } from "./types.js";
+import { type ActionsStringDiagnostic } from "./decision.js";
 import { type DecisionActionExclusion } from "./providerCapabilities.js";
+export interface ProviderUsage {
+    promptTokens: number;
+    completionTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    cacheWrite5mTokens?: number;
+    cacheWrite1hTokens?: number;
+}
+export declare function anthropicUsage(raw: unknown): ProviderUsage | undefined;
 export interface DecideInput {
     system: string;
     user: string;
+    /** Optional equivalent presentation for explicitly verified hosted routes. */
+    compactUser?: string;
     maxTokens?: number;
     timeoutMs?: number;
     excludeActionTypes?: readonly DecisionActionExclusion[];
+    decisionContract?: "pm_paper_v2";
 }
 export interface DecideRouteAttempt {
     provider: string;
@@ -16,6 +29,10 @@ export interface DecideRouteAttempt {
     retryAfterMs?: number;
     latencyMs: number;
     error?: string;
+    responseSource?: "tool_call" | "content_fallback" | "content";
+    actionsStringDiagnostic?: ActionsStringDiagnostic;
+    /** Scheduler admission categories, never free-form provider error text. */
+    admissionReasons?: Array<"request_budget" | "token_budget" | "concurrency" | "shared_key_cooldown" | "model_cooldown">;
 }
 export interface DecideRouteMeta {
     policyVersion: string;
@@ -29,14 +46,13 @@ export type DecideResult = {
     ok: true;
     text: string;
     responseSource?: "tool_call" | "content_fallback" | "content";
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-    };
+    usage?: ProviderUsage;
     route?: DecideRouteMeta;
 } | {
     ok: false;
     error: string;
+    failureClass?: "malformed";
+    usage?: ProviderUsage;
     status?: number;
     retryAfterMs?: number;
     retryableHttpFailure?: true;
@@ -58,10 +74,13 @@ export interface ProviderEnv {
 /** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
 export declare function classifyProviderFailure(result: Extract<DecideResult, {
     ok: false;
-}>): "capacity" | "permanent" | "transient";
-export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
+}>): "capacity" | "permanent" | "transient" | "malformed";
+export interface ProviderRouteOptions {
+    nemotronJsonContent?: boolean | (() => boolean);
+}
+export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch, options?: ProviderRouteOptions): Provider;
 export declare function providerForRoute(route: {
     provider: ProviderName;
     model: string;
     baseUrl?: string | null;
-}, apiKey: string, fetchFn?: typeof fetch): Provider;
+}, apiKey: string, fetchFn?: typeof fetch, options?: ProviderRouteOptions): Provider;