@coinrithm/mcp-trading 0.7.15 → 0.7.17

package/dist/agent/cli.js

@@ -18,12 +18,17 @@ import { buildManifest, writeManifest } from "./manifest.js";
 import { parseFrontmatter } from "./frontmatter.js";
 import { renderFolderOfOne, ejectFiles, PRESET_NAMES, } from "./templates.js";
 import { COINRITHM_API } from "./version.js";
-import { stableStringify, envFlag } from "./util.js";
-import { CoinRithmClient } from "./client.js";
+import { stableStringify, envFlag, parseCadenceMs, sleep } from "./util.js";
+import { CoinRithmClient, DEFAULT_BASE_URL } from "./client.js";
 import { selectProvider } from "./providers.js";
 import { runLoop } from "./runner.js";
 import { loadState, saveState } from "./state.js";
 import { makeRunId } from "./runEvidence.js";
+import { readCorpus, writeCassette } from "./bench/cassette.js";
+import { recordCassette } from "./bench/recordingClient.js";
+import { runBench } from "./bench/bench.js";
+import { buildPmLabels, buildPriceLabels, DEFAULT_LABEL_HORIZON_HOURS, } from "./bench/labelBuilder.js";
+import { parseLabelFile } from "./bench/labels.js";
 const fail = (lines) => ({ ok: false, code: 1, lines });
 function issuesResult(issues, header) {
     return {
@@ -438,8 +443,254 @@ export async function cmdRun(path, opts = {}) {
         release();
     }
 }
+const MAX_RECORD_CYCLES = 10_000;
+// Record bench cassettes (see bench/cassette.ts). Read-only by construction:
+// every cycle runs DRY-RUN through a recording transport that refuses all
+// non-GET requests, with a brain that never calls a model, so only
+// COINRITHM_API_KEY is needed and no model key is read. The agent's own state
+// file is not touched; each recorded cycle starts from a fresh run state.
+export async function cmdRecord(path, opts = {}) {
+    if (!opts.out)
+        return fail(["record needs --out <dir> for the cassettes"]);
+    const cycles = opts.cycles ?? 1;
+    if (!Number.isInteger(cycles) || cycles < 1 || cycles > MAX_RECORD_CYCLES)
+        return fail([`--cycles must be an integer from 1 to ${MAX_RECORD_CYCLES}`]);
+    let loaded;
+    try {
+        loaded = loadAgent(path, "self-host");
+    }
+    catch (e) {
+        if (e instanceof ResolveError)
+            return issuesResult(e.issues, "resolve failed");
+        throw e;
+    }
+    const everyMs = opts.every !== undefined
+        ? parseCadenceMs(opts.every)
+        : (parseCadenceMs(loaded.spec.trigger.cadence) ?? 3_600_000);
+    if (everyMs === null)
+        return fail([`--every "${opts.every}" is not a cadence like 5m or 1h`]);
+    const apiKey = process.env.COINRITHM_API_KEY;
+    if (!apiKey)
+        return fail([
+            "COINRITHM_API_KEY is not set (recording reads your paper account; it never writes)",
+        ]);
+    const mergedProse = runtimeProse(loaded.resolved);
+    const lines = [
+        `record DRY-RUN (reads only, no model call): ${loaded.spec.name}, ${cycles} cycle(s)`,
+    ];
+    const files = [];
+    for (let i = 0; i < cycles; i++) {
+        let cassette;
+        try {
+            cassette = await recordCassette({
+                spec: loaded.spec,
+                mergedProse,
+                apiKey,
+                baseUrl: process.env.COINRITHM_API_URL || undefined,
+                fetchFn: opts.fetchFn,
+            });
+        }
+        catch (e) {
+            lines.push(`✗ cycle ${i + 1} failed: ${e.message}`);
+            return { ok: false, code: 1, lines, data: files };
+        }
+        files.push(writeCassette(resolvePath(opts.out), cassette));
+        const cycle = cassette.recordCycle;
+        lines.push(`recorded ${cassette.id}: ${cassette.responses.length} read(s), asOf ${cassette.asOf}, cycle ${cycle.decisionType ?? cycle.decision}${cycle.skipReason ? ` (${cycle.skipReason})` : ""}` +
+            (cassette.refusedRequests.length
+                ? `, ${cassette.refusedRequests.length} write(s) refused`
+                : ""));
+        if (i < cycles - 1)
+            await (opts.sleepFn ?? sleep)(everyMs);
+    }
+    return { ok: true, code: 0, lines, data: files };
+}
+// Write outcome labels for a recorded corpus (bench/labelBuilder.ts), reads
+// only: price bars from candles published after each cassette's asOf (with
+// COINRITHM_API_KEY), and PM settlement from the public event verdict
+// (settlementEligible + "settle" + a provider won/lost outcome result; any
+// other state stays unlabelled).
+export async function cmdLabel(opts = {}) {
+    if (!opts.corpus)
+        return fail(["label needs --corpus <dir>"]);
+    const horizonHours = opts.horizonHours ?? DEFAULT_LABEL_HORIZON_HOURS;
+    if (!Number.isFinite(horizonHours) || horizonHours <= 0 || horizonHours > 720)
+        return fail(["--horizon-hours must be a number in (0, 720]"]);
+    const apiKey = process.env.COINRITHM_API_KEY;
+    if (!apiKey)
+        return fail([
+            "COINRITHM_API_KEY is not set (labels read public market candles through your key; nothing is written)",
+        ]);
+    const dir = resolvePath(opts.corpus);
+    let corpus;
+    try {
+        corpus = readCorpus(dir);
+    }
+    catch (e) {
+        return fail([e.message]);
+    }
+    const client = new CoinRithmClient({
+        apiKey,
+        baseUrl: process.env.COINRITHM_API_URL || undefined,
+        fetchFn: opts.fetchFn,
+    });
+    const results = await buildPriceLabels(corpus.cassettes, {
+        fetchCandles: (coinId, range) => client.candles(coinId, range),
+        horizonHours,
+        nowMs: opts.nowMs ?? Date.now(),
+        existing: corpus.labels,
+        overwrite: opts.overwrite,
+    });
+    const base = (process.env.COINRITHM_API_URL || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const fetchFn = opts.fetchFn ?? fetch;
+    const pmResults = await buildPmLabels(corpus.cassettes, {
+        // The public event detail: the same verdict the event page shows.
+        fetchEvent: async (source, slug) => {
+            const res = await fetchFn(`${base}/api/prediction-markets/events/${encodeURIComponent(source)}/${encodeURIComponent(slug)}`, { method: "GET", signal: AbortSignal.timeout(15_000) });
+            return {
+                ok: res.ok,
+                status: res.status,
+                data: res.ok ? await res.json() : null,
+            };
+        },
+        existing: corpus.labels,
+        overwrite: opts.overwrite,
+    });
+    const lines = [
+        `label (reads only): ${corpus.cassettes.length} cassette(s), horizon ${horizonHours} h`,
+    ];
+    let written = 0;
+    for (const r of results) {
+        const pm = pmResults.find((p) => p.id === r.id);
+        const notes = [];
+        let file;
+        if (r.status === "built") {
+            file = { ...r.file };
+            notes.push(`${r.range} bars for ${r.symbols.length} symbol(s)${r.missing.length ? `, missing ${r.missing.join(",")}` : ""}`);
+        }
+        else {
+            notes.push(`prices ${r.status}${r.status === "not_yet" ? ` (labelable after ${r.labelableAfter})` : ""}${r.status === "horizon_mismatch" ? ` (existing file labels ${r.existingHorizonHours ?? "no"} h, not ${horizonHours} h; rerun with --overwrite)` : ""}`);
+        }
+        if (pm) {
+            notes.push(`pm ${pm.labelled} new settled outcome(s) from ${pm.events} event(s)${pm.failed ? `, ${pm.failed} read(s) failed` : ""}`);
+            const hasPm = Object.keys(pm.pm).length > 0;
+            if (opts.overwrite) {
+                // --overwrite REPLACES the PM part, even with nothing: a label that
+                // was settled before but is void/unresolved now must not survive.
+                const base = file ?? corpus.labels[r.id];
+                if (base || hasPm) {
+                    const { pm: _replaced, ...rest } = base ?? {};
+                    file = hasPm ? { ...rest, pm: pm.pm } : rest;
+                }
+            }
+            else if (pm.labelled > 0 || (file && hasPm))
+                file = { ...(file ?? corpus.labels[r.id] ?? {}), pm: pm.pm };
+        }
+        lines.push(`${r.id}: ${notes.join("; ")}`);
+        if (!file)
+            continue;
+        const path = join(dir, "labels", `${r.id}.json`);
+        // The bench reads it back through the same validator; fail closed here.
+        parseLabelFile(file, `labels/${r.id}.json`);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+        written += 1;
+    }
+    lines.push(`wrote ${written} label file(s); PM outcomes without a settled platform verdict stay unlabelled`);
+    return { ok: true, code: 0, lines, data: { prices: results, pm: pmResults } };
+}
+// Compare agent variants on a recorded corpus (see bench/bench.ts). Each
+// variant runs with its own model, built exactly as `run` builds it from the
+// variant's model config and the environment's keys. Never writes.
+export async function cmdBench(opts = {}) {
+    if (!opts.corpus)
+        return fail(["bench needs --corpus <dir>"]);
+    if (!opts.variants || opts.variants.length === 0)
+        return fail(["bench needs at least one --variant name=<agentPath>"]);
+    if (opts.seed !== undefined &&
+        (!Number.isSafeInteger(opts.seed) || opts.seed < 0))
+        return fail(["--seed must be a non-negative integer"]);
+    let corpus;
+    try {
+        corpus = readCorpus(resolvePath(opts.corpus));
+    }
+    catch (e) {
+        return fail([e.message]);
+    }
+    const variants = [];
+    for (const arg of opts.variants) {
+        const eq = arg.indexOf("=");
+        if (eq <= 0 || eq === arg.length - 1)
+            return fail([`--variant "${arg}" must look like name=<agentPath>`]);
+        const name = arg.slice(0, eq);
+        const agentPath = arg.slice(eq + 1);
+        let loaded;
+        try {
+            loaded = loadAgent(agentPath, "self-host");
+        }
+        catch (e) {
+            if (e instanceof ResolveError)
+                return issuesResult(e.issues, `variant ${name}: resolve failed`);
+            throw e;
+        }
+        let provider;
+        try {
+            provider = opts.providerFor
+                ? opts.providerFor(loaded.spec)
+                : selectProvider(loaded.spec, process.env, fetch);
+        }
+        catch (e) {
+            return fail([`variant ${name}: ${e.message}`]);
+        }
+        variants.push({
+            name,
+            spec: loaded.spec,
+            mergedProse: runtimeProse(loaded.resolved),
+            provider,
+        });
+    }
+    const lines = [
+        `bench DRY-RUN: ${corpus.cassettes.length} cassette(s) x ${variants.length} variant(s) x ${opts.repeats ?? 3} repeat(s)`,
+    ];
+    if (corpus.ignored.length)
+        lines.push(`ignored non-cassette file(s): ${corpus.ignored.join(", ")}`);
+    let report;
+    try {
+        report = await runBench({
+            cassettes: corpus.cassettes,
+            labels: corpus.labels,
+            variants,
+            repeats: opts.repeats,
+            seed: opts.seed,
+            baselines: opts.baselines,
+        });
+    }
+    catch (e) {
+        return fail([...lines, `✗ ${e.message}`]);
+    }
+    const summary = report.variants;
+    for (const [name, v] of Object.entries(summary)) {
+        const codes = Object.entries(v.all.actions.rejectCodes)
+            .map(([c, n]) => `${c} ${n}`)
+            .join(", ");
+        lines.push(`${name}: ${v.all.cycles} cycle(s), accepted ${v.all.actions.accepted}, rejected ${v.all.actions.rejected}${codes ? ` (${codes})` : ""}, model failures ${v.all.modelFailures}, cycles missing inputs ${v.all.cyclesWithMissingInputs}, repeat consistency ${v.all.repeatConsistency ?? "n/a"}`);
+    }
+    for (const c of report.comparisons) {
+        const accepted = c.all.metrics.acceptedActions;
+        lines.push(`${c.a} vs ${c.b}: overlap ${c.all.actionOverlapJaccard ?? "n/a"}, accepted diff ${accepted.meanDiff ?? "n/a"} (95% CI ${accepted.ci95 ? `${accepted.ci95[0]}..${accepted.ci95[1]}` : "n/a"}, n=${accepted.n})`);
+    }
+    if (opts.out) {
+        writeFileSync(resolvePath(opts.out), `${JSON.stringify(report, null, 2)}\n`, "utf8");
+        lines.push(`wrote ${resolvePath(opts.out)}`);
+    }
+    lines.push(`contentHash ${report.contentHash}`);
+    return { ok: true, code: 0, lines, data: report };
+}
 function parseFlags(args) {
     const out = { _: [] };
+    // A missing or non-numeric value becomes NaN so the command rejects it,
+    // never silently falls back to its default.
+    const num = (v) => (v === undefined ? NaN : Number(v));
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
         if (a === "--hosted")
@@ -462,6 +713,26 @@ function parseFlags(args) {
             out.state = args[++i];
         else if (a === "--expect-definition")
             out.expectDefinition = args[++i] ?? "";
+        else if (a === "--out")
+            out.out = args[++i];
+        else if (a === "--cycles")
+            out.cycles = num(args[++i]);
+        else if (a === "--every")
+            out.every = args[++i] ?? "";
+        else if (a === "--corpus")
+            out.corpus = args[++i];
+        else if (a === "--variant")
+            out.variant = [...(out.variant ?? []), args[++i] ?? ""];
+        else if (a === "--repeats")
+            out.repeats = num(args[++i]);
+        else if (a === "--seed")
+            out.seed = num(args[++i]);
+        else if (a === "--no-baselines")
+            out.noBaselines = true;
+        else if (a === "--horizon-hours")
+            out.horizonHours = num(args[++i]);
+        else if (a === "--overwrite")
+            out.overwrite = true;
         else
             out._.push(a);
     }
@@ -476,6 +747,9 @@ function usageLines() {
         "  eject <agent.md | dir>",
         "  lock <path>",
         "  run <path> [--once] [--live] [--dry-run] [--state <file>] [--expect-definition sha256:...]   (dry-run by default)",
+        "  record <path> --out <dir> [--cycles N] [--every 5m]   (bench inputs; reads only, no model call)",
+        "  bench --corpus <dir> --variant a=<path> --variant b=<path> [--repeats 3] [--seed N] [--no-baselines] [--out report.json]",
+        "  label --corpus <dir> [--horizon-hours 24] [--overwrite]   (price outcome labels after asOf; reads only)",
     ];
 }
 export async function main(argv) {
@@ -513,6 +787,30 @@ export async function main(argv) {
             });
             break;
         }
+        case "record":
+            r = await cmdRecord(pos[0] ?? ".", {
+                out: flags.out,
+                cycles: flags.cycles,
+                every: flags.every,
+            });
+            break;
+        case "label":
+            r = await cmdLabel({
+                corpus: flags.corpus,
+                horizonHours: flags.horizonHours,
+                overwrite: flags.overwrite,
+            });
+            break;
+        case "bench":
+            r = await cmdBench({
+                corpus: flags.corpus,
+                variants: flags.variant,
+                repeats: flags.repeats,
+                seed: flags.seed,
+                out: flags.out,
+                baselines: !flags.noBaselines,
+            });
+            break;
         case undefined:
         case "help":
         case "--help":

package/dist/agent/client.d.ts

@@ -1,3 +1,4 @@
+import { type PmPaperOpen, type PmPaperClose } from "../pmPaperV2.js";
 import { AgentTrace, ApiResult } from "./types.js";
 export declare const DEFAULT_BASE_URL = "https://api.coinrithm.com";
 export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
@@ -53,6 +54,7 @@ export declare class CoinRithmClient {
     }, trace?: AgentTrace): Promise<ApiResult>;
     resolve(q: string, trace?: AgentTrace): Promise<ApiResult>;
     cryptoMovers(direction: "gainers" | "losers", limit: number, trace?: AgentTrace): Promise<ApiResult>;
