@coinrithm/mcp-trading 0.7.15 → 0.7.16

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

@@ -53,6 +53,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;

package/dist/agent/client.js

@@ -283,6 +283,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);
     }

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

@@ -537,11 +537,14 @@ 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;

package/dist/agent/decision.js

@@ -3,6 +3,7 @@
 // JSON, an unknown action type, a free-form endpoint/tool name, extra unknown
 // fields, or a missing required field — fails closed (the runner skips).
 import { z } from "zod";
+import JSON5 from "json5";
 import { coerceThesis } from "./thesis.js";
 // Small models (especially Llama 3.1 8B) frequently emit numbers as JSON strings
 // ("12345", "0.8", "62000"). Coerce a *clean* numeric string to a number before
@@ -363,15 +364,95 @@ function coerceJson(text) {
     }
     return JSON.parse(s); // throws on invalid JSON -> caller treats as fail-closed
 }
+// Fixed, non-content diagnostics only. Never retain model text, identifiers,
+// action values or reasoning to investigate a provider's encoding failures.
+export const ACTIONS_STRING_DIAGNOSTICS = [
+    "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",
+];
+function diagnoseActionsString(obj) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj))
+        return undefined;
+    const record = obj;
+    if (typeof record.actions !== "string")
+        return undefined;
+    if (record.actions.length > 65_536)
+        return "over_size_limit";
+    const text = record.actions.trim();
+    if (text === "") {
+        return record.decision === "skip" &&
+            decisionSchema.safeParse({ ...record, actions: [] }).success
+            ? "empty_string_valid_skip"
+            : "empty_string_other_decision";
+    }
+    let actions;
+    try {
+        actions = JSON.parse(record.actions);
+    }
+    catch {
+        if (!text.startsWith("["))
+            return "invalid_json";
+        // Diagnostic only: identify alternate literal encodings without accepting
+        // them or retaining content. JSON5 never evaluates expressions. Requiring
+        // finite JSON values keeps Infinity/NaN from looking like usable actions.
+        try {
+            const candidate = JSON5.parse(text);
+            JSON.stringify(candidate, (key, value) => {
+                if (["__proto__", "constructor", "prototype"].includes(key) ||
+                    (typeof value === "number" && !Number.isFinite(value)))
+                    throw new Error("Unsafe diagnostic value");
+                return value;
+            });
+            return Array.isArray(candidate) &&
+                decisionSchema.safeParse({ ...record, actions: candidate }).success
+                ? "json5_array_valid_decision"
+                : "json5_array_invalid_decision";
+        }
+        catch {
+            return "non_json_array_text";
+        }
+    }
+    if (!Array.isArray(actions))
+        return "json_nonarray";
+    if (!decisionSchema.safeParse({ ...record, actions }).success)
+        return "json_array_invalid_decision";
+    return actions.length === 0
+        ? "json_array_empty_valid_decision"
+        : "json_array_nonempty_valid_decision";
+}
+function safeIssueMessage(issue) {
+    // These Zod messages echo model-supplied values or unknown field names.
+    // Other messages in this fixed schema describe types or contract limits.
+    switch (issue.code) {
+        case "invalid_enum_value":
+            return "Invalid enum value";
+        case "invalid_literal":
+            return "Invalid literal value";
+        case "unrecognized_keys":
+            return "Unrecognized field(s)";
+        default:
+            return issue.message;
+    }
+}
 export function parseDecision(text) {
     let obj;
     try {
         obj = normalizeDecisionVerb(coerceJson(text));
     }
-    catch (err) {
+    catch {
         return {
             ok: false,
-            error: `model output is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            // Node's JSON syntax errors can include excerpts of private model text.
+            error: "model output is not valid JSON",
         };
     }
     const res = decisionSchema.safeParse(obj);
@@ -379,8 +460,9 @@ export function parseDecision(text) {
         return {
             ok: false,
             error: res.error.issues
-                .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+                .map((i) => `${i.path.join(".") || "(root)"}: ${safeIssueMessage(i)}`)
                 .join("; "),
+            actionsStringDiagnostic: diagnoseActionsString(obj),
         };
     }
     const d = res.data;

package/dist/agent/decisionValidator.d.ts

@@ -20,7 +20,37 @@ export interface DecisionContext {
     realizedLossTodayMusd: number;
     targetedPositionIds: number[];
     targetedOrderIds: number[];
+    pmEventsOpenedThisCycle?: string[];
+    pmCoinHorizonsOpenedThisCycle?: PmCoinHorizon[];
+    nowMs?: number;
 }
+/**
+ * Edge (points) risk.pmMinEdgeGapPct requires at a fee-inclusive entry cost:
+ * pct% of the room left to 100. Cost at or above 100 leaves no room, so any
+ * positive gap rule makes the requirement unreachable rather than zero.
+ */
+export declare function requiredGapEdgePoints(entryPct: number, gapPct: number): number;
+/** Ends within this of each other share a coin horizon (venue date splits). */
+export declare const PM_COIN_HORIZON_WINDOW_MS: number;
+/** An end beyond this is a venue sentinel, never a real horizon. */
+export declare const PM_PLAUSIBLE_END_MAX_MS: number;
+export interface PmCoinHorizon {
+    coins: string[];
+    endMs: number;
+}
+/** The later of observation.asOf and the validation clock, when known. */
+export declare function pmReferenceMs(asOf: string, nowMs?: number): number;
+/**
+ * The coin horizon of a market or held position, or null when it cannot be
+ * grouped: no linked coin, or an end that is missing, unparseable, not after
+ * the reference time, or more than 5 years after it (venue sentinels).
+ */
+export declare function pmCoinHorizonOf(item: {
+    coins?: string[];
+    endDate?: string;
+}, refMs: number): PmCoinHorizon | null;
+/** Event key shared by pm_open actions, held positions and markets. */
+export declare function pmEventKey(source: string, slug: string): string;
 /**
  * True when a thesis says, in so many words, that it is betting AGAINST the
  * outcome the action is buying. Deliberately narrow: it fires only when the