@coinrithm/mcp-trading 0.7.15 → 0.7.16

package/dist/agent/providers.js

@@ -3,7 +3,64 @@
 // 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";
+import { parseDecision } from "./decision.js";
+import { chatShapeFor, buildChatBody, withJsonContentTransport, canRetrySuperToolOutput, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
+// A token count as Anthropic reports it: a non-negative safe integer. Zero
+// is a real count; anything else (missing, null, negative, NaN, fractional,
+// a string) is malformed.
+function exactCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+// Anthropic usage, including prompt-cache reads and writes (and the 5m/1h
+// write split) when reported. Strict, because paid metering prices it (root
+// review of #118): input_tokens and output_tokens are mandatory, and a
+// malformed reported field (mandatory or cache) makes the WHOLE usage unknown
+// (undefined), never zero, so the call is metered uncertain instead of free.
+// Cache fields the response does not carry at all stay absent. A reported
+// write total must equal its 5m/1h split; a split without a total implies it.
+export function anthropicUsage(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return undefined;
+    const u = raw;
+    const promptTokens = exactCount(u.input_tokens);
+    const completionTokens = exactCount(u.output_tokens);
+    if (promptTokens === undefined || completionTokens === undefined)
+        return undefined;
+    const usage = { promptTokens, completionTokens };
+    const optional = (value) => value === undefined ? undefined : (exactCount(value) ?? null);
+    const cacheRead = optional(u.cache_read_input_tokens);
+    const cacheWrite = optional(u.cache_creation_input_tokens);
+    let write5m;
+    let write1h;
+    if (u.cache_creation !== undefined) {
+        const split = u.cache_creation;
+        if (typeof split !== "object" || split === null || Array.isArray(split))
+            return undefined;
+        const s = split;
+        write5m = optional(s.ephemeral_5m_input_tokens);
+        write1h = optional(s.ephemeral_1h_input_tokens);
+    }
+    if ([cacheRead, cacheWrite, write5m, write1h].includes(null))
+        return undefined;
+    if (write5m != null || write1h != null) {
+        const splitTotal = (write5m ?? 0) + (write1h ?? 0);
+        if (cacheWrite != null && cacheWrite !== splitTotal)
+            return undefined;
+        usage.cacheWriteTokens = splitTotal;
+        if (write5m != null)
+            usage.cacheWrite5mTokens = write5m;
+        if (write1h != null)
+            usage.cacheWrite1hTokens = write1h;
+    }
+    else if (cacheWrite != null) {
+        usage.cacheWriteTokens = cacheWrite;
+    }
+    if (cacheRead != null)
+        usage.cacheReadTokens = cacheRead;
+    return usage;
+}
 // NVIDIA NIM is OpenAI-compatible; the `nvidia` preset hard-wires the hosted
 // endpoint so an agent only needs `{ provider: nvidia, name: "<model id>" }`.
 const NVIDIA_BASE_URL = CAP_NVIDIA_BASE_URL;
@@ -31,6 +88,8 @@ const DEFAULT_TIMEOUT_MS = 300_000;
 const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
 /** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
 export function classifyProviderFailure(result) {
+    if (result.failureClass === "malformed")
+        return "malformed";
     if (result.status === 429 ||
         (result.status === 503 &&
             /resourceexhausted|worker local total request limit/i.test(result.error ?? "")))
@@ -186,15 +245,27 @@ class AnthropicProvider {
                 }
                 const json = (await res.json());
                 const text = json.content?.map((c) => c.text ?? "").join("") ?? "";
-                const usage = json.usage
-                    ? {
-                        promptTokens: json.usage.input_tokens ?? 0,
-                        completionTokens: json.usage.output_tokens ?? 0,
-                    }
-                    : undefined;
+                // Absent or malformed usage is undefined (unknown), never zero.
+                const usage = anthropicUsage(json.usage);
+                if (json.stop_reason === "max_tokens" ||
+                    json.stop_reason === "model_context_window_exceeded") {
+                    return {
+                        ok: false,
+                        failureClass: "malformed",
+                        error: json.stop_reason === "max_tokens"
+                            ? "provider returned incomplete decision (output token limit)"
+                            : "provider returned incomplete decision (context window limit)",
+                        usage,
+                    };
+                }
                 return text
                     ? { ok: true, text, usage, responseSource: "content" }
-                    : { ok: false, error: "anthropic returned empty content" };
+                    : // Answered (and billed) with nothing usable: keep the usage.
+                        {
+                            ok: false,
+                            error: "anthropic returned empty content",
+                            ...(usage ? { usage } : {}),
+                        };
             });
         }
         catch (err) {
@@ -213,24 +284,40 @@ class AnthropicProvider {
         }
     }
 }
+function wantsJsonContent(options) {
+    const v = options.nemotronJsonContent;
+    if (typeof v !== "function")
+        return v === true;
+    try {
+        return v() === true;
+    }
+    catch {
+        return false;
+    }
+}
 class OpenAiCompatProvider {
     provider;
     model;
     apiKey;
     baseUrl;
     fetchFn;
+    options;
     label;
-    constructor(provider, model, apiKey, baseUrl, fetchFn) {
+    constructor(provider, model, apiKey, baseUrl, fetchFn, options = {}) {
         this.provider = provider;
         this.model = model;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
         this.fetchFn = fetchFn;
+        this.options = options;
         this.label = `${baseUrl}/${model}`;
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        const shape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        const baseShape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        const shape = wantsJsonContent(this.options)
+            ? withJsonContentTransport(baseShape)
+            : baseShape;
         let failureResponse;
         try {
             return await withProviderTimeout(timeoutMs, async (signal) => {
@@ -273,6 +360,14 @@ class OpenAiCompatProvider {
                         completionTokens: json.usage.completion_tokens ?? 0,
                     }
                     : undefined;
+                if (json.choices?.[0]?.finish_reason === "length") {
+                    return {
+                        ok: false,
+                        failureClass: "malformed",
+                        error: "provider returned incomplete decision (output token limit)",
+                        usage,
+                    };
+                }
                 return text
                     ? {
                         ok: true,
@@ -303,20 +398,24 @@ 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.
+// Direct NVIDIA recovery has one shared two-call/deadline budget. Explicit
+// server refusals retry the original request; rejected Super tool encoding
+// retries JSON content on the same configured route. The shared router owns
+// its own admission budget and MUST NOT receive this wrapper. No model
+// substitution or repair/coercion of a rejected decision is allowed.
 class SameModelRetryProvider {
     delegate;
     provider;
     model;
+    contentRetry;
+    baseUrl;
     label;
-    constructor(delegate, provider, model) {
+    constructor(delegate, provider, model, contentRetry, baseUrl) {
         this.delegate = delegate;
         this.provider = provider;
         this.model = model;
+        this.contentRetry = contentRetry;
+        this.baseUrl = baseUrl;
         this.label = delegate.label;
     }
     async decide(input) {
@@ -324,56 +423,95 @@ class SameModelRetryProvider {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const first = await this.delegate.decide(input);
         const firstFinished = Date.now();
-        if (first.ok || !first.retryableHttpFailure) {
+        const parsedFirst = first.ok ? parseDecision(first.text) : undefined;
+        const retryContent = first.ok &&
+            parsedFirst?.ok === false &&
+            this.contentRetry !== undefined &&
+            canRetrySuperToolOutput({ provider: this.provider, model: this.model, baseUrl: this.baseUrl }, first.responseSource, parsedFirst.actionsStringDiagnostic);
+        if (!retryContent && (first.ok || !first.retryableHttpFailure)) {
             return first;
         }
-        const delayMs = Math.max(1000, first.retryAfterMs ?? 0);
+        const delayMs = retryContent
+            ? 0
+            : Math.max(1000, first.ok ? 0 : (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));
+        if (delayMs > 0)
+            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({
+        const retryResult = await (retryContent ? this.contentRetry : 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,
-                    failureClass: classifyProviderFailure(res) === "capacity"
-                        ? "capacity"
-                        : res.status !== undefined && res.status < 500
-                            ? "permanent"
-                            : "transient",
-                }
-                : {}),
-        });
+        const parsedRetry = retryResult.ok
+            ? parseDecision(retryResult.text)
+            : undefined;
+        const result = retryResult.ok && parsedRetry?.ok === false
+            ? {
+                ok: false,
+                failureClass: "malformed",
+                error: parsedRetry.error,
+                usage: retryResult.usage,
+            }
+            : retryResult;
+        const attempt = (res, latencyMs) => {
+            const parsed = res.ok ? parseDecision(res.text) : undefined;
+            return {
+                provider: this.provider,
+                model: this.model,
+                outcome: res.ok && parsed?.ok ? "success" : "failed",
+                latencyMs,
+                ...(res.ok ? { responseSource: res.responseSource } : {}),
+                ...(parsed?.ok === false
+                    ? {
+                        failureClass: "malformed",
+                        error: parsed.error,
+                        actionsStringDiagnostic: parsed.actionsStringDiagnostic,
+                    }
+                    : {}),
+                ...(!res.ok
+                    ? {
+                        error: res.error,
+                        status: res.status,
+                        retryAfterMs: res.retryAfterMs,
+                        failureClass: res.failureClass ??
+                            (classifyProviderFailure(res) === "capacity"
+                                ? "capacity"
+                                : res.status !== undefined && res.status < 500
+                                    ? "permanent"
+                                    : "transient"),
+                    }
+                    : {}),
+            };
+        };
+        // Sum reported usage from both physical calls, including rejected output.
+        // Missing usage is unknown, not evidence that a request consumed no tokens.
+        const usage = first.usage || result.usage
+            ? {
+                promptTokens: (first.usage?.promptTokens ?? 0) +
+                    (result.usage?.promptTokens ?? 0),
+                completionTokens: (first.usage?.completionTokens ?? 0) +
+                    (result.usage?.completionTokens ?? 0),
+            }
+            : undefined;
         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,
+            ...(usage ? { usage } : {}),
             route: {
-                policyVersion: "coinrithm.configured-same-model-retry.v2",
+                policyVersion: "coinrithm.configured-same-model-retry.v3",
                 profile: "configured",
                 effectiveProvider: this.provider,
                 effectiveModel: this.model,
                 reason: "configured_direct",
                 attempts: [
                     attempt(first, firstFinished - started),
-                    attempt(result, Date.now() - retryStarted),
+                    attempt(retryResult, Date.now() - retryStarted),
                 ],
             },
         };
@@ -382,7 +520,7 @@ class SameModelRetryProvider {
 // 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.
-export function selectProvider(spec, env, fetchFn = fetch) {
+export function selectProvider(spec, env, fetchFn = fetch, options = {}) {
     if (!spec.model) {
         throw new Error("no model configured: set model.provider + model.name in the agent (self-host needs an explicit model)");
     }
@@ -411,15 +549,17 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn, options);
     return provider === "nvidia"
-        ? new SameModelRetryProvider(direct, provider, name)
+        ? new SameModelRetryProvider(direct, provider, name, new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn, {
+            nemotronJsonContent: true,
+        }), baseUrl)
         : 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
 // exercises byte-identical request shapes to a real cycle.
-export function providerForRoute(route, apiKey, fetchFn = fetch) {
+export function providerForRoute(route, apiKey, fetchFn = fetch, options = {}) {
     if (route.provider === "mechanical")
         return new MechanicalProvider(route.model);
     if (route.provider === "anthropic")
@@ -428,5 +568,5 @@ export function providerForRoute(route, apiKey, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible route needs a baseUrl");
     }
-    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn);
+    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn, options);
 }

package/dist/agent/resolve.js

@@ -43,6 +43,9 @@ const CONFIG_BLOCKS = [
     "killSwitch",
     "objective",
     "capabilities",
+    "signals",
+    "data",
+    "universe",
 ];
 const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;

package/dist/agent/runner.d.ts

@@ -1,6 +1,7 @@
 import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { Provider } from "./providers.js";
 import { AgentSpec, RunState, CycleResult, Decision, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence } from "./types.js";
+import { type ObserveOptions } from "./observe.js";
 import { type DecisionInputRecord } from "./decisionReceipt.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
@@ -13,6 +14,13 @@ export interface RunnerDeps {
     log?: (line: string) => void;
     /** Optional private storage hook. Its failure never changes cycle execution. */
     onDecisionInputRecord?: (record: DecisionInputRecord) => void;
+    /** Hosted shared-pool admission only; protective checks still run every cycle. */
+    minModelIntervalSeconds?: number;
+    /** Opt-in hosted canary; changes presentation only, preserving all values. */
+    compactPromptTables?: boolean;
+    /** Bench replay only (bench.ts): observation overrides. Live runs never
+     *  set it. */
+    observeOptions?: ObserveOptions;
 }
 export declare function houseAgentForecastEnabled(): boolean;
 export declare function agentOpportunityCaptureEnabled(): boolean;

