@coinrithm/mcp-trading 0.7.8 → 0.7.10

package/dist/agent/client.js

@@ -4,8 +4,10 @@
 // from an agent file). 429 backs off on Retry-After; 401/403/409/422 are
 // FAIL-CLOSED cycle outcomes (returned, not retried). fetch + sleep are
 // injectable so tests run with no network and no real waits.
-import { sleep as realSleep } from "./util.js";
+import { setTimeout as sleep } from "node:timers/promises";
+import { retryAfterSeconds } from "../retryAfter.js";
 export const DEFAULT_BASE_URL = "https://api.coinrithm.com";
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 function traceHeaders(trace) {
     const h = {};
     if (!trace)
@@ -30,6 +32,8 @@ export class CoinRithmClient {
     fetchFn;
     sleepFn;
     maxRetries;
+    requestTimeoutMs;
+    signal;
     extraHeaders;
     // Every 429 seen this session (read or write, retried or not) — feeds the
     // rate-limit-pressure kill-switch, which a write-only counter would miss.
@@ -38,8 +42,15 @@ export class CoinRithmClient {
         this.apiKey = cfg.apiKey;
         this.baseUrl = (cfg.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
         this.fetchFn = cfg.fetchFn ?? fetch;
-        this.sleepFn = cfg.sleepFn ?? realSleep;
+        this.sleepFn = cfg.sleepFn;
         this.maxRetries = cfg.maxRetries ?? 3;
+        this.requestTimeoutMs = cfg.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        if (!Number.isSafeInteger(this.requestTimeoutMs) ||
+            this.requestTimeoutMs < 1 ||
+            this.requestTimeoutMs > 2_147_483_647) {
+            throw new Error("requestTimeoutMs must be an integer between 1 and 2147483647");
+        }
+        this.signal = cfg.signal;
         this.extraHeaders = cfg.extraHeaders;
     }
     async request(method, path, opts = {}) {
@@ -59,53 +70,101 @@ export class CoinRithmClient {
         };
         if (opts.body !== undefined)
             headers["Content-Type"] = "application/json";
-        for (let attempt = 0;; attempt++) {
-            let res;
-            try {
-                res = await this.fetchFn(url.toString(), {
+        const controller = new AbortController();
+        let timedOut = false;
+        const cancel = () => controller.abort(new Error("API request cancelled"));
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort(new Error("API request deadline exceeded"));
+        }, this.requestTimeoutMs);
+        this.signal?.addEventListener("abort", cancel, { once: true });
+        if (this.signal?.aborted)
+            cancel();
+        let rejectAborted;
+        const aborted = new Promise((_, reject) => {
+            rejectAborted = () => reject(controller.signal.reason);
+            controller.signal.addEventListener("abort", rejectAborted, {
+                once: true,
+            });
+            if (controller.signal.aborted)
+                rejectAborted();
+        });
+        const perform = async () => {
+            for (let attempt = 0;; attempt++) {
+                controller.signal.throwIfAborted();
+                const res = await this.fetchFn(url.toString(), {
                     method,
                     headers,
                     body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+                    signal: controller.signal,
                 });
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    status: 0,
-                    data: {
-                        error: "network_error",
-                        message: err instanceof Error ? err.message : String(err),
-                    },
-                };
-            }
-            const retryAfter = Number(res.headers.get("retry-after"));
-            if (res.status === 429)
-                this.rateLimitHits += 1;
-            if (res.status === 429 && attempt < this.maxRetries) {
-                await this.sleepFn((Number.isFinite(retryAfter) ? retryAfter : 5) * 1000);
-                continue;
-            }
-            const text = await res.text();
-            let data = text;
-            if (text) {
-                try {
-                    data = JSON.parse(text);
+                controller.signal.throwIfAborted();
+                const retryAfter = retryAfterSeconds(res.headers.get("retry-after"));
+                if (res.status === 429)
+                    this.rateLimitHits += 1;
+                if (res.status === 429 && attempt < this.maxRetries) {
+                    // Release this response before waiting so retries do not retain sockets.
+                    void res.body?.cancel().catch(() => { });
+                    const delayMs = (retryAfter ?? 5) * 1000;
+                    // Never shorten a provider's Retry-After or overflow a Node timer.
+                    if (delayMs >= this.requestTimeoutMs)
+                        await aborted;
+                    else if (this.sleepFn)
+                        await this.sleepFn(delayMs);
+                    else
+                        await sleep(delayMs, undefined, { signal: controller.signal });
+                    continue;
                 }
-                catch {
-                    /* leave as text */
+                const text = await res.text();
+                controller.signal.throwIfAborted();
+                let data = text;
+                if (text) {
+                    try {
+                        data = JSON.parse(text);
+                    }
+                    catch {
+                        /* leave as text */
+                    }
                 }
+                return {
+                    ok: res.ok,
+                    status: res.status,
+                    data,
+                    retryAfterSeconds: res.status === 429 ? retryAfter : undefined,
+                    rateLimitRemaining: Number(res.headers.get("ratelimit-remaining")) || undefined,
+                    ledgerEventId: res.headers.get("x-coinrithm-ledger-event-id"),
+                };
             }
+        };
+        try {
+            // The race also bounds injected transports that do not honor AbortSignal.
+            return await Promise.race([perform(), aborted]);
+        }
+        catch (err) {
             return {
-                ok: res.ok,
-                status: res.status,
-                data,
-                retryAfterSeconds: res.status === 429 && Number.isFinite(retryAfter)
-                    ? retryAfter
-                    : undefined,
-                rateLimitRemaining: Number(res.headers.get("ratelimit-remaining")) || undefined,
-                ledgerEventId: res.headers.get("x-coinrithm-ledger-event-id"),
+                ok: false,
+                status: 0,
+                data: {
+                    error: timedOut
+                        ? "request_timeout"
+                        : controller.signal.aborted
+                            ? "request_aborted"
+                            : "network_error",
+                    message: timedOut
+                        ? `API request exceeded ${this.requestTimeoutMs}ms deadline`
+                        : controller.signal.aborted
+                            ? "API request cancelled"
+                            : err instanceof Error
+                                ? err.message
+                                : String(err),
+                },
             };
         }
+        finally {
+            clearTimeout(timer);
+            this.signal?.removeEventListener("abort", cancel);
+            controller.signal.removeEventListener("abort", rejectAborted);
+        }
     }
     // ── reads ──────────────────────────────────────────────────────────────────
     me(trace) {

package/dist/agent/configurationWarnings.d.ts

@@ -0,0 +1 @@
+export declare function configurationWarnings(raw: Record<string, unknown>): string[];

package/dist/agent/configurationWarnings.js

@@ -0,0 +1,21 @@
+// Advisory only: these fields remain loadable for backwards compatibility.
+export function configurationWarnings(raw) {
+    const warnings = [];
+    if (Array.isArray(raw.capabilities) &&
+        raw.capabilities.includes("websearch")) {
+        warnings.push("capabilities.websearch is reserved: the runner does not perform web searches");
+    }
+    if (raw.abstention && typeof raw.abstention === "object") {
+        for (const key of [
+            "onStaleData",
+            "onWeakSignal",
+            "onMissingQuote",
+            "onInsufficientBalance",
+        ]) {
+            if (Object.prototype.hasOwnProperty.call(raw.abstention, key)) {
+                warnings.push(`abstention.${key} is inactive: changing it does not change execution; freshness, quote and balance checks remain mandatory`);
+            }
+        }
+    }
+    return warnings;
+}

package/dist/agent/decisionReceipt.d.ts

@@ -3,9 +3,12 @@ import { type DailyRiskBudget } from "./prompt.js";
 export declare const DECISION_INPUT_MAX_BYTES: number;
 export type DecisionInputPhase = "before_observation" | "observed" | "decision_input";
 type Scalar = string | number | boolean | null;
-type Row = Record<string, Scalar | string[] | Record<string, Scalar | string[]>>;
+interface Row {
+    [key: string]: Scalar | string[] | Row;
+}
 export interface DecisionInputRecord {
     version: "coinrithm.decision-input.v1";
+    projectionVersion?: "coinrithm.decision-input-projection.v2";
     visibility: "private";
     completeness: "partial";
     phase: DecisionInputPhase;

package/dist/agent/decisionReceipt.js

@@ -49,6 +49,7 @@ export function buildDecisionInputRecord(input) {
     const budget = buildDailyRiskBudget(input.spec, input.state);
     const record = {
         version: "coinrithm.decision-input.v1",
+        projectionVersion: "coinrithm.decision-input-projection.v2",
         visibility: "private",
         completeness: "partial",
         phase: input.phase,
@@ -149,6 +150,12 @@ export function buildDecisionInputRecord(input) {
             ema20AboveEma50: bool(obj(r.indicators).ema20AboveEma50),
             brokeRecentHigh: bool(obj(r.indicators).brokeRecentHigh),
             brokeRecentLow: bool(obj(r.indicators).brokeRecentLow),
+            bollinger: numeric(obj(obj(r.indicators).bollinger), [
+                "upper",
+                "mid",
+                "lower",
+            ]),
+            recent20: numeric(obj(obj(r.indicators).recent20), ["high", "low"]),
         },
         fundamentals: numeric(obj(r.fundamentals), [
             "marketCapRank",
@@ -156,11 +163,18 @@ export function buildDecisionInputRecord(input) {
             "volume24hUsd",
         ]),
     }));
+    // Context-only movers are not executable candidates. Preserve their order
+    // and numeric facts without copying provider names or arbitrary free text.
+    add("universeMovers", obs.universeMovers, (r) => ({
+        symbol: id(r.symbol, 20),
+        ...numeric(r, ["change24hPct", "priceUsd"]),
+    }));
     add("futuresPositions", obs.openPositions, (r) => ({
         id: num(r.id),
         symbol: id(r.symbol, 20),
         coinId: id(r.coinId, 32),
         side: code(r.side, ["long", "short"]),
+        openedAt: sourceTimestamp(r.openedAt) ?? null,
         ...numeric(r, [
             "leverage",
             "marginMusd",
@@ -238,7 +252,6 @@ export function buildDecisionInputRecord(input) {
         ["news", obs.news],
         ["pmResolutions", obs.pmResolutions],
         ["newClosedTrades", obs.newClosedTrades],
-        ["universeMovers", obs.universeMovers],
         ["journal", input.state.journal],
     ]) {
         record.counts[name] = {
@@ -247,7 +260,7 @@ export function buildDecisionInputRecord(input) {
             omitted: arr(values).length,
         };
     }
-    record.omissions.push("unlisted_fields_and_nested_indicators_excluded");
+    record.omissions.push("unlisted_fields_excluded");
     if (Object.values(record.counts).some((v) => v.omitted > 0))
         record.omissions.push("list_rows_omitted");
     // Leave room for fixed outcome/error metadata. Drop the largest remaining
@@ -303,6 +316,7 @@ const OMISSIONS = [
     "config_fingerprint_unavailable",
     "observation_not_available",
     "unlisted_fields_and_nested_indicators_excluded",
+    "unlisted_fields_excluded",
     "list_rows_omitted",
     "byte_budget_exceeded",
     "evidence_capture_failed",
@@ -327,6 +341,7 @@ const LIST_KEYS = {
         "symbol",
         "coinId",
         "side",
+        "openedAt",
         "leverage",
         "marginMusd",
         "unrealizedPnlMusd",
@@ -361,6 +376,7 @@ const LIST_KEYS = {
         "decisionSupport",
     ],
     signals: ["symbol", "kind", "bias", "strength", "held"],
+    universeMovers: ["symbol", "change24hPct", "priceUsd"],
 };
 const NESTED_KEYS = {
     freshness: ["status", "ageSeconds", "asOf", "basis"],
@@ -391,7 +407,11 @@ const NESTED_KEYS = {
         "ema20AboveEma50",
         "brokeRecentHigh",
         "brokeRecentLow",
+        "bollinger",
+        "recent20",
     ],
+    bollinger: ["upper", "mid", "lower"],
+    recent20: ["high", "low"],
     fundamentals: ["marketCapRank", "marketCapUsd", "volume24hUsd"],
 };
 function keysOnly(value, keys) {
@@ -408,7 +428,7 @@ function validRow(value, keys) {
             return true;
         if (NESTED_KEYS[key])
             return validRow(v, NESTED_KEYS[key]);
-        if (key === "asOf" || key === "assessedAt")
+        if (key === "asOf" || key === "assessedAt" || key === "openedAt")
             return sourceTimestamp(v) === v;
         if (key === "basis")
             return code(v, FRESHNESS_BASES) !== null;
@@ -489,6 +509,7 @@ export function sanitizeDecisionInputRecord(value) {
         const r = JSON.parse(encoded);
         if (!keysOnly(r, [
             "version",
+            "projectionVersion",
             "visibility",
             "completeness",
             "phase",
@@ -506,6 +527,9 @@ export function sanitizeDecisionInputRecord(value) {
             "omissions",
         ]))
             return undefined;
+        if (r.projectionVersion !== undefined &&
+            r.projectionVersion !== "coinrithm.decision-input-projection.v2")
+            return undefined;
         if (r.version !== "coinrithm.decision-input.v1" ||
             r.visibility !== "private" ||
             r.completeness !== "partial")

package/dist/agent/decisionValidator.js

@@ -3,6 +3,7 @@
 // come from the spec (not the observation or the model), a prompt-injection in
 // market text cannot widen a limit or force a trade. Covers futures + spot + PM.
 import { ok, fail, actionVenue, spotBuyCost, } from "./types.js";
+import { checkEntryPredicates } from "./entryPredicates.js";
 const SERVER_MAX_LEVERAGE = 20;
 // Minimum edge, in probability POINTS, between the model's own forecast for
 // the outcome it is backing and what that outcome currently costs. Live
@@ -51,6 +52,9 @@ export function validateAction(action, ctx) {
         return fail("no_poll_before_write", "must successfully poll /trades before writing");
     }
     const increasesRisk = isRiskIncreasingAction(action);
+    const entryCondition = checkEntryPredicates(action, spec, observation);
+    if (!entryCondition.valid)
+        return entryCondition;
     if (increasesRisk &&
         ctx.riskIncreasesThisCycle >= spec.limits.maxWritesPerCycle) {
         return fail("write_budget_exceeded", `maxWritesPerCycle ${spec.limits.maxWritesPerCycle} reached`);

package/dist/agent/engine.d.ts

@@ -8,7 +8,7 @@ export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
 export { resolveAgent } from "./resolve.js";
 export { validateSkill, type SkillValidationMode } from "./skillValidator.js";
-export { newState, rollDay } from "./state.js";
+export { newState, rollDay, loadState, saveState } from "./state.js";
 export { makeRunId } from "./runEvidence.js";
 export { parseCadenceMs } from "./util.js";
 export { BENCHMARK_AGENTS, BENCHMARK_STRATEGIES, decideMechanical, isBenchmarkStrategy, type BenchmarkStrategy, type BenchmarkAgentDefinition, } from "./mechanical.js";

package/dist/agent/engine.js

@@ -18,7 +18,7 @@ export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec } from "./skill.js";
 export { resolveAgent } from "./resolve.js";
 export { validateSkill } from "./skillValidator.js";
-export { newState, rollDay } from "./state.js";
+export { newState, rollDay, loadState, saveState } from "./state.js";
 export { makeRunId } from "./runEvidence.js";
 export { parseCadenceMs } from "./util.js";
 // Mechanical BENCHMARK baseline agents (sol #7): the deterministic, non-LLM

package/dist/agent/entryPredicates.d.ts

@@ -0,0 +1,10 @@
+import type { AgentSpec, Observation, ProposedAction, ValidationResult } from "./types.js";
+export interface EntryPredicate {
+    side: "long" | "short";
+    metric: "change1h" | "change24h";
+    operator: "gte" | "lte";
+    threshold: number;
+    maxAgeSeconds: number;
+}
+export declare function entryPredicateIssues(value: unknown): ValidationResult[];
+export declare function checkEntryPredicates(action: ProposedAction, spec: AgentSpec, observation: Observation): ValidationResult;

package/dist/agent/entryPredicates.js

@@ -0,0 +1,67 @@
+import { fail, ok } from "./types.js";
+export function entryPredicateIssues(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 16)
+        return [
+            fail("entry_predicate_config", "risk.entryPredicates must contain 1–16 conditions"),
+        ];
+    const keys = ["side", "metric", "operator", "threshold", "maxAgeSeconds"];
+    const issues = [];
+    for (const [i, item] of value.entries()) {
+        const p = item;
+        if (!p ||
+            typeof p !== "object" ||
+            Array.isArray(p) ||
+            Object.keys(p).some((key) => !keys.includes(key)) ||
+            !["long", "short"].includes(p.side) ||
+            !["change1h", "change24h"].includes(p.metric) ||
+            !["gte", "lte"].includes(p.operator) ||
+            typeof p.threshold !== "number" ||
+            !Number.isFinite(p.threshold) ||
+            typeof p.maxAgeSeconds !== "number" ||
+            !Number.isFinite(p.maxAgeSeconds) ||
+            p.maxAgeSeconds <= 0) {
+            issues.push(fail("entry_predicate_config", `risk.entryPredicates[${i}] has an invalid condition`));
+        }
+    }
+    return issues;
+}
+export function checkEntryPredicates(action, spec, observation) {
+    const rules = spec.risk.entryPredicates;
+    if (rules === undefined)
+        return ok();
+    if (action.type !== "futures_open" &&
+        !(action.type === "spot_order" && action.side === "buy"))
+        return ok();
+    const invalid = entryPredicateIssues(rules);
+    if (invalid.length)
+        return invalid[0];
+    const side = action.type === "futures_open" ? action.side : "long";
+    const applicable = rules.filter((rule) => rule.side === side);
+    if (!applicable.length)
+        return ok();
+    const entry = observation.watch.find((item) => item.symbol.toUpperCase() === action.symbol.toUpperCase());
+    const observedAt = Date.parse(observation.asOf);
+    const age = entry?.freshness?.ageSeconds;
+    for (const rule of applicable) {
+        const value = entry?.[rule.metric];
+        // Missing evidence never becomes a passing predicate. Include time since
+        // observation so a long model call cannot freeze the freshness clock.
+        if (entry?.freshness?.status !== "fresh" ||
+            typeof age !== "number" ||
+            !Number.isFinite(age) ||
+            age < 0 ||
+            !Number.isFinite(observedAt) ||
+            age + Math.max(0, (Date.now() - observedAt) / 1000) >
+                rule.maxAgeSeconds ||
+            typeof value !== "number" ||
+            !Number.isFinite(value)) {
+            return fail("entry_predicate_evidence", `fresh ${rule.metric} evidence required for ${action.symbol}`);
+        }
+        if (!(rule.operator === "gte"
+            ? value >= rule.threshold
+            : value <= rule.threshold)) {
+            return fail("entry_predicate_false", `${action.symbol} ${rule.metric}=${value} does not satisfy ${rule.operator} ${rule.threshold}`);
+        }
+    }
+    return ok();
+}

package/dist/agent/gate.js

@@ -58,27 +58,27 @@ export function evaluateGate(observation, state, policy, nowMs) {
     // evaluate PREDICTION MARKETS — they carry edge even when crypto prices are flat,
     // so an agent on a quiet tape shouldn't go dark on PM. At most once per cooldown
     // (gated on the last LLM call, which any fire resets), so it's not every cycle.
+    let pmPeriodic = false;
     if (codeList.length === 0) {
         const pmAvailable = observation.pmMarkets.length > 0;
         const sinceLastCall = state.lastLlmCallAt == null ? Infinity : nowMs - state.lastLlmCallAt;
         if (pmAvailable &&
             policy.pmEvalCooldownMinutes > 0 &&
             sinceLastCall >= policy.pmEvalCooldownMinutes * 60_000) {
+            pmPeriodic = true;
+            codeList.push("PM_PERIODIC");
+        }
+        else {
             return {
-                fire: true,
-                codes: ["PM_PERIODIC"],
-                reason: "PM periodic eval (quiet price tape)",
+                fire: false,
+                codes: [],
+                reason: "no trigger (flat tape, no open position)",
             };
         }
-        return {
-            fire: false,
-            codes: [],
-            reason: "no trigger (flat tape, no open position)",
-        };
     }
     // A real trigger exists. Open positions are NEVER starved by budget/debounce
     // (managing a live position is always allowed); the caps below only throttle
-    // fresh entry-only cycles so a chop-storm of entry setups can't burn the budget.
+    // fresh entry-only cycles, including periodic PM evaluations.
     if (!hasPosition) {
         if (policy.maxLlmCallsPerHour > 0) {
             const recent = (state.llmCallTimestamps ?? []).filter((t) => nowMs - t < 3_600_000);
@@ -90,7 +90,8 @@ export function evaluateGate(observation, state, policy, nowMs) {
                 };
             }
         }
-        if (policy.debounceMinutes > 0) {
+        // PM already passed its own cooldown; debounce only crypto-entry triggers.
+        if (!pmPeriodic && policy.debounceMinutes > 0) {
             const fp = [...codeList].sort().join(",");
             if (state.lastTriggerFingerprint === fp &&
                 state.lastLlmCallAt != null &&
@@ -106,7 +107,9 @@ export function evaluateGate(observation, state, policy, nowMs) {
     return {
         fire: true,
         codes: codeList,
-        reason: `triggers: ${codeList.join(",")}`,
+        reason: pmPeriodic
+            ? "PM periodic eval (quiet price tape)"
+            : `triggers: ${codeList.join(",")}`,
     };
 }
 // Record that this cycle spent an LLM call — feeds the budget + debounce next

package/dist/agent/opportunityReporter.d.ts

@@ -0,0 +1,16 @@
+import type { CoinRithmClient, ProvenanceReport } from "./client.js";
+import type { AgentSpec, AgentTrace, PostedOpportunity } from "./types.js";
+export declare function createOpportunityReporter({ client, spec, live, enabled, runId, decisionId, provenance, baseTrace, log, }: {
+    client: CoinRithmClient;
+    spec: AgentSpec;
+    live: boolean;
+    enabled: boolean;
+    runId: string;
+    decisionId: string;
+    provenance: ProvenanceReport;
+    baseTrace: AgentTrace;
+    log: (line: string) => void;
+}): {
+    post: (o: PostedOpportunity) => Promise<void>;
+    readonly posted: PostedOpportunity | undefined;
+};

package/dist/agent/opportunityReporter.js

@@ -0,0 +1,38 @@
+export function createOpportunityReporter({ client, spec, live, enabled, runId, decisionId, provenance, baseTrace, log, }) {
+    let opportunityPosted = false;
+    let postedOpportunity;
+    const post = async (o) => {
+        if (!enabled || !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)}`);
+        }
+    };
+    return {
+        post,
+        get posted() {
+            return postedOpportunity;
+        },
+    };
+}

package/dist/agent/prompt.js

@@ -117,6 +117,11 @@ opts = {}) {
                     : '- DIRECTION: LONG ONLY — every futures_open MUST be side:"long". A short is REJECTED by the runner no matter how strong the setup looks.',
             ]
             : []),
+        ...(r.entryPredicates
+            ? [
+                `- Binding crypto entry conditions (all conditions matching the entry side must pass on fresh observed data): ${JSON.stringify(r.entryPredicates)}. Missing evidence is a rejection. These conditions never authorize exceeding another cap.`,
+            ]
+            : []),
         // With universe_scan, the validator's gate is WATCH-membership (manual
         // watchlist ∪ this cycle's discovered entries) — saying "ONLY these" here
         // while the universe-scan section below calls discovered movers tradable

package/dist/agent/providers.d.ts

@@ -20,7 +20,7 @@ export interface DecideRouteMeta {
     profile: "fast" | "strong" | "configured";
     effectiveProvider?: string;
     effectiveModel?: string;
-    reason: "configured" | "circuit_fallback" | "capacity_fallback" | "provider_fallback" | "malformed_fallback" | "byo";
+    reason: "configured" | "configured_direct" | "circuit_fallback" | "capacity_fallback" | "provider_fallback" | "malformed_fallback" | "byo";
     attempts: DecideRouteAttempt[];
 }
 export type DecideResult = {
@@ -36,6 +36,7 @@ export type DecideResult = {
     error: string;
     status?: number;
     retryAfterMs?: number;
+    retryableHttpFailure?: true;
     deferred?: boolean;
     route?: DecideRouteMeta;
 };