@coinrithm/mcp-trading 0.7.2 → 0.7.3

package/dist/agent/runner.js

@@ -2,7 +2,9 @@
 // spot, futures, and prediction markets. Dry-run never writes. Live uses
 // idempotency keys + agentTrace and exports run evidence. The client + provider
 // are injected so the loop is fully unit-testable with no network/model calls.
+import { COINRITHM_API } from "./version.js";
 import { spotBuyCost, DEFAULT_TRIGGER_POLICY, } from "./types.js";
+import { decideMechanical } from "./mechanical.js";
 import { evaluateGate, noteLlmCall, estimateCostUsd } from "./gate.js";
 import { baseSymbol } from "./setups.js";
 import { observe } from "./observe.js";
@@ -15,6 +17,70 @@ import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
 import { rollDay, checkKillSwitch, accrueRealized, saveState, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
 import { parseCadenceMs, sleep } from "./util.js";
+// Independent-forecast kill-switch. Default ON: the fleet elicits + submits its
+// OWN forecastProbability on PM opens. Set HOUSE_AGENT_FORECAST_ENABLED to
+// "false"/"0"/"no"/"off" to ship pm/open requests WITHOUT the field, byte-identical
+// to pre-forecast behavior (prompt extension also drops out). Read at CALL TIME
+// (not module-load) so a process env / a test can toggle it without re-import.
+export function houseAgentForecastEnabled() {
+    const v = (process.env.HOUSE_AGENT_FORECAST_ENABLED ?? "")
+        .trim()
+        .toLowerCase();
+    return !["false", "0", "no", "off"].includes(v);
+}
+// Opportunity-capture kill-switch. Default ON: the runner reports the NON-opened
+// opportunities the trade paths cannot see — the model ABSTAINING while PM markets
+// were listed, forecasting WITHOUT trading (forecast_only), or a validated pm_open
+// whose quote EXPIRED at act time (quote_expired) — so the public evaluation is not
+// selection-biased toward opened trades. Mirrors the backend env name; set
+// AGENT_OPPORTUNITY_CAPTURE_ENABLED to "false"/"0"/"no"/"off" to disable. Read at
+// CALL TIME so a process env / a test can toggle it without re-import. Only ever
+// posts on a LIVE cycle (dry-run never writes), at most ONCE per cycle.
+export function agentOpportunityCaptureEnabled() {
+    const v = (process.env.AGENT_OPPORTUNITY_CAPTURE_ENABLED ?? "")
+        .trim()
+        .toLowerCase();
+    return !["false", "0", "no", "off"].includes(v);
+}
+// The runner's SELF-REPORTED runtime kind. This is the npm coinrithm-agent runner,
+// so the honest default is "self_host_runner". When the house scheduler spawns the
+// runner it may set COINRITHM_RUNTIME_KIND=hosted_scheduler — a purely DESCRIPTIVE
+// label that carries NO trust (the backend forces providerVerified=false for every
+// keyed caller regardless), so it can never be used to fake verification. Any
+// unrecognized value falls back to self_host_runner.
+export function runnerRuntimeKind() {
+    const v = (process.env.COINRITHM_RUNTIME_KIND ?? "").trim().toLowerCase();
+    return v === "hosted_scheduler" ? "hosted_scheduler" : "self_host_runner";
+}
+// Build the runner's REAL provenance from what it honestly knows: its runtime kind,
+// the published package version (read from package.json via version.ts), and the
+// self-reported model provider/name from the resolved agent spec. Everything the
+// runner cannot truthfully attest (bundle/skill/prompt/config hashes, evidence refs)
+// is OMITTED — absent > fabricated. Sending this block makes the artifact v2; the
+// server still stamps the policy versions + providerVerified itself.
+export function buildRunnerProvenance(spec) {
+    const prov = {
+        runtimeKind: runnerRuntimeKind(),
+        packageVersion: COINRITHM_API.mcpVersion,
+    };
+    if (spec.model?.provider)
+        prov.modelProvider = spec.model.provider;
+    if (spec.model?.name)
+        prov.modelName = spec.model.name;
+    return prov;
+}
+// Clamp a model-proposed forecast to the backend's exclusive (0,100) rail as a
+// whole-or-one-decimal value in [1,99]. Returns undefined for missing / null /
+// NaN / non-finite input (absent > fake — the trade proceeds WITHOUT the field;
+// the value is NEVER defaulted to the market price / entryProbability). The
+// decision parser already tolerates non-numeric model output down to undefined,
+// so this mainly enforces the numeric range.
+export function sanitizeForecastProbability(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw))
+        return undefined;
+    const clamped = Math.min(99, Math.max(1, raw));
+    return Math.round(clamped * 10) / 10; // one-decimal precision
+}
 // A stable idempotency-key component per distinct intent (so a lost response
 // replays rather than re-trades, but a genuinely new intent gets a new key).
 function intentKeyOf(action) {
@@ -154,9 +220,98 @@ export function rationaleForAction(a, decisionRationale, perActionSummary, total
         ? decisionRationale
         : summarizeAction(a);
 }
+// A market's current probability (stored 0..1) as whole percentage POINTS (0..100),
+// the basis the opportunity/decision record uses. undefined when not reported.
+function marketPct(prob) {
+    return typeof prob === "number" && Number.isFinite(prob)
+        ? Math.round(prob * 100)
+        : undefined;
+}
+// Find the discovered market matching a resolved pm_open triple (case-insensitive
+// source/slug, exact outcome id) — for the observed market probability.
+function findPmMarket(pmMarkets, ref) {
+    return pmMarkets.find((m) => (m.source ?? "").toLowerCase() === (ref.source ?? "").toLowerCase() &&
+        (m.slug ?? "").toLowerCase() === (ref.slug ?? "").toLowerCase() &&
+        m.outcomeExternalMarketId === ref.outcomeExternalMarketId);
+}
+// Build the NON-opened opportunity for a MODEL-SKIP cycle, or null when there is no
+// PM universe to report on. The top listed market is the subject and the universe
+// breadth rides in universeSize so ONE post captures the whole cohort (never one
+// per market). A pm_open the model listed WITH a usable forecast makes it
+// forecast_only (it produced a probability but chose not to trade); otherwise it is
+// a plain abstention. NEVER defaults the forecast to the market price.
+//
+// NOTE: parseDecision() clears a pure `skip` decision's actions to [] (an act with
+// actions goes down the act path instead), so in the live runner this yields
+// `abstained`. The forecast_only rule is exercised whenever a decision reaches here
+// WITH surviving actions (kept faithful to the capture spec + future-proof; covered
+// directly by the unit test).
+export function buildSkipOpportunity(decision, pmMarkets, forecastEnabled) {
+    if (pmMarkets.length === 0)
+        return null;
+    const universeSize = pmMarkets.length;
+    const reasonCode = decision.reason?.trim() || undefined;
+    const pmAction = decision.actions.find((a) => a.type === "pm_open");
+    if (forecastEnabled && pmAction) {
+        const fc = sanitizeForecastProbability(pmAction.forecastProbability);
+        if (fc != null) {
+            // Resolve the forecasted market for an honest subject; fall back to the top
+            // listed market when the ref can't be resolved (still a valid forecast_only).
+            const resolved = resolvePmRef(pmAction, pmMarkets);
+            const subject = (resolved.ok ? findPmMarket(pmMarkets, resolved.action) : undefined) ??
+                pmMarkets[0];
+            return {
+                kind: "forecast_only",
+                source: subject.source,
+                slug: subject.slug,
+                outcomeExternalMarketId: subject.outcomeExternalMarketId,
+                universeSize,
+                forecastProbability: fc,
+                marketProbability: marketPct(subject.probability),
+                reasonCode,
+            };
+        }
+    }
+    const top = pmMarkets[0];
+    return {
+        kind: "abstained",
+        source: top.source,
+        slug: top.slug,
+        outcomeExternalMarketId: top.outcomeExternalMarketId,
+        universeSize,
+        marketProbability: marketPct(top.probability),
+        reasonCode,
+    };
+}
+// A validated pm_open that FAILED at act with quote-expiry semantics — the server
+// rejected the open with a 422 mock_entry_blocked, i.e. the eligibility/quality/
+// pricing state moved between the quote the runner validated and the act, so the
+// quote it acted on had effectively expired. Distinct from a risk/balance 422
+// (insufficient_balance), which is not a quote-expiry.
+function isQuoteExpiredResult(status, data) {
+    if (status !== 422)
+        return false;
+    const d = asObj(data);
+    return asStr(d.error) === "mock_entry_blocked";
+}
+// Joined server block reasons (reasonCode) for a quote_expired opportunity.
+function blockReasonsOf(data) {
+    const d = asObj(data);
+    const reasons = Array.isArray(d.blockReasons)
+        ? d.blockReasons.map(String).filter((s) => s.length > 0)
+        : [];
+    return reasons.length > 0 ? reasons.join(",") : undefined;
+}
 export async function runCycle(deps) {
     const { client, provider, spec, mergedProse, state, live, stateFile } = deps;
     const log = deps.log ?? (() => { });
+    // One flag read per cycle governs BOTH the prompt extension and the submission,
+    // so they can never diverge (prompt asks for it iff we would submit it).
+    const forecastEnabled = houseAgentForecastEnabled();
+    // The runner's REAL provenance for this cycle (runtime kind + package version +
+    // self-reported model). Attached to every durable-artifact write (pm_open,
+    // opportunity) so the artifact records WHAT RAN. Constant per cycle.
+    const provenance = buildRunnerProvenance(spec);
     state.cyclesRun += 1;
     rollDay(state);
     // Kill-switch pre-check: a disabled agent never observes, decides, or acts.
@@ -177,6 +332,42 @@ export async function runCycle(deps) {
     const runId = state.runId;
     const decisionId = makeDecisionId(state.cyclesRun);
     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)}`);
+        }
+    };
     // OBSERVE
     const obs = await observe(client, spec, state, baseTrace);
     const observation = obs.observation;
@@ -262,68 +453,97 @@ export async function runCycle(deps) {
             writeAccepted: 0,
         };
     }
-    noteLlmCall(state, gate.codes, nowMs);
-    // DECIDE
-    const system = buildSystemPrompt(spec, mergedProse);
-    const user = buildUserPrompt(observation, state.journal);
-    const tokensInEst = Math.round((system.length + user.length) / 4);
-    // Prompt-size + trigger visibility in the live terminal.
-    log(`prompt ~${tokensInEst} tok ` +
-        `(pm ${observation.pmMarkets.length}, trades ${observation.newClosedTrades.length}, watch ${observation.watch.length}, setups ${observation.setups.length}, triggers ${gate.codes.join("|") || "none"})`);
-    const res = await provider.decide({ system, user });
-    // Metering: prefer provider-reported usage; fall back to a chars/4 estimate.
-    const tokensIn = res.ok
-        ? (res.usage?.promptTokens ?? tokensInEst)
-        : tokensInEst;
-    const tokensOut = res.ok
-        ? (res.usage?.completionTokens ?? Math.round(res.text.length / 4))
-        : 0;
-    const estimatedCostUsd = estimateCostUsd(providerName, tokensIn, tokensOut);
-    const meter = {
-        triggerCodes: gate.codes,
-        llmCallMade: true,
-        tokensIn,
-        tokensOut,
-        estimatedCostUsd,
-    };
-    if (!res.ok) {
-        state.consecutiveModelFailures += 1;
-        saveState(stateFile, state);
-        log(`model error: ${res.error}`);
-        return {
-            decision: "skip",
-            skipReason: `model error: ${res.error}`,
-            planned: [],
-            modelFailed: true,
-            live,
-            ...meter,
-            decisionType: "model_error",
-            writeAttempted: 0,
-            writeAccepted: 0,
+    // DECIDE. Two paths share the same downstream validate+act loop:
+    //   • mechanical benchmark agents (provider "mechanical") compute the decision
+    //     deterministically from the observation — no prompt, no model call, no
+    //     inference cost. They never touch the LLM budget/debounce (noteLlmCall).
+    //   • every other agent asks its BYO model.
+    let decision;
+    let meter;
+    if (providerName === "mechanical") {
+        const mech = decideMechanical({
+            strategy: spec.model?.name ?? "",
+            observation,
+            dateKey: state.dayKey,
+        });
+        for (const l of mech.log)
+            log(l);
+        decision = mech.decision;
+        state.consecutiveModelFailures = 0;
+        // Zero-cost cycle: a mechanical decision made no LLM call.
+        meter = {
+            triggerCodes: gate.codes,
+            llmCallMade: false,
+            tokensIn: 0,
+            tokensOut: 0,
+            estimatedCostUsd: 0,
         };
     }
-    const parsed = parseDecision(res.text);
-    if (!parsed.ok) {
-        state.consecutiveModelFailures += 1;
-        saveState(stateFile, state);
-        log(`model output invalid: ${parsed.error}`);
-        return {
-            decision: "skip",
-            skipReason: `model output invalid: ${parsed.error}`,
-            // Never persist raw model text (no-CoT privacy policy) — the parse error
-            // in skipReason is the diagnostic; the malformed output is not stored.
-            rawModelOutput: undefined,
-            planned: [],
-            modelFailed: true,
-            live,
-            ...meter,
-            decisionType: "model_error",
-            writeAttempted: 0,
-            writeAccepted: 0,
+    else {
+        noteLlmCall(state, gate.codes, nowMs);
+        const system = buildSystemPrompt(spec, mergedProse, {
+            includeForecast: forecastEnabled,
+        });
+        const user = buildUserPrompt(observation, state.journal);
+        const tokensInEst = Math.round((system.length + user.length) / 4);
+        // Prompt-size + trigger visibility in the live terminal.
+        log(`prompt ~${tokensInEst} tok ` +
+            `(pm ${observation.pmMarkets.length}, trades ${observation.newClosedTrades.length}, watch ${observation.watch.length}, setups ${observation.setups.length}, triggers ${gate.codes.join("|") || "none"})`);
+        const res = await provider.decide({ system, user });
+        // Metering: prefer provider-reported usage; fall back to a chars/4 estimate.
+        const tokensIn = res.ok
+            ? (res.usage?.promptTokens ?? tokensInEst)
+            : tokensInEst;
+        const tokensOut = res.ok
+            ? (res.usage?.completionTokens ?? Math.round(res.text.length / 4))
+            : 0;
+        const estimatedCostUsd = estimateCostUsd(providerName, tokensIn, tokensOut);
+        meter = {
+            triggerCodes: gate.codes,
+            llmCallMade: true,
+            tokensIn,
+            tokensOut,
+            estimatedCostUsd,
         };
+        if (!res.ok) {
+            state.consecutiveModelFailures += 1;
+            saveState(stateFile, state);
+            log(`model error: ${res.error}`);
+            return {
+                decision: "skip",
+                skipReason: `model error: ${res.error}`,
+                planned: [],
+                modelFailed: true,
+                live,
+                ...meter,
+                decisionType: "model_error",
+                writeAttempted: 0,
+                writeAccepted: 0,
+            };
+        }
+        const parsed = parseDecision(res.text);
+        if (!parsed.ok) {
+            state.consecutiveModelFailures += 1;
+            saveState(stateFile, state);
+            log(`model output invalid: ${parsed.error}`);
+            return {
+                decision: "skip",
+                skipReason: `model output invalid: ${parsed.error}`,
+                // Never persist raw model text (no-CoT privacy policy) — the parse error
+                // in skipReason is the diagnostic; the malformed output is not stored.
+                rawModelOutput: undefined,
+                planned: [],
+                modelFailed: true,
+                live,
+                ...meter,
+                decisionType: "model_error",
+                writeAttempted: 0,
+                writeAccepted: 0,
+            };
+        }
+        state.consecutiveModelFailures = 0;
+        decision = parsed.decision;
     }
-    state.consecutiveModelFailures = 0;
-    const decision = parsed.decision;
     // Reasoning captured for the Arena terminal (keystone transparency): the
     // model's PARSED, sanitized short analysis + decision confidence. We do NOT
     // persist the full raw model text — a response can carry prose reasoning
@@ -336,6 +556,13 @@ export async function runCycle(deps) {
     const rawModelOutput = undefined;
     if (decision.decision === "skip" || decision.actions.length === 0) {
         state.consecutiveRejectCycles += 1;
+        // Capture the abstention / forecast-only: the model evaluated a non-empty PM
+        // universe and chose NOT to open, so the public evaluation must see it (else an
+        // agent looks skilled by exposure choice alone). One post carries the whole
+        // cohort via universeSize.
+        const skipOpp = buildSkipOpportunity(decision, observation.pmMarkets, forecastEnabled);
+        if (skipOpp)
+            await postOpportunity(skipOpp);
         saveState(stateFile, state);
         log(`model chose skip${decision.reason ? `: ${decision.reason}` : ""}`);
         return {
@@ -350,6 +577,7 @@ export async function runCycle(deps) {
             decisionType: "skip",
             writeAttempted: decision.actions.length,
             writeAccepted: 0,
+            ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
         };
     }
     // VALIDATE (+ ACT when live). Quote evidence is fetched by the runner.
@@ -404,6 +632,44 @@ export async function runCycle(deps) {
                 log(`reject pm_open: duplicate_intent (hold PM ${pm.slug})`);
                 continue;
             }
+            // Independent forecast submission (HOUSE_AGENT_FORECAST_ENABLED, default ON).
+            // Attach the model's OWN probability the backed side wins — clamped to [1,99],
+            // OMITTED when absent/unparseable (a bad forecast never blocks the trade), and
+            // NEVER defaulted to the market price. Flag OFF strips any forecast so the open
+            // request is byte-identical to pre-forecast behavior.
+            if (forecastEnabled) {
+                const fc = sanitizeForecastProbability(pm.forecastProbability);
+                if (fc != null) {
+                    const mkt = observation.pmMarkets.find((m) => (m.source ?? "").toLowerCase() ===
+                        (pm.source ?? "").toLowerCase() &&
+                        (m.slug ?? "").toLowerCase() === (pm.slug ?? "").toLowerCase() &&
+                        m.outcomeExternalMarketId === pm.outcomeExternalMarketId);
+                    const marketPct = typeof mkt?.probability === "number" &&
+                        Number.isFinite(mkt.probability)
+                        ? Math.round(mkt.probability * 100)
+                        : undefined;
+                    // Anti-echo: an EXACT match on the market's integer probability is still
+                    // submitted (a forecast can legitimately agree) — but we LOG it so echo
+                    // rates stay observable; we never silently mutate the value. NOTE: the
+                    // market-implied BENCHMARK agent (provider "mechanical", model.name
+                    // "market-implied") echoes the market probability BY DESIGN — it IS the
+                    // baseline definition — so a 100% echo rate there is expected, not a
+                    // defect. Its agentModel/description say BENCHMARK so this log line is
+                    // never mistaken for a mispriced skill agent.
+                    if (marketPct != null && Math.round(fc) === marketPct) {
+                        log(`pm_open forecast ${fc} == market prob ${marketPct}% (echo) — submitting as-is`);
+                    }
+                    action = { ...pm, forecastProbability: fc };
+                }
+                else {
+                    action = { ...pm, forecastProbability: undefined };
+                }
+            }
+            else if (pm.forecastProbability != null) {
+                // Flag off but the model still emitted a forecast — strip it so the request
+                // carries NO forecastProbability field (byte-identical to pre-forecast).
+                action = { ...pm, forecastProbability: undefined };
+            }
         }
         // Anti-churn critic: block re-opening a futures position we ALREADY hold unless
         // it's a confirmed WINNER with room (a legit scale-in). Stops the re-open-a-
@@ -437,6 +703,24 @@ export async function runCycle(deps) {
             }
         }
         const quote = await fetchQuote(client, action, observation, baseTrace);
+        // Early PM skip: the quote's openBlocked preview tells us a pm/open right now
+        // would be rejected 422 by the open-time quality gate (distinct from the
+        // eligible/blockReasons SHAPE gate the validator checks). Bail here with a clear
+        // reason instead of burning the open attempt on a guaranteed 422.
+        if (action.type === "pm_open" && quote?.openBlocked === true) {
+            const reasons = Array.isArray(quote.openBlockReasons)
+                ? quote.openBlockReasons.map(String)
+                : [];
+            planned.push({
+                action,
+                accepted: false,
+                code: "pm_open_blocked",
+                reason: `open-time quality gate would reject this (422): ${JSON.stringify(reasons)}`,
+                quote,
+            });
+            log(`skip pm_open early: openBlocked (${reasons.join(",") || "quality gate"})`);
+            continue;
+        }
         // Auto-clamp a missing/wrong-side futures take-profit to a valid R:R target
         // off the stop, so the open isn't silently rejected server-side (the runner
         // owns trigger orientation; weak models routinely mis-sign it).
@@ -501,7 +785,7 @@ export async function runCycle(deps) {
         // than a secondary trade — see rationaleForAction). Sanitized short reasoning
         // only — never raw chain-of-thought.
         rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length));
-        const r = await executeAction(client, action, observation, trace, idem);
+        const r = await executeAction(client, action, observation, trace, idem, provenance);
         planned.push({
             action,
             accepted: true,
@@ -525,6 +809,25 @@ export async function runCycle(deps) {
         }
         else {
             anyExecFailed = true;
+            // Quote-expiry capture: a validated pm_open the SERVER rejected at act time
+            // with a 422 mock_entry_blocked — the eligibility/quality/pricing state moved
+            // between the quote we validated and the act, so the quote expired. Report it
+            // (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({
+                    kind: "quote_expired",
+                    source: pm.source,
+                    slug: pm.slug,
+                    outcomeExternalMarketId: pm.outcomeExternalMarketId,
+                    universeSize: observation.pmMarkets.length,
+                    forecastProbability: forecastEnabled
+                        ? sanitizeForecastProbability(pm.forecastProbability)
+                        : undefined,
+                    marketProbability: marketPct(findPmMarket(observation.pmMarkets, pm)?.probability),
+                    reasonCode: blockReasonsOf(r.data),
+                });
+            }
         }
         log(`${r.ok ? "executed" : "FAILED"} ${action.type} (HTTP ${r.status})`);
     }
@@ -564,6 +867,7 @@ export async function runCycle(deps) {
         decisionType: "act",
         writeAttempted: decision.actions.length,
         writeAccepted: planned.filter((p) => p.accepted).length,
+        ...(postedOpportunity ? { opportunity: postedOpportunity } : {}),
     };
 }
 export async function runLoop(deps, opts = {}) {

package/dist/agent/scorecard.js

@@ -48,7 +48,9 @@ function normalCdf(z) {
     const p = d *
         t *
         (0.31938153 +
-            t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+            t *
+                (-0.356563782 +
+                    t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
     return z >= 0 ? 1 - p : p;
 }
 // Max peak-to-trough drawdown (mUSD, >= 0) on a cumulative series.
@@ -107,7 +109,7 @@ function ece(preds) {
     for (let b = 0; b < buckets; b += 1) {
         const lo = b / buckets;
         const hi = (b + 1) / buckets;
-        const inB = preds.filter((x) => (b === buckets - 1 ? x.p >= lo && x.p <= hi : x.p >= lo && x.p < hi));
+        const inB = preds.filter((x) => b === buckets - 1 ? x.p >= lo && x.p <= hi : x.p >= lo && x.p < hi);
         if (inB.length === 0)
             continue;
         const avgP = mean(inB.map((x) => x.p));
@@ -127,7 +129,9 @@ export function computeScorecard(input) {
     const avgWin = wins.length ? grossWin / wins.length : 0;
     const avgLoss = losses.length ? grossLoss / losses.length : 0;
     const pWin = decided ? wins.length / decided : null;
-    const rs = input.returns && input.returns.length ? input.returns.filter(Number.isFinite) : pnls;
+    const rs = input.returns && input.returns.length
+        ? input.returns.filter(Number.isFinite)
+        : pnls;
     const returnsBasis = input.returns && input.returns.length ? "returns" : "realized_pnl";
     const ann = input.annualizationFactor ?? 1;
     const cumulative = input.cumulative && input.cumulative.length
@@ -156,7 +160,11 @@ export function computeScorecard(input) {
         calibration_error: round0(ece(input.predictions ?? [])),
         stop_coverage: input.gates?.stopCoverage ?? null,
         evidence_coverage: input.gates?.evidenceCoverage ?? null,
-        leakage_clean: input.gates?.leakageClean == null ? null : input.gates.leakageClean ? 1 : 0,
+        leakage_clean: input.gates?.leakageClean == null
+            ? null
+            : input.gates.leakageClean
+                ? 1
+                : 0,
     };
     // Canonicalize (sorted keys) and hash, so the report card carries a stable,
     // verifiable fingerprint — a scorecard whose hash does not reproduce is not trusted.

package/dist/agent/setups.js

@@ -62,31 +62,77 @@ function classify(w, openPositions) {
     const out = [];
     // Primary trend-following / breakout read.
     if (ind.brokeRecentHigh === true) {
-        out.push({ symbol: w.symbol, kind: "breakout", bias: "long", strength: 0.8, note });
+        out.push({
+            symbol: w.symbol,
+            kind: "breakout",
+            bias: "long",
+            strength: 0.8,
+            note,
+        });
     }
     else if (ind.brokeRecentLow === true) {
-        out.push({ symbol: w.symbol, kind: "breakdown", bias: "short", strength: 0.8, note });
+        out.push({
+            symbol: w.symbol,
+            kind: "breakdown",
+            bias: "short",
+            strength: 0.8,
+            note,
+        });
     }
     else if (up && ch >= LEAN_MOVE_PCT) {
-        out.push({ symbol: w.symbol, kind: "uptrend", bias: "long", strength: ch >= STRONG_MOVE_PCT ? 0.75 : 0.6, note });
+        out.push({
+            symbol: w.symbol,
+            kind: "uptrend",
+            bias: "long",
+            strength: ch >= STRONG_MOVE_PCT ? 0.75 : 0.6,
+            note,
+        });
     }
     else if (down && ch <= -LEAN_MOVE_PCT) {
-        out.push({ symbol: w.symbol, kind: "downtrend", bias: "short", strength: ch <= -STRONG_MOVE_PCT ? 0.75 : 0.6, note });
+        out.push({
+            symbol: w.symbol,
+            kind: "downtrend",
+            bias: "short",
+            strength: ch <= -STRONG_MOVE_PCT ? 0.75 : 0.6,
+            note,
+        });
     }
     else if (overbought) {
-        out.push({ symbol: w.symbol, kind: "stretched", bias: "fade-short", strength: 0.55, note });
+        out.push({
+            symbol: w.symbol,
+            kind: "stretched",
+            bias: "fade-short",
+            strength: 0.55,
+            note,
+        });
     }
     else if (oversold) {
-        out.push({ symbol: w.symbol, kind: "stretched", bias: "fade-long", strength: 0.55, note });
+        out.push({
+            symbol: w.symbol,
+            kind: "stretched",
+            bias: "fade-long",
+            strength: 0.55,
+            note,
+        });
     }
     else if (Math.abs(ch) >= STRONG_MOVE_PCT) {
         // A strong move with no clean EMA stack — still tradeable momentum.
-        out.push({ symbol: w.symbol, kind: ch > 0 ? "uptrend" : "downtrend", bias: ch > 0 ? "long" : "short", strength: 0.55, note });
+        out.push({
+            symbol: w.symbol,
+            kind: ch > 0 ? "uptrend" : "downtrend",
+            bias: ch > 0 ? "long" : "short",
+            strength: 0.55,
+            note,
+        });
     }
     // Secondary COUNTER-TREND fade: a standing trend that is ALSO RSI-extreme is a
     // mean-reversion candidate. Only add it when the primary was the trend itself
     // (so we don't double-list a pure stretched read).
-    const primaryIsTrend = out[0] && (out[0].kind === "uptrend" || out[0].kind === "downtrend" || out[0].kind === "breakout" || out[0].kind === "breakdown");
+    const primaryIsTrend = out[0] &&
+        (out[0].kind === "uptrend" ||
+            out[0].kind === "downtrend" ||
+            out[0].kind === "breakout" ||
+            out[0].kind === "breakdown");
     if (primaryIsTrend && (oversold || overbought)) {
         out.push({
             symbol: w.symbol,
@@ -103,7 +149,9 @@ function classify(w, openPositions) {
     // exceeds_cap churn). A winner with room is the one case a same-side "open" is OK
     // (scaling in); otherwise it's manage-only.
     const wb = baseSymbol(w.symbol);
-    const pos = wb ? openPositions.find((p) => baseSymbol(p.symbol) === wb) : undefined;
+    const pos = wb
+        ? openPositions.find((p) => baseSymbol(p.symbol) === wb)
+        : undefined;
     const held = pos && (pos.side === "long" || pos.side === "short") ? pos.side : undefined;
     if (held) {
         const u = pos?.unrealizedPnlMusd;

package/dist/agent/skill.js

@@ -12,7 +12,7 @@ import { checkCapabilityDrift } from "./capabilityGuard.js";
 // guardrails. "Unlimited" is normalised to a large finite value so cap-merge arithmetic
 // (most-restrictive-wins) and JSON serialisation stay simple.
 export const UNLIMITED_TRADES_PER_DAY = 1_000_000;
-const normalizeTradeCap = (v) => (v <= 0 ? UNLIMITED_TRADES_PER_DAY : v);
+const normalizeTradeCap = (v) => v <= 0 ? UNLIMITED_TRADES_PER_DAY : v;
 const DEFAULT_LIMITS = {
     maxTradesPerDay: UNLIMITED_TRADES_PER_DAY,
     maxWritesPerCycle: 2,