package/dist/agent/runner.js

@@ -2,6 +2,7 @@
 // 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 { signalThresholdsOf } from "./signals.js";
 import { classifyProviderFailure } from "./providers.js";
 import { COINRITHM_API } from "./version.js";
 import { spotBuyCost, DEFAULT_TRIGGER_POLICY, } from "./types.js";
@@ -15,7 +16,7 @@ import { createOpportunityReporter } from "./opportunityReporter.js";
 import { enrichWhaleContext, observe } from "./observe.js";
 import { buildDailyRiskBudget, buildFuturesCapacity, buildSystemPrompt, buildUserPrompt, } from "./prompt.js";
 import { parseDecision } from "./decision.js";
-import { validateAction, isRiskIncreasingAction, } from "./decisionValidator.js";
+import { validateAction, isRiskIncreasingAction, pmEventKey, pmCoinHorizonOf, pmReferenceMs, } from "./decisionValidator.js";
 import { resolvePmRef } from "./resolvePm.js";
 import { fetchQuote, executeAction } from "./act.js";
 import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
@@ -482,7 +483,7 @@ async function runCycleCore(deps, capture) {
         log,
     });
     // OBSERVE
-    const obs = await observe(client, spec, state, baseTrace);
+    const obs = await observe(client, spec, state, baseTrace, deps.observeOptions);
     const observation = obs.observation;
     const nowMs = Date.now();
     // Slice 2: attach to each open position the thesis it was opened on (from
