@coinrithm/mcp-trading 0.7.16 → 0.7.18

package/dist/agent/providers.js

@@ -3,7 +3,7 @@
 // single structured-JSON decision (parsed in decision.ts). No free-form tool
 // execution — the model only proposes; the runner disposes.
 import { retryAfterSeconds } from "../retryAfter.js";
-import { parseDecision } from "./decision.js";
+import { parseDecisionForContract, } from "./decision.js";
 import { chatShapeFor, buildChatBody, withJsonContentTransport, canRetrySuperToolOutput, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
 // A token count as Anthropic reports it: a non-negative safe integer. Zero
 // is a real count; anything else (missing, null, negative, NaN, fractional,
@@ -334,6 +334,7 @@ class OpenAiCompatProvider {
                         user: input.user,
                         maxTokens: input.maxTokens ?? 1024,
                         excludeActionTypes: input.excludeActionTypes,
+                        decisionContract: input.decisionContract,
                     })),
                 });
                 if (!res.ok) {
@@ -423,7 +424,9 @@ class SameModelRetryProvider {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const first = await this.delegate.decide(input);
         const firstFinished = Date.now();
-        const parsedFirst = first.ok ? parseDecision(first.text) : undefined;
+        const parsedFirst = first.ok
+            ? parseDecisionForContract(first.text, input.decisionContract)
+            : undefined;
         const retryContent = first.ok &&
             parsedFirst?.ok === false &&
             this.contentRetry !== undefined &&
@@ -450,7 +453,7 @@ class SameModelRetryProvider {
             timeoutMs: remainingMs,
         });
         const parsedRetry = retryResult.ok
-            ? parseDecision(retryResult.text)
+            ? parseDecisionForContract(retryResult.text, input.decisionContract)
             : undefined;
         const result = retryResult.ok && parsedRetry?.ok === false
             ? {
@@ -461,7 +464,9 @@ class SameModelRetryProvider {
             }
             : retryResult;
         const attempt = (res, latencyMs) => {
-            const parsed = res.ok ? parseDecision(res.text) : undefined;
+            const parsed = res.ok
+                ? parseDecisionForContract(res.text, input.decisionContract)
+                : undefined;
             return {
                 provider: this.provider,
                 model: this.model,

package/dist/agent/runner.d.ts

@@ -1,6 +1,6 @@
 import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { Provider } from "./providers.js";
-import { AgentSpec, RunState, CycleResult, Decision, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence } from "./types.js";
+import { AgentSpec, RunState, CycleResult, Decision, PlannedAction, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence, LastRejection, TakeProfitRepair } from "./types.js";
 import { type ObserveOptions } from "./observe.js";
 import { type DecisionInputRecord } from "./decisionReceipt.js";
 export interface RunnerDeps {
@@ -30,7 +30,15 @@ export declare function sanitizeForecastProbability(raw: unknown): number | unde
 export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence, capitalMinimumRewardRisk?: number): {
     action: ProposedAction;
     repaired: boolean;
+    reason?: TakeProfitRepair["reason"];
 };
+export declare const LAST_REJECTIONS_MAX = 5;
+/**
+ * Pure: the rejected actions of one validated decision, newest decision only,
+ * for the next prompt. Undefined when nothing was rejected, so a fixed
+ * mistake drops out at once.
+ */
+export declare function lastRejectionsOf(planned: readonly PlannedAction[], at: string): LastRejection[] | undefined;
 export declare function rationaleForAction(a: ProposedAction, decisionRationale: string | undefined, perActionSummary: string | undefined, totalActions: number): string | undefined;
 export declare function buildSkipOpportunity(decision: Decision, pmMarkets: PmMarket[], forecastEnabled: boolean): PostedOpportunity | null;
 export declare function runCycle(deps: RunnerDeps): Promise<CycleResult>;

package/dist/agent/runner.js

@@ -19,6 +19,7 @@ import { parseDecision } from "./decision.js";
 import { validateAction, isRiskIncreasingAction, pmEventKey, pmCoinHorizonOf, pmReferenceMs, } from "./decisionValidator.js";
 import { resolvePmRef } from "./resolvePm.js";
 import { fetchQuote, executeAction } from "./act.js";
+import { executionOutcome, exitOutcomeMetadata, } from "./futuresCloseOutcome.js";
 import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
 import { rollDay, checkKillSwitch, saveState, isPermanentModelError, isAuthFailureSkip, PERMANENT_MODEL_ERROR_THRESHOLD, AUTH_FAILURE_THRESHOLD, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
@@ -137,8 +138,10 @@ function cashConsumed(action, quote) {
 // WHOLE open (take_profit_not_*_mark) — the position never opens, so the model
 // can't "let winners run". Here we substitute a sensible R:R target off the stop so
 // the open succeeds with a valid TP. Only fires when a usable stop is present (so
-// risk is computable) and the TP is actually missing/wrong-side; a correct TP is
-// left untouched. Systemic fix for the whole free-tier 8B/instruct fleet.
+// risk is computable) and the TP is missing/wrong-side, or (capital policy only,
+// owner GO 2026-10-08) on the right side but inside the agent's own reward:risk
+// floor, where it is widened to the floor and never narrowed. Any other correct
+// TP is left untouched. Systemic fix for the whole free-tier 8B/instruct fleet.
 const DEFAULT_TP_RR = 1.5; // reward:risk of the substituted take-profit
 export function repairFuturesTakeProfit(action, quote, capitalMinimumRewardRisk) {
     if (action.type !== "futures_open")
@@ -155,7 +158,10 @@ export function repairFuturesTakeProfit(action, quote, capitalMinimumRewardRisk)
         Number.isFinite(tp) &&
         tp > 0 &&
         (isLong ? tp > entry : tp < entry);
-    if (tpValid)
+    // A correct-side TP is only revisited against the agent's own capital R:R
+    // floor (owner GO 2026-10-08: widen a too-close target instead of refusing
+    // the trade; 114 capital_quote_reward_risk_too_low refusals in 10 h).
+    if (tpValid && capitalMinimumRewardRisk === undefined)
         return { action, repaired: false };
     // Stop must be on the correct side to imply a positive risk distance; if it
     // isn't, leave the action for the validator to reject (don't fabricate).
@@ -176,15 +182,30 @@ export function repairFuturesTakeProfit(action, quote, capitalMinimumRewardRisk)
             return { action, repaired: false };
         const notional = action.marginMusd * action.leverage;
         const fee = bps / 10_000;
+        // Fail closed on economics that cannot yield a finite target.
+        if (!(Number.isFinite(notional) && notional > 0) || !(fee < 1))
+            return { action, repaired: false };
         const stopRisk = (notional * risk) / entry + entryFee + ((notional * sl) / entry) * fee;
         const required = (capitalMinimumRewardRisk + 1e-8) * stopRisk;
         target = isLong
             ? (entry * (notional + entryFee + required)) / (notional * (1 - fee))
             : (entry * (notional - entryFee - required)) / (notional * (1 + fee));
     }
-    if (!(target > 0))
+    if (!Number.isFinite(target) || !(target > 0))
+        return { action, repaired: false };
+    // Widen only: a valid TP at or beyond the floor is the model's choice.
+    if (tpValid && (isLong ? tp >= target : tp <= target))
         return { action, repaired: false };
-    return { action: { ...action, takeProfitPrice: target }, repaired: true };
+    const reason = tpValid
+        ? "below_reward_risk_floor"
+        : typeof tp === "number" && Number.isFinite(tp) && tp > 0
+            ? "wrong_side"
+            : "missing";
+    return {
+        action: { ...action, takeProfitPrice: target },
+        repaired: true,
+        reason,
+    };
 }
 // One-line, human-readable summary of an executed action for the agent's journal
 // (slice-3 memory). Compact so a few entries cost almost nothing in the prompt.
@@ -193,6 +214,48 @@ export function repairFuturesTakeProfit(action, quote, capitalMinimumRewardRisk)
 function thesisTail(t) {
     return t ? ` on thesis: ${t.summary.slice(0, 70)}` : "";
 }
+/** What the model tried, for its own rejection feedback (not a completed move). */
+function describeAttempt(a) {
+    switch (a.type) {
+        case "futures_open":
+            return `futures_open ${a.side} ${a.symbol}`;
+        case "futures_close":
+            return `futures_close pos#${a.positionId}`;
+        case "futures_set_sltp":
+            return `futures_set_sltp pos#${a.positionId} (stopLossPrice ${a.stopLossPrice ?? "unchanged"}, takeProfitPrice ${a.takeProfitPrice ?? "unchanged"})`;
+        case "spot_order":
+            return `spot_order ${a.side} ${a.symbol}`;
+        case "spot_cancel":
+            return `spot_cancel order#${a.orderId}`;
+        case "pm_open":
+            return `pm_open ${a.ref ?? a.slug}`;
+    }
+}
+export const LAST_REJECTIONS_MAX = 5;
+const REJECTION_REASON_MAX = 200;
+/**
+ * Pure: the rejected actions of one validated decision, newest decision only,
+ * for the next prompt. Undefined when nothing was rejected, so a fixed
+ * mistake drops out at once.
+ */
+export function lastRejectionsOf(planned, at) {
+    const rejected = planned.filter((p) => !p.accepted && p.code);
+    if (rejected.length === 0)
+        return undefined;
+    return rejected.slice(0, LAST_REJECTIONS_MAX).map((p) => ({
+        at,
+        action: describeAttempt(p.action),
+        code: p.code,
+        ...(p.reason
+            ? {
+                reason: p.reason
+                    .replace(/\s+/g, " ")
+                    .trim()
+                    .slice(0, REJECTION_REASON_MAX),
+            }
+            : {}),
+    }));
+}
 function summarizeAction(a) {
     switch (a.type) {
         case "futures_open":
@@ -607,25 +670,33 @@ async function runCycleCore(deps, capture) {
             ...observationReceipt,
         };
         const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
+        const outcome = executionOutcome(action, r);
         exitPlanned.push({
             action,
             accepted: true,
             code: "thesis_invalidated",
             reason: why,
-            executed: r.ok,
+            executed: outcome.executed,
+            ...exitOutcomeMetadata(outcome),
             result: r.data,
         });
-        if (r.ok) {
+        if (outcome.newWrite) {
             state.intentSeq[intentKey] = seq + 1;
             state.writesToday += 1;
+        }
+        if (outcome.executed) {
             forgetThesis(state, thesisKey("futures", pos.id));
             closedByThesis.push(pos.id);
-            state.journal = [
-                ...(state.journal ?? []),
-                { at: observation.asOf, did: `thesis exit: closed ${label} (${why})` },
-            ].slice(-12);
+            if (!outcome.replayed)
+                state.journal = [
+                    ...(state.journal ?? []),
+                    {
+                        at: observation.asOf,
+                        did: `thesis exit: closed ${label} (${why})`,
+                    },
+                ].slice(-12);
         }
-        log(`${r.ok ? "executed" : "FAILED"} thesis exit on ${label} (HTTP ${r.status}): ${why}`);
+        log(`${outcome.executed ? "executed" : outcome.pending ? "pending" : "FAILED"} thesis exit on ${label} (HTTP ${r.status}): ${why}`);
     }
     if (closedByThesis.length > 0) {
         // The model must see the book as it IS now: drop the closed positions,
@@ -677,7 +748,8 @@ async function runCycleCore(deps, capture) {
             tokensOut: 0,
             estimatedCostUsd: 0,
             writeAttempted: live ? exitPlanned.length : 0,
-            writeAccepted: exitPlanned.filter((p) => p.executed).length,
+            writeAccepted: exitPlanned.filter((p) => p.writeRecorded ?? p.executed)
+                .length,
             ...observationReceipt,
         };
     }
@@ -740,6 +812,7 @@ async function runCycleCore(deps, capture) {
         const userOptions = {
             venues: spec.venues,
             dailyRiskBudget: buildDailyRiskBudget(spec, state),
+            ...(state.lastRejections ? { lastRejections: state.lastRejections } : {}),
             ...(usesCapitalSizing(spec) ? { capitalSizing: spec.capitalSizing } : {}),
             ...(futuresCapacity ? { futuresCapacity } : {}),
             ...actionAvailability,
@@ -975,7 +1048,9 @@ async function runCycleCore(deps, capture) {
     // undefined (not the raw text) → db.ts stores NULL for raw_model_output.
     const rawModelOutput = undefined;
     if (decision.decision === "skip" || decision.actions.length === 0) {
-        state.consecutiveRejectCycles += 1;
+        if (!exitPlanned.length ||
+            !exitPlanned.every((p) => p.executionPending === true))
+            state.consecutiveRejectCycles += 1;
         // Capture the abstention / forecast-only: the model evaluated a non-empty PM
         // universe and chose NOT to open, so the public evaluation must see it (else an
         // agent looks skilled by exposure choice alone). One post carries the whole
@@ -983,6 +1058,8 @@ async function runCycleCore(deps, capture) {
         const skipOpp = buildSkipOpportunity(decision, observation.pmMarkets, forecastEnabled);
         if (skipOpp)
             await opportunities.post(skipOpp);
+        // A valid new decision saw the feedback and did not repeat it.
+        state.lastRejections = undefined;
         saveState(stateFile, state);
         log(`model chose skip${decision.reason ? `: ${decision.reason}` : ""}`);
         return {
@@ -1006,6 +1083,7 @@ async function runCycleCore(deps, capture) {
     }
     // VALIDATE (+ ACT when live). Quote evidence is fetched by the runner.
     const planned = [];
+    const protectionRefusals = [];
     let riskIncreasesThisCycle = 0;
     let openCount = observation.openPositions.length;
     // RUNNING totals so multiple opens in one cycle accumulate correctly.
@@ -1030,6 +1108,7 @@ async function runCycleCore(deps, capture) {
     let anyAccepted = false;
     let anyExecuted = false;
     let anyExecFailed = false;
+    let anyPending = false;
     for (let action of decision.actions) {
         let capitalSizing;
         // Resolve a short PM ref (pm1…pmN) to the canonical {source,slug,outcome} BEFORE
@@ -1201,12 +1280,25 @@ async function runCycleCore(deps, capture) {
         }
         // Auto-clamp a missing/wrong-side futures take-profit to a valid R:R target
         // off the stop, so the open isn't silently rejected server-side (the runner
-        // owns trigger orientation; weak models routinely mis-sign it).
+        // owns trigger orientation; weak models routinely mis-sign it). Under a
+        // capital policy a correct-side TP inside the R:R floor is widened to it.
+        let takeProfitRepair;
         {
             const fixed = repairFuturesTakeProfit(action, quote, capitalSizingEnabled ? spec.capitalSizing?.minRewardRisk : undefined);
             if (fixed.repaired) {
+                // Diagnostics keep the model's own request next to the applied target.
+                const requested = action
+                    .takeProfitPrice;
                 action = fixed.action;
-                log(`repaired ${action.type} take-profit -> ${action.takeProfitPrice} (R:R off stop; model TP was missing/wrong-side)`);
+                takeProfitRepair = {
+                    requestedTakeProfitPrice: typeof requested === "number" && Number.isFinite(requested)
+                        ? requested
+                        : null,
+                    appliedTakeProfitPrice: action
+                        .takeProfitPrice,
+                    reason: fixed.reason ?? "missing",
+                };
+                log(`repaired ${action.type} take-profit ${requested ?? "missing"} -> ${action.takeProfitPrice} (R:R off stop; model TP was missing, wrong-side or inside the reward:risk floor)`);
             }
         }
         const ctx = {
@@ -1240,6 +1332,7 @@ async function runCycleCore(deps, capture) {
                 reason: v.reason,
                 quote,
                 ...(capitalSizing ? { capitalSizing } : {}),
+                ...(takeProfitRepair ? { takeProfitRepair } : {}),
             });
             log(`reject ${action.type}: ${v.code} (${v.reason})`);
             continue;
@@ -1255,6 +1348,7 @@ async function runCycleCore(deps, capture) {
                 reason: "paper capital policy rejected quoted economics",
                 quote,
                 capitalSizing,
+                ...(takeProfitRepair ? { takeProfitRepair } : {}),
             });
             log(`reject ${action.type}: ${capitalRejection}`);
             continue;
@@ -1284,6 +1378,7 @@ async function runCycleCore(deps, capture) {
                 quote,
                 executed: false,
                 ...(capitalSizing ? { capitalSizing } : {}),
+                ...(takeProfitRepair ? { takeProfitRepair } : {}),
             });
             // Opt-in simulations reserve the same accepted capital as paper-live.
             // No close/sell proceeds are credited until a future observed wallet read.
@@ -1317,18 +1412,27 @@ async function runCycleCore(deps, capture) {
             ...observationReceipt,
         };
         const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
+        const outcome = executionOutcome(action, r);
         planned.push({
             action,
             accepted: true,
             quote,
-            executed: r.ok,
+            executed: outcome.executed,
+            ...exitOutcomeMetadata(outcome),
             result: r.data,
             ...(capitalSizing ? { capitalSizing } : {}),
+            ...(takeProfitRepair ? { takeProfitRepair } : {}),
         });
-        if (r.ok) {
-            anyExecuted = true;
+        if (outcome.newWrite) {
             state.intentSeq[intentKey] = seq + 1;
             state.writesToday += 1;
+        }
+        if (outcome.pending)
+            anyPending = true;
+        if (outcome.executed) {
+            anyExecuted = true;
+            if (outcome.v2 && action.type === "futures_close")
+                forgetThesis(state, thesisKey("futures", action.positionId));
             if (isRiskIncreasingAction(action)) {
                 riskIncreasesThisCycle += 1;
                 state.riskIncreasesToday += 1;
@@ -1364,8 +1468,25 @@ async function runCycleCore(deps, capture) {
             if (capitalSizingEnabled)
                 committedCapitalMusd += capitalCashCost(action, quote);
         }
-        else {
+        else if (!outcome.pending) {
             anyExecFailed = true;
+            // The mark can move after local validation. This explicit API rejection
+            // confirms that the protection update was refused. A timeout/5xx cannot
+            // establish that nothing happened and must never enter this feedback.
+            const response = asObj(r.data);
+            if (action.type === "futures_set_sltp" &&
+                r.status === 422 &&
+                response.error === "sl_tp_invalid") {
+                const codes = Array.isArray(response.blockReasons)
+                    ? response.blockReasons.filter((code) => typeof code === "string" && /^[a-z][a-z0-9_]{0,79}$/.test(code))
+                    : [];
+                protectionRefusals.push({
+                    action,
+                    accepted: false,
+                    code: "sl_tp_invalid",
+                    reason: codes.slice(0, 5).join(", ") || "Recheck the current mark.",
+                });
+            }
             // A transport/server failure does not prove an entry stayed unfilled.
             // Reserve its possible spend for subsequent actions this cycle, without
             // recording a confirmed trade or advancing its idempotency sequence.
@@ -1402,23 +1523,30 @@ async function runCycleCore(deps, capture) {
                 });
             }
         }
-        log(`${r.ok ? "executed" : "FAILED"} ${action.type} (HTTP ${r.status})`);
+        log(`${outcome.executed ? "executed" : outcome.pending ? "pending" : "FAILED"} ${action.type} (HTTP ${r.status})`);
     }
     // Reset the reject kill-switch only on real PROGRESS: an accepted-but-FAILED
     // live write is not progress, or a persistently failing live agent would
     // never trip the kill-switch.
     const progressed = live ? anyExecuted : anyAccepted;
+    state.lastRejections = lastRejectionsOf([...planned, ...protectionRefusals], observation.asOf);
     state.consecutiveRejectCycles = progressed
         ? 0
-        : state.consecutiveRejectCycles + 1;
+        : live && anyPending && planned.every((p) => p.executionPending === true)
+            ? state.consecutiveRejectCycles
+            : state.consecutiveRejectCycles + 1;
     state.consecutiveExecFailures =
-        anyExecFailed && !anyExecuted ? state.consecutiveExecFailures + 1 : 0;
+        anyExecFailed && !anyExecuted
+            ? state.consecutiveExecFailures + 1
+            : !anyExecuted && anyPending
+                ? state.consecutiveExecFailures
+                : 0;
     state.rateLimitHits = client.rateLimitHits ?? state.rateLimitHits;
     // Memory describes completed moves, not policy acceptance. A backend rejection,
     // lost response, or dry-run plan must not become "opened" / "trailed stop" in
     // the next model prompt. Attempts remain in planned[] and the audit ledger.
     const moves = planned
-        .filter((p) => p.accepted && p.executed === true)
+        .filter((p) => p.accepted && p.executed === true && p.executionReplayed !== true)
         .map((p) => summarizeAction(p.action));
     if (moves.length > 0) {
         // A cycle-wide rationale may describe a failed/rejected sibling action.

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

package/dist/agent/skillValidator.js

@@ -28,6 +28,7 @@ export function validateCapitalSizingPolicy(value) {
         ...percentKeys,
         "cashReservePct",
         "minRewardRisk",
+        "highConviction",
     ]);
     for (const key of Object.keys(p)) {
         if (!allowedKeys.has(key))
@@ -57,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") {

package/dist/agent/strictLint.js

@@ -87,6 +87,7 @@ const ALLOWED_KEYS = {
         "totalCapitalPct",
         "cashReservePct",
         "minRewardRisk",
+        "highConviction",
     ],
     limits: [
         "maxTradesPerDay",

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

@@ -58,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";
@@ -687,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;
@@ -718,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;
@@ -743,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. */

package/dist/agent/version.d.ts

@@ -5,7 +5,7 @@ export declare const COINRITHM_API: {
     readonly kind: "coinrithm-agent-api";
     readonly baseUrl: "https://api.coinrithm.com";
     readonly mcpUrl: "https://mcp.coinrithm.com/mcp";
-    readonly openapiVersion: "1.7.0";
+    readonly openapiVersion: "1.9.0";
     readonly mcpPackage: "@coinrithm/mcp-trading";
     readonly mcpVersion: string;
 };

package/dist/agent/version.js

@@ -20,7 +20,7 @@ export const COINRITHM_API = {
     mcpUrl: "https://mcp.coinrithm.com/mcp",
     // The API CONTRACT version (openapi.yaml info.version). Versioned independently
     // from the npm package below — hand-bump this when the OpenAPI contract changes.
-    openapiVersion: "1.7.0",
+    openapiVersion: "1.9.0",
     mcpPackage: "@coinrithm/mcp-trading",
     mcpVersion: PACKAGE_VERSION,
 };