@coinrithm/mcp-trading 0.7.2 → 0.7.4

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;