@coinrithm/mcp-trading 0.7.12 → 0.7.14

package/dist/agent/act.d.ts

@@ -1,4 +1,9 @@
 import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { ProposedAction, AgentTrace, ApiResult, Observation, QuoteEvidence } from "./types.js";
-export declare function fetchQuote(client: CoinRithmClient, action: ProposedAction, observation: Observation, trace?: AgentTrace): Promise<QuoteEvidence | undefined>;
-export declare function executeAction(client: CoinRithmClient, action: ProposedAction, observation: Observation, trace: AgentTrace, idempotencyKey: string, provenance?: ProvenanceReport): Promise<ApiResult>;
+/** Configured policy values the server enforces independently of the model's
+ * action fields (2026-09-24: the PM entry floor). */
+export interface ExecutionPolicy {
+    pmMinEntryProbabilityPct?: number;
+}
+export declare function fetchQuote(client: CoinRithmClient, action: ProposedAction, observation: Observation, trace?: AgentTrace, policy?: ExecutionPolicy): Promise<QuoteEvidence | undefined>;
+export declare function executeAction(client: CoinRithmClient, action: ProposedAction, observation: Observation, trace: AgentTrace, idempotencyKey: string, provenance?: ProvenanceReport, policy?: ExecutionPolicy): Promise<ApiResult>;

package/dist/agent/act.js

@@ -1,13 +1,45 @@
 // Act phase: fetch the quote evidence for an open (the runner does this, never
 // the model) and execute a validated action (futures / spot / PM) with an
 // idempotency key.
-import { asObj, asNum } from "./extract.js";
+import { asObj, asNum, asStr } from "./extract.js";
 import { freshnessOf } from "./pmContext.js";
+function fundingQuoteEvidence(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const f = asObj(value);
+    const estimatedPerIntervalMusd = Object.prototype.hasOwnProperty.call(f, "estimatedPerIntervalMusd")
+        ? (asNum(f.estimatedPerIntervalMusd) ??
+            (f.estimatedPerIntervalMusd === null ? null : undefined))
+        : undefined;
+    return {
+        ...(asStr(f.venue) !== undefined ? { venue: asStr(f.venue) } : {}),
+        ...(asStr(f.symbol) !== undefined ? { symbol: asStr(f.symbol) } : {}),
+        ...(asNum(f.rate) !== undefined ? { rate: asNum(f.rate) } : {}),
+        ...(asNum(f.intervalHours) !== undefined
+            ? { intervalHours: asNum(f.intervalHours) }
+            : {}),
+        ...(asStr(f.nextFundingTime) !== undefined
+            ? { nextFundingTime: asStr(f.nextFundingTime) }
+            : {}),
+        ...(asStr(f.asOf) !== undefined ? { asOf: asStr(f.asOf) } : {}),
+        ...(estimatedPerIntervalMusd !== undefined
+            ? { estimatedPerIntervalMusd }
+            : {}),
+        ...(asNum(f.annualizedRate) !== undefined
+            ? { annualizedRate: asNum(f.annualizedRate) }
+            : {}),
+    };
+}
 function coinIdFor(observation, symbol) {
     return (observation.watch.find((w) => w.symbol.toUpperCase() === symbol.toUpperCase())?.coinId ?? undefined);
 }
