@coinrithm/mcp-trading 0.7.2 → 0.7.4

package/dist/agent/cli.js

@@ -7,14 +7,14 @@
 import { mkdirSync, writeFileSync, existsSync, statSync, readFileSync, openSync, closeSync, unlinkSync, } from "node:fs";
 import { resolve as resolvePath, dirname, join, basename } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { resolveAgent, ResolveError, mergeProseParts, isSkillProseSource } from "./resolve.js";
+import { resolveAgent, ResolveError, mergeProseParts, isSkillProseSource, } from "./resolve.js";
 import { buildSpec, loadAgent } from "./skill.js";
 import { validateSkill } from "./skillValidator.js";
 import { strictLint } from "./strictLint.js";
 import { checkCapabilityDrift } from "./capabilityGuard.js";
 import { buildManifest, writeManifest } from "./manifest.js";
 import { parseFrontmatter } from "./frontmatter.js";
-import { renderFolderOfOne, ejectFiles, PRESET_NAMES } from "./templates.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";
@@ -43,12 +43,16 @@ function pinWarnings(path) {
         if (!existsSync(pin))
             return [];
         const parsed = parseYaml(readFileSync(pin, "utf8"));
-        const v = parsed?.api?.openapiVersion;
-        if (v && v !== COINRITHM_API.openapiVersion) {
-            return [
-                `⚠ functionality/coinrithm.yaml pins API ${v}; current is ${COINRITHM_API.openapiVersion} (warning only, not a block)`,
-            ];
+        const warnings = [];
+        const openapi = parsed?.api?.openapiVersion;
+        if (openapi && openapi !== COINRITHM_API.openapiVersion) {
+            warnings.push(`⚠ functionality/coinrithm.yaml pins API ${openapi}; current is ${COINRITHM_API.openapiVersion} (warning only, not a block)`);
         }
+        const mcp = parsed?.api?.mcpVersion;
+        if (mcp && mcp !== COINRITHM_API.mcpVersion) {
+            warnings.push(`⚠ functionality/coinrithm.yaml pins MCP ${mcp}; current is ${COINRITHM_API.mcpVersion} (warning only, not a block)`);
+        }
+        return warnings;
     }
     catch {
         /* ignore */
@@ -62,7 +66,9 @@ export function cmdNew(targetPath, opts = {}) {
     }
     const preset = (opts.preset ?? "conservative");
     if (!PRESET_NAMES.includes(preset)) {
-        return fail([`unknown preset "${preset}" (allowed: ${PRESET_NAMES.join(", ")})`]);
+        return fail([
+            `unknown preset "${preset}" (allowed: ${PRESET_NAMES.join(", ")})`,
+        ]);
     }
     const dir = resolvePath(targetPath);
     if (!dir || dir === resolvePath("."))
@@ -125,17 +131,25 @@ export function cmdLock(path) {
             ...drift.map((i) => `  [${i.code}] ${i.path ? `${i.path}: ` : ""}${i.message}`),
         ]
         : [];
-    return { ok: true, code: 0, lines: [`wrote ${out}`, `configHash ${manifest.configHash}`, ...warn] };
+    return {
+        ok: true,
+        code: 0,
+        lines: [`wrote ${out}`, `configHash ${manifest.configHash}`, ...warn],
+    };
 }
 export function cmdEject(path) {
     const agentDir = agentDirOf(path);
     const abs = resolvePath(path);
-    const keystone = existsSync(abs) && statSync(abs).isDirectory() ? join(abs, "agent.md") : abs;
+    const keystone = existsSync(abs) && statSync(abs).isDirectory()
+        ? join(abs, "agent.md")
+        : abs;
     if (!existsSync(keystone))
         return fail([`no agent.md at ${keystone}`]);
     const { data: fm, body } = parseFrontmatter(readFileSync(keystone, "utf8"));
     if (Array.isArray(fm.extends)) {
-        return fail(["agent already uses `extends` (already ejected?) — nothing to do"]);
+        return fail([
+            "agent already uses `extends` (already ejected?) — nothing to do",
+        ]);
     }
     const before = buildSpec(fm);
     const { files } = ejectFiles(fm, body);
@@ -149,13 +163,17 @@ export function cmdEject(path) {
         after = buildSpec(resolveAgent(agentDir).rawFrontmatter);
     }
     catch (e) {
-        return fail([`ejected folder failed to re-resolve: ${e.message}`]);
+        return fail([
+            `ejected folder failed to re-resolve: ${e.message}`,
+        ]);
     }
     const same = stableStringify(before) === stableStringify(after);
     const lines = [
         `ejected into ${agentDir}`,
         ...Object.keys(files).map((f) => `  + ${f}`),
-        same ? "✓ resolved spec unchanged" : "✗ WARNING: resolved spec CHANGED after eject",
+        same
+            ? "✓ resolved spec unchanged"
+            : "✗ WARNING: resolved spec CHANGED after eject",
     ];
     return { ok: same, code: same ? 0 : 1, lines };
 }
@@ -170,7 +188,10 @@ export function cmdInspect(path, json = false) {
         throw e;
     }
     const spec = buildSpec(resolved.rawFrontmatter);
-    const lint = [...strictLint(resolved.rawFrontmatter), ...checkCapabilityDrift(resolved, spec)];
+    const lint = [
+        ...strictLint(resolved.rawFrontmatter),
+        ...checkCapabilityDrift(resolved, spec),
+    ];
     const v = validateSkill({ spec, body: resolved.mergedProse, raw: resolved.rawFrontmatter }, "self-host");
     const output = {
         resolvedConfig: resolved.rawFrontmatter,
@@ -179,7 +200,12 @@ export function cmdInspect(path, json = false) {
         validation: { valid: v.valid, issues: v.issues, lint },
     };
     if (json) {
-        return { ok: v.valid, code: 0, lines: [JSON.stringify(output, null, 2)], data: output };
+        return {
+            ok: v.valid,
+            code: 0,
+            lines: [JSON.stringify(output, null, 2)],
+            data: output,
+        };
     }
     const lines = [
         `name:        ${spec.name}`,
@@ -278,7 +304,9 @@ export async function cmdRun(path, opts = {}) {
     }
     const apiKey = process.env.COINRITHM_API_KEY;
     if (!apiKey)
-        return fail(["COINRITHM_API_KEY is not set (needed to read your paper account)"]);
+        return fail([
+            "COINRITHM_API_KEY is not set (needed to read your paper account)",
+        ]);
     let provider;
     try {
         provider = selectProvider(loaded.spec, process.env, fetch);
@@ -286,11 +314,16 @@ export async function cmdRun(path, opts = {}) {
     catch (e) {
         return fail([e.message]);
     }
-    const client = new CoinRithmClient({ apiKey, baseUrl: process.env.COINRITHM_API_URL });
+    const client = new CoinRithmClient({
+        apiKey,
+        baseUrl: process.env.COINRITHM_API_URL,
+    });
     const stateFile = opts.stateFile ?? join(agentDirOf(path), ".agent.state.json");
     const release = acquireLock(stateFile);
     if (!release) {
-        return fail([`another runner holds ${stateFile}.lock — only one runner per agent at a time`]);
+        return fail([
+            `another runner holds ${stateFile}.lock — only one runner per agent at a time`,
+        ]);
     }
     // A self-host `run` is a cadence-paced loop users stop with Ctrl-C. Node exits
     // on SIGINT/SIGTERM WITHOUT unwinding the finally across the awaited loop, so
@@ -315,7 +348,9 @@ export async function cmdRun(path, opts = {}) {
             return fail([e.message]);
         }
         if (state.disabled) {
-            return fail([`agent is disabled: ${state.disabledReason ?? "kill-switch"} — clear ${stateFile} to reset`]);
+            return fail([
+                `agent is disabled: ${state.disabledReason ?? "kill-switch"} — clear ${stateFile} to reset`,
+            ]);
         }
         const live = !!opts.live;
         const lines = [
@@ -399,7 +434,10 @@ export async function main(argv) {
     let r;
     switch (cmd) {
         case "new":
-            r = cmdNew(pos[0] ?? "", { template: flags.template, preset: flags.preset });
+            r = cmdNew(pos[0] ?? "", {
+                template: flags.template,
+                preset: flags.preset,
+            });
             break;
         case "validate":
             r = cmdValidate(pos[0] ?? ".", flags.hosted ? "hosted" : "self-host");
@@ -416,7 +454,11 @@ export async function main(argv) {
         case "run": {
             // dry-run is the default; only --live (or LIVE=1) AND not --dry-run trades.
             const live = (!!flags.live || process.env.LIVE === "1") && !flags.dryRun;
-            r = await cmdRun(pos[0] ?? ".", { once: flags.once, live, stateFile: flags.state });
+            r = await cmdRun(pos[0] ?? ".", {
+                once: flags.once,
+                live,
+                stateFile: flags.state,
+            });
             break;
         }
         case undefined:
@@ -426,10 +468,13 @@ export async function main(argv) {
             r = { ok: true, code: 0, lines: usageLines() };
             break;
         default:
-            r = { ok: false, code: 1, lines: [`unknown command "${cmd}"`, ...usageLines()] };
+            r = {
+                ok: false,
+                code: 1,
+                lines: [`unknown command "${cmd}"`, ...usageLines()],
+            };
     }
     for (const line of r.lines) {
-        // eslint-disable-next-line no-console
         console.log(line);
     }
     return r.code;

package/dist/agent/client.d.ts

@@ -1,5 +1,20 @@
 import { AgentTrace, ApiResult } from "./types.js";
 export declare const DEFAULT_BASE_URL = "https://api.coinrithm.com";
+export type ProvenanceReport = {
+    runtimeKind?: "hosted_scheduler" | "self_host_runner" | "byo_api" | "mcp_tool";
+    packageVersion?: string;
+    bundleId?: string;
+    bundleVersion?: string;
+    skillVersions?: Record<string, string>;
+    promptHash?: string;
+    configHash?: string;
+    modelProvider?: string;
+    modelName?: string;
+    evidenceRef?: {
+        snapshotIds?: string[];
+        sourceCapturedAt?: string;
+    };
+};
 export interface ClientConfig {
     apiKey: string;
     baseUrl?: string;
@@ -107,8 +122,26 @@ export declare class CoinRithmClient {
         outcomeExternalMarketId: string;
         stakeMusd: number;
         idempotencyKey: string;
+        forecastProbability?: number;
+        provenance?: ProvenanceReport;
         agentTrace?: AgentTrace;
     }): Promise<ApiResult>;
+    reportPmOpportunity(body: {
+        kind: "abstained" | "forecast_only" | "quote_expired";
+        source?: string;
+        slug?: string;
+        outcomeExternalMarketId?: string;
+        forecastProbability?: number;
+        marketProbability?: number;
+        reasonCode?: string;
+        cohort?: {
+            universeSize?: number;
+            horizon?: string;
+        };
+        decisionId?: string | null;
+        runId?: string | null;
+        provenance?: ProvenanceReport;
+    }, trace?: AgentTrace): Promise<ApiResult>;
     exportRunEvidence(runId: string): Promise<ApiResult>;
 }
 export declare function isFailClosed(status: number): boolean;

package/dist/agent/client.js

@@ -64,7 +64,10 @@ export class CoinRithmClient {
                 return {
                     ok: false,
                     status: 0,
-                    data: { error: "network_error", message: err instanceof Error ? err.message : String(err) },
+                    data: {
+                        error: "network_error",
+                        message: err instanceof Error ? err.message : String(err),
+                    },
                 };
             }
             const retryAfter = Number(res.headers.get("retry-after"));
@@ -88,7 +91,9 @@ export class CoinRithmClient {
                 ok: res.ok,
                 status: res.status,
                 data,
-                retryAfterSeconds: res.status === 429 && Number.isFinite(retryAfter) ? retryAfter : undefined,
+                retryAfterSeconds: res.status === 429 && Number.isFinite(retryAfter)
+                    ? retryAfter
+                    : undefined,
                 rateLimitRemaining: Number(res.headers.get("ratelimit-remaining")) || undefined,
                 ledgerEventId: res.headers.get("x-coinrithm-ledger-event-id"),
             };
@@ -120,17 +125,24 @@ export class CoinRithmClient {
         return this.request("GET", "/api/agent/trades", { query, trace });
     }
     futuresPositions(query, trace) {
-        return this.request("GET", "/api/agent/positions/futures", { query, trace });
+        return this.request("GET", "/api/agent/positions/futures", {
+            query,
+            trace,
+        });
     }
     futuresQuote(body, trace) {
-        return this.request("POST", "/api/agent/futures/quote", { body: { ...body, agentTrace: trace } });
+        return this.request("POST", "/api/agent/futures/quote", {
+            body: { ...body, agentTrace: trace },
+        });
     }
     // ── spot ─────────────────────────────────────────────────────────────────
     openOrders(query, trace) {
         return this.request("GET", "/api/agent/orders/open", { query, trace });
     }
     spotQuote(body, trace) {
-        return this.request("POST", "/api/agent/spot/quote", { body: { ...body, agentTrace: trace } });
+        return this.request("POST", "/api/agent/spot/quote", {
+            body: { ...body, agentTrace: trace },
+        });
     }
     // ── prediction markets ───────────────────────────────────────────────────
     discoverPmMarkets(query, trace) {
@@ -149,7 +161,9 @@ export class CoinRithmClient {
         return this.request("GET", "/api/agent/positions/pm", { query, trace });
     }
     pmQuote(body, trace) {
-        return this.request("POST", "/api/agent/pm/quote", { body: { ...body, agentTrace: trace } });
+        return this.request("POST", "/api/agent/pm/quote", {
+            body: { ...body, agentTrace: trace },
+        });
     }
     // ── writes ─────────────────────────────────────────────────────────────────
     openFutures(body) {
@@ -173,9 +187,22 @@ export class CoinRithmClient {
     openPmPosition(body) {
         return this.request("POST", "/api/agent/pm/open", { body });
     }
+    // Report a NON-opened PM opportunity (abstained / forecast_only / quote_expired)
+    // so the public evaluation captures the FULL opportunity universe, not only
+    // opened trades. EVIDENCE, not a trade: needs only the read scope and does not
+    // move a wallet/position. Best-effort at the call site — a failure never affects
+    // the cycle. decisionId is the per-cycle idempotency key (server dedupes on
+    // (apiKeyId, decisionId)).
+    reportPmOpportunity(body, trace) {
+        return this.request("POST", "/api/agent/pm/opportunity", {
+            body: { ...body, agentTrace: trace },
+        });
+    }
     // Run-evidence export — runId is URL-encoded into the query.
     exportRunEvidence(runId) {
-        return this.request("GET", "/api/agent/ledger/export", { query: { runId } });
+        return this.request("GET", "/api/agent/ledger/export", {
+            query: { runId },
+        });
     }
 }
 // 401/403/409/422 are terminal, fail-closed outcomes for a cycle (auth/scope,

package/dist/agent/decision.d.ts

@@ -111,12 +111,14 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     stakeMusd: z.ZodEffects<z.ZodTypeAny, any, unknown>;
     confidence: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodTypeAny, any, unknown>>>, any, unknown>;
     rationaleSummary: z.ZodOptional<z.ZodString>;
+    forecastProbability: z.ZodOptional<z.ZodEffects<z.ZodAny, number | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     type: "pm_open";
     source?: string | undefined;
     slug?: string | undefined;
     outcomeExternalMarketId?: string | undefined;
     stakeMusd?: any;
+    forecastProbability?: number | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
     ref?: string | undefined;
@@ -126,6 +128,7 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     slug?: string | undefined;
     outcomeExternalMarketId?: string | undefined;
     stakeMusd?: unknown;
+    forecastProbability?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
     ref?: string | undefined;

package/dist/agent/decision.js

@@ -8,12 +8,29 @@ import { z } from "zod";
 // validating; leave anything else untouched so genuine garbage ("abc", "pos#5")
 // still fails closed. This is why actions were being rejected with
 // "actions.0.positionId: Expected number, received string".
-const num = (inner) => z.preprocess((v) => (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v)) ? Number(v) : v), inner);
+const num = (inner) => z.preprocess((v) => typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))
+    ? Number(v)
+    : v, inner);
 // Optional 0..1 confidence, tolerant of stringified/null input.
 const confidence = num(z.number().min(0).max(1))
     .nullable()
     .optional()
     .transform((v) => v ?? undefined);
+// The model's OWN 0-100 forecast for the backed PM side (its independent
+// probability the side wins, decided from the question — NOT the market price).
+// Deliberately TOLERANT: a missing / null / non-numeric value becomes undefined
+// (the runner then omits the field) rather than failing the whole action. A bad
+// forecast must NEVER block an otherwise-valid trade. Out-of-range values are NOT
+// rejected here — the runner clamps them to the backend's [1,99] rail. Kept as a
+// permissive `any→number|undefined` so it can never throw inside the strict
+// discriminated union.
+const forecastProbability = z
+    .any()
+    .transform((v) => {
+    const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+    return typeof n === "number" && Number.isFinite(n) ? n : undefined;
+})
+    .optional();
 const futuresOpen = z
     .object({
     type: z.literal("futures_open"),
@@ -79,6 +96,7 @@ const pmOpen = z
     stakeMusd: num(z.number().positive()),
     confidence,
     rationaleSummary: z.string().optional(),
+    forecastProbability,
 })
     .strict();
 export const actionSchema = z.discriminatedUnion("type", [
@@ -164,13 +182,18 @@ export function parseDecision(text) {
         obj = normalizeDecisionVerb(coerceJson(text));
     }
     catch (err) {
-        return { ok: false, error: `model output is not valid JSON: ${err instanceof Error ? err.message : String(err)}` };
+        return {
+            ok: false,
+            error: `model output is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+        };
     }
     const res = decisionSchema.safeParse(obj);
     if (!res.success) {
         return {
             ok: false,
-            error: res.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; "),
+            error: res.error.issues
+                .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+                .join("; "),
         };
     }
     const d = res.data;

package/dist/agent/decisionValidator.js

@@ -21,7 +21,8 @@ export function validateAction(action, ctx) {
     // throttled (we want an active Arena), and hosted agents only when the customer sets a
     // positive cap. The risk caps below (daily loss, open margin, leverage, stops) are the
     // real guardrails and always apply regardless of the trade-count cap.
-    if (spec.limits.maxTradesPerDay > 0 && ctx.writesToday >= spec.limits.maxTradesPerDay) {
+    if (spec.limits.maxTradesPerDay > 0 &&
+        ctx.writesToday >= spec.limits.maxTradesPerDay) {
         return fail("daily_trade_cap", `maxTradesPerDay ${spec.limits.maxTradesPerDay} reached`);
     }
     // Deny-list: an open on a blocked symbol is rejected up front (deny wins over

package/dist/agent/deploymentOverlay.js

@@ -8,14 +8,34 @@
 // agent runs on a default tier and this still enforces it.)
 // Effective caps per tier. Tightenable later from config; these are the defaults.
 export const TIER_LIMITS = {
-    free_demo: { maxLlmCallsPerHour: 4, minCadenceSeconds: 3600, maxConcurrentAgents: 1 },
-    builder: { maxLlmCallsPerHour: 20, minCadenceSeconds: 900, maxConcurrentAgents: 3 },
-    pro: { maxLlmCallsPerHour: 120, minCadenceSeconds: 60, maxConcurrentAgents: 10 },
+    free_demo: {
+        maxLlmCallsPerHour: 4,
+        minCadenceSeconds: 3600,
+        maxConcurrentAgents: 1,
+    },
+    builder: {
+        maxLlmCallsPerHour: 20,
+        minCadenceSeconds: 900,
+        maxConcurrentAgents: 3,
+    },
+    pro: {
+        maxLlmCallsPerHour: 120,
+        minCadenceSeconds: 60,
+        maxConcurrentAgents: 10,
+    },
     // BYO key = the user's own model quota, so we don't cap their calls; we still
     // host + meter + verify (that's what they pay the infra fee for).
-    byok: { maxLlmCallsPerHour: 0, minCadenceSeconds: 60, maxConcurrentAgents: 5 },
+    byok: {
+        maxLlmCallsPerHour: 0,
+        minCadenceSeconds: 60,
+        maxConcurrentAgents: 5,
+    },
     // The house showcase fleet — uncapped, runs on our pooled keys.
-    house: { maxLlmCallsPerHour: 0, minCadenceSeconds: 60, maxConcurrentAgents: 0 },
+    house: {
+        maxLlmCallsPerHour: 0,
+        minCadenceSeconds: 60,
+        maxConcurrentAgents: 0,
+    },
 };
 // Tighten one numeric cap: 0 means "unlimited" on either side. The tier always wins
 // where it imposes a finite cap; it can never raise a request.

package/dist/agent/engine.d.ts

@@ -1,5 +1,5 @@
 export { runCycle, type RunnerDeps } from "./runner.js";
-export { selectProvider, type ProviderEnv, type Provider } from "./providers.js";
+export { selectProvider, type ProviderEnv, type Provider, } from "./providers.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
 export { resolveAgent } from "./resolve.js";
@@ -7,4 +7,5 @@ export { validateSkill, type SkillValidationMode } from "./skillValidator.js";
 export { newState, rollDay } from "./state.js";
 export { makeRunId } from "./runEvidence.js";
 export { parseCadenceMs } from "./util.js";
+export { BENCHMARK_AGENTS, BENCHMARK_STRATEGIES, decideMechanical, isBenchmarkStrategy, type BenchmarkStrategy, type BenchmarkAgentDefinition, } from "./mechanical.js";
 export type { AgentSpec, RunState, CycleResult, PlannedAction, Venue, ProviderName, ModelConfig, } from "./types.js";

package/dist/agent/engine.js

@@ -6,7 +6,7 @@
 // This barrel is the ONE import a host scheduler needs; it re-exports only the
 // stable engine pieces, never the CLI.
 export { runCycle } from "./runner.js";
-export { selectProvider } from "./providers.js";
+export { selectProvider, } from "./providers.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec } from "./skill.js";
 export { resolveAgent } from "./resolve.js";
@@ -14,3 +14,6 @@ export { validateSkill } from "./skillValidator.js";
 export { newState, rollDay } from "./state.js";
 export { makeRunId } from "./runEvidence.js";
 export { parseCadenceMs } from "./util.js";
+// Mechanical BENCHMARK baseline agents (sol #7): the deterministic, non-LLM
+// reference line the scheduler seeds into agent_runtime and the runner executes.
+export { BENCHMARK_AGENTS, BENCHMARK_STRATEGIES, decideMechanical, isBenchmarkStrategy, } from "./mechanical.js";

package/dist/agent/extract.js

@@ -1,5 +1,7 @@
 // Defensive extractors for untyped API JSON.
-export const asObj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+export const asObj = (v) => v && typeof v === "object" && !Array.isArray(v)
+    ? v
+    : {};
 export const asArr = (v) => (Array.isArray(v) ? v : []);
 export const asNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
 export const asStr = (v) => typeof v === "string" ? v : undefined;

package/dist/agent/gate.js

@@ -64,9 +64,17 @@ export function evaluateGate(observation, state, policy, nowMs) {
         if (pmAvailable &&
             policy.pmEvalCooldownMinutes > 0 &&
             sinceLastCall >= policy.pmEvalCooldownMinutes * 60_000) {
-            return { fire: true, codes: ["PM_PERIODIC"], reason: "PM periodic eval (quiet price tape)" };
+            return {
+                fire: true,
+                codes: ["PM_PERIODIC"],
+                reason: "PM periodic eval (quiet price tape)",
+            };
         }
-        return { fire: false, codes: [], reason: "no trigger (flat tape, no open position)" };
+        return {
+            fire: false,
+            codes: [],
+            reason: "no trigger (flat tape, no open position)",
+        };
     }
     // A real trigger exists. Open positions are NEVER starved by budget/debounce
     // (managing a live position is always allowed); the caps below only throttle
@@ -75,7 +83,11 @@ export function evaluateGate(observation, state, policy, nowMs) {
         if (policy.maxLlmCallsPerHour > 0) {
             const recent = (state.llmCallTimestamps ?? []).filter((t) => nowMs - t < 3_600_000);
             if (recent.length >= policy.maxLlmCallsPerHour) {
-                return { fire: false, codes: codeList, reason: `hourly LLM budget ${policy.maxLlmCallsPerHour} reached` };
+                return {
+                    fire: false,
+                    codes: codeList,
+                    reason: `hourly LLM budget ${policy.maxLlmCallsPerHour} reached`,
+                };
             }
         }
         if (policy.debounceMinutes > 0) {
@@ -83,11 +95,19 @@ export function evaluateGate(observation, state, policy, nowMs) {
             if (state.lastTriggerFingerprint === fp &&
                 state.lastLlmCallAt != null &&
                 nowMs - state.lastLlmCallAt < policy.debounceMinutes * 60_000) {
-                return { fire: false, codes: codeList, reason: `debounced (same triggers within ${policy.debounceMinutes}m)` };
+                return {
+                    fire: false,
+                    codes: codeList,
+                    reason: `debounced (same triggers within ${policy.debounceMinutes}m)`,
+                };
             }
         }
     }
-    return { fire: true, codes: codeList, reason: `triggers: ${codeList.join(",")}` };
+    return {
+        fire: true,
+        codes: codeList,
+        reason: `triggers: ${codeList.join(",")}`,
+    };
 }
 // Record that this cycle spent an LLM call — feeds the budget + debounce next
 // cycle. Mutates state; the caller persists it.

package/dist/agent/index.js

@@ -4,7 +4,6 @@ import { main } from "./cli.js";
 main(process.argv.slice(2))
     .then((code) => process.exit(code))
     .catch((err) => {
-    // eslint-disable-next-line no-console
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
 });

package/dist/agent/indicators.js

@@ -133,14 +133,16 @@ export function computeIndicators(candles, opts = {}) {
         const f = Math.pow(10, figs - Math.ceil(Math.log10(Math.abs(n))));
         return Math.round(n * f) / f;
     };
-    const sigN = (n, figs = 6) => (n == null ? null : sig(n, figs));
+    const sigN = (n, figs = 6) => n == null ? null : sig(n, figs);
     return {
         asOfClose: sig(close),
         rsi14: rsi14 == null ? null : Math.round(rsi14 * 10) / 10,
         ema20: sigN(ema20),
         ema50: sigN(ema50),
         atr14: sigN(atr14),
-        bollinger: bb == null ? null : { upper: sig(bb.upper), mid: sig(bb.mid), lower: sig(bb.lower) },
+        bollinger: bb == null
+            ? null
+            : { upper: sig(bb.upper), mid: sig(bb.mid), lower: sig(bb.lower) },
         recent20: r20 == null ? null : { high: sig(r20.high), low: sig(r20.low) },
         aboveEma20: ema20 == null ? null : close > ema20,
         ema20AboveEma50: ema20 == null || ema50 == null ? null : ema20 > ema50,

package/dist/agent/manifest.js

@@ -5,7 +5,7 @@
 import { writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { sha256, stableStringify, toPosix } from "./util.js";
-import { RESOLVER_VERSION, RUNNER_VERSION, MANIFEST_SCHEMA } from "./version.js";
+import { RESOLVER_VERSION, RUNNER_VERSION, MANIFEST_SCHEMA, } from "./version.js";
 export function buildManifest(resolved, spec) {
     // configHash binds the RESOLVED spec to the resolver + schema version, so a
     // run reproduces only against the same compile (not just the same files).

package/dist/agent/mechanical.d.ts

@@ -0,0 +1,36 @@
+import { AgentSpec, Decision, Observation, PmMarket } from "./types.js";
+export declare const BENCHMARK_STRATEGIES: readonly ["market-implied", "base-rate", "random"];
+export type BenchmarkStrategy = (typeof BENCHMARK_STRATEGIES)[number];
+export declare function isBenchmarkStrategy(s: string): s is BenchmarkStrategy;
+export declare const BASE_RATE_UNINFORMATIVE = 50;
+export declare const BENCHMARK_STAKE_MUSD = 10;
+export declare const RANDOM_FORECAST_MIN = 20;
+export declare const RANDOM_FORECAST_MAX = 80;
+export declare function marketKey(m: {
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+}): string;
+export declare function seededRandomForecast(seed: string): number;
+export declare function pickBenchmarkMarket(markets: PmMarket[], heldKeys?: Set<string>): PmMarket | undefined;
+export declare function benchmarkForecast(strategy: BenchmarkStrategy, market: PmMarket, dateKey: string): number | undefined;
+export interface MechanicalDecideInput {
+    strategy: string;
+    observation: Observation;
+    dateKey?: string;
+    stakeMusd?: number;
+}
+export interface MechanicalDecideResult {
+    decision: Decision;
+    log: string[];
+}
+export declare function decideMechanical(input: MechanicalDecideInput): MechanicalDecideResult;
+export interface BenchmarkAgentDefinition {
+    handle: string;
+    displayName: string;
+    strategy: BenchmarkStrategy;
+    cadenceSeconds: number;
+    spec: AgentSpec;
+    prose: string;
+}
+export declare const BENCHMARK_AGENTS: BenchmarkAgentDefinition[];