@coinrithm/mcp-trading 0.7.3 → 0.7.5

package/dist/agent/observationReceipt.js

@@ -0,0 +1,10 @@
+// A compact, privacy-safe receipt for the exact structured observation used by
+// one decision. We persist the digest, never the full prompt or model output.
+import { INDICATOR_VERSION } from "./indicators.js";
+import { sha256, stableStringify } from "./util.js";
+export function buildObservationReceipt(observation) {
+    return {
+        observationHash: sha256(stableStringify(observation)),
+        indicatorVersion: INDICATOR_VERSION,
+    };
+}

package/dist/agent/observe.d.ts

@@ -4,4 +4,8 @@ export interface ObserveOutput {
     observation: Observation;
     skip?: string;
 }
+export declare function isCalibrationChurnMarket(market: {
+    slug?: string;
+    title?: string;
+}): boolean;
 export declare function observe(client: CoinRithmClient, spec: AgentSpec, state: RunState, trace?: AgentTrace): Promise<ObserveOutput>;

package/dist/agent/observe.js

@@ -28,6 +28,16 @@ const PM_COIN_NAMES = {
     UNI: "Uniswap",
     SUI: "Sui",
 };
+// Repeated micro-contracts are useful for execution smoke tests but are a poor
+// calibration universe: outcomes overlap heavily, resolve too quickly to admit
+// meaningful independent research, and drown the public scorecard in Bitcoin
+// coin flips. Non-mechanical calibration agents receive a deeper discovery
+// page with these rows removed. Mechanical baselines intentionally keep the
+// unmodified universe so their reference contract remains reproducible.
+const PM_CALIBRATION_CHURN_RE = /(updown|up-or-down|-5-?min|-5m-|-15m|15m(?:-|$)|(?:5|15)\s+min(?:ute)?s?|-1h-|hourly|-daily-|\bdaily\b|what-price-will[^\n]*(?:today|tomorrow)|-above-on-|-price-on-|this[ -]week|of[ -]the[ -]week|-weekly-)/i;
+export function isCalibrationChurnMarket(market) {
+    return PM_CALIBRATION_CHURN_RE.test(`${market.slug ?? ""} ${market.title ?? ""}`);
+}
 // Fetch candles for one coin and reduce them to a compact indicator bundle.
 // Tolerant by design: any failure (HTTP error, malformed/sparse candles) returns
 // null so the cycle proceeds with price-only context rather than skipping.
