@coinrithm/mcp-trading 0.7.13 → 0.7.15

package/dist/agent/providerCapabilities.js

@@ -54,18 +54,48 @@ export function chatShapeFor(provider, model, baseUrl) {
         minProbeCompletionTokens: 1024,
     };
 }
+// Transport-only restriction: drop the excluded variants from the action oneOf
+// a route decodes against. parseDecision keeps validating the FULL contract, so
+// a route that does not enforce a schema can still propose the action and the
+// validator rejects it. Never returns an empty oneOf.
+export function restrictDecisionSchema(schema, exclude) {
+    if (!exclude?.length)
+        return schema;
+    const properties = schema.properties;
+    const actions = properties?.actions;
+    const variants = actions?.items?.oneOf;
+    if (!properties || !actions || !Array.isArray(variants))
+        return schema;
+    const kept = variants.filter((variant) => {
+        const type = variant
+            .properties?.type?.const;
+        return !exclude.includes(type);
+    });
+    if (kept.length === variants.length || kept.length === 0)
+        return schema;
+    return {
+        ...schema,
+        properties: {
+            ...properties,
+            actions: { ...actions, items: { ...actions.items, oneOf: kept } },
+        },
+    };
+}
 /** Build the chat-completions body for a route from its capability shape. */
 export function buildChatBody(shape, args) {
     const system = shape.systemHint
         ? `${shape.systemHint}\n\n${args.system}`
         : args.system;
+    const jsonSchema = shape.jsonSchema
+        ? restrictDecisionSchema(shape.jsonSchema, args.excludeActionTypes)
+        : undefined;
     return {
         model: args.model,
         ...(shape.allowsTemperature
             ? { temperature: args.temperature ?? 0.2 }
             : {}),
         [shape.tokenParam]: args.maxTokens,
-        ...(shape.jsonSchema && shape.jsonSchemaTransport === "tool_call"
+        ...(jsonSchema && shape.jsonSchemaTransport === "tool_call"
             ? {
                 tools: [
                     {
@@ -73,7 +103,7 @@ export function buildChatBody(shape, args) {
                         function: {
                             name: DECISION_TOOL_NAME,
                             description: "Submit the complete CoinRithm paper-trading decision for this cycle.",
-                            parameters: shape.jsonSchema,
+                            parameters: jsonSchema,
                         },
                     },
                 ],
@@ -85,12 +115,12 @@ export function buildChatBody(shape, args) {
             : {}),
         ...(shape.jsonResponseFormat && shape.jsonSchemaTransport !== "tool_call"
             ? {
-                response_format: shape.jsonSchema
+                response_format: jsonSchema
                     ? {
                         type: "json_schema",
                         json_schema: {
                             name: "coinrithm_trading_decision",
-                            schema: shape.jsonSchema,
+                            schema: jsonSchema,
                         },
                     }
                     : { type: "json_object" },

package/dist/agent/providers.d.ts

@@ -1,9 +1,11 @@
 import { AgentSpec, ProviderName } from "./types.js";
+import { type DecisionActionExclusion } from "./providerCapabilities.js";
 export interface DecideInput {
     system: string;
     user: string;
     maxTokens?: number;
     timeoutMs?: number;
+    excludeActionTypes?: readonly DecisionActionExclusion[];
 }
 export interface DecideRouteAttempt {
     provider: string;
@@ -26,6 +28,7 @@ export interface DecideRouteMeta {
 export type DecideResult = {
     ok: true;
     text: string;
+    responseSource?: "tool_call" | "content_fallback" | "content";
     usage?: {
         promptTokens: number;
         completionTokens: number;

package/dist/agent/providers.js

@@ -193,7 +193,7 @@ class AnthropicProvider {
                     }
                     : undefined;
                 return text
-                    ? { ok: true, text, usage }
+                    ? { ok: true, text, usage, responseSource: "content" }
                     : { ok: false, error: "anthropic returned empty content" };
             });
         }
@@ -246,6 +246,7 @@ class OpenAiCompatProvider {
                         system: input.system,
                         user: input.user,
                         maxTokens: input.maxTokens ?? 1024,
+                        excludeActionTypes: input.excludeActionTypes,
                     })),
                 });
                 if (!res.ok) {
@@ -273,7 +274,16 @@ class OpenAiCompatProvider {
                     }
                     : undefined;
                 return text
-                    ? { ok: true, text, usage }
+                    ? {
+                        ok: true,
+                        text,
+                        usage,
+                        responseSource: decisionArguments != null
+                            ? "tool_call"
+                            : shape.jsonSchemaTransport === "tool_call"
+                                ? "content_fallback"
+                                : "content",
+                    }
                     : { ok: false, error: "provider returned empty content" };
             });
         }

package/dist/agent/resolve.js

@@ -47,7 +47,14 @@ const CONFIG_BLOCKS = [
 const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;
 // Optional prose files (markdown the LLM reads), in assembly order.
-const PROSE_FILES = ["character/thesis.md", "character/persona.md"];
+const PROSE_FILES = [
+    "character/thesis.md",
+    "character/persona.md",
+    "character/entries.md",
+    "character/exits.md",
+    "character/sizing.md",
+    "character/research.md",
+];
 // Prose files carry an OPTIONAL YAML frontmatter block (type/title/description/
 // tags) that is authoring metadata, not doctrine — the model gains nothing from
 // `tags: [agent, persona, mean-reversion]`. It was being merged verbatim into

package/dist/agent/runner.js

@@ -9,10 +9,11 @@ import { usesCapitalSizing, prepareCapitalAction, validateCapitalAction, capital
 import { decideMechanical } from "./mechanical.js";
 import { evaluateGate, noteLlmCall, estimateCostUsd } from "./gate.js";
 import { baseSymbol, scanSetups } from "./setups.js";
+import { futuresEntryPreflight } from "./futuresEligibility.js";
 import { reconcileObservation } from "./reconcileObservation.js";
 import { createOpportunityReporter } from "./opportunityReporter.js";
-import { observe } from "./observe.js";
-import { buildDailyRiskBudget, buildSystemPrompt, buildUserPrompt, } from "./prompt.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 { resolvePmRef } from "./resolvePm.js";
@@ -425,10 +426,29 @@ async function runCycleCore(deps, capture) {
     const provenance = buildRunnerProvenance(spec);
     state.cyclesRun += 1;
     rollDay(state);
+    // Old state did not identify which route failed. Carrying that count into
+    // a replacement model can request a hold on its very first error.
+    if (state.consecutivePermanentModelErrors &&
+        !state.permanentModelErrorRoute) {
+        state.consecutivePermanentModelErrors = 0;
+    }
     const runId = state.runId;
     const decisionId = makeDecisionId(state.cyclesRun);
     const captureBase = { runId, decisionId, spec, mergedProse, state };
     capture({ ...captureBase, phase: "before_observation" });
+    // These exits happen before both provider invocation and action execution.
+    // Record that known absence explicitly; missing metering means unknown to
+    // audit consumers. Do not default later failures to zero: a call/write may
+    // already have occurred by then.
+    const preDecisionMeter = {
+        llmCallMade: false,
+        decisionType: "skip",
+        tokensIn: 0,
+        tokensOut: 0,
+        estimatedCostUsd: 0,
+        writeAttempted: 0,
+        writeAccepted: 0,
+    };
     // Kill-switch pre-check: a disabled agent never observes, decides, or acts.
     const tripped = checkKillSwitch(spec, state);
     if (tripped) {
@@ -442,6 +462,7 @@ async function runCycleCore(deps, capture) {
             disabled: true,
             disabledReason: tripped,
             live,
+            ...preDecisionMeter,
         };
     }
     // Establish durable run identity before the first possible write. A process
@@ -505,6 +526,7 @@ async function runCycleCore(deps, capture) {
             disabled: true,
             disabledReason: state.disabledReason,
             live,
+            ...preDecisionMeter,
             ...observationReceipt,
         };
     }
@@ -529,6 +551,7 @@ async function runCycleCore(deps, capture) {
                     disabled: true,
                     disabledReason: state.disabledReason,
                     live,
+                    ...preDecisionMeter,
                     ...observationReceipt,
                 };
             }
@@ -540,6 +563,7 @@ async function runCycleCore(deps, capture) {
             skipReason: obs.skip,
             planned: [],
             live,
+            ...preDecisionMeter,
             ...observationReceipt,
         };
     }
@@ -581,7 +605,7 @@ async function runCycleCore(deps, capture) {
             ...makeTrace(runId, decisionId, spec, undefined, `Thesis exit: ${why}`),
             ...observationReceipt,
         };
-        const r = await executeAction(client, action, observation, trace, idem, provenance);
+        const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
         exitPlanned.push({
             action,
             accepted: true,
@@ -618,15 +642,15 @@ 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);
-    capture({
-        ...captureBase,
-        phase: "decision_input",
-        observation,
-        observationFingerprint: observationReceipt.observationHash,
-        preThesisObservationFingerprint,
-    });
     const providerName = spec.model?.provider ?? "nvidia";
     if (!gate.fire) {
+        capture({
+            ...captureBase,
+            phase: "decision_input",
+            observation,
+            observationFingerprint: observationReceipt.observationHash,
+            preThesisObservationFingerprint,
+        });
         saveState(stateFile, state);
         log(`gate: skip (${gate.reason})`);
         return {
@@ -645,6 +669,20 @@ async function runCycleCore(deps, capture) {
             ...observationReceipt,
         };
     }
+    if (providerName !== "mechanical" &&
+        spec.capabilities.includes("whale_context") &&
+        spec.venues.includes("pm")) {
+        observation.whaleContext = await enrichWhaleContext(client, observation);
+        observationReceipt = buildObservationReceipt(observation);
+        Object.assign(baseTrace, observationReceipt);
+    }
+    capture({
+        ...captureBase,
+        phase: "decision_input",
+        observation,
+        observationFingerprint: observationReceipt.observationHash,
+        preThesisObservationFingerprint,
+    });
     // 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
@@ -672,19 +710,43 @@ async function runCycleCore(deps, capture) {
         };
     }
     else {
+        const futuresCapacity = spec.venues.includes("futures")
+            ? buildFuturesCapacity(spec, observation)
+            : undefined;
+        // One exclusion drives both the textual action menu and transport schema.
+        // It is a proposal hint only; parsing and validation stay unchanged.
+        const capacitySpent = futuresCapacity !== undefined &&
+            (futuresCapacity.slotsLeft === 0 ||
+                futuresCapacity.marginHeadroomMusd <= 0);
+        const actionAvailability = capacitySpent
+            ? { excludeActionTypes: ["futures_open"] }
+            : {};
         const system = buildSystemPrompt(spec, mergedProse, {
             includeForecast: forecastEnabled,
+            ...actionAvailability,
         });
         const user = buildUserPrompt(observation, state.journal, {
             venues: spec.venues,
             dailyRiskBudget: buildDailyRiskBudget(spec, state),
             ...(usesCapitalSizing(spec) ? { capitalSizing: spec.capitalSizing } : {}),
+            ...(futuresCapacity ? { futuresCapacity } : {}),
+            ...actionAvailability,
         });
         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 });
+        // With either futures cap spent, a schema-enforcing route is not offered
+        // futures_open at all. Other routes can still propose it; the validator
+        // rejects it there exactly as before.
+        if (capacitySpent) {
+            log(`futures capacity spent (slotsLeft ${futuresCapacity.slotsLeft}, marginHeadroomMusd ${futuresCapacity.marginHeadroomMusd}): futures_open withheld from schema-enforcing routes`);
+        }
+        const res = await provider.decide({
+            system,
+            user,
+            ...actionAvailability,
+        });
         const route = res.route;
         const actualCallMade = route
             ? route.attempts.some((attempt) => attempt.outcome !== "deferred")
@@ -764,13 +826,34 @@ async function runCycleCore(deps, capture) {
             // for what deserves them: revoked credentials, drawdown, kill-switch,
             // user action. Transient errors reset the permanent streak.
             if (isPermanentModelError(res.error)) {
+                // The router retains the last non-capacity failure even when a later
+                // fallback returns 429. Its effective route still describes the last
+                // actual call for metering, not necessarily the error returned here.
+                const failureAttempt = route?.attempts
+                    .slice()
+                    .reverse()
+                    .find((attempt) => attempt.outcome === "failed" &&
+                    attempt.failureClass !== "capacity" &&
+                    attempt.error === res.error);
+                const failureRoute = {
+                    provider: failureAttempt?.provider ??
+                        route?.effectiveProvider ??
+                        providerName,
+                    model: failureAttempt?.model ??
+                        route?.effectiveModel ??
+                        spec.model?.name ??
+                        "unknown",
+                };
+                const previousRoute = state.permanentModelErrorRoute;
+                const sameRoute = previousRoute?.provider === failureRoute.provider &&
+                    previousRoute?.model === failureRoute.model;
                 state.consecutivePermanentModelErrors =
-                    (state.consecutivePermanentModelErrors ?? 0) + 1;
+                    (sameRoute ? (state.consecutivePermanentModelErrors ?? 0) : 0) + 1;
+                state.permanentModelErrorRoute = failureRoute;
                 if (state.consecutivePermanentModelErrors >=
                     PERMANENT_MODEL_ERROR_THRESHOLD) {
                     const hold = {
-                        provider: route?.effectiveProvider ?? spec.model?.provider ?? "unknown",
-                        model: route?.effectiveModel ?? spec.model?.name ?? "unknown",
+                        ...failureRoute,
                         error: res.error.slice(0, 200),
                     };
                     saveState(stateFile, state);
@@ -792,6 +875,7 @@ async function runCycleCore(deps, capture) {
             }
             else {
                 state.consecutivePermanentModelErrors = 0;
+                delete state.permanentModelErrorRoute;
             }
             saveState(stateFile, state);
             log(`model error: ${res.error}`);
@@ -808,7 +892,27 @@ async function runCycleCore(deps, capture) {
                 ...observationReceipt,
             };
         }
+        // A returned model response proves availability even if its decision JSON
+        // is invalid. Output validation keeps its own failure counter below.
+        state.consecutivePermanentModelErrors = 0;
+        delete state.permanentModelErrorRoute;
         const parsed = parseDecision(res.text);
+        if (capacitySpent) {
+            // Persist only route provenance and a parsed action-presence bit in the
+            // existing cycle log. Unknown adapters and malformed decisions must not
+            // be miscounted as tool compliance; raw output stays unretained.
+            const responseSource = res.responseSource === "tool_call" ||
+                res.responseSource === "content_fallback" ||
+                res.responseSource === "content"
+                ? res.responseSource
+                : "unknown";
+            log(`capacity-response ${JSON.stringify({
+                responseSource,
+                withheldActionProposed: parsed.ok
+                    ? parsed.decision.actions.some((action) => action.type === "futures_open")
+                    : null,
+            })}`);
+        }
         if (!parsed.ok) {
             state.consecutiveModelFailures += 1;
             saveState(stateFile, state);
@@ -830,7 +934,6 @@ async function runCycleCore(deps, capture) {
             };
         }
         state.consecutiveModelFailures = 0;
-        state.consecutivePermanentModelErrors = 0;
         decision = parsed.decision;
     }
     // Reasoning captured for the Arena terminal (keystone transparency): the
@@ -935,7 +1038,7 @@ async function runCycleCore(deps, capture) {
                 log(`reject pm_open: duplicate_intent (hold PM ${pm.slug})`);
                 continue;
             }
-            // Independent forecast submission (HOUSE_AGENT_FORECAST_ENABLED, default ON).
+            // Market-aware 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
@@ -1027,7 +1130,26 @@ async function runCycleCore(deps, capture) {
                 }
             }
         }
-        const quote = await fetchQuote(client, action, observation, baseTrace);
+        // Supported-reference preflight (backend-v2 #106, J-74): skip a NEW futures
+        // open on a coin the observation EXPLICITLY reports has no supported (or only
+        // a stale) perpetual reference, before spending a quote the server gate would
+        // refuse. Unknown eligibility, adds/management on a held coin, spot and PM
+        // pass; the server gate stays authoritative at quote/open time.
+        const preflight = futuresEntryPreflight(action, observation);
+        if (preflight) {
+            planned.push({
+                action,
+                accepted: false,
+                code: preflight.code,
+                ...(capitalSizing ? { capitalSizing } : {}),
+                reason: preflight.reason,
+            });
+            log(`reject ${action.type}: ${preflight.code}`);
+            continue;
+        }
+        const quote = await fetchQuote(client, action, observation, baseTrace, {
+            pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct,
+        });
         // 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
@@ -1150,7 +1272,7 @@ async function runCycleCore(deps, capture) {
             rationaleForAction(action, decision.rationale, meta.rationaleSummary, decision.actions.length)),
             ...observationReceipt,
         };
-        const r = await executeAction(client, action, observation, trace, idem, provenance);
+        const r = await executeAction(client, action, observation, trace, idem, provenance, { pmMinEntryProbabilityPct: spec.risk.pmMinEntryProbabilityPct });
         planned.push({
             action,
             accepted: true,

package/dist/agent/skill.js

@@ -109,6 +109,15 @@ export function buildSpec(raw) {
                     entryPredicates: risk.entryPredicates,
                 }
                 : {}),
+            // Optional PM entry floor: an absent key stays absent (no floor); an
+            // explicit value is carried AS WRITTEN, malformed or not, so hosted
+            // validation fails closed instead of a typo silently meaning "no floor"
+            // (the same rule entryPredicates follow).
+            ...(risk.pmMinEntryProbabilityPct !== undefined
+                ? {
+                    pmMinEntryProbabilityPct: risk.pmMinEntryProbabilityPct,
+                }
+                : {}),
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),

package/dist/agent/skillValidator.js

@@ -108,6 +108,13 @@ export function validateSkill(parsed, mode = "self-host") {
             add("skill_risk_sl", "risk.requireStopLoss must be true or false");
         if (!Array.isArray(r.watchlist) || r.watchlist.length === 0)
             add("skill_risk_watchlist", "risk.watchlist must be a non-empty list of symbols");
+        // Optional PM entry floor: absent means no floor; present must be a finite
+        // number of probability points in [0, 100].
+        if (r.pmMinEntryProbabilityPct !== undefined) {
+            const f = r.pmMinEntryProbabilityPct;
+            if (typeof f !== "number" || !Number.isFinite(f) || f < 0 || f > 100)
+                add("skill_risk_pm_entry_floor", "risk.pmMinEntryProbabilityPct must be a number between 0 and 100 (points; omit for no floor)");
+        }
         // Fail-closed on the side restriction: a typo ("shorts_only") must never
         // silently mean "unrestricted" — that is exactly how a prose-only
         // constraint failed live on 2026-08-24.
@@ -171,8 +178,10 @@ export function validateSkill(parsed, mode = "self-host") {
                 add("skill_limits_trades", "limits.maxTradesPerDay must be a number >= 0 (0 = unlimited daily trades)");
             if (!isPosNum(l.maxWritesPerCycle))
                 add("skill_limits_writes", "limits.maxWritesPerCycle must be a positive number");
-            if (!isPosNum(l.maxDailyLossMusd))
-                add("skill_limits_loss", "limits.maxDailyLossMusd must be a positive number");
+            // 0 = no daily loss cap: the runner only enforces a positive value and
+            // the hosted API already accepts 0..50,000, so hosted validation must too.
+            if (!isNonNegNum(l.maxDailyLossMusd))
+                add("skill_limits_loss", "limits.maxDailyLossMusd must be a number >= 0 (0 = no daily loss cap)");
             if (!isPosNum(l.maxOpenMarginMusd))
                 add("skill_limits_open", "limits.maxOpenMarginMusd must be a positive number");
         }

package/dist/agent/strictLint.js

@@ -50,6 +50,7 @@ const ALLOWED_KEYS = {
         "blocklist",
         "direction",
         "entryPredicates",
+        "pmMinEntryProbabilityPct",
     ],
     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];