@coinrithm/mcp-trading 0.7.16 → 0.7.18

package/dist/agent/pmPaperDecision.d.ts

@@ -0,0 +1,187 @@
+import { z } from "zod";
+import type { ActionsStringDiagnostic } from "./decision.js";
+export declare const pmV2OpenActionSchema: z.ZodObject<Omit<{
+    source: z.ZodEnum<["kalshi", "polymarket"]>;
+    slug: z.ZodString;
+    outcomeExternalMarketId: z.ZodString;
+    side: z.ZodEnum<["yes", "no"]>;
+    maxCashBudget: z.ZodEffects<z.ZodString, string, string>;
+    idempotencyKey: z.ZodString;
+    minEntryProbabilityPct: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    thesis: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+} & {
+    forecastProbability: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "idempotencyKey" | "minEntryProbabilityPct"> & {
+    type: z.ZodLiteral<"pm_v2_open">;
+}, "strict", z.ZodTypeAny, {
+    source: "kalshi" | "polymarket";
+    type: "pm_v2_open";
+    slug: string;
+    outcomeExternalMarketId: string;
+    side: "yes" | "no";
+    maxCashBudget: string;
+    forecastProbability: string;
+    thesis?: string | null | undefined;
+}, {
+    source: "kalshi" | "polymarket";
+    type: "pm_v2_open";
+    slug: string;
+    outcomeExternalMarketId: string;
+    side: "yes" | "no";
+    maxCashBudget: string;
+    forecastProbability: string;
+    thesis?: string | null | undefined;
+}>;
+export declare const pmV2CloseActionSchema: z.ZodObject<Omit<{
+    positionId: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+    detail: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+}, "idempotencyKey"> & {
+    type: z.ZodLiteral<"pm_v2_close">;
+}, "strict", z.ZodTypeAny, {
+    type: "pm_v2_close";
+    positionId: number;
+    detail?: string | null | undefined;
+}, {
+    type: "pm_v2_close";
+    positionId: number;
+    detail?: string | null | undefined;
+}>;
+export declare const pmPaperDecisionSchema: z.ZodEffects<z.ZodObject<{
+    decision: z.ZodEnum<["act", "skip"]>;
+    reason: z.ZodOptional<z.ZodString>;
+    rationale: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    actions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<Omit<{
+        source: z.ZodEnum<["kalshi", "polymarket"]>;
+        slug: z.ZodString;
+        outcomeExternalMarketId: z.ZodString;
+        side: z.ZodEnum<["yes", "no"]>;
+        maxCashBudget: z.ZodEffects<z.ZodString, string, string>;
+        idempotencyKey: z.ZodString;
+        minEntryProbabilityPct: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        thesis: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    } & {
+        forecastProbability: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    }, "idempotencyKey" | "minEntryProbabilityPct"> & {
+        type: z.ZodLiteral<"pm_v2_open">;
+    }, "strict", z.ZodTypeAny, {
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    }, {
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    }>, z.ZodObject<Omit<{
+        positionId: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        detail: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    }, "idempotencyKey"> & {
+        type: z.ZodLiteral<"pm_v2_close">;
+    }, "strict", z.ZodTypeAny, {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    }, {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}>, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}>;
+export type PmPaperAction = z.infer<typeof pmV2OpenActionSchema> | z.infer<typeof pmV2CloseActionSchema>;
+export declare function parsePmPaperDecision(text: string): {
+    ok: true;
+    decision: z.infer<typeof pmPaperDecisionSchema>;
+} | {
+    ok: false;
+    error: string;
+    actionsStringDiagnostic?: ActionsStringDiagnostic;
+};
+export declare const PM_PAPER_DECISION_JSON_SCHEMA: Record<string, unknown>;

package/dist/agent/pmPaperDecision.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { pmPaperAgentOpenSchema, pmPaperCloseSchema } from "../pmPaperV2.js";
+// forecastProbability is required: a house open without it fails locally
+// instead of spending a write on the API's 422 forecast_required.
+export const pmV2OpenActionSchema = pmPaperAgentOpenSchema
+    .omit({ idempotencyKey: true, minEntryProbabilityPct: true })
+    .extend({ type: z.literal("pm_v2_open") })
+    .strict();
+export const pmV2CloseActionSchema = pmPaperCloseSchema
+    .omit({ idempotencyKey: true })
+    .extend({ type: z.literal("pm_v2_close") })
+    .strict();
+export const pmPaperDecisionSchema = z
+    .object({
+    decision: z.enum(["act", "skip"]),
+    reason: z.string().max(280).optional(),
+    rationale: z.string().max(1000).optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    actions: z
+        .array(z.discriminatedUnion("type", [
+        pmV2OpenActionSchema,
+        pmV2CloseActionSchema,
+    ]))
+        .max(1),
+})
+    .strict()
+    .refine((value) => value.decision === "act"
+    ? value.actions.length === 1
+    : value.actions.length === 0);
+export function parsePmPaperDecision(text) {
+    try {
+        const parsed = pmPaperDecisionSchema.safeParse(JSON.parse(text));
+        return parsed.success
+            ? { ok: true, decision: parsed.data }
+            : { ok: false, error: "invalid PM paper v2 decision" };
+    }
+    catch {
+        return { ok: false, error: "invalid PM paper v2 JSON" };
+    }
+}
+const decimal = {
+    type: "string",
+    pattern: "^(0|[1-9]\\d*)(\\.\\d{1,18})?$",
+    maxLength: 40,
+};
+export const PM_PAPER_DECISION_JSON_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["decision", "actions"],
+    properties: {
+        decision: { type: "string", enum: ["act", "skip"] },
+        reason: { type: "string", maxLength: 280 },
+        rationale: { type: "string", maxLength: 1000 },
+        confidence: { type: "number", minimum: 0, maximum: 1 },
+        actions: {
+            type: "array",
+            maxItems: 1,
+            items: {
+                oneOf: [
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        required: [
+                            "type",
+                            "source",
+                            "slug",
+                            "outcomeExternalMarketId",
+                            "side",
+                            "maxCashBudget",
+                            "forecastProbability",
+                        ],
+                        properties: {
+                            type: { const: "pm_v2_open" },
+                            source: { type: "string", enum: ["kalshi", "polymarket"] },
+                            slug: { type: "string", minLength: 1, maxLength: 256 },
+                            outcomeExternalMarketId: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 256,
+                            },
+                            side: { type: "string", enum: ["yes", "no"] },
+                            maxCashBudget: decimal,
+                            forecastProbability: decimal,
+                            thesis: { type: ["string", "null"], maxLength: 280 },
+                        },
+                    },
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["type", "positionId"],
+                        properties: {
+                            type: { const: "pm_v2_close" },
+                            positionId: { type: "integer", minimum: 1, maximum: 2147483647 },
+                            detail: { type: ["string", "null"], maxLength: 1024 },
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};

package/dist/agent/pmPaperPolicy.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const pmHouseIdentitySchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    apiKeyId: z.ZodNumber;
+    walletId: z.ZodNumber;
+    houseAgentId: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+}, {
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+}>;
+export declare const pmHousePolicySchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    apiKeyId: z.ZodNumber;
+    walletId: z.ZodNumber;
+    houseAgentId: z.ZodNumber;
+} & {
+    version: z.ZodLiteral<"pm_paper_house_v2">;
+    entryEnabled: z.ZodDefault<z.ZodBoolean>;
+    maxCashBudgetPerEntry: z.ZodEffects<z.ZodString, string, string>;
+    maxOpenPositions: z.ZodNumber;
+    maxEntriesPerDay: z.ZodNumber;
+    maxModelCallsPerHour: z.ZodDefault<z.ZodNumber>;
+    maxDailyLoss: z.ZodEffects<z.ZodString, string, string>;
+    discoveryQuery: z.ZodString;
+    maxEndDays: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    version: "pm_paper_house_v2";
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+    entryEnabled: boolean;
+    maxCashBudgetPerEntry: string;
+    maxOpenPositions: number;
+    maxEntriesPerDay: number;
+    maxModelCallsPerHour: number;
+    maxDailyLoss: string;
+    discoveryQuery: string;
+    maxEndDays?: number | undefined;
+}, {
+    version: "pm_paper_house_v2";
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+    maxCashBudgetPerEntry: string;
+    maxOpenPositions: number;
+    maxEntriesPerDay: number;
+    maxDailyLoss: string;
+    discoveryQuery: string;
+    entryEnabled?: boolean | undefined;
+    maxModelCallsPerHour?: number | undefined;
+    maxEndDays?: number | undefined;
+}>;
+export type PmHouseIdentity = z.infer<typeof pmHouseIdentitySchema>;
+export type PmHousePolicy = z.infer<typeof pmHousePolicySchema>;
+export declare const samePmHouse: (a: PmHouseIdentity, b: PmHouseIdentity) => boolean;
+export declare function readPmHousePolicies(raw: string | undefined): readonly PmHousePolicy[];
+export declare function selectPmHousePolicy(agent: {
+    id: number;
+    ownerUserId?: number | null;
+    isHouse?: boolean;
+}, policies?: readonly PmHousePolicy[]): PmHousePolicy | undefined;
+export declare function pmCashUnits(value: string): bigint;

package/dist/agent/pmPaperPolicy.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { pmPaperOpenSchema } from "../pmPaperV2.js";
+const id = z.number().int().positive().max(2147483647);
+export const pmHouseIdentitySchema = z
+    .object({ userId: id, apiKeyId: id, walletId: id, houseAgentId: id })
+    .strict();
+export const pmHousePolicySchema = pmHouseIdentitySchema
+    .extend({
+    version: z.literal("pm_paper_house_v2"),
+    entryEnabled: z.boolean().default(false),
+    maxCashBudgetPerEntry: pmPaperOpenSchema.shape.maxCashBudget,
+    maxOpenPositions: z.number().int().min(1).max(20),
+    maxEntriesPerDay: z.number().int().min(1).max(100),
+    maxModelCallsPerHour: z.number().int().min(1).max(30).default(12),
+    maxDailyLoss: pmPaperOpenSchema.shape.maxCashBudget,
+    discoveryQuery: z.string().min(1).max(100),
+    maxEndDays: z.number().int().min(1).max(30).optional(),
+})
+    .strict();
+export const samePmHouse = (a, b) => a.userId === b.userId &&
+    a.apiKeyId === b.apiKeyId &&
+    a.walletId === b.walletId &&
+    a.houseAgentId === b.houseAgentId;
+export function readPmHousePolicies(raw) {
+    if (raw === undefined || raw === "")
+        return [];
+    const policies = z.array(pmHousePolicySchema).max(10).parse(JSON.parse(raw));
+    if (new Set(policies.map((p) => p.houseAgentId)).size !== policies.length ||
+        new Set(policies.map((p) => p.apiKeyId)).size !== policies.length ||
+        new Set(policies.map((p) => p.walletId)).size !== policies.length)
+        throw new Error("Duplicate PM house policy identity");
+    return policies;
+}
+export function selectPmHousePolicy(agent, policies = []) {
+    if (agent.isHouse !== true)
+        return undefined;
+    return policies.find((p) => p.houseAgentId === agent.id && p.userId === agent.ownerUserId);
+}
+export function pmCashUnits(value) {
+    if (!/^-?(0|[1-9]\d*)(\.\d{1,18})?$/.test(value) || value.length > 41)
+        throw new Error("Invalid exact paper cash");
+    const negative = value.startsWith("-");
+    const [whole, fraction = ""] = (negative ? value.slice(1) : value).split(".");
+    const units = BigInt(whole) * 10n ** 18n + BigInt(fraction.padEnd(18, "0"));
+    return negative ? -units : units;
+}

package/dist/agent/prompt.d.ts

@@ -1,4 +1,4 @@
-import { AgentSpec, Observation, PmResolution, RunState, type ObjectivePrimary } from "./types.js";
+import { AgentSpec, Observation, PmResolution, RunState, LastRejection, type ObjectivePrimary, type OpenPosition } from "./types.js";
 import type { DecisionActionExclusion } from "./providerCapabilities.js";
 export interface DailyRiskBudget {
     version: "coinrithm.daily-risk-budget.v1";
@@ -25,6 +25,16 @@ export declare function buildSystemPrompt(spec: AgentSpec, mergedProse: string,
     includeForecast?: boolean;
     excludeActionTypes?: readonly DecisionActionExclusion[];
 }): string;
+/**
+ * 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 declare function stopBoundLines(positions: readonly OpenPosition[]): string[];
 export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     at: string;
     did: string;
@@ -35,4 +45,5 @@ export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     futuresCapacity?: FuturesCapacity;
     compactTables?: boolean;
     excludeActionTypes?: readonly DecisionActionExclusion[];
+    lastRejections?: readonly LastRejection[];
 }): string;

package/dist/agent/prompt.js

@@ -9,6 +9,9 @@ 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.
@@ -158,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
@@ -404,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
@@ -413,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.");
     }
@@ -472,7 +540,7 @@ export function buildUserPrompt(obs, journal, opts = {}) {
         if (typeof minRewardRisk === "number" &&
             Number.isFinite(minRewardRisk) &&
             minRewardRisk >= 1) {
-            lines.push(`REWARD:RISK FLOOR ${minRewardRisk} (your capitalSizing.minRewardRisk, enforced with fees; an open below 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.`);
+            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(", ");
@@ -489,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"] : []),
         ];
@@ -505,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.
@@ -521,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.");
@@ -590,7 +674,10 @@ 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,

package/dist/agent/providerCapabilities.d.ts

@@ -29,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,3 +1,4 @@
+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";
@@ -110,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

@@ -18,6 +18,7 @@ export interface DecideInput {
     maxTokens?: number;
     timeoutMs?: number;
     excludeActionTypes?: readonly DecisionActionExclusion[];
+    decisionContract?: "pm_paper_v2";
 }
 export interface DecideRouteAttempt {
     provider: string;