@coinrithm/mcp-trading 0.7.2 → 0.7.3

package/dist/agent/prompt.js

@@ -33,18 +33,24 @@ export function formatPmResolutions(resolutions) {
         `Resolved since last cycle: ${items.join("; ")}.`,
     ];
 }
-export function buildSystemPrompt(spec, mergedProse) {
+export function buildSystemPrompt(spec, mergedProse, 
+// includeForecast (default OFF here; the runner passes the house-agent flag):
+// when true, pm_open asks the model for its OWN independent forecastProbability
+// (1..99) — its probability the backed side wins, judged from the question, NOT
+// echoed from the market price. This feeds the agent's public calibration record.
+opts = {}) {
     const r = spec.risk;
     const v = spec.venues;
+    const includeForecast = opts.includeForecast === true;
     const actions = [];
     if (v.includes("futures")) {
-        actions.push('{"type":"futures_open","symbol","side":"long"|"short","leverage","marginMusd","stopLossPrice","takeProfitPrice","confidence":0..1}', '{"type":"futures_close","positionId","fraction"}', '{"type":"futures_set_sltp","positionId","stopLossPrice","takeProfitPrice"}', 'FUTURES TRIGGER RULES (the server rejects the WHOLE open otherwise): a LONG\'s takeProfitPrice must be ABOVE the current mark and stopLossPrice BELOW it (and above liquidationPrice); a SHORT is inverted (TP below mark, SL above). Every open position in observation.openPositions shows entryPrice, markPrice, liquidationPrice, stopLossPrice, takeProfitPrice — read them and place triggers on the correct side. NEVER attach stopLossPrice/takeProfitPrice to a futures_open for a symbol you ALREADY hold (the server treats it as an add and rejects it) — adjust that position with futures_set_sltp on its positionId instead.');
+        actions.push('{"type":"futures_open","symbol","side":"long"|"short","leverage","marginMusd","stopLossPrice","takeProfitPrice","confidence":0..1}', '{"type":"futures_close","positionId","fraction"}', '{"type":"futures_set_sltp","positionId","stopLossPrice","takeProfitPrice"}', "FUTURES TRIGGER RULES (the server rejects the WHOLE open otherwise): a LONG's takeProfitPrice must be ABOVE the current mark and stopLossPrice BELOW it (and above liquidationPrice); a SHORT is inverted (TP below mark, SL above). Every open position in observation.openPositions shows entryPrice, markPrice, liquidationPrice, stopLossPrice, takeProfitPrice — read them and place triggers on the correct side. NEVER attach stopLossPrice/takeProfitPrice to a futures_open for a symbol you ALREADY hold (the server treats it as an add and rejects it) — adjust that position with futures_set_sltp on its positionId instead.");
     }
     if (v.includes("spot")) {
         actions.push('{"type":"spot_order","symbol","side":"buy"|"sell","orderType":"market"|"limit"|"stop","quantity","limitPrice","stopPrice","confidence":0..1}', '{"type":"spot_cancel","orderId"}');
     }
     if (v.includes("pm")) {
-        actions.push('{"type":"pm_open","ref":"pmN","stakeMusd","confidence":0..1}  (set "ref" to the `ref` of the ONE observation.pmMarkets entry you are betting — e.g. "pm3" — copied EXACTLY; stakeMusd >= 10)');
+        actions.push(`{"type":"pm_open","ref":"pmN","stakeMusd","confidence":0..1${includeForecast ? ',"forecastProbability":1..99' : ""}}  (set "ref" to one of the refs listed THIS cycle (pm1..pmN) — the \`ref\` of the ONE observation.pmMarkets entry you are betting, e.g. "pm3", copied EXACTLY; a ref NOT in this cycle's list is rejected as pm_ref_unknown and wastes the cycle; stakeMusd >= 10${includeForecast ? '; set "forecastProbability" to YOUR OWN probability 1-99 that this outcome wins — see the forecast rule below' : ""})`);
     }
     return [
         "You operate a CoinRithm PAPER-TRADING agent (simulated 50,000 mUSD; not real money, not financial advice).",
@@ -65,7 +71,12 @@ export function buildSystemPrompt(spec, mergedProse) {
             : []),
         "- prediction markets are a FIRST-CLASS venue for you — a pm_open is as real a trade as a futures/spot open, not an afterthought. Each observation.pmMarkets entry carries a short `ref` (pm1, pm2, …), an `outcome` label, and `prob` (0..1, the market's CURRENT odds). BET (pm_open) an outcome when YOUR estimate of its true probability differs MATERIALLY from the market's — that gap is your edge (e.g. prob 0.35 but you think it's really ~0.55 -> buy). Skip only markets pinned near 0 or 1 (no edge left). Every entry in observation.pmMarkets is already filtered to one you CAN open (binary/settlement-grade) — so a listed market will not bounce at quote. Pick ONLY a listed market and identify it by copying its `ref` into the action; min stake 10 mUSD. Do NOT re-bet a market+outcome you ALREADY hold (check observation.pmPositions) — that is churn and will be rejected; bet a DIFFERENT market or skip.",
         "- PM stake is a SEPARATE budget from your futures margin: the futures margin cap (maxOpenMarginMusd) does NOT limit pm_open. So when your futures are at the margin/position cap — you hold the max, or a futures_open keeps getting REJECTED with open_margin_exceeds_cap — prediction markets are STILL fully open to you. PIVOT to pm_open on a mispriced market instead of re-proposing a futures_open that will just be rejected: a rejected open wastes the entire cycle, an eligible PM bet does not.",
-        "- YOUR SHARPEST PM EDGE is the crypto price view you JUST formed: crypto PM markets resolve on the very prices you analyse, so you have a genuine information edge there that you do NOT have on coin futures alone. EVERY cycle you reach a price conviction, it is REQUIRED that you scan observation.pmMarkets for a crypto market that same view prices wrong and, if one is materially mispriced, open it with pm_open — treat that mispricing exactly like a flagged coin setup (an ACT, not a skip). If you are bearish BTC, a 'BTC above $X by <date>' priced high is a NO; if bullish ETH, an 'ETH above $Y' priced low is a YES. Leaving a clearly mispriced crypto market untraded is the same mistake as ignoring a flagged setup. (For non-crypto events you have no special edge; skip unless the odds are obviously off.)",
+        "- YOUR SHARPEST PM EDGE is the crypto price view you JUST formed: crypto PM markets resolve on the very prices you analyse, so you have a genuine information edge there that you do NOT have on coin futures alone. EVERY cycle you reach a price conviction, it is REQUIRED that you scan observation.pmMarkets for a LISTED crypto market that same view prices wrong and, if one is materially mispriced, open it with pm_open by its `ref` — treat that mispricing exactly like a flagged coin setup (an ACT, not a skip). If you are bearish BTC, a 'BTC above $X by <date>' priced high is a NO; if bullish ETH, an 'ETH above $Y' priced low is a YES. ESCAPE HATCH — only the markets actually listed in observation.pmMarkets THIS cycle (pm1..pmN) are bettable: if NONE of them matches the coin or view you formed, that is a legitimate SKIP for PM (say so in one clause and move on) — do NOT invent, guess, or increment a ref for a market you wish existed, because a made-up ref is rejected (pm_ref_unknown) and wastes the whole cycle exactly like a rejected open. The mistake to avoid is leaving a LISTED, clearly mispriced crypto market untraded — a mispricing that is NOT on this cycle's board is simply not actionable now, not a miss. (For non-crypto events you have no special edge; skip unless the odds are obviously off.)",
+        ...(includeForecast
+            ? [
+                "- FORECAST RULE (pm_open forecastProbability): before you look at what the market is pricing, decide YOUR OWN probability the outcome you are backing actually WINS — reason ONLY from the question, its resolution criteria, and the deadline. Put that number (1-99, whole or one decimal) in `forecastProbability`. This is graded against reality as your PUBLIC calibration record, so it must be YOUR judgement, NOT the market's: do NOT copy, round, or anchor it to the observation.pmMarkets `prob`. It is FINE if your honest forecast happens to land on the market's number — but reaching that by echoing the price defeats the point. If you genuinely cannot form an independent view, OMIT the field rather than parroting the market (an absent forecast is better than a fake one, and it never blocks the bet).",
+            ]
+            : []),
         `- abstention.minConfidence ${spec.abstention.minConfidence}: opens below this are rejected, so act with genuine conviction — but routine caution is no reason to sit out a clear setup`,
         ...(spec.capabilities.includes("indicators")
             ? [
@@ -95,14 +106,14 @@ export function buildSystemPrompt(spec, mergedProse) {
         "",
         "## How to act — a decisive trader in character, not a bystander",
         "You ARE the character in the strategy above; trade like it. When you have a clear read — even a moderate-confidence one — TAKE THE POSITION, sized within your caps and protected with a stop. You wake every cycle and people watch you live: an agent that watches forever and never commits is useless to them and to itself.",
-        'Skip ONLY when the read is genuinely contradictory (signals fight each other), the data is stale, or you truly have no edge this cycle. A quiet tape where your thesis still has a small but REAL edge is an ACT, not a skip — take it, small, with a stop. Do not confuse caution with paralysis.',
+        "Skip ONLY when the read is genuinely contradictory (signals fight each other), the data is stale, or you truly have no edge this cycle. A quiet tape where your thesis still has a small but REAL edge is an ACT, not a skip — take it, small, with a stop. Do not confuse caution with paralysis.",
         'In "rationale" (shown LIVE in your public terminal) speak in YOUR voice and commit to a view in 1-2 vivid, specific sentences — what you see and what you are DOING about it, like a trader posting their move, not a risk report. Good: "ETH punched through the weekly high on real volume — long here with a stop under the breakout, this is exactly my setup." Weak: "conditions are mixed, waiting for clarity." Keep "reason" a short label.',
         "",
         "## Flagged setups this cycle — your wake-up list (observation.setups)",
         "A deterministic scan already checked every watchlist coin and put the ones with real, tradeable structure RIGHT NOW into observation.setups — each has symbol, kind, bias, strength, and a factual note (trend / RSI / breakout / ATR reads). This is your shortlist; you do NOT need to re-derive whether a setup exists.",
         '- If observation.setups is NON-EMPTY: act on the strongest one that fits YOUR strategy. The `bias` is the trend-following read; if you are a contrarian / mean-reversion trader, FADE it with the same facts (e.g. a downtrend that is also "RSI oversold" is YOUR long). Skipping a flagged setup needs a SPECIFIC reason tied to your thesis — "no clear setup" is NOT a valid skip when setups are listed.',
         "- If observation.setups is EMPTY: no coin has a flagged structure right now — but BEFORE you skip, check observation.pmMarkets for a crypto market your current read prices wrong (a PM mispricing is a valid ACT even with zero coin setups). Only then, if nothing is mispriced, skip new entries and just manage any open positions.",
-        '- A setup tagged `held` (held: long|short) is a position you ALREADY hold. Do NOT propose a new open on it — that only hits the margin cap and wastes the cycle. MANAGE it instead: trail the stop toward your target, ADD only if you have margin room AND fresh conviction, or cut if the thesis broke.',
+        "- A setup tagged `held` (held: long|short) is a position you ALREADY hold. Do NOT propose a new open on it — that only hits the margin cap and wastes the cycle. MANAGE it instead: trail the stop toward your target, ADD only if you have margin room AND fresh conviction, or cut if the thesis broke.",
         "",
         "## After you act — hold with conviction, do not churn",
         "A position is a thesis that needs TIME to work. Once you are in WITH a stop, let the stop or your target close it: do NOT bail on the next cycle over a small adverse tick, and do NOT manually close a fresh position unless the thesis is structurally invalidated (the level broke, the trend flipped) — not merely because price wiggled against you. A trade opened and closed minutes later just donates the round-trip fee + spread to noise.",

package/dist/agent/providers.js

@@ -32,7 +32,9 @@ const DEFAULT_TIMEOUT_MS = 300_000;
 // instruct mode (measured ~3-4s, clean JSON). Apply it automatically for any
 // nemotron model so a per-cadence decision never blows the cadence.
 function applyReasoningToggle(model, system) {
-    return /nemotron/i.test(model) ? `detailed thinking off\n\n${system}` : system;
+    return /nemotron/i.test(model)
+        ? `detailed thinking off\n\n${system}`
+        : system;
 }
 // fetch with a hard timeout via AbortController. A custom fetchFn (tests) that
 // ignores `signal` still works — the timer just never fires for it.
@@ -66,6 +68,8 @@ function envKey(provider, env) {
             return env.GEMINI_API_KEY ?? env.MODEL_API_KEY;
         case "openai-compatible":
             return env.MODEL_API_KEY ?? env.OPENAI_API_KEY;
+        case "mechanical":
+            return undefined; // no LLM, no key — selectProvider short-circuits before this matters
     }
 }
 function baseUrlFor(provider, configured) {
@@ -82,6 +86,25 @@ function baseUrlFor(provider, configured) {
             return (configured ?? "").replace(/\/+$/, "");
         case "anthropic":
             return "https://api.anthropic.com/v1";
+        case "mechanical":
+            return ""; // never used — mechanical agents make no HTTP call
+    }
+}
+// Non-LLM stub for the mechanical BENCHMARK agents. It satisfies the Provider
+// contract so the deps stay non-null, but decide() is NEVER invoked: runCycle
+// detects a mechanical agent and computes the decision deterministically before
+// the provider is asked. If it is ever called, it fails closed (loudly) rather
+// than silently pretending to reason.
+class MechanicalProvider {
+    label;
+    constructor(strategy) {
+        this.label = `mechanical/${strategy}`;
+    }
+    async decide() {
+        return {
+            ok: false,
+            error: "mechanical benchmark provider has no model — runCycle must short-circuit before decide() (this call is a bug)",
+        };
     }
 }
 class AnthropicProvider {
@@ -127,7 +150,9 @@ class AnthropicProvider {
                     completionTokens: json.usage.output_tokens ?? 0,
                 }
                 : undefined;
-            return text ? { ok: true, text, usage } : { ok: false, error: "anthropic returned empty content" };
+            return text
+                ? { ok: true, text, usage }
+                : { ok: false, error: "anthropic returned empty content" };
         }
         catch (err) {
             return { ok: false, error: callError(err, timeoutMs) };
@@ -162,7 +187,10 @@ class OpenAiCompatProvider {
                     max_tokens: input.maxTokens ?? 1024,
                     response_format: { type: "json_object" },
                     messages: [
-                        { role: "system", content: applyReasoningToggle(this.model, input.system) },
+                        {
+                            role: "system",
+                            content: applyReasoningToggle(this.model, input.system),
+                        },
                         { role: "user", content: input.user },
                     ],
                 }),
@@ -182,7 +210,9 @@ class OpenAiCompatProvider {
                     completionTokens: json.usage.completion_tokens ?? 0,
                 }
                 : undefined;
-            return text ? { ok: true, text, usage } : { ok: false, error: "provider returned empty content" };
+            return text
+                ? { ok: true, text, usage }
+                : { ok: false, error: "provider returned empty content" };
         }
         catch (err) {
             return { ok: false, error: callError(err, timeoutMs) };
@@ -197,6 +227,11 @@ export function selectProvider(spec, env, fetchFn = fetch) {
         throw new Error("no model configured: set model.provider + model.name in the agent (self-host needs an explicit model)");
     }
     const { provider, name, baseUrl } = spec.model;
+    // Mechanical benchmark agents need NO model key: they never call a model. Return
+    // the stub before the env-key requirement so a benchmark can be constructed with
+    // no ANTHROPIC/NVIDIA/etc. key present.
+    if (provider === "mechanical")
+        return new MechanicalProvider(name);
     const key = envKey(provider, env);
     if (!key) {
         const varName = provider === "anthropic"

package/dist/agent/resolve.js

@@ -15,7 +15,7 @@
 //     YAML/frontmatter feeds rawFrontmatter; only markdown bodies feed
 //     mergedProse.
 import { readFileSync, existsSync, statSync, lstatSync } from "node:fs";
-import { resolve as resolvePath, relative as relativePath, join, isAbsolute } from "node:path";
+import { resolve as resolvePath, relative as relativePath, join, isAbsolute, } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { parseFrontmatter } from "./frontmatter.js";
 import { sha256, toPosix, isPathInside, boundTail, scanForSecrets, } from "./util.js";
@@ -43,7 +43,6 @@ const CONFIG_BLOCKS = [
     "objective",
     "capabilities",
 ];
-const IDENTITY_KEYS = ["name", "description", "spec", "mode"];
 const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;
 // Optional prose files (markdown the LLM reads), in assembly order.
@@ -81,7 +80,11 @@ function rel(dir, abs) {
 function safePath(ctx, ref, label) {
     const syn = refSyntaxIssue(ref);
     if (syn) {
-        ctx.issues.push({ code: "unsafe_ref", path: ref, message: `${label} "${ref}": ${syn}` });
+        ctx.issues.push({
+            code: "unsafe_ref",
+            path: ref,
+            message: `${label} "${ref}": ${syn}`,
+        });
         return null;
     }
     const target = resolvePath(ctx.dir, ref);
@@ -221,7 +224,13 @@ function resolveSingleFile(abs) {
             },
         ]);
     }
-    const ctx = { dir, issues, hashes: {}, mergeOrder: [], seenLower: new Map() };
+    const ctx = {
+        dir,
+        issues,
+        hashes: {},
+        mergeOrder: [],
+        seenLower: new Map(),
+    };
     const r = toPosix(abs);
     ctx.hashes[r] = sha256(content);
     ctx.mergeOrder.push(r);
@@ -269,7 +278,13 @@ function loadSkillList(ctx, frontmatter) {
     return [];
 }
 function resolveDirectory(dir) {
-    const ctx = { dir, issues: [], hashes: {}, mergeOrder: [], seenLower: new Map() };
+    const ctx = {
+        dir,
+        issues: [],
+        hashes: {},
+        mergeOrder: [],
+        seenLower: new Map(),
+    };
     const keystoneAbs = findKeystone(dir);
     if (!keystoneAbs) {
         throw new ResolveError([
@@ -507,7 +522,9 @@ export function isSkillProseSource(source) {
 // blank line. The resolver uses this for mergedProse; the run path reuses it to
 // re-assemble a skills-ablated prompt deterministically.
 export function mergeProseParts(parts) {
-    return parts.map((p) => `<!-- ${p.source} -->\n${p.text.trim()}`).join("\n\n");
+    return parts
+        .map((p) => `<!-- ${p.source} -->\n${p.text.trim()}`)
+        .join("\n\n");
 }
 export function resolveAgent(inputPath) {
     const abs = resolvePath(inputPath);

package/dist/agent/resolvePm.js

@@ -35,13 +35,24 @@ export function resolvePmRef(action, pmMarkets) {
     if (ref) {
         const mkt = pmMarkets.find((m) => trimLower(m.ref) === ref);
         if (!mkt) {
-            const known = pmMarkets.length
-                ? `pm1..pm${pmMarkets.length}`
+            const listed = pmMarkets.length;
+            const known = listed
+                ? `pm1..pm${listed}`
                 : "(none discovered this cycle)";
+            // Trace-reading diagnostic (no behaviour change — still pm_ref_unknown). The
+            // refs are stamped contiguous pm1..pmN every cycle, so an unmatched ref is
+            // either INVENTED — its index runs past what was listed (or nothing was
+            // listed at all), i.e. the model made up a market that was never on the board
+            // (the pm_ref hallucination this guard exists for) — or STALE: an in-range ref
+            // that still doesn't match (e.g. carried over from a prior cycle's board).
+            const n = Number.parseInt(ref.replace(/^pm/i, ""), 10);
+            const diag = listed === 0 || !Number.isFinite(n) || n < 1 || n > listed
+                ? "invented (ref index is beyond the markets listed this cycle)"
+                : "stale (in-range ref does not match this cycle's listed markets)";
             return {
                 ok: false,
                 code: "pm_ref_unknown",
-                reason: `ref ${ref} is not one of this cycle's listed PM markets ${known}`,
+                reason: `ref ${ref} is not one of this cycle's listed PM markets ${known} — ${diag}`,
             };
         }
         // Canonicalise: take the triple from the matched market, drop the ref.

package/dist/agent/runEvidence.js

@@ -2,7 +2,9 @@
 // agentTrace stamped on every traced call, and the export at the end.
 import { shortId } from "./util.js";
 export function makeRunId(spec) {
-    const slug = (spec.name || "agent").replace(/[^a-z0-9-]+/gi, "-").toLowerCase();
+    const slug = (spec.name || "agent")
+        .replace(/[^a-z0-9-]+/gi, "-")
+        .toLowerCase();
     return `${slug}-${shortId()}`;
 }
 export function makeDecisionId(cycle) {
@@ -19,5 +21,7 @@ export function makeTrace(runId, decisionId, spec, confidence, rationaleSummary)
 }
 export async function exportRunEvidence(client, runId) {
     const r = await client.exportRunEvidence(runId);
-    return r.ok ? r.data : { error: `run-evidence export failed (HTTP ${r.status})` };
+    return r.ok
+        ? r.data
+        : { error: `run-evidence export failed (HTTP ${r.status})` };
 }

package/dist/agent/runner.d.ts

@@ -1,6 +1,6 @@
-import { CoinRithmClient } from "./client.js";
+import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { Provider } from "./providers.js";
-import { AgentSpec, RunState, CycleResult, ProposedAction, QuoteEvidence } from "./types.js";
+import { AgentSpec, RunState, CycleResult, Decision, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence } from "./types.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
     provider: Provider;
@@ -11,11 +11,17 @@ export interface RunnerDeps {
     stateFile?: string;
     log?: (line: string) => void;
 }
+export declare function houseAgentForecastEnabled(): boolean;
+export declare function agentOpportunityCaptureEnabled(): boolean;
+export declare function runnerRuntimeKind(): ProvenanceReport["runtimeKind"];
+export declare function buildRunnerProvenance(spec: AgentSpec): ProvenanceReport;
+export declare function sanitizeForecastProbability(raw: unknown): number | undefined;
 export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence): {
     action: ProposedAction;
     repaired: boolean;
 };
 export declare function rationaleForAction(a: ProposedAction, decisionRationale: string | undefined, perActionSummary: string | undefined, totalActions: number): string | undefined;
+export declare function buildSkipOpportunity(decision: Decision, pmMarkets: PmMarket[], forecastEnabled: boolean): PostedOpportunity | null;
 export declare function runCycle(deps: RunnerDeps): Promise<CycleResult>;
 export interface LoopOptions {
     once?: boolean;