@coinrithm/mcp-trading 0.7.13 → 0.7.14

package/CHANGELOG.md

@@ -5,6 +5,46 @@ ships two binaries — `coinrithm-mcp` (the MCP server) and `coinrithm-agent` (t
 self-host agent runner) — versioned together. The CoinRithm **API contract** is
 versioned separately (see `openapi.yaml` `info.version`, currently `1.7.0`).
 
+## 0.7.14
+
+- Scope permanent model-error streaks to the attempted provider/model. Discard
+  legacy unattributed streaks and reset availability failures on a successful
+  provider response, including malformed decisions. Old-route failures cannot
+  request an early hold on a replacement model; agent risk limits are unchanged.
+- Attribute a routed permanent-error hold to the attempt that produced the error,
+  even when a later fallback is rate-limited; keep actual-call metering unchanged.
+- Preflight futures protection updates against observed side, mark and liquidation
+  prices, including retained triggers. Reject known invalid end-states with an
+  actionable reason before a write; the API remains authoritative as prices move.
+- Add the optional `risk.pmMinEntryProbabilityPct` policy (0..100 points): the
+  runner rejects `pm_open` when the chosen outcome's raw market probability at
+  entry is below the floor, with a reason that names both numbers. Fees stay
+  in the forecast-edge check, so a 19-point outcome fails a 20-point floor even
+  when fees lift its cost above 20. Absent keeps today's behaviour; a set floor
+  with no quoted probability fails closed. The floor is rendered in the prompt's
+  hard caps.
+- Retain candle timestamps and compact coverage/interval evidence alongside
+  indicators, separately from market-price freshness. Missing timestamps stay
+  unknown; nominal five-minute cadence does not imply current or regular bars.
+  Model input and private decision evidence retain the same context.
+- Load optional `character/entries.md`, `exits.md`, `sizing.md` and `research.md`
+  from local bundles so Studio strategy sections reach the model, manifest and
+  compiled definition. Existing bundles without these files are unchanged.
+- Include the exact compiled strategy definition and its digest in local
+  inspection; expose the same snapshot builder to engine consumers.
+- Add `run --expect-definition` to reject a changed baseline before model or
+  account access. The digest is not a full replay record or broker adapter.
+- Hosted validation accepts `limits.maxDailyLossMusd: 0` as no daily loss cap,
+  matching the runner and the hosted API; negative and non-finite values are
+  still rejected.
+- Tactic cap merges treat 0 as unlimited for `maxTradesPerDay` and
+  `maxDailyLossMusd`: a tactic may tighten 0 to a positive cap but can no
+  longer turn a positive cap into 0. Writes and margins keep lower-is-tighter.
+
+Publication and hosted deployment are verified separately. See the repository's
+[release status](https://github.com/CoinRithm/coinrithm-agent-trading#version-clarity)
+for registry availability and the hosted runtime evidence.
+
 ## 0.7.13
 
 - Preserve optional per-outcome venue terms in compact prediction-market output,

package/README.md

@@ -43,14 +43,16 @@ This package ships two binaries:
 
 > **Paper trading only** — virtual funds (50,000 mUSD). Not financial advice.
 
-## Version 0.7.13
-
-This patch corrects provider-capacity classification and exports
-`classifyProviderFailure` from the supported engine entry point. Retry counts
-and trading behavior are unchanged. See [CHANGELOG.md](./CHANGELOG.md).
-This version also includes public whale-wallet context and the clarified
-market-price calibration definitions on the 40-tool surface. Check
-`npm view @coinrithm/mcp-trading version` and the
+## Version 0.7.14
+
+This release makes a configured prediction-market entry floor executable
+(`risk.pmMinEntryProbabilityPct`: runner preflight plus the API's own re-check
+at execution), preflights futures stop/target updates against observed prices,
+loads the optional strategy sections from local bundles, pins compiled strategy
+definitions (`run --expect-definition`), retains candle timing evidence, and
+scopes permanent model-error streaks to the attempted provider/model. Trading
+limits and retry counts are otherwise unchanged. See [CHANGELOG.md](./CHANGELOG.md).
+Check `npm view @coinrithm/mcp-trading version` and the
 [release status](https://github.com/CoinRithm/coinrithm-agent-trading#version-clarity)
 for registry availability; hosted deployments and npm releases are separate.
 

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/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,4 +1,5 @@
 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, classifyProviderFailure, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
 export { parseDecision } from "./decision.js";

package/dist/agent/engine.js

@@ -6,6 +6,7 @@
 // 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, classifyProviderFailure, } from "./providers.js";
 export { parseDecision } from "./decision.js";

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")

package/dist/agent/observe.js

@@ -6,10 +6,10 @@ import { computeIndicators } from "./indicators.js";
 import { scanSetups } from "./setups.js";
 import { freshnessOf, pmQualityOf, pmDecisionSupportOf } from "./pmContext.js";
 import { deriveCapitalBook, usesCapitalSizing } from "./capitalSizing.js";
-// Candle granularity feeding the indicators: the 1D range = 5-minute candles
-// (~5-min fresh, ~288 bars — ample for EMA50/RSI14/Bollinger20), which suits the
-// short cadence the hosted house agents run on. Probe-verified 2026-06-17.
+// The 1D endpoint nominally returns 288 five-minute bars. Timestamps and gaps
+// are checked separately; requesting this range does not establish freshness.
 const INDICATOR_RANGE = "1D";
+const INDICATOR_INTERVAL_SECONDS = 300;
 // `universe_scan` bounds: how many top movers to pull, and how many of those
 // to fully resolve into tradable watch entries (each resolved row costs a
 // resolve + market [+ candles] call).
@@ -73,6 +73,49 @@ const PM_CALIBRATION_CHURN_RE = /(updown|up-or-down|-5-?min|-5m-|-15m|15m(?:-|$)
 export function isCalibrationChurnMarket(market) {
     return PM_CALIBRATION_CHURN_RE.test(`${market.slug ?? ""} ${market.title ?? ""}`);
 }
+// The live endpoint's t is Unix seconds. Missing/malformed values (including
+// millisecond epochs) stay unknown; never substitute retrieval time.
+function candleTimestamp(value) {
+    return typeof value === "number" &&
+        Number.isInteger(value) &&
+        value > 0 &&
+        value <= 253_402_300_799
+        ? value
+        : undefined;
+}
+function candleIntervals(times) {
+    let timestampedBarCount = 0;
+    let checkedIntervalCount = 0;
+    let irregularIntervalCount = 0;
+    let maxGapSeconds;
+    for (let i = 0; i < times.length; i++) {
+        const current = times[i];
+        if (current === undefined)
+            continue;
+        timestampedBarCount++;
+        const previous = times[i - 1];
+        if (previous === undefined)
+            continue;
+        const gap = current - previous;
+        checkedIntervalCount++;
+        if (gap !== INDICATOR_INTERVAL_SECONDS)
+            irregularIntervalCount++;
+        maxGapSeconds = Math.max(maxGapSeconds ?? 0, gap);
+    }
+    const intervalStatus = irregularIntervalCount > 0
+        ? "irregular"
+        : times.length < 2 || timestampedBarCount !== times.length
+            ? "unknown"
+            : "regular";
+    return {
+        barCount: times.length,
+        timestampedBarCount,
+        checkedIntervalCount,
+        irregularIntervalCount,
+        intervalStatus,
+        ...(maxGapSeconds === undefined ? {} : { maxGapSeconds }),
+    };
+}
 // Fetch candles for one coin and reduce them to a compact indicator bundle plus
 // the 24h volume. Tolerant by design: any failure (HTTP error, malformed/sparse
 // candles) yields null indicators so the cycle proceeds with price-only context
@@ -92,6 +135,7 @@ async function fetchCandleContext(client, coinId, trace) {
         return { indicators: null };
     // Endpoint shape: { candles: [{ t, o, h, l, c, v, vm }] } ascending (oldest first).
     const candles = [];
+    const times = [];
     let latestVolume;
     let latestVolumeMissingVenues;
     for (const raw of asArr(asObj(cr.data).candles)) {
@@ -104,6 +148,7 @@ async function fetchCandleContext(client, coinId, trace) {
             continue;
         const volume = asNum(c.v);
         candles.push({ open, high, low, close, volume: volume ?? undefined });
+        times.push(candleTimestamp(c.t));
         latestVolume = volume != null && volume >= 0 ? volume : undefined;
         const coverage = asNum(c.vm);
         latestVolumeMissingVenues =
@@ -114,8 +159,22 @@ async function fetchCandleContext(client, coinId, trace) {
                 ? coverage
                 : undefined;
     }
+    const latestTime = times.at(-1);
+    const recent = candleIntervals(times.slice(-15));
     return {
         indicators: computeIndicators(candles),
+        indicatorContext: {
+            range: INDICATOR_RANGE,
+            nominalIntervalSeconds: INDICATOR_INTERVAL_SECONDS,
+            ...candleIntervals(times),
+            ...(latestTime === undefined
+                ? {}
+                : { asOf: new Date(latestTime * 1000).toISOString() }),
+            recent15: {
+                barCount: recent.barCount,
+                intervalStatus: recent.intervalStatus,
+            },
+        },
         volume24hUsd: latestVolume,
         volumeMissingVenues: latestVolumeMissingVenues,
     };
@@ -147,6 +206,8 @@ async function enrichFromCandles(client, entry, coinId, trace) {
     const cc = await fetchCandleContext(client, coinId, trace);
     if (cc.indicators)
         entry.indicators = cc.indicators;
+    if (cc.indicatorContext)
+        entry.indicatorContext = cc.indicatorContext;
     if (cc.volume24hUsd != null) {
         entry.fundamentals = {
             ...(entry.fundamentals ?? {}),

package/dist/agent/prompt.js

@@ -147,6 +147,11 @@ opts = {}) {
                 "- YOUR SHARPEST PM EDGE is the crypto price view you JUST formed: crypto PM markets resolve on the very prices you analyse, so you have a genuine information edge there that you do NOT have on coin futures alone. EVERY cycle you reach a price conviction, it is REQUIRED that you scan observation.pmMarkets for a LISTED crypto market that same view prices wrong and, if one is materially mispriced, open it with pm_open by its `ref` — treat that mispricing exactly like a flagged coin setup (an ACT, not a skip). If you are bearish BTC, a 'BTC above $X by <date>' priced high is a NO; if bullish ETH, an 'ETH above $Y' priced low is a YES. ESCAPE HATCH — only the markets actually listed in observation.pmMarkets THIS cycle (pm1..pmN) are bettable: if NONE of them matches the coin or view you formed, that is a legitimate SKIP for PM (say so in one clause and move on) — do NOT invent, guess, or increment a ref for a market you wish existed, because a made-up ref is rejected (pm_ref_unknown) and wastes the whole cycle exactly like a rejected open. The mistake to avoid is leaving a LISTED, clearly mispriced crypto market untraded — a mispricing that is NOT on this cycle's board is simply not actionable now, not a miss. (For non-crypto events you have no special edge; skip unless the odds are obviously off.)",
             ]
             : []),
+        ...(hasPm && typeof r.pmMinEntryProbabilityPct === "number"
+            ? [
+                `- PM ENTRY FLOOR: pm_open on an outcome whose market probability is below ${r.pmMinEntryProbabilityPct} points is REJECTED by the runner (the chosen outcome's own price; fees are not counted). Do not propose cheaper longshots; look for edge on outcomes priced at or above the floor.`,
+            ]
+            : []),
         ...(includeForecast
             ? [
                 "- FORECAST RULE (pm_open forecastProbability): before you look at what the market is pricing, decide YOUR OWN probability the outcome you are backing actually WINS — reason ONLY from the question, its resolution criteria, and the deadline. Put that number (1-99, whole or one decimal) in `forecastProbability`. This is graded against reality as your PUBLIC calibration record, so it must be YOUR judgement, NOT the market's: do NOT copy, round, or anchor it to the observation.pmMarkets `prob`. It is FINE if your honest forecast happens to land on the market's number — but reaching that by echoing the price defeats the point. If you genuinely cannot form an independent view, OMIT the field rather than parroting the market (an absent forecast is better than a fake one, and it never blocks the bet). A forecast you DO give is enforced: if it is not above what the outcome currently costs, the open is rejected, because buying something you price below the market is a losing trade by your own numbers.",
@@ -156,7 +161,8 @@ opts = {}) {
         ...(spec.capabilities.includes("indicators")
             ? [
                 "",
-                "## Signals — each watch entry may carry `indicators` (computed from 5-minute candles)",
+                "## Signals — each watch entry may carry `indicators` (nominal five-minute candles)",
+                "- `indicatorContext` reports accepted candle counts, source `asOf` and intervalStatus (regular/irregular/unknown); compare its asOf with observation.asOf for age. /market freshness is separate. nominalIntervalSeconds=300 does not prove fresh, continuous candles. Missing timestamps are unknown; stale, future-dated or irregular candles do not establish a current five-minute signal. `recent15` describes only recent spacing; Wilder atr14 also retains earlier history, so recent regularity does not erase older gaps.",
                 "- rsi14: momentum (>70 overbought, <30 oversold); ema20 & ema50: trend; atr14: volatility (size stops off it); bollinger {upper,mid,lower}; recent20 {high,low}: breakout levels.",
                 "- boolean reads: aboveEma20, ema20AboveEma50 (uptrend when both true), brokeRecentHigh (breakout), brokeRecentLow (breakdown).",
                 "- a null field = not enough data; ignore it. These INFORM your decision; they never widen a cap.",

package/dist/agent/resolve.js

@@ -47,7 +47,14 @@ const CONFIG_BLOCKS = [
 const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;
 // Optional prose files (markdown the LLM reads), in assembly order.
-const PROSE_FILES = ["character/thesis.md", "character/persona.md"];
+const PROSE_FILES = [
+    "character/thesis.md",
+    "character/persona.md",
+    "character/entries.md",
+    "character/exits.md",
+    "character/sizing.md",
+    "character/research.md",
+];
 // Prose files carry an OPTIONAL YAML frontmatter block (type/title/description/
 // tags) that is authoring metadata, not doctrine — the model gains nothing from
 // `tags: [agent, persona, mean-reversion]`. It was being merged verbatim into

package/dist/agent/runner.js

@@ -425,6 +425,12 @@ async function runCycleCore(deps, capture) {
     const provenance = buildRunnerProvenance(spec);
     state.cyclesRun += 1;
     rollDay(state);
+    // Old state did not identify which route failed. Carrying that count into
+    // a replacement model can request a hold on its very first error.
+    if (state.consecutivePermanentModelErrors &&
+        !state.permanentModelErrorRoute) {
+        state.consecutivePermanentModelErrors = 0;
+    }
     const runId = state.runId;
     const decisionId = makeDecisionId(state.cyclesRun);
     const captureBase = { runId, decisionId, spec, mergedProse, state };
@@ -581,7 +587,7 @@ async function runCycleCore(deps, capture) {
             ...makeTrace(runId, decisionId, spec, undefined, `Thesis exit: ${why}`),
             ...observationReceipt,
         };
-        const r = await executeAction(client, action, observation, trace, idem, provenance);
+        const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
         exitPlanned.push({
             action,
             accepted: true,
@@ -764,13 +770,34 @@ async function runCycleCore(deps, capture) {
             // for what deserves them: revoked credentials, drawdown, kill-switch,
             // user action. Transient errors reset the permanent streak.
             if (isPermanentModelError(res.error)) {
+                // The router retains the last non-capacity failure even when a later
+                // fallback returns 429. Its effective route still describes the last
+                // actual call for metering, not necessarily the error returned here.
+                const failureAttempt = route?.attempts
+                    .slice()
+                    .reverse()
+                    .find((attempt) => attempt.outcome === "failed" &&
+                    attempt.failureClass !== "capacity" &&
+                    attempt.error === res.error);
+                const failureRoute = {
+                    provider: failureAttempt?.provider ??
+                        route?.effectiveProvider ??
+                        providerName,
+                    model: failureAttempt?.model ??
+                        route?.effectiveModel ??
+                        spec.model?.name ??
+                        "unknown",
+                };
+                const previousRoute = state.permanentModelErrorRoute;
+                const sameRoute = previousRoute?.provider === failureRoute.provider &&
+                    previousRoute?.model === failureRoute.model;
                 state.consecutivePermanentModelErrors =
-                    (state.consecutivePermanentModelErrors ?? 0) + 1;
+                    (sameRoute ? (state.consecutivePermanentModelErrors ?? 0) : 0) + 1;
+                state.permanentModelErrorRoute = failureRoute;
                 if (state.consecutivePermanentModelErrors >=
                     PERMANENT_MODEL_ERROR_THRESHOLD) {
                     const hold = {
-                        provider: route?.effectiveProvider ?? spec.model?.provider ?? "unknown",
-                        model: route?.effectiveModel ?? spec.model?.name ?? "unknown",
+                        ...failureRoute,
                         error: res.error.slice(0, 200),
                     };
                     saveState(stateFile, state);
@@ -792,6 +819,7 @@ async function runCycleCore(deps, capture) {
             }
             else {
                 state.consecutivePermanentModelErrors = 0;
+                delete state.permanentModelErrorRoute;
             }
             saveState(stateFile, state);
             log(`model error: ${res.error}`);
@@ -808,6 +836,10 @@ async function runCycleCore(deps, capture) {
                 ...observationReceipt,
             };
         }
+        // A returned model response proves availability even if its decision JSON
+        // is invalid. Output validation keeps its own failure counter below.
+        state.consecutivePermanentModelErrors = 0;
+        delete state.permanentModelErrorRoute;
         const parsed = parseDecision(res.text);
         if (!parsed.ok) {
             state.consecutiveModelFailures += 1;
@@ -830,7 +862,6 @@ async function runCycleCore(deps, capture) {
             };
         }
         state.consecutiveModelFailures = 0;
-        state.consecutivePermanentModelErrors = 0;
         decision = parsed.decision;
     }
     // Reasoning captured for the Arena terminal (keystone transparency): the
@@ -1027,7 +1058,9 @@ async function runCycleCore(deps, capture) {
                 }
             }
         }
-        const quote = await fetchQuote(client, action, observation, baseTrace);
+        const quote = await fetchQuote(client, action, observation, baseTrace, {
+            pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct,
+        });
         // Early PM skip: the quote's openBlocked preview tells us a pm/open right now
         // would be rejected 422 by the open-time quality gate (distinct from the
         // eligible/blockReasons SHAPE gate the validator checks). Bail here with a clear
@@ -1150,7 +1183,7 @@ async function runCycleCore(deps, capture) {
             rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length)),
             ...observationReceipt,
         };
-        const r = await executeAction(client, action, observation, trace, idem, provenance);
+        const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
         planned.push({
             action,
             accepted: true,

package/dist/agent/skill.js

@@ -109,6 +109,15 @@ export function buildSpec(raw) {
                     entryPredicates: risk.entryPredicates,
                 }
                 : {}),
+            // Optional PM entry floor: an absent key stays absent (no floor); an
+            // explicit value is carried AS WRITTEN, malformed or not, so hosted
+            // validation fails closed instead of a typo silently meaning "no floor"
+            // (the same rule entryPredicates follow).
+            ...(risk.pmMinEntryProbabilityPct !== undefined
+                ? {
+                    pmMinEntryProbabilityPct: risk.pmMinEntryProbabilityPct,
+                }
+                : {}),
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),

package/dist/agent/skillValidator.js

@@ -108,6 +108,13 @@ export function validateSkill(parsed, mode = "self-host") {
             add("skill_risk_sl", "risk.requireStopLoss must be true or false");
         if (!Array.isArray(r.watchlist) || r.watchlist.length === 0)
             add("skill_risk_watchlist", "risk.watchlist must be a non-empty list of symbols");
+        // Optional PM entry floor: absent means no floor; present must be a finite
+        // number of probability points in [0, 100].
+        if (r.pmMinEntryProbabilityPct !== undefined) {
+            const f = r.pmMinEntryProbabilityPct;
+            if (typeof f !== "number" || !Number.isFinite(f) || f < 0 || f > 100)
+                add("skill_risk_pm_entry_floor", "risk.pmMinEntryProbabilityPct must be a number between 0 and 100 (points; omit for no floor)");
+        }
         // Fail-closed on the side restriction: a typo ("shorts_only") must never
         // silently mean "unrestricted" — that is exactly how a prose-only
         // constraint failed live on 2026-08-24.
@@ -171,8 +178,10 @@ export function validateSkill(parsed, mode = "self-host") {
                 add("skill_limits_trades", "limits.maxTradesPerDay must be a number >= 0 (0 = unlimited daily trades)");
             if (!isPosNum(l.maxWritesPerCycle))
                 add("skill_limits_writes", "limits.maxWritesPerCycle must be a positive number");
-            if (!isPosNum(l.maxDailyLossMusd))
-                add("skill_limits_loss", "limits.maxDailyLossMusd must be a positive number");
+            // 0 = no daily loss cap: the runner only enforces a positive value and
+            // the hosted API already accepts 0..50,000, so hosted validation must too.
+            if (!isNonNegNum(l.maxDailyLossMusd))
+                add("skill_limits_loss", "limits.maxDailyLossMusd must be a number >= 0 (0 = no daily loss cap)");
             if (!isPosNum(l.maxOpenMarginMusd))
                 add("skill_limits_open", "limits.maxOpenMarginMusd must be a positive number");
         }

package/dist/agent/strictLint.js

@@ -50,6 +50,7 @@ const ALLOWED_KEYS = {
         "blocklist",
         "direction",
         "entryPredicates",
+        "pmMinEntryProbabilityPct",
     ],
     sizing: null,
     capitalSizing: [

package/dist/agent/types.d.ts

@@ -34,6 +34,7 @@ export interface RiskConfig {
     watchlist: string[];
     blocklist?: string[];
     direction?: "long_only" | "short_only";
+    pmMinEntryProbabilityPct?: number;
 }
 export interface LimitsConfig {
     maxTradesPerDay: number;
@@ -133,6 +134,21 @@ export interface Freshness {
     asOf?: string;
     basis?: string;
 }
+export interface IndicatorContext {
+    range: "1D";
+    nominalIntervalSeconds: 300;
+    barCount: number;
+    timestampedBarCount: number;
+    checkedIntervalCount: number;
+    irregularIntervalCount: number;
+    intervalStatus: "regular" | "irregular" | "unknown";
+    maxGapSeconds?: number;
+    asOf?: string;
+    recent15: {
+        barCount: number;
+        intervalStatus: "regular" | "irregular" | "unknown";
+    };
+}
 export interface WatchEntry {
     symbol: string;
     coinId: string | null;
@@ -144,6 +160,7 @@ export interface WatchEntry {
     sentimentBullishPct?: number;
     freshness?: Freshness;
     indicators?: IndicatorSet;
+    indicatorContext?: IndicatorContext;
     discovered?: boolean;
     slug?: string;
     fundamentals?: CoinFundamentals;
@@ -437,6 +454,10 @@ export interface RunState {
     lastLlmCallAt?: number;
     lastTriggerFingerprint?: string;
     consecutivePermanentModelErrors?: number;
+    permanentModelErrorRoute?: {
+        provider: string;
+        model: string;
+    };
     consecutiveAuthFailures?: number;
     journal?: Array<{
         at: string;

package/dist/client.d.ts

@@ -174,6 +174,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         forecastProbability?: number;
         bankrollMusd?: number;
+        minEntryProbabilityPct?: number;
     } & {
         agentTrace?: AgentTrace;
     }, apiKey?: string): Promise<ApiResult>;
@@ -221,6 +222,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         idempotencyKey: string;
         forecastProbability?: number;
+        minEntryProbabilityPct?: number;
         thesis?: string;
         provenance?: ProvenanceReport;
     }>, apiKey?: string): Promise<ApiResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinrithm/mcp-trading",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "mcpName": "io.github.CoinRithm/mcp-trading",
   "description": "CoinRithm paper-trading toolkit: an MCP server (coinrithm-mcp) AND a self-host agent runner (coinrithm-agent) for spot, futures, and prediction markets with a user-minted API key.",
   "type": "module",