@coinrithm/mcp-trading 0.7.14 → 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

@@ -40,13 +40,27 @@ export declare class CoinRithmClient {
     rateLimitHits: number;
     constructor(cfg: ClientConfig);
     private request;
+    private publicRequest;
+    credentialFingerprint(): string;
     me(trace?: AgentTrace): Promise<ApiResult>;
+    performance(trace?: AgentTrace, options?: {
+        timeoutMs?: number;
+        maxRetries?: number;
+    }): Promise<ApiResult>;
     portfolio(trace?: AgentTrace): Promise<ApiResult>;
     wallet(query?: {
         coinId?: string;
     }, 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;
+    }): Promise<ApiResult>;
+    getPublicPmWhaleWallet(source: string, wallet: string, options?: {
+        timeoutMs?: number;
+    }): Promise<ApiResult>;
     market(coinId: string, trace?: AgentTrace): Promise<ApiResult>;
     candles(coinId: string, range: string, trace?: AgentTrace): Promise<ApiResult>;
     trades(query?: {

package/dist/agent/client.js

@@ -4,6 +4,7 @@
 // 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 { createHash } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 import { retryAfterSeconds } from "../retryAfter.js";
 export const DEFAULT_BASE_URL = "https://api.coinrithm.com";
@@ -54,6 +55,16 @@ export class CoinRithmClient {
         this.extraHeaders = cfg.extraHeaders;
     }
     async request(method, path, opts = {}) {
+        const requestTimeoutMs = opts.timeoutMs !== undefined &&
+            Number.isSafeInteger(opts.timeoutMs) &&
+            opts.timeoutMs >= 1
+            ? Math.min(opts.timeoutMs, this.requestTimeoutMs)
+            : this.requestTimeoutMs;
+        const maxRetries = opts.maxRetries !== undefined &&
+            Number.isSafeInteger(opts.maxRetries) &&
+            opts.maxRetries >= 0
+            ? Math.min(opts.maxRetries, this.maxRetries)
+            : this.maxRetries;
         const url = new URL(this.baseUrl + path);
         if (opts.query) {
             for (const [k, v] of Object.entries(opts.query)) {
@@ -76,7 +87,7 @@ export class CoinRithmClient {
         const timer = setTimeout(() => {
             timedOut = true;
             controller.abort(new Error("API request deadline exceeded"));
-        }, this.requestTimeoutMs);
+        }, requestTimeoutMs);
         this.signal?.addEventListener("abort", cancel, { once: true });
         if (this.signal?.aborted)
             cancel();
@@ -102,12 +113,12 @@ export class CoinRithmClient {
                 const retryAfter = retryAfterSeconds(res.headers.get("retry-after"));
                 if (res.status === 429)
                     this.rateLimitHits += 1;
-                if (res.status === 429 && attempt < this.maxRetries) {
+                if (res.status === 429 && attempt < maxRetries) {
                     // Release this response before waiting so retries do not retain sockets.
                     void res.body?.cancel().catch(() => { });
                     const delayMs = (retryAfter ?? 5) * 1000;
                     // Never shorten a provider's Retry-After or overflow a Node timer.
-                    if (delayMs >= this.requestTimeoutMs)
+                    if (delayMs >= requestTimeoutMs)
                         await aborted;
                     else if (this.sleepFn)
                         await this.sleepFn(delayMs);
@@ -151,7 +162,7 @@ export class CoinRithmClient {
                             ? "request_aborted"
                             : "network_error",
                     message: timedOut
-                        ? `API request exceeded ${this.requestTimeoutMs}ms deadline`
+                        ? `API request exceeded ${requestTimeoutMs}ms deadline`
                         : controller.signal.aborted
                             ? "API request cancelled"
                             : err instanceof Error
@@ -166,10 +177,96 @@ export class CoinRithmClient {
             controller.signal.removeEventListener("abort", rejectAborted);
         }
     }
+    // Keyless, bounded reads against the public PM surface. These deliberately
+    // bypass the authenticated request path so a runner key cannot leak into a
+    // public context lookup. No retries are added here; the enrichment is
+    // optional and its deadline includes response-body consumption.
+    async publicRequest(path, query, timeoutMs = 5_000) {
+        const url = new URL(this.baseUrl + path);
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value !== undefined && value !== null && value !== "")
+                url.searchParams.set(key, String(value));
+        }
+        const controller = new AbortController();
+        if (this.signal?.aborted) {
+            return { ok: false, status: 0, data: { error: "network_error" } };
+        }
+        const cancel = () => controller.abort();
+        this.signal?.addEventListener("abort", cancel, { once: true });
+        const deadlineMs = Math.min(timeoutMs, this.requestTimeoutMs);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, deadlineMs);
+        let rejectAborted;
+        const aborted = new Promise((_, reject) => {
+            rejectAborted = () => reject(new Error("public request aborted"));
+            controller.signal.addEventListener("abort", rejectAborted, {
+                once: true,
+            });
+        });
+        if (this.signal?.aborted)
+            cancel();
+        try {
+            const perform = async () => {
+                const res = await this.fetchFn(url.toString(), {
+                    method: "GET",
+                    headers: { Accept: "application/json" },
+                    signal: controller.signal,
+                });
+                const text = await res.text();
+                let data = text;
+                if (text) {
+                    try {
+                        data = JSON.parse(text);
+                    }
+                    catch {
+                        /* leave as text */
+                    }
+                }
+                return { ok: res.ok, status: res.status, data };
+            };
+            return await Promise.race([perform(), aborted]);
+        }
+        catch {
+            return {
+                ok: false,
+                status: 0,
+                data: {
+                    error: timedOut ? "timeout" : "network_error",
+                },
+            };
+        }
+        finally {
+            clearTimeout(timer);
+            controller.signal.removeEventListener("abort", rejectAborted);
+            this.signal?.removeEventListener("abort", cancel);
+        }
+    }
+    // A stable, non-reversible identity for this credential and API base, for
+    // per-agent in-memory caches that must outlive one client instance (the
+    // hosted scheduler builds a new client every cycle). Never the key itself.
+    credentialFingerprint() {
+        return createHash("sha256")
+            .update(`${this.baseUrl}\n${this.apiKey}`, "utf8")
+            .digest("hex")
+            .slice(0, 32);
+    }
     // ── reads ──────────────────────────────────────────────────────────────────
     me(trace) {
         return this.request("GET", "/api/agent/me", { trace });
     }
+    // GET /api/agent/performance: the calling key's own realized performance.
+    // Newer backends add an optional `pmCalibration` block (the key's settled PM
+    // forecast record), parsed defensively in observe.
+    performance(trace, options) {
+        return this.request("GET", "/api/agent/performance", {
+            trace,
+            timeoutMs: options?.timeoutMs,
+            maxRetries: options?.maxRetries,
+        });
+    }
     portfolio(trace) {
         return this.request("GET", "/api/agent/portfolio", { trace });
     }
@@ -186,6 +283,18 @@ 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);
+    }
+    getPublicPmWhaleWallet(source, wallet, options) {
+        return this.publicRequest(`/api/prediction-markets/whales/wallets/${encodeURIComponent(source)}/${encodeURIComponent(wallet)}`, undefined, options?.timeoutMs);
+    }
     market(coinId, trace) {
         return this.request("GET", `/api/agent/market/${encodeURIComponent(coinId)}`, { trace });
     }

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;