-// Read-only quote BEFORE any open. Returns ineligible (never throws) on error.
-export async function fetchQuote(client, action, observation, trace) {
+const pmFloorBody = (policy) => typeof policy?.pmMinEntryProbabilityPct === "number" &&
+    Number.isFinite(policy.pmMinEntryProbabilityPct)
+    ? { minEntryProbabilityPct: policy.pmMinEntryProbabilityPct }
+    : {};
+export async function fetchQuote(client, action, observation, trace, policy) {
     let r;
     if (action.type === "futures_open") {
         const coinId = coinIdFor(observation, action.symbol);
@@ -32,6 +64,10 @@ export async function fetchQuote(client, action, observation, trace) {
             slug: action.slug,
             outcomeExternalMarketId: action.outcomeExternalMarketId,
             stakeMusd: action.stakeMusd,
+            ...(action.forecastProbability != null
+                ? { forecastProbability: action.forecastProbability }
+                : {}),
+            ...pmFloorBody(policy),
         }, trace);
     }
     else {
@@ -62,6 +98,9 @@ export async function fetchQuote(client, action, observation, trace) {
                 futuresFeeBps: asNum(asObj(d.executionModel).feeBps),
                 estimatedEntryFeeMusd: asNum(asObj(d.executionModel).estimatedEntryFeeMusd),
                 cashRequiredMusd: asNum(d.cashRequiredMusd),
+                ...(Object.prototype.hasOwnProperty.call(d, "funding")
+                    ? { funding: fundingQuoteEvidence(d.funding) }
+                    : {}),
             }
             : {}),
         // Freshness lives in the response's `observation` block (anti-look-ahead).
@@ -76,7 +115,7 @@ export async function executeAction(client, action, observation, trace, idempote
 // Optional SELF-REPORTED runner provenance, attached to a pm_open only (the one
 // durable-artifact write path here). Absent => the request is byte-identical to
 // pre-provenance behavior.
-provenance) {
+provenance, policy) {
     if (action.type === "futures_open") {
         const coinId = coinIdFor(observation, action.symbol);
         if (!coinId)
@@ -146,6 +185,10 @@ provenance) {
             ...(action.forecastProbability != null
                 ? { forecastProbability: action.forecastProbability }
                 : {}),
+            ...(action.thesis?.summary ? { thesis: action.thesis.summary } : {}),
+            // The CONFIGURED entry floor rides along so the server re-checks it inside
+            // its locked open transaction (absent => byte-identical request).
+            ...pmFloorBody(policy),
             // Attach runner provenance only when present (byte-identical to before when absent).
             ...(provenance ? { provenance } : {}),
             agentTrace: trace,

package/dist/agent/cli.d.ts

@@ -18,5 +18,6 @@ export declare function cmdRun(path: string, opts?: {
     once?: boolean;
     live?: boolean;
     stateFile?: string;
+    expectDefinition?: string;
 }): Promise<CmdResult>;
 export declare function main(argv: string[]): Promise<number>;

package/dist/agent/cli.js

@@ -10,6 +10,7 @@ import { resolve as resolvePath, dirname, join, basename } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { resolveAgent, ResolveError, mergeProseParts, isSkillProseSource, hostedProseBudget, HOSTED_PROSE_MAX_CHARS, } from "./resolve.js";
 import { buildSpec, loadAgent } from "./skill.js";
+import { buildAgentDefinitionSnapshot } from "./definitionSnapshot.js";
 import { validateSkill } from "./skillValidator.js";
 import { strictLint } from "./strictLint.js";
 import { checkCapabilityDrift } from "./capabilityGuard.js";
@@ -227,6 +228,9 @@ export function cmdInspect(path, json = false) {
         resolvedConfig: resolved.rawFrontmatter,
         provenance: resolved.provenance,
         contentHashes: resolved.contentHashes,
+        // The local runtime consumes these exact compiled inputs. In particular,
+        // skill ablation changes prose, not the source manifest or hard caps.
+        compiledDefinition: buildAgentDefinitionSnapshot(spec, runtimeProse(resolved)),
         validation: { valid: v.valid, issues: v.issues, lint },
     };
     if (json) {
@@ -244,11 +248,17 @@ export function cmdInspect(path, json = false) {
         `model:       ${spec.model ? `${spec.model.provider}/${spec.model.name}` : "(host free-tier)"}`,
         `risk:        maxLeverage=${spec.risk.maxLeverage} perTradeMargin=${spec.risk.perTradeMarginMusd} requireStopLoss=${spec.risk.requireStopLoss}`,
         `sources:     ${Object.keys(resolved.contentHashes).length} file(s)`,
+        `definition:  ${output.compiledDefinition.definitionHash}`,
         `validation:  ${v.valid ? "valid" : "INVALID"}${lint.length ? ` (+${lint.length} lint note(s))` : ""}`,
         ...output.warnings.map((warning) => `⚠ ${warning}`),
     ];
     return { ok: v.valid, code: 0, lines, data: output };
 }
+function runtimeProse(resolved) {
+    return envFlag(process.env.COINRITHM_AGENT_DISABLE_SKILLS)
+        ? mergeProseParts(resolved.proseParts.filter((part) => !isSkillProseSource(part.source)))
+        : resolved.mergedProse;
+}
 // Is a process still alive? signal 0 probes without sending — ESRCH means it's
 // gone, EPERM means it exists but we can't signal it (still alive). Unknown PIDs
 // (NaN / non-positive) are treated as alive so we never reclaim a malformed lock.
@@ -333,6 +343,16 @@ export async function cmdRun(path, opts = {}) {
             return issuesResult(e.issues, "resolve failed");
         throw e;
     }
+    const mergedProse = runtimeProse(loaded.resolved);
+    const definition = buildAgentDefinitionSnapshot(loaded.spec, mergedProse);
+    if (opts.expectDefinition !== undefined &&
+        opts.expectDefinition !== definition.definitionHash) {
+        return fail([
+            "compiled agent definition does not match --expect-definition; no model or account call was made",
+            `current definition: ${definition.definitionHash}`,
+            "inspect the change before choosing a new baseline",
+        ]);
+    }
     const apiKey = process.env.COINRITHM_API_KEY;
     if (!apiKey)
         return fail([
@@ -386,14 +406,12 @@ export async function cmdRun(path, opts = {}) {
         const live = !!opts.live;
         const lines = [
             `run ${live ? "LIVE (paper trades WILL be placed)" : "DRY-RUN (no writes; set --live or LIVE=1)"} — ${loaded.spec.name}`,
+            `definition: ${definition.definitionHash}`,
         ];
         // Skills ablation kill-switch: drop tactic-skill prose from the prompt for
         // token-cost control or A/B testing. Affects ONLY the run-time prompt — the
         // resolver, manifest, and caps are untouched (the spec is still enforced).
         const disableSkills = envFlag(process.env.COINRITHM_AGENT_DISABLE_SKILLS);
-        const mergedProse = disableSkills
-            ? mergeProseParts(loaded.resolved.proseParts.filter((p) => !isSkillProseSource(p.source)))
-            : loaded.body;
         if (disableSkills) {
             const dropped = loaded.resolved.proseParts.filter((p) => isSkillProseSource(p.source)).length;
             lines.push(`skills DISABLED via COINRITHM_AGENT_DISABLE_SKILLS — ${dropped} tactic skill(s) dropped from the prompt (caps unchanged)`);
@@ -442,6 +460,8 @@ function parseFlags(args) {
             out.preset = args[++i];
         else if (a === "--state")
             out.state = args[++i];
+        else if (a === "--expect-definition")
+            out.expectDefinition = args[++i] ?? "";
         else
             out._.push(a);
     }
@@ -455,7 +475,7 @@ function usageLines() {
         "  inspect <path> [--json]",
         "  eject <agent.md | dir>",
         "  lock <path>",
-        "  run <path> [--once] [--live] [--dry-run] [--state <file>]   (dry-run by default)",
+        "  run <path> [--once] [--live] [--dry-run] [--state <file>] [--expect-definition sha256:...]   (dry-run by default)",
     ];
 }
 export async function main(argv) {
@@ -489,6 +509,7 @@ export async function main(argv) {
                 once: flags.once,
                 live,
                 stateFile: flags.state,
+                expectDefinition: flags.expectDefinition,
             });
             break;
         }

package/dist/agent/client.d.ts

@@ -91,6 +91,9 @@ export declare class CoinRithmClient {
         slug: string;
         outcomeExternalMarketId: string;
         stakeMusd: number;
+        side?: "yes" | "no";
+        forecastProbability?: number;
+        bankrollMusd?: number;
     }, trace?: AgentTrace): Promise<ApiResult>;
     openFutures(body: {
         coinId: string;
@@ -133,6 +136,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         idempotencyKey: string;
         forecastProbability?: number;
+        thesis?: string;
         provenance?: ProvenanceReport;
         agentTrace?: AgentTrace;
     }): Promise<ApiResult>;

package/dist/agent/decision.d.ts

@@ -19,9 +19,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     marginMusd?: any;
     stopLossPrice?: any;
     takeProfitPrice?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     symbol: string;
     side: "long" | "short";
@@ -30,9 +30,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     marginMusd?: unknown;
     stopLossPrice?: unknown;
     takeProfitPrice?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"futures_close">;
     positionId: z.ZodEffects<z.ZodTypeAny, any, unknown>;
@@ -44,16 +44,16 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     type: "futures_close";
     positionId?: any;
     fraction?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     type: "futures_close";
     positionId?: unknown;
     fraction?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"futures_set_sltp">;
     positionId: z.ZodEffects<z.ZodTypeAny, any, unknown>;
@@ -67,17 +67,17 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     stopLossPrice?: any;
     takeProfitPrice?: any;
     positionId?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     type: "futures_set_sltp";
     stopLossPrice?: unknown;
     takeProfitPrice?: unknown;
     positionId?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"spot_order">;
     symbol: z.ZodString;
@@ -97,9 +97,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     quantity?: any;
     limitPrice?: any;
     stopPrice?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     symbol: string;
     side: "buy" | "sell";
@@ -108,9 +108,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     quantity?: unknown;
     limitPrice?: unknown;
     stopPrice?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"spot_cancel">;
     orderId: z.ZodEffects<z.ZodTypeAny, any, unknown>;
@@ -119,16 +119,16 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     thesis: z.ZodOptional<z.ZodEffects<z.ZodAny, import("./types.js").Thesis | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     type: "spot_cancel";
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
     orderId?: any;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     type: "spot_cancel";
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
     orderId?: unknown;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"pm_open">;
     ref: z.ZodOptional<z.ZodString>;
@@ -147,9 +147,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     outcomeExternalMarketId?: string | undefined;
     stakeMusd?: any;
     forecastProbability?: number | undefined;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
     ref?: string | undefined;
 }, {
     type: "pm_open";
@@ -158,9 +158,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     outcomeExternalMarketId?: string | undefined;
     stakeMusd?: unknown;
     forecastProbability?: any;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
     ref?: string | undefined;
 }>]>;
 export declare const DECISION_JSON_SCHEMA: {

package/dist/agent/decisionReceipt.js

@@ -138,6 +138,31 @@ export function buildDecisionInputRecord(input) {
             "sentimentBullishPct",
         ]),
         freshness: freshness(r.freshness),
+        ...(r.indicatorContext
+            ? {
+                indicatorContext: {
+                    range: code(obj(r.indicatorContext).range, ["1D"]),
+                    asOf: sourceTimestamp(obj(r.indicatorContext).asOf) ?? null,
+                    intervalStatus: code(obj(r.indicatorContext).intervalStatus, [
+                        "regular",
+                        "irregular",
+                        "unknown",
+                    ]),
+                    ...numeric(obj(r.indicatorContext), [
+                        "nominalIntervalSeconds",
+                        "barCount",
+                        "timestampedBarCount",
+                        "checkedIntervalCount",
+                        "irregularIntervalCount",
+                        "maxGapSeconds",
+                    ]),
+                    recent15: {
+                        ...numeric(obj(obj(r.indicatorContext).recent15), ["barCount"]),
+                        intervalStatus: code(obj(obj(r.indicatorContext).recent15).intervalStatus, ["regular", "irregular", "unknown"]),
+                    },
+                },
+            }
+            : {}),
         indicators: {
             ...numeric(obj(r.indicators), [
                 "asOfClose",
@@ -334,6 +359,7 @@ const LIST_KEYS = {
         "sentimentBullishPct",
         "freshness",
         "indicators",
+        "indicatorContext",
         "fundamentals",
     ],
     futuresPositions: [
@@ -379,6 +405,19 @@ const LIST_KEYS = {
     universeMovers: ["symbol", "change24hPct", "priceUsd"],
 };
 const NESTED_KEYS = {
+    indicatorContext: [
+        "range",
+        "asOf",
+        "nominalIntervalSeconds",
+        "barCount",
+        "timestampedBarCount",
+        "checkedIntervalCount",
+        "irregularIntervalCount",
+        "maxGapSeconds",
+        "intervalStatus",
+        "recent15",
+    ],
+    recent15: ["barCount", "intervalStatus"],
     freshness: ["status", "ageSeconds", "asOf", "basis"],
     quality: [
         "decisionEligible",
@@ -432,6 +471,10 @@ function validRow(value, keys) {
             return sourceTimestamp(v) === v;
         if (key === "basis")
             return code(v, FRESHNESS_BASES) !== null;
+        if (key === "range")
+            return code(v, ["1D"]) !== null;
+        if (key === "intervalStatus")
+            return code(v, ["regular", "irregular", "unknown"]) !== null;
         if (key === "policyVersion")
             return typeof v === "string" && /^pm-quality-\d{1,3}$/.test(v);
         if (key === "warningReasons" || key === "blockReasons") {

package/dist/agent/decisionValidator.js

@@ -17,6 +17,44 @@ const PM_MIN_FORECAST_EDGE_POINTS = (() => {
     return Number.isFinite(raw) && raw >= 0 ? raw : 2;
 })();
 const PM_MIN_STAKE_MUSD = 10; // server minimum prediction-market stake
+// Match backend-v2 validateSlTpPrices, including its boundary tolerance. This
+// preflight uses observed evidence only; the API still checks a fresh mark and
+// locked position at execution. Older observations can omit these prices.
+const TRIGGER_PRICE_EPS = 1e-8;
+function validateTriggerUpdate(action, pos) {
+    // executeAction omits null as well as undefined; neither clears a trigger in
+    // this runner. Check the resulting state, including retained protection.
+    const sl = action.stopLossPrice ?? pos.stopLossPrice;
+    const tp = action.takeProfitPrice ?? pos.takeProfitPrice;
+    const positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+    if (sl != null && !positive(sl))
+        return fail("invalid_stop_loss_price", `position ${pos.id}: stop loss must be finite and positive`);
+    if (tp != null && !positive(tp))
+        return fail("invalid_take_profit_price", `position ${pos.id}: take profit must be finite and positive`);
+    if (pos.side !== "long" && pos.side !== "short")
+        return ok();
+    const long = pos.side === "long";
+    const mark = pos.markPrice;
+    const liq = pos.liquidationPrice;
+    if (sl != null) {
+        if (positive(mark) &&
+            (long ? sl >= mark - TRIGGER_PRICE_EPS : sl <= mark + TRIGGER_PRICE_EPS)) {
+            return fail(long ? "stop_loss_not_below_mark" : "stop_loss_not_above_mark", `position ${pos.id}: ${pos.side} effective stop ${sl} must be ${long ? "below" : "above"} observed mark ${mark}; omitted triggers keep their existing values`);
+        }
+        if (positive(liq) &&
+            (long ? sl <= liq + TRIGGER_PRICE_EPS : sl >= liq - TRIGGER_PRICE_EPS)) {
+            return fail(long
+                ? "stop_loss_not_above_liquidation"
+                : "stop_loss_not_below_liquidation", `position ${pos.id}: ${pos.side} effective stop ${sl} must be ${long ? "above" : "below"} observed liquidation ${liq}; omitted triggers keep their existing values`);
+        }
+    }
+    if (tp != null &&
+        positive(mark) &&
+        (long ? tp <= mark + TRIGGER_PRICE_EPS : tp >= mark - TRIGGER_PRICE_EPS)) {
+        return fail(long ? "take_profit_not_above_mark" : "take_profit_not_below_mark", `position ${pos.id}: ${pos.side} effective take profit ${tp} must be ${long ? "above" : "below"} observed mark ${mark}; omitted triggers keep their existing values`);
+    }
+    return ok();
+}
 // Entry budgets are exposure budgets, not emergency-action budgets. Closing a
 // futures position, updating its protection, cancelling an order, or selling
 // spot reduces/contains risk and must remain available after an entry cap.
@@ -219,6 +257,7 @@ export function validateAction(action, ctx) {
             if (!hasTrigger) {
                 return fail("sltp_no_op", "futures_set_sltp must set at least one positive stopLossPrice or takeProfitPrice");
             }
+            return validateTriggerUpdate(action, pos);
         }
         return ok();
     }
@@ -316,6 +355,41 @@ export function validateAction(action, ctx) {
         if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
             return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
         }
+        // Hard entry-price floor (opt-in, 2026-09-24): compares the CHOSEN
+        // outcome's raw market probability at entry (the quote's entryProbability,
+        // points) with risk.pmMinEntryProbabilityPct. Fees are deliberately left
+        // out: a 19-point outcome fails a 20-point floor even when fees push its
+        // all-in cost above 20 (fees belong to the edge check below). No
+        // discovery-price fallback: with a floor set and no finite quoted
+        // probability the open is rejected, never waved through.
+        const entryFloor = spec.risk.pmMinEntryProbabilityPct;
+        if (entryFloor !== undefined) {
+            // A present-but-invalid floor never silently means "no floor".
+            if (typeof entryFloor !== "number" ||
+                !Number.isFinite(entryFloor) ||
+                entryFloor < 0 ||
+                entryFloor > 100) {
+                return fail("pm_entry_floor_invalid", `risk.pmMinEntryProbabilityPct ${JSON.stringify(entryFloor)} is not a number between 0 and 100`);
+            }
+            const market = ctx.quote.entryProbability;
+            if (typeof market !== "number" ||
+                !Number.isFinite(market) ||
+                market < 0 ||
+                market > 100) {
+                return fail("pm_entry_price_unavailable", `entry floor ${entryFloor}pt is set but the quote carries no usable market probability for the chosen outcome (${JSON.stringify(market ?? null)})`);
+            }
+            if (market + 1e-9 < entryFloor) {
+                const stake = ctx.quote.stakeMusd;
+                const shares = ctx.quote.sharesEstimate;
+                const cost = typeof stake === "number" &&
+                    typeof shares === "number" &&
+                    stake > 0 &&
+                    shares > 0
+                    ? ` (fee-inclusive cost ${((stake / shares) * 100).toFixed(1)}pt)`
+                    : "";
+                return fail("pm_entry_below_floor", `market ${market.toFixed(1)}pt is below the ${entryFloor}pt entry floor for the chosen outcome${cost}`);
+            }
+        }
         // Forecast consistency. By prompt contract forecastProbability is the
         // model's own probability (1-99) that the outcome IT IS BACKING wins, so
         // buying that outcome only makes sense when the forecast clears what the

package/dist/agent/definitionSnapshot.d.ts

@@ -0,0 +1,22 @@
+import type { AgentSpec } from "./types.js";
+/** Private, portable definition; deliberately excludes mutable account state. */
+export interface AgentDefinitionSnapshot {
+    schema: "coinrithm.agent-definition.v1";
+    engine: {
+        packageVersion: string;
+        resolverVersion: string;
+        indicatorVersion: string;
+        apiContractVersion: string;
+    };
+    /** Pass the actual post-overlay spec, without rebuilding it from frontmatter. */
+    spec: AgentSpec;
+    /** Exact strategy prose supplied to runCycle, after any skills ablation. */
+    mergedProse: string;
+    definitionHash: string;
+}
+/**
+ * Binds the compiled definition and declared engine versions, not the original
+ * source folder alone. This is an integrity/comparison hash, not a signature,
+ * complete replay record, or attestation of a particular deployed binary.
+ */
+export declare function buildAgentDefinitionSnapshot(spec: AgentSpec, mergedProse: string): AgentDefinitionSnapshot;

package/dist/agent/definitionSnapshot.js

@@ -0,0 +1,28 @@
+import { INDICATOR_VERSION } from "./indicators.js";
+import { COINRITHM_API, RESOLVER_VERSION } from "./version.js";
+import { sha256, stableStringify } from "./util.js";
+/**
+ * Binds the compiled definition and declared engine versions, not the original
+ * source folder alone. This is an integrity/comparison hash, not a signature,
+ * complete replay record, or attestation of a particular deployed binary.
+ */
+export function buildAgentDefinitionSnapshot(spec, mergedProse) {
+    const definition = {
+        schema: "coinrithm.agent-definition.v1",
+        engine: {
+            packageVersion: COINRITHM_API.mcpVersion,
+            resolverVersion: RESOLVER_VERSION,
+            indicatorVersion: INDICATOR_VERSION,
+            apiContractVersion: COINRITHM_API.openapiVersion,
+        },
+        spec,
+        mergedProse,
+    };
+    // Detach from caller-owned spec: later mutations must not invalidate a saved
+    // artifact while leaving its old hash attached to it.
+    const serialized = stableStringify(definition);
+    return {
+        ...JSON.parse(serialized),
+        definitionHash: sha256(serialized),
+    };
+}

package/dist/agent/engine.d.ts

@@ -1,6 +1,7 @@
 export { runCycle, type RunnerDeps } from "./runner.js";
+export { buildAgentDefinitionSnapshot, type AgentDefinitionSnapshot, } from "./definitionSnapshot.js";
 export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, type DecisionInputRecord, } from "./decisionReceipt.js";
-export { selectProvider, providerForRoute, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
+export { selectProvider, providerForRoute, classifyProviderFailure, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
 export { parseDecision } from "./decision.js";
 export { chatShapeFor, buildChatBody, type ChatShape, } from "./providerCapabilities.js";
 export { probeDecisionContract, type ProbeRoute, type ProbeDecisionResult, } from "./decisionProbe.js";

package/dist/agent/engine.js

@@ -6,8 +6,9 @@
 // This barrel is the ONE import a host scheduler needs; it re-exports only the
 // stable engine pieces, never the CLI.
 export { runCycle } from "./runner.js";
+export { buildAgentDefinitionSnapshot, } from "./definitionSnapshot.js";
 export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, } from "./decisionReceipt.js";
-export { selectProvider, providerForRoute, } from "./providers.js";
+export { selectProvider, providerForRoute, classifyProviderFailure, } from "./providers.js";
 export { parseDecision } from "./decision.js";
 // Reliability slice A: the declarative request-capability table and the
 // representative decision probe (route eligibility = a REAL parsed decision,

package/dist/agent/mergeRules.d.ts

@@ -1,5 +1,5 @@
 import { ResolveIssue } from "./types.js";
-export type CapDirection = "lower" | "higher" | "true";
+export type CapDirection = "lower" | "lower_zero_off" | "higher" | "true";
 export declare const RISK_CAPS: Record<string, CapDirection>;
 export declare const LIMIT_CAPS: Record<string, CapDirection>;
 export declare function isAtLeastAsRestrictive(dir: CapDirection, candidate: unknown, base: unknown): boolean;

package/dist/agent/mergeRules.js

@@ -8,6 +8,9 @@
 //
 // Normal (non-cap) config uses simple precedence (inline > $ref > defaults),
 // handled in the resolver; this module owns only the cap arithmetic.
+// 0 is "no cap" for lower_zero_off; every other value compares as itself.
+const zeroOffLimit = (n) => (n === 0 ? Infinity : n);
+const isZeroOffValue = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
 // risk.* hard caps a tactic module may tighten.
 export const RISK_CAPS = {
     maxLeverage: "lower",
@@ -17,9 +20,9 @@ export const RISK_CAPS = {
 };
 // limits.* throughput/spend caps a tactic module may tighten.
 export const LIMIT_CAPS = {
-    maxTradesPerDay: "lower",
+    maxTradesPerDay: "lower_zero_off",
     maxWritesPerCycle: "lower",
-    maxDailyLossMusd: "lower",
+    maxDailyLossMusd: "lower_zero_off",
     maxOpenMarginMusd: "lower",
 };
 // Is `candidate` at least as restrictive as `base` (i.e. a legal tightening)?
@@ -29,6 +32,11 @@ export function isAtLeastAsRestrictive(dir, candidate, base) {
         // legal: base=false→candidate any; base=true→candidate must be true.
         return base === true ? candidate === true : true;
     }
+    if (dir === "lower_zero_off") {
+        if (!isZeroOffValue(candidate) || !isZeroOffValue(base))
+            return false;
+        return zeroOffLimit(candidate) <= zeroOffLimit(base);
+    }
     if (typeof candidate !== "number" || typeof base !== "number") {
         // a non-numeric cap candidate where a number is expected is not a legal
         // tightening (caller will surface a type issue separately).
@@ -40,6 +48,13 @@ export function isAtLeastAsRestrictive(dir, candidate, base) {
 export function mostRestrictive(dir, a, b) {
     if (dir === "true")
         return a === true || b === true ? true : false;
+    if (dir === "lower_zero_off") {
+        if (!isZeroOffValue(a))
+            return b;
+        if (!isZeroOffValue(b))
+            return a;
+        return zeroOffLimit(a) <= zeroOffLimit(b) ? a : b;
+    }
     if (typeof a !== "number")
         return b;
     if (typeof b !== "number")