+    agentUniverse(query: Record<string, string | number>, trace?: AgentTrace): Promise<ApiResult>;
     getPublicPmWhales(options?: {
         timeoutMs?: number;
         limit?: number;
@@ -85,6 +87,10 @@ export declare class CoinRithmClient {
         side: string;
         quantity: number;
     }, trace?: AgentTrace): Promise<ApiResult>;
+    discoverPmPaperV2(query?: {
+        q?: string;
+        limit?: number;
+    }, trace?: AgentTrace): Promise<ApiResult>;
     discoverPmMarkets(query?: {
         q?: string;
         source?: string;
@@ -142,6 +148,14 @@ export declare class CoinRithmClient {
         agentTrace?: AgentTrace;
     }): Promise<ApiResult>;
     cancelSpotOrder(orderId: number, idempotencyKey?: string, trace?: AgentTrace): Promise<ApiResult>;
+    openPmPaperV2(body: PmPaperOpen): Promise<ApiResult>;
+    replayPmPaperV2Open(body: PmPaperOpen): Promise<ApiResult>;
+    closePmPaperV2(body: PmPaperClose): Promise<ApiResult>;
+    pmPaperV2Positions(query?: {
+        status?: "open";
+        beforeId?: number;
+        limit?: number;
+    }): Promise<ApiResult>;
     openPmPosition(body: {
         source: string;
         slug: string;

package/dist/agent/client.js

@@ -1,9 +1,4 @@
-// Thin CoinRithm agent-API client for the runner (futures-focused v1).
-//
-// Auth: the user's own crk_live_ key from COINRITHM_API_KEY (env only — never
-// from an agent file). 429 backs off on Retry-After; 401/403/409/422 are
-// FAIL-CLOSED cycle outcomes (returned, not retried). fetch + sleep are
-// injectable so tests run with no network and no real waits.
+import { PM_PAPER_V2_BASE, } from "../pmPaperV2.js";
 import { createHash } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 import { retryAfterSeconds } from "../retryAfter.js";
@@ -283,6 +278,12 @@ export class CoinRithmClient {
             ? "/api/coins/top-losers"
             : "/api/coins/top-gainers", { query: { limit }, trace });
     }
+    // Market-boundaries screener (GET /api/agent/universe, read scope): rows
+    // inside the agent's declared rank band / volume floor / sectors, sorted by
+    // the agent's notion of an opportunity. Shared 60 s server cache.
+    agentUniverse(query, trace) {
+        return this.request("GET", "/api/agent/universe", { query, trace });
+    }
     getPublicPmWhales(options) {
         return this.publicRequest("/api/prediction-markets/whales", { limit: options?.limit }, options?.timeoutMs);
     }
@@ -322,6 +323,9 @@ export class CoinRithmClient {
         });
     }
     // ── prediction markets ───────────────────────────────────────────────────
+    discoverPmPaperV2(query, trace) {
+        return this.request("GET", "/api/agent/pm/v2/discover", { query, trace });
+    }
     discoverPmMarkets(query, trace) {
         return this.request("GET", "/api/agent/pm/discover", { query, trace });
     }
@@ -361,6 +365,19 @@ export class CoinRithmClient {
             trace,
         });
     }
