@coinrithm/mcp-trading 0.7.8 → 0.7.10

package/dist/agent/providers.js

@@ -2,6 +2,7 @@
 // never from an agent file. One call returns one chunk of text that must be a
 // single structured-JSON decision (parsed in decision.ts). No free-form tool
 // execution — the model only proposes; the runner disposes.
+import { retryAfterSeconds } from "../retryAfter.js";
 import { chatShapeFor, buildChatBody, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
 // NVIDIA NIM is OpenAI-compatible; the `nvidia` preset hard-wires the hosted
 // endpoint so an agent only needs `{ provider: nvidia, name: "<model id>" }`.
@@ -27,6 +28,7 @@ const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai
 // (the recurring Leo/70B timeout). A real hang still aborts -> retried next cadence.
 // MUST stay below the scheduler's RUN_LOCK_SECONDS and HEARTBEAT_STALE_MS.
 const DEFAULT_TIMEOUT_MS = 300_000;
+const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
 // Per-route request quirks (reasoning toggles, token param, temperature) live
 // in the capability table — providerCapabilities.ts is the single source; this
 // module only assembles and sends.
@@ -58,22 +60,24 @@ function callError(err, timeoutMs) {
     }
     return err instanceof Error ? err.message : String(err);
 }
+// Error text reaches retained cycle evidence. Redact before truncating so a
+// credential crossing the size boundary cannot leave a partial key behind.
+function safeProviderError(text, apiKey) {
+    return (apiKey ? text.split(apiKey).join("[redacted]") : text)
+        .replace(/Bearer\s+[^\s"'<>\\]+/gi, "Bearer [redacted]")
+        .replace(/(?:nvapi-|crk_live_|sk-|sk_live_|ghp_|AIza)[A-Za-z0-9_-]+/g, "[redacted]")
+        .replace(/eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "[redacted]")
+        .replace(/((?:api[_-]?key|access[_-]?token|password|secret)["']?\s*[:=]\s*["']?)[^\s"',}&<>]+/gi, "$1[redacted]")
+        .slice(0, 2000);
+}
 // Parse a Retry-After header (delta-seconds or HTTP-date) into ms, capped at
 // one hour — a provider asking for more is treated as "an hour, then re-probe".
 const RETRY_AFTER_CAP_MS = 3_600_000;
 function retryAfterMs(res) {
-    const raw = res.headers.get("retry-after");
-    if (!raw)
-        return undefined;
-    const secs = Number(raw);
-    if (Number.isFinite(secs) && secs >= 0) {
-        return Math.min(Math.round(secs * 1000), RETRY_AFTER_CAP_MS);
-    }
-    const at = Date.parse(raw);
-    if (!Number.isFinite(at))
-        return undefined;
-    const ms = at - Date.now();
-    return ms > 0 ? Math.min(ms, RETRY_AFTER_CAP_MS) : 0;
+    const seconds = retryAfterSeconds(res.headers.get("retry-after"));
+    return seconds === undefined
+        ? undefined
+        : Math.min(Math.round(seconds * 1000), RETRY_AFTER_CAP_MS);
 }
 function envKey(provider, env) {
     switch (provider) {
@@ -165,7 +169,7 @@ class AnthropicProvider {
                         ok: false,
                         // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
                         // unbounded provider error page must not bloat the ledger row.
-                        error: `anthropic HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
+                        error: `anthropic HTTP ${res.status}: ${safeProviderError(await res.text(), this.apiKey)}`,
                         status: res.status,
                         retryAfterMs: retryAfterMs(res),
                     };
@@ -186,9 +190,9 @@ class AnthropicProvider {
         catch (err) {
             return {
                 ok: false,
-                error: failureResponse
+                error: safeProviderError(failureResponse
                     ? `anthropic HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
-                    : callError(err, timeoutMs),
+                    : callError(err, timeoutMs), this.apiKey),
                 ...(failureResponse
                     ? {
                         status: failureResponse.status,
@@ -240,9 +244,12 @@ class OpenAiCompatProvider {
                         ok: false,
                         // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
                         // unbounded provider error page must not bloat the ledger row.
-                        error: `provider HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
+                        error: `provider HTTP ${res.status}: ${safeProviderError(await res.text(), this.apiKey)}`,
                         status: res.status,
                         retryAfterMs: retryAfterMs(res),
+                        ...(RETRYABLE_SERVER_STATUSES.has(res.status)
+                            ? { retryableHttpFailure: true }
+                            : {}),
                     };
                 }
                 const json = (await res.json());
@@ -263,9 +270,9 @@ class OpenAiCompatProvider {
         catch (err) {
             return {
                 ok: false,
-                error: failureResponse
+                error: safeProviderError(failureResponse
                     ? `provider HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
-                    : callError(err, timeoutMs),
+                    : callError(err, timeoutMs), this.apiKey),
                 ...(failureResponse
                     ? {
                         status: failureResponse.status,
@@ -276,6 +283,86 @@ class OpenAiCompatProvider {
         }
     }
 }
+// A direct NVIDIA 5xx previously lost the whole cycle until the next cadence.
+// Retry only an explicit server refusal, once, on the identical configured
+// route. The shared router owns its own attempt/capacity budget and MUST NOT
+// receive this wrapper. No auth/404/429, network, timeout or decision repair
+// retries; no model substitution or request-parameter changes.
+class SameModelRetryProvider {
+    delegate;
+    provider;
+    model;
+    label;
+    constructor(delegate, provider, model) {
+        this.delegate = delegate;
+        this.provider = provider;
+        this.model = model;
+        this.label = delegate.label;
+    }
+    async decide(input) {
+        const started = Date.now();
+        const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const first = await this.delegate.decide(input);
+        const firstFinished = Date.now();
+        if (first.ok || !first.retryableHttpFailure) {
+            return first;
+        }
+        const delayMs = Math.max(1000, first.retryAfterMs ?? 0);
+        // Honor the provider's cooldown; a long one waits for the next cycle. Both
+        // attempts and this backoff share the ORIGINAL deadline, never two 5m caps.
+        if (delayMs > 5000 || delayMs >= timeoutMs - (firstFinished - started)) {
+            return first;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        const retryStarted = Date.now();
+        const remainingMs = timeoutMs - (retryStarted - started);
+        if (remainingMs <= 0)
+            return first;
+        const result = await this.delegate.decide({
+            ...input,
+            timeoutMs: remainingMs,
+        });
+        const attempt = (res, latencyMs) => ({
+            provider: this.provider,
+            model: this.model,
+            outcome: res.ok ? "success" : "failed",
+            latencyMs,
+            ...(!res.ok
+                ? {
+                    error: res.error,
+                    status: res.status,
+                    retryAfterMs: res.retryAfterMs,
+                    ...(res.status !== undefined
+                        ? {
+                            failureClass: res.status === 429
+                                ? "capacity"
+                                : res.status >= 500
+                                    ? "transient"
+                                    : "permanent",
+                        }
+                        : {}),
+                }
+                : {}),
+        });
+        return {
+            // Usage, when present, describes only the final response. The preceding
+            // 5xx did not report usage; attempt evidence is not total billed tokens
+            // or a certificate that returned text passed the trading-decision parser.
+            ...result,
+            route: {
+                policyVersion: "coinrithm.configured-same-model-retry.v1",
+                profile: "configured",
+                effectiveProvider: this.provider,
+                effectiveModel: this.model,
+                reason: "configured_direct",
+                attempts: [
+                    attempt(first, firstFinished - started),
+                    attempt(result, Date.now() - retryStarted),
+                ],
+            },
+        };
+    }
+}
 // Build the provider from the spec's model block + env key. Throws a clear
 // error if no model is configured (self-host requires one) or the env key is
 // missing. fetch is injectable for tests.
@@ -308,7 +395,10 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    return new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    return provider === "nvidia"
+        ? new SameModelRetryProvider(direct, provider, name)
+        : direct;
 }
 // Build a provider for an EXPLICIT route + raw key (no spec, no env) — the
 // decision probe's entry point. Same classes as selectProvider, so a probe

package/dist/agent/reconcileObservation.d.ts

@@ -0,0 +1,2 @@
+import type { RunState, Observation } from "./types.js";
+export declare function reconcileObservation(state: RunState, observation: Observation): void;

package/dist/agent/reconcileObservation.js

@@ -0,0 +1,33 @@
+import { accrueRealized } from "./state.js";
+import { asObj, asNum, asStr } from "./extract.js";
+export function reconcileObservation(state, observation) {
+    accrueRealized(state, observation.newClosedTrades);
+    state.cursor = observation.syncCursor;
+    for (const t of observation.newClosedTrades) {
+        state.seen.push(`${asStr(asObj(t).venue) ?? "futures"}:${asNum(asObj(t).id) ?? String(asObj(t).id)}`);
+    }
+    state.seen = state.seen.slice(-500);
+    // Slice-3 reflection: journal closed-trade OUTCOMES (not just opens) so the agent
+    // remembers how its theses RESOLVED — a stop-out it should not revenge-trade, a
+    // winner its style works on. Defensive field reads (the /trades shape varies);
+    // a partial entry is harmless, a missing one is skipped.
+    for (const t of observation.newClosedTrades.slice(-5)) {
+        const o = asObj(t);
+        const sym = asStr(o.symbol) ?? asStr(o.coinSymbol) ?? asStr(o.coinId);
+        const pnl = asNum(o.realizedPnlMusd) ??
+            asNum(o.pnlMusd) ??
+            asNum(o.realizedPnl) ??
+            asNum(o.pnl);
+        const side = asStr(o.side);
+        if (sym || pnl != null) {
+            const did = `closed ${side ?? ""} ${sym ?? "position"}`.trim() +
+                (pnl != null
+                    ? `: ${pnl >= 0 ? "+" : ""}${Math.round(pnl)}mUSD ${pnl >= 0 ? "WIN" : "LOSS"}`
+                    : "");
+            state.journal = [
+                ...(state.journal ?? []),
+                { at: observation.asOf, did },
+            ].slice(-12);
+        }
+    }
+}

package/dist/agent/runner.js

@@ -8,6 +8,8 @@ import { usesCapitalSizing, prepareCapitalAction, validateCapitalAction, capital
 import { decideMechanical } from "./mechanical.js";
 import { evaluateGate, noteLlmCall, estimateCostUsd } from "./gate.js";
 import { baseSymbol, scanSetups } from "./setups.js";
+import { reconcileObservation } from "./reconcileObservation.js";
+import { createOpportunityReporter } from "./opportunityReporter.js";
 import { observe } from "./observe.js";
 import { buildDailyRiskBudget, buildSystemPrompt, buildUserPrompt, } from "./prompt.js";
 import { parseDecision } from "./decision.js";
@@ -15,7 +17,7 @@ import { validateAction, isRiskIncreasingAction, } from "./decisionValidator.js"
 import { resolvePmRef } from "./resolvePm.js";
 import { fetchQuote, executeAction } from "./act.js";
 import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
-import { rollDay, checkKillSwitch, accrueRealized, saveState, isPermanentModelError, isAuthFailureSkip, PERMANENT_MODEL_ERROR_THRESHOLD, AUTH_FAILURE_THRESHOLD, } from "./state.js";
+import { rollDay, checkKillSwitch, saveState, isPermanentModelError, isAuthFailureSkip, PERMANENT_MODEL_ERROR_THRESHOLD, AUTH_FAILURE_THRESHOLD, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
 import { parseCadenceMs, sleep } from "./util.js";
 import { buildObservationReceipt } from "./observationReceipt.js";
@@ -441,43 +443,22 @@ async function runCycleCore(deps, capture) {
             live,
         };
     }
+    // Establish durable run identity before the first possible write. A process
+    // killed before its first response must not restart with a new idempotency key.
+    if (live)
+        saveState(stateFile, state);
     const baseTrace = makeTrace(runId, decisionId, spec);
-    // Opportunity capture (kills evaluation selection bias). Post at most ONE
-    // non-opened opportunity per cycle, LIVE only (dry-run never writes), best-effort
-    // — a failed post never affects the cycle result. The latch is set BEFORE the
-    // await so a failure never retries within the cycle (respects the write budget);
-    // the cohort/universe field carries the breadth, so we never post per-market.
-    const captureOpportunity = agentOpportunityCaptureEnabled();
-    let opportunityPosted = false;
-    let postedOpportunity;
-    const postOpportunity = async (o) => {
-        if (!captureOpportunity || !live || opportunityPosted)
-            return;
-        opportunityPosted = true;
-        postedOpportunity = o;
-        try {
-            await client.reportPmOpportunity({
-                kind: o.kind,
-                source: o.source,
-                slug: o.slug,
-                outcomeExternalMarketId: o.outcomeExternalMarketId,
-                forecastProbability: o.forecastProbability,
-                marketProbability: o.marketProbability,
-                reasonCode: o.reasonCode,
-                cohort: {
-                    universeSize: o.universeSize,
-                    horizon: spec.objective?.horizon,
-                },
-                decisionId,
-                runId,
-                provenance,
-            }, baseTrace);
-            log(`reported ${o.kind} opportunity (universe ${o.universeSize ?? "?"})`);
-        }
-        catch (err) {
-            log(`opportunity post failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
+    const opportunities = createOpportunityReporter({
+        client,
+        spec,
+        live,
+        enabled: agentOpportunityCaptureEnabled(),
+        runId,
+        decisionId,
+        provenance,
+        baseTrace,
+        log,
+    });
     // OBSERVE
     const obs = await observe(client, spec, state, baseTrace);
     const observation = obs.observation;
@@ -496,35 +477,7 @@ async function runCycleCore(deps, capture) {
     // Reads build the observation, so its hash cannot exist before they finish.
     // From this point every durable write carries the exact decision-input receipt.
     Object.assign(baseTrace, observationReceipt);
-    accrueRealized(state, observation.newClosedTrades);
-    state.cursor = observation.syncCursor;
-    for (const t of observation.newClosedTrades) {
-        state.seen.push(`${asStr(asObj(t).venue) ?? "futures"}:${asNum(asObj(t).id) ?? String(asObj(t).id)}`);
-    }
-    state.seen = state.seen.slice(-500);
-    // Slice-3 reflection: journal closed-trade OUTCOMES (not just opens) so the agent
-    // remembers how its theses RESOLVED — a stop-out it should not revenge-trade, a
-    // winner its style works on. Defensive field reads (the /trades shape varies);
-    // a partial entry is harmless, a missing one is skipped.
-    for (const t of observation.newClosedTrades.slice(-5)) {
-        const o = asObj(t);
-        const sym = asStr(o.symbol) ?? asStr(o.coinSymbol) ?? asStr(o.coinId);
-        const pnl = asNum(o.realizedPnlMusd) ??
-            asNum(o.pnlMusd) ??
-            asNum(o.realizedPnl) ??
-            asNum(o.pnl);
-        const side = asStr(o.side);
-        if (sym || pnl != null) {
-            const did = `closed ${side ?? ""} ${sym ?? "position"}`.trim() +
-                (pnl != null
-                    ? `: ${pnl >= 0 ? "+" : ""}${Math.round(pnl)}mUSD ${pnl >= 0 ? "WIN" : "LOSS"}`
-                    : "");
-            state.journal = [
-                ...(state.journal ?? []),
-                { at: observation.asOf, did },
-            ].slice(-12);
-        }
-    }
+    reconcileObservation(state, observation);
     capture({
         ...captureBase,
         phase: "observed",
@@ -897,7 +850,7 @@ async function runCycleCore(deps, capture) {
         // cohort via universeSize.
         const skipOpp = buildSkipOpportunity(decision, observation.pmMarkets, forecastEnabled);
         if (skipOpp)
-            await postOpportunity(skipOpp);
+            await opportunities.post(skipOpp);
         saveState(stateFile, state);
         log(`model chose skip${decision.reason ? `: ${decision.reason}` : ""}`);
         return {
@@ -912,7 +865,7 @@ async function runCycleCore(deps, capture) {
             decisionType: "skip",
             writeAttempted: decision.actions.length,
             writeAccepted: 0,
-            ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+            ...(opportunities.posted ? { opportunity: opportunities.posted } : {}),
             ...observationReceipt,
         };
     }
@@ -1265,7 +1218,7 @@ async function runCycleCore(deps, capture) {
             // (once-per-cycle; carries the universe breadth in the cohort field).
             if (action.type === "pm_open" && isQuoteExpiredResult(r.status, r.data)) {
                 const pm = action;
-                await postOpportunity({
+                await opportunities.post({
                     kind: "quote_expired",
                     source: pm.source,
                     slug: pm.slug,
@@ -1291,13 +1244,18 @@ async function runCycleCore(deps, capture) {
     state.consecutiveExecFailures =
         anyExecFailed && !anyExecuted ? state.consecutiveExecFailures + 1 : 0;
     state.rateLimitHits = client.rateLimitHits ?? state.rateLimitHits;
-    // Slice-3 memory: journal the accepted move(s) + the thesis behind them so next
-    // cycle has continuity (manage with memory of WHY; don't re-open what we just did).
+    // Memory describes completed moves, not policy acceptance. A backend rejection,
+    // lost response, or dry-run plan must not become "opened" / "trailed stop" in
+    // the next model prompt. Attempts remain in planned[] and the audit ledger.
     const moves = planned
-        .filter((p) => p.accepted)
+        .filter((p) => p.accepted && p.executed === true)
         .map((p) => summarizeAction(p.action));
     if (moves.length > 0) {
-        const did = `${moves.join("; ")}${rationale ? ` — ${rationale.slice(0, 90)}` : ""}`;
+        // A cycle-wide rationale may describe a failed/rejected sibling action.
+        // Keep it only when every proposed action executed; per-action theses are
+        // already included by summarizeAction for confirmed opens.
+        const confirmedRationale = moves.length === planned.length ? rationale : undefined;
+        const did = `${moves.join("; ")}${confirmedRationale ? ` — ${confirmedRationale.slice(0, 90)}` : ""}`;
         state.journal = [
             ...(state.journal ?? []),
             { at: observation.asOf, did },
@@ -1317,7 +1275,7 @@ async function runCycleCore(deps, capture) {
         decisionType: "act",
         writeAttempted: decision.actions.length,
         writeAccepted: planned.filter((p) => p.accepted).length,
-        ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
+        ...(opportunities.posted ? { opportunity: opportunities.posted } : {}),
         ...observationReceipt,
     };
 }

package/dist/agent/skill.js

@@ -103,6 +103,12 @@ export function buildSpec(raw) {
             ? { capitalSizing: buildCapitalSizing(raw.capitalSizing) }
             : {}),
         risk: {
+            // Preserve malformed explicit policies for fail-closed validation.
+            ...(risk.entryPredicates !== undefined
+                ? {
+                    entryPredicates: risk.entryPredicates,
+                }
+                : {}),
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),

package/dist/agent/skillValidator.js

@@ -1,5 +1,6 @@
 import { fail, VENUES, PROVIDERS, SPEC_VERSION, OBJECTIVE_PRIMARIES, ALLOWED_CAPABILITIES, } from "./types.js";
 import { parseCadenceMs, scanForSecrets } from "./util.js";
+import { entryPredicateIssues } from "./entryPredicates.js";
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isPosNum = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
 // maxTradesPerDay accepts 0 as the explicit "unlimited daily trades" sentinel.
@@ -93,6 +94,8 @@ export function validateSkill(parsed, mode = "self-host") {
     }
     else {
         const r = raw.risk;
+        if (r.entryPredicates !== undefined)
+            issues.push(...entryPredicateIssues(r.entryPredicates));
         if (!isPosNum(r.maxLeverage))
             add("skill_risk_leverage", "risk.maxLeverage must be a positive number");
         else if (r.maxLeverage > 20)

package/dist/agent/state.js

@@ -1,6 +1,7 @@
 // Local run state: the cursor, dedupe set, daily counters, and the kill-switch
 // inputs. Persisted to a JSON file so a re-run resumes where it left off.
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, rmSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { dirname } from "node:path";
 import { dayKey } from "./util.js";
 import { asObj, asNum } from "./extract.js";
@@ -59,8 +60,22 @@ export function loadState(file, runId) {
 export function saveState(file, state) {
     if (!file)
         return;
+    const serialized = JSON.stringify(state, null, 2);
     mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(state, null, 2), "utf8");
+    // A sibling file keeps rename on the same filesystem. Readers see either
+    // the previous complete state or the new one, never a truncated JSON write.
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, serialized, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
 }
 export function rollDay(state) {
     const today = dayKey();

package/dist/agent/strictLint.js

@@ -49,6 +49,7 @@ const ALLOWED_KEYS = {
         "watchlist",
         "blocklist",
         "direction",
+        "entryPredicates",
     ],
     sizing: null,
     capitalSizing: [

package/dist/agent/templates.js

@@ -50,37 +50,37 @@ const PRESETS = {
         modelFail: 5,
     },
 };
-const THESIS_BODY = `# Momentum Futures — strategy
-
-You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
-Everything here is simulated; it is not financial advice and never touches real
-money. Edit this prose freely (any language) — it is your agent's borders.
-
-## Each cycle
-
-1. Ground yourself: read your portfolio and open positions first. Never assume
-   balances or what is already open.
-2. Scan the watchlist. A candidate is a coin whose short and medium momentum
-   agree (both up, or both down) and is not already an open position.
-3. Pick the strongest candidate and commit when the read is clear — even a
-   moderate-confidence one — sized small with a stop. Skip only when the signals
-   contradict or the data is stale; a quiet tape where your edge is still real
-   is an act, not a skip.
-4. Quote before you open. Read the liquidation price and confirm it is sane. If
-   the quote is not eligible, relay the reason and stop.
-5. Open small and protected: enter in the trend direction and set a stop-loss at
-   open. Place the take-profit a touch wider than the stop.
-6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
-   fired while you were not looking, and react to what actually happened.
-
-The hard caps (leverage, margin, watchlist) live in the config blocks above and
+const THESIS_BODY = `# Momentum Futures — strategy
+
+You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
+Everything here is simulated; it is not financial advice and never touches real
+money. Edit this prose freely (any language) — it is your agent's borders.
+
+## Each cycle
+
+1. Ground yourself: read your portfolio and open positions first. Never assume
+   balances or what is already open.
+2. Scan the watchlist. A candidate is a coin whose short and medium momentum
+   agree (both up, or both down) and is not already an open position.
+3. Pick the strongest candidate and commit when the read is clear — even a
+   moderate-confidence one — sized small with a stop. Skip only when the signals
+   contradict or the data is stale; a quiet tape where your edge is still real
+   is an act, not a skip.
+4. Quote before you open. Read the liquidation price and confirm it is sane. If
+   the quote is not eligible, relay the reason and stop.
+5. Open small and protected: enter in the trend direction and set a stop-loss at
+   open. Place the take-profit a touch wider than the stop.
+6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
+   fired while you were not looking, and react to what actually happened.
+
+The hard caps (leverage, margin, watchlist) live in the config blocks above and
 are enforced by the runner — change them there, not in this prose.`;
-const PERSONA_STUB = `# Persona
-
-Decisive and in character. Acts on a clear read — even a moderate-confidence one
-— sized small and protected with a stop, and skips only when the read is
-contradictory or the data is stale. States its reasoning plainly in its own
-voice, and never frames paper results as real-money advice.
+const PERSONA_STUB = `# Persona
+
+Decisive and in character. Acts on a clear read — even a moderate-confidence one
+— sized small and protected with a stop, and skips only when the read is
+contradictory or the data is stale. States its reasoning plainly in its own
+voice, and never frames paper results as real-money advice.
 `;
 export function buildAgentObject(name, preset) {
     const p = PRESETS[preset];
@@ -182,6 +182,10 @@ export function ejectFiles(fm, body) {
     };
     if (fm.sizing)
         agentFm.sizing = fm.sizing;
+    if (fm.capitalSizing !== undefined)
+        agentFm.capitalSizing = fm.capitalSizing;
+    if (fm.triggerPolicy !== undefined)
+        agentFm.triggerPolicy = fm.triggerPolicy;
     if (fm.objective)
         agentFm.objective = fm.objective;
     if (fm.capabilities)

package/dist/agent/types.d.ts

@@ -26,6 +26,7 @@ export interface TriggerPolicy {
 }
 export declare const DEFAULT_TRIGGER_POLICY: TriggerPolicy;
 export interface RiskConfig {
+    entryPredicates?: import("./entryPredicates.js").EntryPredicate[];
     maxLeverage: number;
     perTradeMarginMusd: number;
     maxConcurrentPositions: number;

package/dist/agent/util.js

@@ -1,5 +1,5 @@
 // Small dependency-free helpers shared across the runner.
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { resolve as resolvePath, relative as relativePath, isAbsolute, } from "node:path";
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 // Parse a cadence string ("30s", "15m", "1h", "4h", "1d") to milliseconds.
@@ -63,8 +63,8 @@ export function scanForSecrets(value, pathPrefix = "", findings = []) {
 }
 // Short random id (for runId/decisionId/idempotencyKey suffixes).
 export function shortId() {
-    // randomUUID is available in Node 18+ (globalThis.crypto).
-    return crypto.randomUUID().slice(0, 8);
+    // Import the Node API: globalThis.crypto is not enabled by default in Node 18.
+    return randomUUID().slice(0, 8);
 }
 // ── Resolver helpers (cross-platform-deterministic) ──────────────────────────
 // Normalize file content for hashing: CRLF/CR -> LF, strip trailing whitespace,

package/dist/client.js

@@ -17,6 +17,7 @@
 //
 // IMPORTANT: this module must NEVER write to stdout (stdout is the MCP JSON-RPC
 // channel). All diagnostics go to stderr via the logger below.
+import { retryAfterSeconds } from "./retryAfter.js";
 export const DEFAULT_BASE_URL = "https://api.coinrithm.com";
 export function log(...args) {
     // stderr only — stdout is reserved for the MCP protocol.
@@ -139,12 +140,12 @@ export class CoinRithmClient {
         if (res.status === 429) {
             // Surface the back-off contract so an agent can pace itself instead of
             // hammering: 120 req/min per key baseline, 20 trade-writes/min.
-            const retryAfter = Number(res.headers.get("retry-after"));
+            const retryAfter = retryAfterSeconds(res.headers.get("retry-after"));
             data = {
                 ...(typeof data === "object" && data !== null
                     ? data
                     : { error: String(data) }),
-                retryAfterSeconds: Number.isFinite(retryAfter) ? retryAfter : null,
+                retryAfterSeconds: retryAfter ?? null,
                 hint: "Rate limited. Wait retryAfterSeconds (or the Retry-After header) before retrying; pace future calls using the RateLimit-Remaining response header.",
             };
         }

package/dist/http.d.ts

@@ -1,2 +1,8 @@
 #!/usr/bin/env node
-export {};
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CoinRithmClient } from "./client.js";
+import { type CompletionLogger } from "./httpCompletion.js";
+export declare function createHttpApp(client: CoinRithmClient, options?: {
+    completionLogger?: CompletionLogger;
+    createServer?: () => McpServer;
+}): import("express-serve-static-core").Express;