@coinrithm/mcp-trading 0.7.9 → 0.7.11

package/CHANGELOG.md

@@ -5,10 +5,53 @@ 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.9
-
-This entry describes the package contents. Check npm for publication status;
-a source version or hosted deployment does not confirm npm delivery.
+## 0.7.11 — 2026-09-15
+
+Fix opportunity reporting that previously treated resolved API failures as
+successful submissions. Only `ok: true` confirms a report. HTTP errors remain
+unconfirmed; transport failures and exceptions have an unknown delivery outcome.
+
+`CycleResult.opportunity` now contains confirmed reports only. The additive
+`opportunityReport` field preserves the attempted payload, outcome and status,
+without API error bodies or exception details. Existing consumers should use
+this field when they need attempted rather than confirmed evidence.
+
+The reporter retains its one-invocation-per-cycle latch and adds no retries.
+Focused regressions compare successful and failed reporting in skip/act cycles
+and verify unchanged trading results and runner state. SDK versions are unchanged.
+This source entry does not establish registry publication or hosted deployment.
+
+## 0.7.10 — 2026-09-15
+
+Source changes following the published 0.7.9 release. The TypeScript SDK remains
+0.3.1 and Python remains 1.8.1; their runtime source is unchanged.
+
+- Persist file-backed run identity before execution so a first-cycle process
+  crash cannot discard the idempotency identity. Transport uncertainty is still
+  not automatically replayed or recorded as a completed trade.
+- Fix runner startup on Node 18: use the imported Node crypto API instead of
+  depending on a global crypto object. The installed-package matrix reproduced
+  this failure on Linux, Windows and macOS.
+- Add the supported `@coinrithm/mcp-trading/engine` entry point, preserving
+  existing deep imports, and separate observation accounting and opportunity
+  reporting from cycle ordering.
+- Add opt-in, machine-checked crypto return predicates and visible warnings for
+  inactive/reserved configuration. Existing agents are not automatically opted in.
+- Serialize scheduler migrations in a bounded transaction; add an offline
+  credential-rotation helper and interruption/recovery rehearsal.
+- Pin workflow actions and verify release-tool checksums. Add installed-package
+  compatibility and restart smoke checks across operating systems and runtimes.
+
+0.7.10 was published and deployed on 2026-09-15. Registry and GitHub downloads
+matched the CI-tested archive; hosted MCP and scheduler deployments finished.
+See the [release record](https://github.com/CoinRithm/coinrithm-agent-trading/releases/tag/mcp-trading-v0.7.10).
+
+## 0.7.9 - 2026-09-15
+
+Published on npm and verified on 2026-09-15: the registry archive matches the
+reviewed artifact and passes fresh-install checks. See the
+[combined release notes](https://github.com/CoinRithm/coinrithm-agent-trading/releases/tag/mcp-trading-v0.7.9)
+for source provenance, verification and community acknowledgments.
 
 Public market-data fidelity and runner reliability release. No MCP tool was
 renamed or removed, and the API **contract stays 1.7.0**.

package/README.md

@@ -42,10 +42,14 @@ This package ships two binaries:
 
 > **Paper trading only** — virtual funds (50,000 mUSD). Not financial advice.
 
-## Version 0.7.9
-
-This version includes the market-data fidelity and runner reliability fixes
-listed in [CHANGELOG.md](./CHANGELOG.md). Check `npm view @coinrithm/mcp-trading
+## Version 0.7.11
+
+This patch corrects opportunity-report status: only a successful API result
+confirms submission. HTTP errors remain unconfirmed, and transport failures
+have an unknown outcome. Attempt evidence is available in
+`CycleResult.opportunityReport`; `opportunity` contains confirmed reports only.
+Trading behavior and the one-report-method-call-per-cycle limit are preserved. See
+[CHANGELOG.md](./CHANGELOG.md). Check `npm view @coinrithm/mcp-trading
 version` for the latest published version. Hosted deployments and npm releases
 are separate.
 
@@ -53,6 +57,11 @@ Runner API operations have a 30-second total deadline, including response
 bodies and 429 retry waits. Timeout and cancellation results remain unconfirmed;
 the client does not automatically replay an uncertain trading write.
 
+Embedding the runner? Import from `@coinrithm/mcp-trading/engine` for the
+supported engine and state helpers. Existing `dist/agent/engine.js` imports
+remain compatible. See the [entry conditions and engine guide](https://github.com/CoinRithm/coinrithm-agent-trading/blob/main/docs/agent-runner.md#binding-entry-conditions-and-strategy-prose)
+for the exact opt-in policy and persistence contract.
+
 ## Quick start
 
 ```bash

package/dist/agent/cli.js

@@ -1,3 +1,4 @@
+import { configurationWarnings } from "./configurationWarnings.js";
 // coinrithm-agent — the public scaffolder/inspector CLI.
 //
 // Authors, validates, ejects, locks, and inspects agent DEFINITIONS. It does
@@ -101,6 +102,7 @@ export function cmdValidate(path, mode = "self-host") {
     const spec = buildSpec(raw);
     const lint = [...strictLint(raw), ...checkCapabilityDrift(resolved, spec)];
     const v = validateSkill({ spec, body: resolved.mergedProse, raw }, mode);
+    const warnings = configurationWarnings(raw);
     // Hosted-only: the managed deploy/edit API caps the merged strategy prose at
     // HOSTED_PROSE_MAX_CHARS and REVERTS the save when it is exceeded, so a
     // bundle that resolves and lints perfectly can still be undeployable through
@@ -129,10 +131,16 @@ export function cmdValidate(path, mode = "self-host") {
     }
     for (const i of v.issues)
         lines.push(`✗ ${i.code}: ${i.reason}`);
+    lines.push(...warnings.map((warning) => `⚠ ${warning}`));
     lines.push(...pinWarnings(path));
     const ok = v.valid && (!lintFatal || lint.length === 0);
     lines.unshift(ok ? `✓ valid (${mode})` : `✗ invalid (${mode})`);
-    return { ok, code: ok ? 0 : 1, lines, data: { lint, validation: v } };
+    return {
+        ok,
+        code: ok ? 0 : 1,
+        lines,
+        data: { lint, validation: v, warnings },
+    };
 }
 export function cmdLock(path) {
     const v = cmdValidate(path, "self-host");
@@ -215,6 +223,7 @@ export function cmdInspect(path, json = false) {
     ];
     const v = validateSkill({ spec, body: resolved.mergedProse, raw: resolved.rawFrontmatter }, "self-host");
     const output = {
+        warnings: configurationWarnings(resolved.rawFrontmatter),
         resolvedConfig: resolved.rawFrontmatter,
         provenance: resolved.provenance,
         contentHashes: resolved.contentHashes,
@@ -236,6 +245,7 @@ export function cmdInspect(path, json = false) {
         `risk:        maxLeverage=${spec.risk.maxLeverage} perTradeMargin=${spec.risk.perTradeMarginMusd} requireStopLoss=${spec.risk.requireStopLoss}`,
         `sources:     ${Object.keys(resolved.contentHashes).length} file(s)`,
         `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 };
 }

package/dist/agent/configurationWarnings.d.ts

@@ -0,0 +1 @@
+export declare function configurationWarnings(raw: Record<string, unknown>): string[];

package/dist/agent/configurationWarnings.js

@@ -0,0 +1,21 @@
+// Advisory only: these fields remain loadable for backwards compatibility.
+export function configurationWarnings(raw) {
+    const warnings = [];
+    if (Array.isArray(raw.capabilities) &&
+        raw.capabilities.includes("websearch")) {
+        warnings.push("capabilities.websearch is reserved: the runner does not perform web searches");
+    }
+    if (raw.abstention && typeof raw.abstention === "object") {
+        for (const key of [
+            "onStaleData",
+            "onWeakSignal",
+            "onMissingQuote",
+            "onInsufficientBalance",
+        ]) {
+            if (Object.prototype.hasOwnProperty.call(raw.abstention, key)) {
+                warnings.push(`abstention.${key} is inactive: changing it does not change execution; freshness, quote and balance checks remain mandatory`);
+            }
+        }
+    }
+    return warnings;
+}

package/dist/agent/decisionValidator.js

@@ -3,6 +3,7 @@
 // come from the spec (not the observation or the model), a prompt-injection in
 // market text cannot widen a limit or force a trade. Covers futures + spot + PM.
 import { ok, fail, actionVenue, spotBuyCost, } from "./types.js";
+import { checkEntryPredicates } from "./entryPredicates.js";
 const SERVER_MAX_LEVERAGE = 20;
 // Minimum edge, in probability POINTS, between the model's own forecast for
 // the outcome it is backing and what that outcome currently costs. Live
@@ -51,6 +52,9 @@ export function validateAction(action, ctx) {
         return fail("no_poll_before_write", "must successfully poll /trades before writing");
     }
     const increasesRisk = isRiskIncreasingAction(action);
+    const entryCondition = checkEntryPredicates(action, spec, observation);
+    if (!entryCondition.valid)
+        return entryCondition;
     if (increasesRisk &&
         ctx.riskIncreasesThisCycle >= spec.limits.maxWritesPerCycle) {
         return fail("write_budget_exceeded", `maxWritesPerCycle ${spec.limits.maxWritesPerCycle} reached`);

package/dist/agent/engine.d.ts

@@ -8,8 +8,8 @@ export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
 export { resolveAgent } from "./resolve.js";
 export { validateSkill, type SkillValidationMode } from "./skillValidator.js";
-export { newState, rollDay } from "./state.js";
+export { newState, rollDay, loadState, saveState } from "./state.js";
 export { makeRunId } from "./runEvidence.js";
 export { parseCadenceMs } from "./util.js";
 export { BENCHMARK_AGENTS, BENCHMARK_STRATEGIES, decideMechanical, isBenchmarkStrategy, type BenchmarkStrategy, type BenchmarkAgentDefinition, } from "./mechanical.js";
-export type { AgentSpec, RunState, CycleResult, PlannedAction, Venue, ProviderName, ModelConfig, } from "./types.js";
+export type { AgentSpec, RunState, CycleResult, OpportunityReport, PostedOpportunity, PlannedAction, Venue, ProviderName, ModelConfig, } from "./types.js";

package/dist/agent/engine.js

@@ -18,7 +18,7 @@ export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec } from "./skill.js";
 export { resolveAgent } from "./resolve.js";
 export { validateSkill } from "./skillValidator.js";
-export { newState, rollDay } from "./state.js";
+export { newState, rollDay, loadState, saveState } from "./state.js";
 export { makeRunId } from "./runEvidence.js";
 export { parseCadenceMs } from "./util.js";
 // Mechanical BENCHMARK baseline agents (sol #7): the deterministic, non-LLM

package/dist/agent/entryPredicates.d.ts

@@ -0,0 +1,10 @@
+import type { AgentSpec, Observation, ProposedAction, ValidationResult } from "./types.js";
+export interface EntryPredicate {
+    side: "long" | "short";
+    metric: "change1h" | "change24h";
+    operator: "gte" | "lte";
+    threshold: number;
+    maxAgeSeconds: number;
+}
+export declare function entryPredicateIssues(value: unknown): ValidationResult[];
+export declare function checkEntryPredicates(action: ProposedAction, spec: AgentSpec, observation: Observation): ValidationResult;

package/dist/agent/entryPredicates.js

@@ -0,0 +1,67 @@
+import { fail, ok } from "./types.js";
+export function entryPredicateIssues(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 16)
+        return [
+            fail("entry_predicate_config", "risk.entryPredicates must contain 1–16 conditions"),
+        ];
+    const keys = ["side", "metric", "operator", "threshold", "maxAgeSeconds"];
+    const issues = [];
+    for (const [i, item] of value.entries()) {
+        const p = item;
+        if (!p ||
+            typeof p !== "object" ||
+            Array.isArray(p) ||
+            Object.keys(p).some((key) => !keys.includes(key)) ||
+            !["long", "short"].includes(p.side) ||
+            !["change1h", "change24h"].includes(p.metric) ||
+            !["gte", "lte"].includes(p.operator) ||
+            typeof p.threshold !== "number" ||
+            !Number.isFinite(p.threshold) ||
+            typeof p.maxAgeSeconds !== "number" ||
+            !Number.isFinite(p.maxAgeSeconds) ||
+            p.maxAgeSeconds <= 0) {
+            issues.push(fail("entry_predicate_config", `risk.entryPredicates[${i}] has an invalid condition`));
+        }
+    }
+    return issues;
+}
+export function checkEntryPredicates(action, spec, observation) {
+    const rules = spec.risk.entryPredicates;
+    if (rules === undefined)
+        return ok();
+    if (action.type !== "futures_open" &&
+        !(action.type === "spot_order" && action.side === "buy"))
+        return ok();
+    const invalid = entryPredicateIssues(rules);
+    if (invalid.length)
+        return invalid[0];
+    const side = action.type === "futures_open" ? action.side : "long";
+    const applicable = rules.filter((rule) => rule.side === side);
+    if (!applicable.length)
+        return ok();
+    const entry = observation.watch.find((item) => item.symbol.toUpperCase() === action.symbol.toUpperCase());
+    const observedAt = Date.parse(observation.asOf);
+    const age = entry?.freshness?.ageSeconds;
+    for (const rule of applicable) {
+        const value = entry?.[rule.metric];
+        // Missing evidence never becomes a passing predicate. Include time since
+        // observation so a long model call cannot freeze the freshness clock.
+        if (entry?.freshness?.status !== "fresh" ||
+            typeof age !== "number" ||
+            !Number.isFinite(age) ||
+            age < 0 ||
+            !Number.isFinite(observedAt) ||
+            age + Math.max(0, (Date.now() - observedAt) / 1000) >
+                rule.maxAgeSeconds ||
+            typeof value !== "number" ||
+            !Number.isFinite(value)) {
+            return fail("entry_predicate_evidence", `fresh ${rule.metric} evidence required for ${action.symbol}`);
+        }
+        if (!(rule.operator === "gte"
+            ? value >= rule.threshold
+            : value <= rule.threshold)) {
+            return fail("entry_predicate_false", `${action.symbol} ${rule.metric}=${value} does not satisfy ${rule.operator} ${rule.threshold}`);
+        }
+    }
+    return ok();
+}

package/dist/agent/opportunityReporter.d.ts

@@ -0,0 +1,17 @@
+import type { CoinRithmClient, ProvenanceReport } from "./client.js";
+import type { AgentSpec, AgentTrace, OpportunityReport, PostedOpportunity } from "./types.js";
+export declare function createOpportunityReporter({ client, spec, live, enabled, runId, decisionId, provenance, baseTrace, log, }: {
+    client: CoinRithmClient;
+    spec: AgentSpec;
+    live: boolean;
+    enabled: boolean;
+    runId: string;
+    decisionId: string;
+    provenance: ProvenanceReport;
+    baseTrace: AgentTrace;
+    log: (line: string) => void;
+}): {
+    post: (o: PostedOpportunity) => Promise<void>;
+    readonly posted: PostedOpportunity | undefined;
+    readonly report: OpportunityReport | undefined;
+};

package/dist/agent/opportunityReporter.js

@@ -0,0 +1,59 @@
+export function createOpportunityReporter({ client, spec, live, enabled, runId, decisionId, provenance, baseTrace, log, }) {
+    let attempted = false;
+    let report;
+    const post = async (o) => {
+        if (!enabled || !live || attempted)
+            return;
+        attempted = true;
+        try {
+            const result = await client.reportPmOpportunity({
+                kind: o.kind,
+                source: o.source,
+                slug: o.slug,
+                outcomeExternalMarketId: o.outcomeExternalMarketId,
+                forecastProbability: o.forecastProbability,
+                marketProbability: o.marketProbability,
+                reasonCode: o.reasonCode,
+                cohort: {
+                    universeSize: o.universeSize,
+                    horizon: spec.objective?.horizon,
+                },
+                decisionId,
+                runId,
+                provenance,
+            }, baseTrace);
+            report = {
+                opportunity: o,
+                outcome: result.ok
+                    ? "confirmed"
+                    : result.status === 0
+                        ? "unknown"
+                        : "http_error",
+                status: result.status,
+            };
+            if (result.ok) {
+                log(`reported ${o.kind} opportunity (universe ${o.universeSize ?? "?"})`);
+            }
+            else if (result.status === 0) {
+                log("opportunity report outcome unknown (transport failure)");
+            }
+            else {
+                log(`opportunity report received HTTP ${result.status}; delivery unconfirmed`);
+            }
+        }
+        catch {
+            report = { opportunity: o, outcome: "unknown", status: 0 };
+            // Exceptions and API error bodies may contain private request details.
+            log("opportunity report outcome unknown (exception)");
+        }
+    };
+    return {
+        post,
+        get posted() {
+            return report?.outcome === "confirmed" ? report.opportunity : undefined;
+        },
+        get report() {
+            return report;
+        },
+    };
+}

package/dist/agent/prompt.js

@@ -117,6 +117,11 @@ opts = {}) {
                     : '- DIRECTION: LONG ONLY — every futures_open MUST be side:"long". A short is REJECTED by the runner no matter how strong the setup looks.',
             ]
             : []),
+        ...(r.entryPredicates
+            ? [
+                `- Binding crypto entry conditions (all conditions matching the entry side must pass on fresh observed data): ${JSON.stringify(r.entryPredicates)}. Missing evidence is a rejection. These conditions never authorize exceeding another cap.`,
+            ]
+            : []),
         // With universe_scan, the validator's gate is WATCH-membership (manual
         // watchlist ∪ this cycle's discovered entries) — saying "ONLY these" here
         // while the universe-scan section below calls discovered movers tradable

package/dist/agent/reconcileObservation.d.ts

@@ -0,0 +1,2 @@
+import type { RunState, Observation } from "./types.js";
+export declare function reconcileObservation(state: RunState, observation: Observation): void;

package/dist/agent/reconcileObservation.js

@@ -0,0 +1,33 @@
+import { accrueRealized } from "./state.js";
+import { asObj, asNum, asStr } from "./extract.js";
+export function reconcileObservation(state, observation) {
+    accrueRealized(state, observation.newClosedTrades);
+    state.cursor = observation.syncCursor;
+    for (const t of observation.newClosedTrades) {
+        state.seen.push(`${asStr(asObj(t).venue) ?? "futures"}:${asNum(asObj(t).id) ?? String(asObj(t).id)}`);
+    }
+    state.seen = state.seen.slice(-500);
+    // Slice-3 reflection: journal closed-trade OUTCOMES (not just opens) so the agent
+    // remembers how its theses RESOLVED — a stop-out it should not revenge-trade, a
+    // winner its style works on. Defensive field reads (the /trades shape varies);
+    // a partial entry is harmless, a missing one is skipped.
+    for (const t of observation.newClosedTrades.slice(-5)) {
+        const o = asObj(t);
+        const sym = asStr(o.symbol) ?? asStr(o.coinSymbol) ?? asStr(o.coinId);
+        const pnl = asNum(o.realizedPnlMusd) ??
+            asNum(o.pnlMusd) ??
+            asNum(o.realizedPnl) ??
+            asNum(o.pnl);
+        const side = asStr(o.side);
+        if (sym || pnl != null) {
+            const did = `closed ${side ?? ""} ${sym ?? "position"}`.trim() +
+                (pnl != null
+                    ? `: ${pnl >= 0 ? "+" : ""}${Math.round(pnl)}mUSD ${pnl >= 0 ? "WIN" : "LOSS"}`
+                    : "");
+            state.journal = [
+                ...(state.journal ?? []),
+                { at: observation.asOf, did },
+            ].slice(-12);
+        }
+    }
+}

package/dist/agent/runner.js

@@ -8,6 +8,8 @@ import { usesCapitalSizing, prepareCapitalAction, validateCapitalAction, capital
 import { decideMechanical } from "./mechanical.js";
 import { evaluateGate, noteLlmCall, estimateCostUsd } from "./gate.js";
 import { baseSymbol, scanSetups } from "./setups.js";
+import { reconcileObservation } from "./reconcileObservation.js";
+import { createOpportunityReporter } from "./opportunityReporter.js";
 import { observe } from "./observe.js";
 import { buildDailyRiskBudget, buildSystemPrompt, buildUserPrompt, } from "./prompt.js";
 import { parseDecision } from "./decision.js";
@@ -15,7 +17,7 @@ import { validateAction, isRiskIncreasingAction, } from "./decisionValidator.js"
 import { resolvePmRef } from "./resolvePm.js";
 import { fetchQuote, executeAction } from "./act.js";
 import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
-import { rollDay, checkKillSwitch, accrueRealized, saveState, isPermanentModelError, isAuthFailureSkip, PERMANENT_MODEL_ERROR_THRESHOLD, AUTH_FAILURE_THRESHOLD, } from "./state.js";
+import { rollDay, checkKillSwitch, saveState, isPermanentModelError, isAuthFailureSkip, PERMANENT_MODEL_ERROR_THRESHOLD, AUTH_FAILURE_THRESHOLD, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
 import { parseCadenceMs, sleep } from "./util.js";
 import { buildObservationReceipt } from "./observationReceipt.js";
@@ -441,43 +443,22 @@ async function runCycleCore(deps, capture) {
             live,
         };
     }
+    // Establish durable run identity before the first possible write. A process
+    // killed before its first response must not restart with a new idempotency key.
+    if (live)
+        saveState(stateFile, state);
     const baseTrace = makeTrace(runId, decisionId, spec);
-    // Opportunity capture (kills evaluation selection bias). Post at most ONE
-    // non-opened opportunity per cycle, LIVE only (dry-run never writes), best-effort
-    // — a failed post never affects the cycle result. The latch is set BEFORE the
-    // await so a failure never retries within the cycle (respects the write budget);
-    // the cohort/universe field carries the breadth, so we never post per-market.
-    const captureOpportunity = agentOpportunityCaptureEnabled();
-    let opportunityPosted = false;
-    let postedOpportunity;
-    const postOpportunity = async (o) => {
-        if (!captureOpportunity || !live || opportunityPosted)
-            return;
-        opportunityPosted = true;
-        postedOpportunity = o;
-        try {
-            await client.reportPmOpportunity({
-                kind: o.kind,
-                source: o.source,
-                slug: o.slug,
-                outcomeExternalMarketId: o.outcomeExternalMarketId,
-                forecastProbability: o.forecastProbability,
-                marketProbability: o.marketProbability,
-                reasonCode: o.reasonCode,
-                cohort: {
-                    universeSize: o.universeSize,
-                    horizon: spec.objective?.horizon,
-                },
-                decisionId,
-                runId,
-                provenance,
-            }, baseTrace);
-            log(`reported ${o.kind} opportunity (universe ${o.universeSize ?? "?"})`);
-        }
-        catch (err) {
-            log(`opportunity post failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
+    const opportunities = createOpportunityReporter({
+        client,
+        spec,
+        live,
+        enabled: agentOpportunityCaptureEnabled(),
+        runId,
+        decisionId,
+        provenance,
+        baseTrace,
+        log,
+    });
     // OBSERVE
     const obs = await observe(client, spec, state, baseTrace);
     const observation = obs.observation;
@@ -496,35 +477,7 @@ async function runCycleCore(deps, capture) {
     // Reads build the observation, so its hash cannot exist before they finish.
     // From this point every durable write carries the exact decision-input receipt.
     Object.assign(baseTrace, observationReceipt);
-    accrueRealized(state, observation.newClosedTrades);
-    state.cursor = observation.syncCursor;
-    for (const t of observation.newClosedTrades) {
-        state.seen.push(`${asStr(asObj(t).venue) ?? "futures"}:${asNum(asObj(t).id) ?? String(asObj(t).id)}`);
-    }
-    state.seen = state.seen.slice(-500);
-    // Slice-3 reflection: journal closed-trade OUTCOMES (not just opens) so the agent
-    // remembers how its theses RESOLVED — a stop-out it should not revenge-trade, a
-    // winner its style works on. Defensive field reads (the /trades shape varies);
-    // a partial entry is harmless, a missing one is skipped.
-    for (const t of observation.newClosedTrades.slice(-5)) {
-        const o = asObj(t);
-        const sym = asStr(o.symbol) ?? asStr(o.coinSymbol) ?? asStr(o.coinId);
-        const pnl = asNum(o.realizedPnlMusd) ??
-            asNum(o.pnlMusd) ??
-            asNum(o.realizedPnl) ??
-            asNum(o.pnl);
-        const side = asStr(o.side);
-        if (sym || pnl != null) {
-            const did = `closed ${side ?? ""} ${sym ?? "position"}`.trim() +
-                (pnl != null
-                    ? `: ${pnl >= 0 ? "+" : ""}${Math.round(pnl)}mUSD ${pnl >= 0 ? "WIN" : "LOSS"}`
-                    : "");
-            state.journal = [
-                ...(state.journal ?? []),
-                { at: observation.asOf, did },
-            ].slice(-12);
-        }
-    }
+    reconcileObservation(state, observation);
     capture({
         ...captureBase,
         phase: "observed",
@@ -897,7 +850,7 @@ async function runCycleCore(deps, capture) {
         // cohort via universeSize.
         const skipOpp = buildSkipOpportunity(decision, observation.pmMarkets, forecastEnabled);
         if (skipOpp)
-            await postOpportunity(skipOpp);
+            await opportunities.post(skipOpp);
         saveState(stateFile, state);
         log(`model chose skip${decision.reason ? `: ${decision.reason}` : ""}`);
         return {
@@ -912,7 +865,10 @@ async function runCycleCore(deps, capture) {
             decisionType: "skip",
             writeAttempted: decision.actions.length,
             writeAccepted: 0,
-            ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+            ...(opportunities.posted ? { opportunity: opportunities.posted } : {}),
+            ...(opportunities.report
+                ? { opportunityReport: opportunities.report }
+                : {}),
             ...observationReceipt,
         };
     }
@@ -1265,7 +1221,7 @@ async function runCycleCore(deps, capture) {
             // (once-per-cycle; carries the universe breadth in the cohort field).
             if (action.type === "pm_open" && isQuoteExpiredResult(r.status, r.data)) {
                 const pm = action;
-                await postOpportunity({
+                await opportunities.post({
                     kind: "quote_expired",
                     source: pm.source,
                     slug: pm.slug,
@@ -1322,7 +1278,10 @@ async function runCycleCore(deps, capture) {
         decisionType: "act",
         writeAttempted: decision.actions.length,
         writeAccepted: planned.filter((p) => p.accepted).length,
-        ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+        ...(opportunities.posted ? { opportunity: opportunities.posted } : {}),
+        ...(opportunities.report
+            ? { opportunityReport: opportunities.report }
+            : {}),
         ...observationReceipt,
     };
 }

package/dist/agent/skill.js

@@ -103,6 +103,12 @@ export function buildSpec(raw) {
             ? { capitalSizing: buildCapitalSizing(raw.capitalSizing) }
             : {}),
         risk: {
+            // Preserve malformed explicit policies for fail-closed validation.
+            ...(risk.entryPredicates !== undefined
+                ? {
+                    entryPredicates: risk.entryPredicates,
+                }
+                : {}),
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),

package/dist/agent/skillValidator.js

@@ -1,5 +1,6 @@
 import { fail, VENUES, PROVIDERS, SPEC_VERSION, OBJECTIVE_PRIMARIES, ALLOWED_CAPABILITIES, } from "./types.js";
 import { parseCadenceMs, scanForSecrets } from "./util.js";
+import { entryPredicateIssues } from "./entryPredicates.js";
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isPosNum = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
 // maxTradesPerDay accepts 0 as the explicit "unlimited daily trades" sentinel.
@@ -93,6 +94,8 @@ export function validateSkill(parsed, mode = "self-host") {
     }
     else {
         const r = raw.risk;
+        if (r.entryPredicates !== undefined)
+            issues.push(...entryPredicateIssues(r.entryPredicates));
         if (!isPosNum(r.maxLeverage))
             add("skill_risk_leverage", "risk.maxLeverage must be a positive number");
         else if (r.maxLeverage > 20)

package/dist/agent/strictLint.js

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

package/dist/agent/templates.js

@@ -50,37 +50,37 @@ const PRESETS = {
         modelFail: 5,
     },
 };
-const THESIS_BODY = `# Momentum Futures — strategy
-
-You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
-Everything here is simulated; it is not financial advice and never touches real
-money. Edit this prose freely (any language) — it is your agent's borders.
-
-## Each cycle
-
-1. Ground yourself: read your portfolio and open positions first. Never assume
-   balances or what is already open.
-2. Scan the watchlist. A candidate is a coin whose short and medium momentum
-   agree (both up, or both down) and is not already an open position.
-3. Pick the strongest candidate and commit when the read is clear — even a
-   moderate-confidence one — sized small with a stop. Skip only when the signals
-   contradict or the data is stale; a quiet tape where your edge is still real
-   is an act, not a skip.
-4. Quote before you open. Read the liquidation price and confirm it is sane. If
-   the quote is not eligible, relay the reason and stop.
-5. Open small and protected: enter in the trend direction and set a stop-loss at
-   open. Place the take-profit a touch wider than the stop.
-6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
-   fired while you were not looking, and react to what actually happened.
-
-The hard caps (leverage, margin, watchlist) live in the config blocks above and
+const THESIS_BODY = `# Momentum Futures — strategy
+
+You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
+Everything here is simulated; it is not financial advice and never touches real
+money. Edit this prose freely (any language) — it is your agent's borders.
+
+## Each cycle
+
+1. Ground yourself: read your portfolio and open positions first. Never assume
+   balances or what is already open.
+2. Scan the watchlist. A candidate is a coin whose short and medium momentum
+   agree (both up, or both down) and is not already an open position.
+3. Pick the strongest candidate and commit when the read is clear — even a
+   moderate-confidence one — sized small with a stop. Skip only when the signals
+   contradict or the data is stale; a quiet tape where your edge is still real
+   is an act, not a skip.
+4. Quote before you open. Read the liquidation price and confirm it is sane. If
+   the quote is not eligible, relay the reason and stop.
+5. Open small and protected: enter in the trend direction and set a stop-loss at
+   open. Place the take-profit a touch wider than the stop.
+6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
+   fired while you were not looking, and react to what actually happened.
+
+The hard caps (leverage, margin, watchlist) live in the config blocks above and
 are enforced by the runner — change them there, not in this prose.`;
-const PERSONA_STUB = `# Persona
-
-Decisive and in character. Acts on a clear read — even a moderate-confidence one
-— sized small and protected with a stop, and skips only when the read is
-contradictory or the data is stale. States its reasoning plainly in its own
-voice, and never frames paper results as real-money advice.
+const PERSONA_STUB = `# Persona
+
+Decisive and in character. Acts on a clear read — even a moderate-confidence one
+— sized small and protected with a stop, and skips only when the read is
+contradictory or the data is stale. States its reasoning plainly in its own
+voice, and never frames paper results as real-money advice.
 `;
 export function buildAgentObject(name, preset) {
     const p = PRESETS[preset];

package/dist/agent/types.d.ts

@@ -26,6 +26,7 @@ export interface TriggerPolicy {
 }
 export declare const DEFAULT_TRIGGER_POLICY: TriggerPolicy;
 export interface RiskConfig {
+    entryPredicates?: import("./entryPredicates.js").EntryPredicate[];
     maxLeverage: number;
     perTradeMarginMusd: number;
     maxConcurrentPositions: number;
@@ -503,6 +504,12 @@ export interface CycleResult {
     writeAttempted?: number;
     writeAccepted?: number;
     opportunity?: PostedOpportunity;
+    opportunityReport?: OpportunityReport;
+}
+export interface OpportunityReport {
+    opportunity: PostedOpportunity;
+    outcome: "confirmed" | "http_error" | "unknown";
+    status: number;
 }
 export interface PostedOpportunity {
     kind: "abstained" | "forecast_only" | "quote_expired";

package/dist/agent/util.js

@@ -1,5 +1,5 @@
 // Small dependency-free helpers shared across the runner.
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { resolve as resolvePath, relative as relativePath, isAbsolute, } from "node:path";
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 // Parse a cadence string ("30s", "15m", "1h", "4h", "1d") to milliseconds.
@@ -63,8 +63,8 @@ export function scanForSecrets(value, pathPrefix = "", findings = []) {
 }
 // Short random id (for runId/decisionId/idempotencyKey suffixes).
 export function shortId() {
-    // randomUUID is available in Node 18+ (globalThis.crypto).
-    return crypto.randomUUID().slice(0, 8);
+    // Import the Node API: globalThis.crypto is not enabled by default in Node 18.
+    return randomUUID().slice(0, 8);
 }
 // ── Resolver helpers (cross-platform-deterministic) ──────────────────────────
 // Normalize file content for hashing: CRLF/CR -> LF, strip trailing whitespace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinrithm/mcp-trading",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "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",
@@ -84,5 +84,14 @@
     "typescript": "^5.5.0",
     "typescript-eslint": "^8.11.0",
     "vitest": "4.1.11"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./engine": {
+      "types": "./dist/agent/engine.d.ts",
+      "import": "./dist/agent/engine.js"
+    },
+    "./package.json": "./package.json",
+    "./dist/*": "./dist/*"
   }
 }