@@ -289,6 +299,9 @@ export async function observe(client, spec, state, trace) {
     let pmResolutions = [];
     let pmMarkets = [];
     if (wantPm) {
+        const curatedCalibrationBoard = spec.objective?.primary === "calibration" &&
+            spec.model?.provider !== "mechanical";
+        const primaryDiscoveryLimit = curatedCalibrationBoard ? 30 : 12;
         // Bias PM discovery toward CRYPTO markets the agent has a price view on — the
         // only PM edge a price agent reliably has (probed 2026-06-24: the default board
         // is World Cup / elections / F1, which an agent has no edge on). The discover
@@ -299,7 +312,7 @@ export async function observe(client, spec, state, trace) {
         const pmQuery = PM_COIN_NAMES[topCoin] ?? spec.risk.watchlist[0] ?? "Bitcoin";
         const [pmPosR, pmDiscFirst] = await Promise.all([
             client.pmPositions(undefined, trace),
-            client.discoverPmMarkets({ q: pmQuery, limit: 12 }, trace),
+            client.discoverPmMarkets({ q: pmQuery, limit: primaryDiscoveryLimit }, trace),
         ]);
         let pmDiscR = pmDiscFirst;
         const firstCount = pmDiscR.ok
@@ -378,6 +391,9 @@ export async function observe(client, spec, state, trace) {
             // quoteable id NESTED at outcomes[].externalMarketId — expandPmMarkets turns
             // that into one row per quoteable outcome (eligible + not-held filtered).
             let mergedRows = expandPmMarkets(pmDiscR.data, heldPmKeys);
+            if (curatedCalibrationBoard) {
+                mergedRows = mergedRows.filter((market) => !isCalibrationChurnMarket(market));
+            }
             // ── Crypto-targeted secondary discover (pm_ref hallucination fix) ────────
             // The prompt tells the model its SHARPEST PM edge is the crypto price view it
             // JUST formed — but that is only actionable if the board actually LISTS a
@@ -409,10 +425,13 @@ export async function observe(client, spec, state, trace) {
                     // rows that actually reference the targeted coin (a fuzzy backend match
                     // can't dilute the board with off-topic events).
                     const primaryEventKeys = new Set(mergedRows.map((m) => `${m.source}|${m.slug}`));
-                    const secRows = expandPmMarkets(secR.data, heldPmKeys)
+                    let secRows = expandPmMarkets(secR.data, heldPmKeys)
                         .filter((m) => titleMentionsCoin(m.title, topAnalyzed))
-                        .filter((m) => !primaryEventKeys.has(`${m.source}|${m.slug}`))
-                        .slice(0, 4);
+                        .filter((m) => !primaryEventKeys.has(`${m.source}|${m.slug}`));
+                    if (curatedCalibrationBoard) {
+                        secRows = secRows.filter((market) => !isCalibrationChurnMarket(market));
+                    }
+                    secRows = secRows.slice(0, 4);
                     // Reserve slots for the targeted rows so the 12-cap can't slice off the
                     // very markets the secondary fetch exists to surface. Primary rows keep
                     // priority; the targeted rows are appended.

package/dist/agent/runner.js

@@ -17,6 +17,7 @@ import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
 import { rollDay, checkKillSwitch, accrueRealized, saveState, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
 import { parseCadenceMs, sleep } from "./util.js";
+import { buildObservationReceipt } from "./observationReceipt.js";
 // Independent-forecast kill-switch. Default ON: the fleet elicits + submits its
 // OWN forecastProbability on PM opens. Set HOUSE_AGENT_FORECAST_ENABLED to
 // "false"/"0"/"no"/"off" to ship pm/open requests WITHOUT the field, byte-identical
@@ -371,6 +372,10 @@ export async function runCycle(deps) {
     // OBSERVE
     const obs = await observe(client, spec, state, baseTrace);
     const observation = obs.observation;
+    const observationReceipt = buildObservationReceipt(observation);
+    // 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) {
@@ -419,13 +424,20 @@ export async function runCycle(deps) {
             disabled: true,
             disabledReason: state.disabledReason,
             live,
+            ...observationReceipt,
         };
     }
     if (obs.skip) {
         state.consecutiveRejectCycles += 1;
         saveState(stateFile, state);
         log(`skip: ${obs.skip}`);
-        return { decision: "skip", skipReason: obs.skip, planned: [], live };
+        return {
+            decision: "skip",
+            skipReason: obs.skip,
+            planned: [],
+            live,
+            ...observationReceipt,
+        };
     }
     // GATE (slice 2): only SPEND an LLM call when a deterministic trigger fires — a
     // flagged entry setup or an open position to manage. No trigger => a cheap
@@ -451,6 +463,7 @@ export async function runCycle(deps) {
             estimatedCostUsd: 0,
             writeAttempted: 0,
             writeAccepted: 0,
+            ...observationReceipt,
         };
     }
     // DECIDE. Two paths share the same downstream validate+act loop:
@@ -519,6 +532,7 @@ export async function runCycle(deps) {
                 decisionType: "model_error",
                 writeAttempted: 0,
                 writeAccepted: 0,
+                ...observationReceipt,
             };
         }
         const parsed = parseDecision(res.text);
@@ -539,6 +553,7 @@ export async function runCycle(deps) {
                 decisionType: "model_error",
                 writeAttempted: 0,
                 writeAccepted: 0,
+                ...observationReceipt,
             };
         }
         state.consecutiveModelFailures = 0;
@@ -578,6 +593,7 @@ export async function runCycle(deps) {
             writeAttempted: decision.actions.length,
             writeAccepted: 0,
             ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+            ...observationReceipt,
         };
     }
     // VALIDATE (+ ACT when live). Quote evidence is fetched by the runner.
@@ -778,13 +794,16 @@ export async function runCycle(deps) {
         const seq = state.intentSeq[intentKey] ?? 0;
         const idem = `${runId}:${intentKey}:${seq}`;
         const meta = action;
-        const trace = makeTrace(runId, decisionId, spec, meta.confidence ?? decision.confidence, 
-        // The trade's "why" on the Arena live floor. Prefer the model's per-action
-        // summary; else the decision rationale, but kept HONEST about this action's
-        // market (a multi-action decision's rationale can be about a DIFFERENT market
-        // than a secondary trade — see rationaleForAction). Sanitized short reasoning
-        // only — never raw chain-of-thought.
-        rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length));
+        const trace = {
+            ...makeTrace(runId, decisionId, spec, meta.confidence ?? decision.confidence, 
+            // The trade's "why" on the Arena live floor. Prefer the model's per-action
+            // summary; else the decision rationale, but kept HONEST about this action's
+            // market (a multi-action decision's rationale can be about a DIFFERENT market
+            // than a secondary trade — see rationaleForAction). Sanitized short reasoning
+            // only — never raw chain-of-thought.
+            rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length)),
+            ...observationReceipt,
+        };
         const r = await executeAction(client, action, observation, trace, idem, provenance);
         planned.push({
             action,
@@ -868,6 +887,7 @@ export async function runCycle(deps) {
         writeAttempted: decision.actions.length,
         writeAccepted: planned.filter((p) => p.accepted).length,
         ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+        ...observationReceipt,
     };
 }
 export async function runLoop(deps, opts = {}) {

package/dist/agent/types.d.ts

@@ -301,6 +301,8 @@ export interface AgentTrace {
     strategyLabel?: string;
     confidence?: number;
     rationaleSummary?: string;
+    observationHash?: string;
+    indicatorVersion?: string;
 }
 export interface ApiResult {
     ok: boolean;
@@ -330,6 +332,8 @@ export interface CycleResult {
     disabled?: boolean;
     disabledReason?: string;
     live: boolean;
+    observationHash?: string;
+    indicatorVersion?: string;
     triggerCodes?: string[];
     llmCallMade?: boolean;
     tokensIn?: number;

package/dist/client.d.ts

@@ -48,6 +48,10 @@ export declare class CoinRithmClient {
     getPublicPmOverview(query?: {
         fiat?: string;
     }): Promise<ApiResult>;
+    getPublicPmSources(query?: {
+        fiat?: string;
+    }): Promise<ApiResult>;
+    getPublicPmSourcesHealth(): Promise<ApiResult>;
     listPublicPmEvents(query?: {
         q?: string;
         source?: string;
@@ -61,6 +65,24 @@ export declare class CoinRithmClient {
         fiat?: string;
     }): Promise<ApiResult>;
     getPublicPmWhales(): Promise<ApiResult>;
+    getPublicPmMatches(query?: {
+        limit?: number;
+        offset?: number;
+        sort?: string;
+        minDivergence?: number;
+        sourceKind?: string;
+        status?: string;
+        maxSnapshotAgeMinutes?: number;
+        requirePriced?: boolean;
+        fiat?: string;
+    }): Promise<ApiResult>;
+    getPublicPmCalibration(): Promise<ApiResult>;
+    getPublicPmCanonicalList(query?: {
+        limit?: number;
+        cursor?: number;
+    }): Promise<ApiResult>;
+    getPublicPmCanonicalDetail(key: string): Promise<ApiResult>;
+    getPublicPmVolumeHistory(): Promise<ApiResult>;
     whoami(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     getPortfolio(query?: {
         fiat?: string;

package/dist/client.js

@@ -203,6 +203,12 @@ export class CoinRithmClient {
     getPublicPmOverview(query) {
         return this.publicRequest("/api/prediction-markets/overview", query);
     }
+    getPublicPmSources(query) {
+        return this.publicRequest("/api/prediction-markets/sources", query);
+    }
+    getPublicPmSourcesHealth() {
+        return this.publicRequest("/api/prediction-markets/sources/health");
+    }
     listPublicPmEvents(query) {
         return this.publicRequest("/api/prediction-markets/events", query);
     }
@@ -212,6 +218,24 @@ export class CoinRithmClient {
     getPublicPmWhales() {
         return this.publicRequest("/api/prediction-markets/whales");
     }
+    // Cross-venue disagreement clusters (approved event matches, graph-clustered).
+    getPublicPmMatches(query) {
+        return this.publicRequest("/api/prediction-markets/matches/public", query);
+    }
+    // Per-venue forecast-accuracy calibration (ECE + reliability curve). No query params.
+    getPublicPmCalibration() {
+        return this.publicRequest("/api/prediction-markets/calibration");
+    }
+    getPublicPmCanonicalList(query) {
+        return this.publicRequest("/api/prediction-markets/canonical", query);
+    }
+    getPublicPmCanonicalDetail(key) {
+        return this.publicRequest(`/api/prediction-markets/canonical/${encodeURIComponent(key)}`);
+    }
+    // Global daily volume trend (real-money venues only). No query params.
+    getPublicPmVolumeHistory() {
+        return this.publicRequest("/api/prediction-markets/volume-history");
+    }
     // Every method takes an optional trailing `apiKey` (the per-request key for
     // the multi-user HTTP path). When omitted, the constructor key (stdio) is used.
     // ---- reads (scope: read) ----

package/dist/http.js

@@ -46,7 +46,9 @@ async function main() {
     const app = express();
     app.use(express.json());
     // Lightweight, unauthenticated liveness probe (handy for Coolify/uptime checks).
-    app.get("/healthz", (_req, res) => {
+    // Keep `/healthz` as the deployment contract and expose `/health` as a
+    // compatibility alias for agents and generic uptime monitors.
+    app.get(["/health", "/healthz"], (_req, res) => {
         res.json({
             ok: true,
             service: "coinrithm-mcp",

package/dist/tools.d.ts

@@ -1,4 +1,26 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CoinRithmClient } from "./client.js";
 export declare const PAPER_NOTE: string;
+/**
+ * Keep keyless discovery calls small enough for an agent context window.
+ * Full event evidence remains available from pm_data_event.
+ */
+export declare function compactPublicPmOverview(data: unknown): unknown;
+export declare function compactPublicPmEvents(data: unknown): unknown;
+/**
+ * Default event detail for agents: enough provenance and comparison evidence
+ * to reason safely without recursively spending an entire context window.
+ * Callers can explicitly request detail=full for the untouched API record.
+ */
+export declare function compactPublicPmEvent(data: unknown): unknown;
+export declare function compactPublicPmWhales(data: unknown, limit: number): unknown;
+/**
+ * Keep cross-venue disagreement clusters small enough for an agent context
+ * window: each event is reduced to eventSummary (drops descriptions, images,
+ * sparklines) and each pairwise comparison keeps only its top-5 highest-delta
+ * shared outcomes (compactComparison) — the same bounding pm_data_event
+ * applies to crossSourceMatches. Verified live: a 5-cluster page drops from
+ * ~466KB to ~48KB.
+ */
+export declare function compactPublicPmDisagreements(data: unknown): unknown;
 export declare function registerTools(server: McpServer, client: CoinRithmClient): void;