@@ -632,7 +633,7 @@ async function runCycleCore(deps, capture) {
         // receipt over the observation the model actually decides on. The exit
         // traces above keep the pre-exit receipt they were decided on.
         observation.openPositions = observation.openPositions.filter((p) => !closedByThesis.includes(p.id));
-        observation.setups = scanSetups(observation.watch, observation.openPositions);
+        observation.setups = scanSetups(observation.watch, observation.openPositions, signalThresholdsOf(spec));
         observationReceipt = buildObservationReceipt(observation);
         Object.assign(baseTrace, observationReceipt);
     }
@@ -642,6 +643,17 @@ async function runCycleCore(deps, capture) {
     // so it touches NO kill-switch counter; it just records the cheap cycle.
     const policy = spec.triggerPolicy ?? DEFAULT_TRIGGER_POLICY;
     const gate = evaluateGate(observation, state, policy, nowMs);
+    const minimumMs = Number.isFinite(deps.minModelIntervalSeconds)
+        ? Math.max(0, deps.minModelIntervalSeconds ?? 0) * 1000
+        : 0;
+    if (gate.fire &&
+        spec.model?.provider !== "mechanical" &&
+        minimumMs > 0 &&
+        state.lastLlmCallAt != null &&
+        nowMs - state.lastLlmCallAt < minimumMs) {
+        gate.fire = false;
+        gate.reason = `shared pool model interval (${Math.ceil(minimumMs / 1000)}s minimum)`;
+    }
     const providerName = spec.model?.provider ?? "nvidia";
     if (!gate.fire) {
         capture({
@@ -664,8 +676,8 @@ async function runCycleCore(deps, capture) {
             tokensIn: 0,
             tokensOut: 0,
             estimatedCostUsd: 0,
-            writeAttempted: 0,
-            writeAccepted: 0,
+            writeAttempted: live ? exitPlanned.length : 0,
+            writeAccepted: exitPlanned.filter((p) => p.executed).length,
             ...observationReceipt,
         };
     }
@@ -725,13 +737,20 @@ async function runCycleCore(deps, capture) {
             includeForecast: forecastEnabled,
             ...actionAvailability,
         });
-        const user = buildUserPrompt(observation, state.journal, {
+        const userOptions = {
             venues: spec.venues,
             dailyRiskBudget: buildDailyRiskBudget(spec, state),
             ...(usesCapitalSizing(spec) ? { capitalSizing: spec.capitalSizing } : {}),
             ...(futuresCapacity ? { futuresCapacity } : {}),
             ...actionAvailability,
-        });
+        };
+        const user = buildUserPrompt(observation, state.journal, userOptions);
+        const compactUser = deps.compactPromptTables
+            ? buildUserPrompt(observation, state.journal, {
+                ...userOptions,
+                compactTables: true,
+            })
+            : undefined;
         const tokensInEst = Math.round((system.length + user.length) / 4);
         // Prompt-size + trigger visibility in the live terminal.
         log(`prompt ~${tokensInEst} tok ` +
@@ -745,6 +764,7 @@ async function runCycleCore(deps, capture) {
         const res = await provider.decide({
             system,
             user,
+            ...(compactUser && compactUser !== user ? { compactUser } : {}),
             ...actionAvailability,
         });
         const route = res.route;
@@ -761,12 +781,11 @@ async function runCycleCore(deps, capture) {
         // Metering: prefer provider-reported usage; fall back to a chars/4 estimate.
         const tokensIn = !actualCallMade
             ? 0
-            : res.ok
-                ? (res.usage?.promptTokens ?? tokensInEst)
-                : tokensInEst;
-        const tokensOut = res.ok
-            ? (res.usage?.completionTokens ?? Math.round(res.text.length / 4))
-            : 0;
+            : (res.usage?.promptTokens ?? tokensInEst);
+        const tokensOut = !actualCallMade
+            ? 0
+            : (res.usage?.completionTokens ??
+                (res.ok ? Math.round(res.text.length / 4) : 0));
         const estimatedCostUsd = estimateCostUsd(effectiveProvider ?? providerName, tokensIn, tokensOut);
         meter = {
             triggerCodes: gate.codes,
@@ -782,6 +801,8 @@ async function runCycleCore(deps, capture) {
             // hosted shared provider use this same path. Attribute only actual calls.
             routeReason: route?.reason ?? (actualCallMade ? "configured_direct" : undefined),
             routeAttempts: route?.attempts,
+            // Provider-reported usage only, never the estimate above.
+            ...(actualCallMade && res.usage ? { providerUsage: res.usage } : {}),
         };
         if (!res.ok) {
             // Upstream 429s are expected provider backpressure, not evidence that the
@@ -800,7 +821,9 @@ async function runCycleCore(deps, capture) {
                     decision: "skip",
                     skipReason: actualCallMade
                         ? "provider rate-limited; retry next cycle"
-                        : "provider capacity deferred",
+                        : res.error === "shared pool owner budget unavailable"
+                            ? "shared pool owner budget deferred"
+                            : "provider capacity deferred",
                     planned: exitPlanned,
                     modelFailed: false,
                     live,
@@ -811,7 +834,6 @@ async function runCycleCore(deps, capture) {
                     ...observationReceipt,
                 };
             }
-            state.consecutiveModelFailures += 1;
             // Permanent-failure classification: a 404/410/model_not_found is a
             // DECOMMISSIONED or misconfigured model that will fail every cycle
             // until something changes (live-measured 2026-08-26: NVIDIA EOL'd the
@@ -874,6 +896,12 @@ async function runCycleCore(deps, capture) {
                 }
             }
             else {
+                // Availability failures have their own route-specific hold counter.
+                // Charging them to the generic kill-switch as well disables BYO and
+                // self-hosted agents that keep retrying outside the shared circuit.
+                // Preserve prior transient/invalid-output failures until a valid
+                // decision clears them; a provider hold is not evidence of recovery.
+                state.consecutiveModelFailures += 1;
                 state.consecutivePermanentModelErrors = 0;
                 delete state.permanentModelErrorRoute;
             }
@@ -997,6 +1025,8 @@ async function runCycleCore(deps, capture) {
     const realizedLossTodayMusd = Math.max(0, -state.realizedPnlTodayMusd);
     const targetedPositionIds = [];
     const targetedOrderIds = [];
+    const pmEventsOpenedThisCycle = [];
+    const pmCoinHorizonsOpenedThisCycle = [];
     let anyAccepted = false;
     let anyExecuted = false;
     let anyExecFailed = false;
@@ -1197,6 +1227,9 @@ async function runCycleCore(deps, capture) {
             realizedLossTodayMusd,
             targetedPositionIds,
             targetedOrderIds,
+            pmEventsOpenedThisCycle,
+            pmCoinHorizonsOpenedThisCycle,
+            nowMs: Date.now(),
         };
         const v = validateAction(action, ctx);
         if (!v.valid) {
@@ -1233,6 +1266,17 @@ async function runCycleCore(deps, capture) {
         if (action.type === "spot_cancel") {
             targetedOrderIds.push(action.orderId);
         }
+        if (action.type === "pm_open") {
+            pmEventsOpenedThisCycle.push(pmEventKey(action.source, action.slug));
+            const opened = observation.pmMarkets.find((m) => m.source === action.source.toLowerCase() &&
+                m.slug === action.slug.toLowerCase() &&
+                m.outcomeExternalMarketId === action.outcomeExternalMarketId);
+            const horizon = opened
+                ? pmCoinHorizonOf(opened, pmReferenceMs(observation.asOf, ctx.nowMs))
+                : null;
+            if (horizon)
+                pmCoinHorizonsOpenedThisCycle.push(horizon);
+        }
         if (!live) {
             planned.push({
                 action,

package/dist/agent/setups.d.ts

@@ -1,3 +1,4 @@
+import { type SignalThresholds } from "./signals.js";
 import { OpenPosition, SetupSignal, WatchEntry } from "./types.js";
 export declare function baseSymbol(s: string | undefined): string;
-export declare function scanSetups(watch: WatchEntry[], openPositions?: OpenPosition[]): SetupSignal[];
+export declare function scanSetups(watch: WatchEntry[], openPositions?: OpenPosition[], thresholds?: SignalThresholds): SetupSignal[];