+    // Explicit opt-in contract; API derives and authorizes the configured house tuple.
+    openPmPaperV2(body) {
+        return this.request("POST", `${PM_PAPER_V2_BASE}/open`, { body });
+    }
+    replayPmPaperV2Open(body) {
+        return this.request("POST", `${PM_PAPER_V2_BASE}/open/replay`, { body });
+    }
+    closePmPaperV2(body) {
+        return this.request("POST", `${PM_PAPER_V2_BASE}/close`, { body });
+    }
+    pmPaperV2Positions(query) {
+        return this.request("GET", `${PM_PAPER_V2_BASE}/positions`, { query });
+    }
     openPmPosition(body) {
         return this.request("POST", "/api/agent/pm/open", { body });
     }

package/dist/agent/configurationWarnings.js

@@ -1,6 +1,17 @@
+// Per-day counters roll over on the UTC date (util.ts dayKey), whatever the
+// bundle declares. trigger.timezone is parsed but read by nothing else, so a
+// non-UTC value would silently promise local-day limits.
+const UTC_NAMES = new Set(["utc", "etc/utc", "z", "gmt", "etc/gmt"]);
 // Advisory only: these fields remain loadable for backwards compatibility.
 export function configurationWarnings(raw) {
     const warnings = [];
+    const trigger = raw.trigger;
+    if (trigger && typeof trigger === "object" && !Array.isArray(trigger)) {
+        const tz = trigger.timezone;
+        if (typeof tz === "string" && !UTC_NAMES.has(tz.trim().toLowerCase())) {
+            warnings.push(`trigger.timezone "${tz}" is informational: maxTradesPerDay and maxDailyLossMusd reset at 00:00 UTC, not in this timezone`);
+        }
+    }
     if (Array.isArray(raw.capabilities) &&
         raw.capabilities.includes("websearch")) {
         warnings.push("capabilities.websearch is reserved: the runner does not perform web searches");

package/dist/agent/decision.d.ts

@@ -13,24 +13,24 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     thesis: z.ZodOptional<z.ZodEffects<z.ZodAny, import("./types.js").Thesis | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     symbol: string;
-    side: "long" | "short";
     type: "futures_open";
+    side: "long" | "short";
+    thesis?: import("./types.js").Thesis | undefined;
     leverage?: any;
     marginMusd?: any;
     stopLossPrice?: any;
     takeProfitPrice?: any;
-    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
 }, {
     symbol: string;
-    side: "long" | "short";
     type: "futures_open";
+    side: "long" | "short";
+    thesis?: any;
     leverage?: unknown;
     marginMusd?: unknown;
     stopLossPrice?: unknown;
     takeProfitPrice?: unknown;
-    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
 }>, z.ZodObject<{
@@ -42,16 +42,16 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     thesis: z.ZodOptional<z.ZodEffects<z.ZodAny, import("./types.js").Thesis | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     type: "futures_close";
+    thesis?: import("./types.js").Thesis | undefined;
     positionId?: any;
     fraction?: any;
-    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
 }, {
     type: "futures_close";
+    thesis?: any;
     positionId?: unknown;
     fraction?: unknown;
-    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
 }>, z.ZodObject<{
@@ -64,18 +64,18 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     thesis: z.ZodOptional<z.ZodEffects<z.ZodAny, import("./types.js").Thesis | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     type: "futures_set_sltp";
+    thesis?: import("./types.js").Thesis | undefined;
+    positionId?: any;
     stopLossPrice?: any;
     takeProfitPrice?: any;
-    positionId?: any;
-    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
 }, {
     type: "futures_set_sltp";
+    thesis?: any;
+    positionId?: unknown;
     stopLossPrice?: unknown;
     takeProfitPrice?: unknown;
-    positionId?: unknown;
-    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
 }>, z.ZodObject<{
@@ -91,24 +91,24 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     thesis: z.ZodOptional<z.ZodEffects<z.ZodAny, import("./types.js").Thesis | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     symbol: string;
+    type: "spot_order";
     side: "buy" | "sell";
     orderType: "limit" | "market" | "stop";
-    type: "spot_order";
+    thesis?: import("./types.js").Thesis | undefined;
     quantity?: any;
     limitPrice?: any;
     stopPrice?: any;
-    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
 }, {
     symbol: string;
+    type: "spot_order";
     side: "buy" | "sell";
     orderType: "limit" | "market" | "stop";
-    type: "spot_order";
+    thesis?: any;
     quantity?: unknown;
     limitPrice?: unknown;
     stopPrice?: unknown;
-    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
 }>, z.ZodObject<{
@@ -145,9 +145,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     source?: string | undefined;
     slug?: string | undefined;
     outcomeExternalMarketId?: string | undefined;
-    stakeMusd?: any;
     forecastProbability?: number | undefined;
     thesis?: import("./types.js").Thesis | undefined;
+    stakeMusd?: any;
     confidence?: any;
     rationaleSummary?: string | undefined;
     ref?: string | undefined;
@@ -156,9 +156,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     source?: string | undefined;
     slug?: string | undefined;
     outcomeExternalMarketId?: string | undefined;
-    stakeMusd?: unknown;
     forecastProbability?: any;
     thesis?: any;
+    stakeMusd?: unknown;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
     ref?: string | undefined;
@@ -537,11 +537,19 @@ export declare const DECISION_JSON_SCHEMA: {
         };
     }];
 };
+export declare const ACTIONS_STRING_DIAGNOSTICS: readonly ["json_array_empty_valid_decision", "json_array_nonempty_valid_decision", "json_array_invalid_decision", "json_nonarray", "invalid_json", "empty_string_valid_skip", "empty_string_other_decision", "non_json_array_text", "json5_array_valid_decision", "json5_array_invalid_decision", "over_size_limit"];
+export type ActionsStringDiagnostic = (typeof ACTIONS_STRING_DIAGNOSTICS)[number];
 export type ParseDecisionResult = {
     ok: true;
     decision: Decision;
 } | {
     ok: false;
     error: string;
+    actionsStringDiagnostic?: ActionsStringDiagnostic;
 };
 export declare function parseDecision(text: string): ParseDecisionResult;
+/** Only the trusted host selects a versioned contract; default stays legacy. */
+export declare function parseDecisionForContract(text: string, contract?: "pm_paper_v2"): ParseDecisionResult | {
+    ok: true;
+    decision: z.infer<typeof import("./pmPaperDecision.js").pmPaperDecisionSchema>;
+};