@coinrithm/mcp-trading 0.7.13 → 0.7.15

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

@@ -35,8 +35,11 @@ function fundingQuoteEvidence(value) {
 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);
@@ -64,6 +67,7 @@ export async function fetchQuote(client, action, observation, trace) {
             ...(action.forecastProbability != null
                 ? { forecastProbability: action.forecastProbability }
                 : {}),
+            ...pmFloorBody(policy),
         }, trace);
     }
     else {
@@ -111,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)
@@ -182,6 +186,9 @@ provenance) {
                 ? { 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

@@ -40,13 +40,26 @@ export declare class CoinRithmClient {
     rateLimitHits: number;
     constructor(cfg: ClientConfig);
     private request;
+    private publicRequest;
+    credentialFingerprint(): string;
     me(trace?: AgentTrace): Promise<ApiResult>;
+    performance(trace?: AgentTrace, options?: {
+        timeoutMs?: number;
+        maxRetries?: number;
+    }): Promise<ApiResult>;
     portfolio(trace?: AgentTrace): Promise<ApiResult>;
     wallet(query?: {
         coinId?: string;
     }, trace?: AgentTrace): Promise<ApiResult>;
     resolve(q: string, trace?: AgentTrace): Promise<ApiResult>;
     cryptoMovers(direction: "gainers" | "losers", limit: number, trace?: AgentTrace): Promise<ApiResult>;
+    getPublicPmWhales(options?: {
+        timeoutMs?: number;
+        limit?: number;
+    }): Promise<ApiResult>;
+    getPublicPmWhaleWallet(source: string, wallet: string, options?: {
+        timeoutMs?: number;
+    }): Promise<ApiResult>;
     market(coinId: string, trace?: AgentTrace): Promise<ApiResult>;
     candles(coinId: string, range: string, trace?: AgentTrace): Promise<ApiResult>;
     trades(query?: {

package/dist/agent/client.js

@@ -4,6 +4,7 @@
 // from an agent file). 429 backs off on Retry-After; 401/403/409/422 are
 // FAIL-CLOSED cycle outcomes (returned, not retried). fetch + sleep are
 // injectable so tests run with no network and no real waits.
+import { createHash } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 import { retryAfterSeconds } from "../retryAfter.js";
 export const DEFAULT_BASE_URL = "https://api.coinrithm.com";
@@ -54,6 +55,16 @@ export class CoinRithmClient {
         this.extraHeaders = cfg.extraHeaders;
     }
     async request(method, path, opts = {}) {
+        const requestTimeoutMs = opts.timeoutMs !== undefined &&
+            Number.isSafeInteger(opts.timeoutMs) &&
+            opts.timeoutMs >= 1
+            ? Math.min(opts.timeoutMs, this.requestTimeoutMs)
+            : this.requestTimeoutMs;
+        const maxRetries = opts.maxRetries !== undefined &&
+            Number.isSafeInteger(opts.maxRetries) &&
+            opts.maxRetries >= 0
+            ? Math.min(opts.maxRetries, this.maxRetries)
+            : this.maxRetries;
         const url = new URL(this.baseUrl + path);
         if (opts.query) {
             for (const [k, v] of Object.entries(opts.query)) {
@@ -76,7 +87,7 @@ export class CoinRithmClient {
         const timer = setTimeout(() => {
             timedOut = true;
             controller.abort(new Error("API request deadline exceeded"));
-        }, this.requestTimeoutMs);
+        }, requestTimeoutMs);
         this.signal?.addEventListener("abort", cancel, { once: true });
         if (this.signal?.aborted)
             cancel();
@@ -102,12 +113,12 @@ export class CoinRithmClient {
                 const retryAfter = retryAfterSeconds(res.headers.get("retry-after"));
                 if (res.status === 429)
                     this.rateLimitHits += 1;
-                if (res.status === 429 && attempt < this.maxRetries) {
+                if (res.status === 429 && attempt < maxRetries) {
                     // Release this response before waiting so retries do not retain sockets.
                     void res.body?.cancel().catch(() => { });
                     const delayMs = (retryAfter ?? 5) * 1000;
                     // Never shorten a provider's Retry-After or overflow a Node timer.
-                    if (delayMs >= this.requestTimeoutMs)
+                    if (delayMs >= requestTimeoutMs)
                         await aborted;
                     else if (this.sleepFn)
                         await this.sleepFn(delayMs);
@@ -151,7 +162,7 @@ export class CoinRithmClient {
                             ? "request_aborted"
                             : "network_error",
                     message: timedOut
-                        ? `API request exceeded ${this.requestTimeoutMs}ms deadline`
+                        ? `API request exceeded ${requestTimeoutMs}ms deadline`
                         : controller.signal.aborted
                             ? "API request cancelled"
                             : err instanceof Error
@@ -166,10 +177,96 @@ export class CoinRithmClient {
             controller.signal.removeEventListener("abort", rejectAborted);
         }
     }
+    // Keyless, bounded reads against the public PM surface. These deliberately
+    // bypass the authenticated request path so a runner key cannot leak into a
+    // public context lookup. No retries are added here; the enrichment is
+    // optional and its deadline includes response-body consumption.
+    async publicRequest(path, query, timeoutMs = 5_000) {
+        const url = new URL(this.baseUrl + path);
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value !== undefined && value !== null && value !== "")
+                url.searchParams.set(key, String(value));
+        }
+        const controller = new AbortController();
+        if (this.signal?.aborted) {
+            return { ok: false, status: 0, data: { error: "network_error" } };
+        }
+        const cancel = () => controller.abort();
+        this.signal?.addEventListener("abort", cancel, { once: true });
+        const deadlineMs = Math.min(timeoutMs, this.requestTimeoutMs);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, deadlineMs);
+        let rejectAborted;
+        const aborted = new Promise((_, reject) => {
+            rejectAborted = () => reject(new Error("public request aborted"));
+            controller.signal.addEventListener("abort", rejectAborted, {
+                once: true,
+            });
+        });
+        if (this.signal?.aborted)
+            cancel();
+        try {
+            const perform = async () => {
+                const res = await this.fetchFn(url.toString(), {
+                    method: "GET",
+                    headers: { Accept: "application/json" },
+                    signal: controller.signal,
+                });
+                const text = await res.text();
+                let data = text;
+                if (text) {
+                    try {
+                        data = JSON.parse(text);
+                    }
+                    catch {
+                        /* leave as text */
+                    }
+                }
+                return { ok: res.ok, status: res.status, data };
+            };
+            return await Promise.race([perform(), aborted]);
+        }
+        catch {
+            return {
+                ok: false,
+                status: 0,
+                data: {
+                    error: timedOut ? "timeout" : "network_error",
+                },
+            };
+        }
+        finally {
+            clearTimeout(timer);
+            controller.signal.removeEventListener("abort", rejectAborted);
+            this.signal?.removeEventListener("abort", cancel);
+        }
+    }
+    // A stable, non-reversible identity for this credential and API base, for
+    // per-agent in-memory caches that must outlive one client instance (the
+    // hosted scheduler builds a new client every cycle). Never the key itself.
+    credentialFingerprint() {
+        return createHash("sha256")
+            .update(`${this.baseUrl}\n${this.apiKey}`, "utf8")
+            .digest("hex")
+            .slice(0, 32);
+    }
     // ── reads ──────────────────────────────────────────────────────────────────
     me(trace) {
         return this.request("GET", "/api/agent/me", { trace });
     }
+    // GET /api/agent/performance: the calling key's own realized performance.
+    // Newer backends add an optional `pmCalibration` block (the key's settled PM
+    // forecast record), parsed defensively in observe.
+    performance(trace, options) {
+        return this.request("GET", "/api/agent/performance", {
+            trace,
+            timeoutMs: options?.timeoutMs,
+            maxRetries: options?.maxRetries,
+        });
+    }
     portfolio(trace) {
         return this.request("GET", "/api/agent/portfolio", { trace });
     }
@@ -186,6 +283,12 @@ export class CoinRithmClient {
             ? "/api/coins/top-losers"
             : "/api/coins/top-gainers", { query: { limit }, trace });
     }
+    getPublicPmWhales(options) {
+        return this.publicRequest("/api/prediction-markets/whales", { limit: options?.limit }, options?.timeoutMs);
+    }
+    getPublicPmWhaleWallet(source, wallet, options) {
+        return this.publicRequest(`/api/prediction-markets/whales/wallets/${encodeURIComponent(source)}/${encodeURIComponent(wallet)}`, undefined, options?.timeoutMs);
+    }
     market(coinId, trace) {
         return this.request("GET", `/api/agent/market/${encodeURIComponent(coinId)}`, { trace });
     }

package/dist/agent/decisionReceipt.d.ts

@@ -8,7 +8,7 @@ interface Row {
 }
 export interface DecisionInputRecord {
     version: "coinrithm.decision-input.v1";
-    projectionVersion?: "coinrithm.decision-input-projection.v2";
+    projectionVersion?: "coinrithm.decision-input-projection.v2" | "coinrithm.decision-input-projection.v3";
     visibility: "private";
     completeness: "partial";
     phase: DecisionInputPhase;
@@ -21,6 +21,10 @@ export interface DecisionInputRecord {
     dailyRiskBudget: DailyRiskBudget | null;
     guardState: Record<string, number | boolean | null>;
     account: Record<string, number | boolean | string | null> | null;
+    marketMood?: {
+        fearGreed: number | null;
+        fetchedAt: string | null;
+    } | null;
     lists: Record<string, Row[]>;
     counts: Record<string, {
         source: number;

package/dist/agent/decisionReceipt.js

@@ -22,6 +22,20 @@ const fingerprint = (value) => typeof value === "string" && /^sha256:[a-f0-9]{64
     ? value
     : null;
 const numeric = (raw, keys) => Object.fromEntries(keys.map((key) => [key, num(raw[key])]));
+const count = (value) => Number.isSafeInteger(value) && value >= 0
+    ? value
+    : null;
+const fearGreed = (value) => {
+    const v = num(value);
+    return v !== null && v >= 0 && v <= 100 ? v : null;
+};
+const PROJECTION_V3 = "coinrithm.decision-input-projection.v3";
+// Watch-row fields that exist only from projection v3 on.
+const SENTIMENT_V3_KEYS = [
+    "sentimentTotalVotes",
+    "sentimentDayUtc",
+    "sentimentUpdatedAt",
+];
 const freshness = (value) => {
     const raw = obj(parseFreshness({ freshness: value }));
     return {
@@ -49,7 +63,7 @@ export function buildDecisionInputRecord(input) {
     const budget = buildDailyRiskBudget(input.spec, input.state);
     const record = {
         version: "coinrithm.decision-input.v1",
-        projectionVersion: "coinrithm.decision-input-projection.v2",
+        projectionVersion: PROJECTION_V3,
         visibility: "private",
         completeness: "partial",
         phase: input.phase,
@@ -115,6 +129,12 @@ export function buildDecisionInputRecord(input) {
         equityMusd: num(obs.equityMusd),
         polledBeforeWrite: bool(obs.polledBeforeWrite),
     };
+    record.marketMood = obs.marketMood
+        ? {
+            fearGreed: fearGreed(obs.marketMood.fearGreed),
+            fetchedAt: sourceTimestamp(obs.marketMood.fetchedAt) ?? null,
+        }
+        : null;
     const add = (name, items, project) => {
         const all = arr(items);
         // Bound work/space independently of the upstream list limit. Preserve order,
@@ -137,7 +157,36 @@ export function buildDecisionInputRecord(input) {
             "change7d",
             "sentimentBullishPct",
         ]),
+        // The sample and its own clocks; null = unknown, never "fresh".
+        sentimentTotalVotes: count(r.sentimentTotalVotes),
+        sentimentDayUtc: sourceTimestamp(r.sentimentDayUtc) ?? null,
+        sentimentUpdatedAt: sourceTimestamp(r.sentimentUpdatedAt) ?? null,
         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",
@@ -332,8 +381,10 @@ const LIST_KEYS = {
         "change24h",
         "change7d",
         "sentimentBullishPct",
+        ...SENTIMENT_V3_KEYS,
         "freshness",
         "indicators",
+        "indicatorContext",
         "fundamentals",
     ],
     futuresPositions: [
@@ -379,6 +430,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",
@@ -428,10 +492,22 @@ function validRow(value, keys) {
             return true;
         if (NESTED_KEYS[key])
             return validRow(v, NESTED_KEYS[key]);
-        if (key === "asOf" || key === "assessedAt" || key === "openedAt")
+        if ([
+            "asOf",
+            "assessedAt",
+            "openedAt",
+            "sentimentDayUtc",
+            "sentimentUpdatedAt",
+        ].includes(key))
             return sourceTimestamp(v) === v;
+        if (key === "sentimentTotalVotes")
+            return count(v) !== null;
         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") {
@@ -522,13 +598,29 @@ export function sanitizeDecisionInputRecord(value) {
             "dailyRiskBudget",
             "guardState",
             "account",
+            "marketMood",
             "lists",
             "counts",
             "omissions",
         ]))
             return undefined;
         if (r.projectionVersion !== undefined &&
-            r.projectionVersion !== "coinrithm.decision-input-projection.v2")
+            r.projectionVersion !== "coinrithm.decision-input-projection.v2" &&
+            r.projectionVersion !== PROJECTION_V3)
+            return undefined;
+        // An older record must never carry, or be mistaken for, v3 fields.
+        const v3 = r.projectionVersion === PROJECTION_V3;
+        if (!v3 &&
+            (r.marketMood !== undefined ||
+                arr(obj(r.lists).watch).some((row) => SENTIMENT_V3_KEYS.some((k) => k in obj(row)))))
+            return undefined;
+        if (r.marketMood !== undefined &&
+            r.marketMood !== null &&
+            (!keysOnly(r.marketMood, ["fearGreed", "fetchedAt"]) ||
+                (r.marketMood.fearGreed !== null &&
+                    fearGreed(r.marketMood.fearGreed) === null) ||
+                (r.marketMood.fetchedAt !== null &&
+                    sourceTimestamp(r.marketMood.fetchedAt) !== r.marketMood.fetchedAt)))
             return undefined;
         if (r.version !== "coinrithm.decision-input.v1" ||
             r.visibility !== "private" ||

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;