@coinrithm/mcp-trading 0.7.6 → 0.7.8

package/dist/agent/decisionValidator.js

@@ -4,7 +4,43 @@
 // market text cannot widen a limit or force a trade. Covers futures + spot + PM.
 import { ok, fail, actionVenue, spotBuyCost, } from "./types.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
+// 2026-09-02: of 7 executed pm_opens in the first release window, 3 backed an
+// outcome their own forecast priced at or BELOW the market (worst -53 points,
+// mean -0.7), i.e. an agent paid 65 for something it thought was worth 45. A
+// few points of cushion also covers spread and fees rather than trading a
+// rounding difference. Env-tunable for a fleet retune without a redeploy.
+const PM_MIN_FORECAST_EDGE_POINTS = (() => {
+    const raw = Number(process.env.AGENT_PM_MIN_FORECAST_EDGE_POINTS);
+    return Number.isFinite(raw) && raw >= 0 ? raw : 2;
+})();
 const PM_MIN_STAKE_MUSD = 10; // server minimum prediction-market stake
+// Entry budgets are exposure budgets, not emergency-action budgets. Closing a
+// futures position, updating its protection, cancelling an order, or selling
+// spot reduces/contains risk and must remain available after an entry cap.
+/**
+ * True when a thesis says, in so many words, that it is betting AGAINST the
+ * outcome the action is buying. Deliberately narrow: it fires only when the
+ * negation names the backed outcome directly ("betting against the Up
+ * outcome" while buying Up), because a false positive here silences a
+ * legitimate trade. Live shape 2026-09-02, cycle 863728.
+ */
+export function thesisContradictsOutcome(summary, outcomeName) {
+    if (!summary || !outcomeName)
+        return false;
+    const outcome = outcomeName.trim().toLowerCase();
+    if (!outcome)
+        return false;
+    const escaped = outcome.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const negation = new RegExp("\\b(?:against|fade|fading)\\s+(?:the\\s+)?[\"']?" + escaped + "\\b", "i");
+    return negation.test(summary);
+}
+export function isRiskIncreasingAction(action) {
+    return (action.type === "futures_open" ||
+        action.type === "pm_open" ||
+        (action.type === "spot_order" && action.side === "buy"));
+}
 export function validateAction(action, ctx) {
     const { spec, observation } = ctx;
     const venue = actionVenue(action);
@@ -14,15 +50,18 @@ export function validateAction(action, ctx) {
     if (spec.sync.requirePollBeforeWrite && !observation.polledBeforeWrite) {
         return fail("no_poll_before_write", "must successfully poll /trades before writing");
     }
-    if (ctx.writesThisCycle >= spec.limits.maxWritesPerCycle) {
+    const increasesRisk = isRiskIncreasingAction(action);
+    if (increasesRisk &&
+        ctx.riskIncreasesThisCycle >= spec.limits.maxWritesPerCycle) {
         return fail("write_budget_exceeded", `maxWritesPerCycle ${spec.limits.maxWritesPerCycle} reached`);
     }
     // maxTradesPerDay <= 0 means UNLIMITED daily trade count — house agents are never
     // throttled (we want an active Arena), and hosted agents only when the customer sets a
     // positive cap. The risk caps below (daily loss, open margin, leverage, stops) are the
     // real guardrails and always apply regardless of the trade-count cap.
-    if (spec.limits.maxTradesPerDay > 0 &&
-        ctx.writesToday >= spec.limits.maxTradesPerDay) {
+    if (increasesRisk &&
+        spec.limits.maxTradesPerDay > 0 &&
+        ctx.riskIncreasesToday >= spec.limits.maxTradesPerDay) {
         return fail("daily_trade_cap", `maxTradesPerDay ${spec.limits.maxTradesPerDay} reached`);
     }
     // Deny-list: an open on a blocked symbol is rejected up front (deny wins over
@@ -36,6 +75,29 @@ export function validateAction(action, ctx) {
             }
         }
     }
+    // Direction constraint (2026-08-24): a strategy's side restriction is a HARD
+    // cap, not prose-obedience. Live incident: a short-only fade agent opened
+    // two momentum LONGS when the flagged-setups act-pressure outweighed its
+    // prose. Closes/SL-TP/cancels are never direction-gated — reducing or
+    // protecting an existing position is not a directional bet.
+    const direction = spec.risk.direction;
+    if (direction) {
+        if (action.type === "futures_open") {
+            if (direction === "short_only" && action.side !== "short") {
+                return fail("direction_constraint", `direction ${direction}: futures_open side must be "short", got "${action.side}"`);
+            }
+            if (direction === "long_only" && action.side !== "long") {
+                return fail("direction_constraint", `direction ${direction}: futures_open side must be "long", got "${action.side}"`);
+            }
+        }
+        // Spot buys are long exposure; a short_only agent must not accumulate
+        // them. Spot sells reduce a holding and stay allowed.
+        if (action.type === "spot_order" &&
+            direction === "short_only" &&
+            action.side === "buy") {
+            return fail("direction_constraint", `direction ${direction}: spot buys are long exposure`);
+        }
+    }
     if (action.type === "futures_open") {
         // Daily realized-loss stop: once today's loss hits the cap, open no new risk.
         if (spec.limits.maxDailyLossMusd > 0 &&
@@ -250,6 +312,38 @@ export function validateAction(action, ctx) {
         if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
             return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
         }
+        // Forecast consistency. By prompt contract forecastProbability is the
+        // model's own probability (1-99) that the outcome IT IS BACKING wins, so
+        // buying that outcome only makes sense when the forecast clears what the
+        // market charges for it. An ABSENT forecast still never blocks a bet (the
+        // prompt promises that); a PRESENT one that contradicts the trade does.
+        // The API's entryProbability is the RAW mid, and executionModel's effective
+        // probability excludes fee. Total stake / net shares is the fee-inclusive
+        // break-even cost. Do not guess units or fall back to a discovery mid.
+        if (!ctx.mechanical && action.forecastProbability != null) {
+            const stake = ctx.quote.stakeMusd;
+            const shares = ctx.quote.sharesEstimate;
+            const entryPct = typeof stake === "number" &&
+                Number.isFinite(stake) &&
+                stake > 0 &&
+                stake === action.stakeMusd &&
+                typeof shares === "number" &&
+                Number.isFinite(shares) &&
+                shares > 0
+                ? (stake / shares) * 100
+                : NaN;
+            if (!Number.isFinite(entryPct) || entryPct <= 0) {
+                return fail("pm_quote_cost_unavailable", "forecast edge requires a matching stake and positive finite net share estimate");
+            }
+            const edge = action.forecastProbability - entryPct;
+            // A cost over 100 is possible; do not clamp an uneconomic quote into range.
+            if (edge + 1e-9 < PM_MIN_FORECAST_EDGE_POINTS) {
+                return fail("forecast_no_positive_edge", `forecast ${action.forecastProbability} vs entry ${entryPct.toFixed(1)} = ${edge.toFixed(1)}pt edge, under the ${PM_MIN_FORECAST_EDGE_POINTS}pt minimum`);
+            }
+        }
+        if (thesisContradictsOutcome(action.thesis?.summary, mkt.outcomeName)) {
+            return fail("thesis_action_conflict", `thesis bets against ${mkt.outcomeName}, which this action buys`);
+        }
         return ok();
     }
     return fail("unknown_action", "unsupported action type");

package/dist/agent/engine.d.ts

@@ -1,5 +1,9 @@
 export { runCycle, type RunnerDeps } from "./runner.js";
-export { selectProvider, type ProviderEnv, type Provider, } from "./providers.js";
+export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, type DecisionInputRecord, } from "./decisionReceipt.js";
+export { selectProvider, providerForRoute, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
+export { parseDecision } from "./decision.js";
+export { chatShapeFor, buildChatBody, type ChatShape, } from "./providerCapabilities.js";
+export { probeDecisionContract, type ProbeRoute, type ProbeDecisionResult, } from "./decisionProbe.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
 export { resolveAgent } from "./resolve.js";

package/dist/agent/engine.js

@@ -6,7 +6,14 @@
 // This barrel is the ONE import a host scheduler needs; it re-exports only the
 // stable engine pieces, never the CLI.
 export { runCycle } from "./runner.js";
-export { selectProvider, } from "./providers.js";
+export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, } from "./decisionReceipt.js";
+export { selectProvider, providerForRoute, } from "./providers.js";
+export { parseDecision } from "./decision.js";
+// Reliability slice A: the declarative request-capability table and the
+// representative decision probe (route eligibility = a REAL parsed decision,
+// never a bare HTTP 200 — the 62f3a12 lesson).
+export { chatShapeFor, buildChatBody, } from "./providerCapabilities.js";
+export { probeDecisionContract, } from "./decisionProbe.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec } from "./skill.js";
 export { resolveAgent } from "./resolve.js";

package/dist/agent/observe.js

@@ -4,6 +4,8 @@
 import { asObj, asArr, asNum, asStr } from "./extract.js";
 import { computeIndicators } from "./indicators.js";
 import { scanSetups } from "./setups.js";
+import { freshnessOf, pmQualityOf, pmDecisionSupportOf } from "./pmContext.js";
+import { deriveCapitalBook, usesCapitalSizing } from "./capitalSizing.js";
 // Candle granularity feeding the indicators: the 1D range = 5-minute candles
 // (~5-min fresh, ~288 bars — ample for EMA50/RSI14/Bollinger20), which suits the
 // short cadence the hosted house agents run on. Probe-verified 2026-06-17.
@@ -11,8 +13,36 @@ const INDICATOR_RANGE = "1D";
 // `universe_scan` bounds: how many top movers to pull, and how many of those
 // to fully resolve into tradable watch entries (each resolved row costs a
 // resolve + market [+ candles] call).
+//
+// RESOLVE_TOP 3 -> 6 on 2026-08-21. Only a resolved row carries indicators, and
+// therefore a `setups` flag; the unresolved remainder is bare symbol + 24h
+// change + price. At 3, a discovery-driven strategy could reason properly about
+// exactly three coins per cycle out of fifteen surfaced.
+//
+// That bit a real user case. A pump-fade agent identifies a candidate from a
+// `stretched`/`fade-short` setup (RSI14 >= 68) and then waits for exhaustion,
+// which by definition means RSI is NO LONGER extreme. Nothing persists between
+// cycles, so the candidate has to still be a resolved row at the moment the
+// exhaustion evidence appears. Discovery is gainers-ranked, so a retracing coin
+// slides down the list — at 3 it fell out almost immediately and went blind
+// exactly when the strategy needed to look at it.
+//
+// 6 roughly doubles how far a coin can slide before losing its indicators. Cost
+// is 3 extra market+candles calls per cycle against CoinRithm's own API (never
+// the model quota) and ~3 more watch entries in the prompt, and only for agents
+// that declare universe_scan.
 const UNIVERSE_SCAN_LIMIT = 15;
-const UNIVERSE_RESOLVE_TOP = 3;
+const UNIVERSE_RESOLVE_TOP = 6;
+// A number that may arrive as a decimal string (the public movers feed).
+const asNumLoose = (v) => {
+    if (typeof v === "number")
+        return Number.isFinite(v) ? v : undefined;
+    if (typeof v === "string" && v.trim() !== "") {
+        const n = Number(v);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    return undefined;
+};
 // Watchlist symbols -> the coin NAMES prediction-market titles use, so an agent
 // discovers PM markets about the coins it actually has a price view on.
 const PM_COIN_NAMES = {
@@ -43,10 +73,11 @@ const PM_CALIBRATION_CHURN_RE = /(updown|up-or-down|-5-?min|-5m-|-15m|15m(?:-|$)
 export function isCalibrationChurnMarket(market) {
     return PM_CALIBRATION_CHURN_RE.test(`${market.slug ?? ""} ${market.title ?? ""}`);
 }
-// Fetch candles for one coin and reduce them to a compact indicator bundle.
-// Tolerant by design: any failure (HTTP error, malformed/sparse candles) returns
-// null so the cycle proceeds with price-only context rather than skipping.
-async function fetchIndicators(client, coinId, trace) {
+// Fetch candles for one coin and reduce them to a compact indicator bundle plus
+// the 24h volume. Tolerant by design: any failure (HTTP error, malformed/sparse
+// candles) yields null indicators so the cycle proceeds with price-only context
+// rather than skipping.
+async function fetchCandleContext(client, coinId, trace) {
     // The try honors the documented tolerance for SYNCHRONOUS throws too (an
     // unexpected client error must degrade to price-only context, never kill
     // the cycle).
@@ -55,10 +86,10 @@ async function fetchIndicators(client, coinId, trace) {
         cr = await client.candles(coinId, INDICATOR_RANGE, trace);
     }
     catch {
-        return null;
+        return { indicators: null };
     }
     if (!cr.ok)
-        return null;
+        return { indicators: null };
     // Endpoint shape: { candles: [{ t, o, h, l, c, v }] } ascending (oldest first).
     const candles = [];
     for (const raw of asArr(asObj(cr.data).candles)) {
@@ -71,12 +102,78 @@ async function fetchIndicators(client, coinId, trace) {
             continue;
         candles.push({ open, high, low, close, volume: asNum(c.v) ?? undefined });
     }
-    return computeIndicators(candles);
+    const lastVolume = candles.length > 0 ? candles[candles.length - 1].volume : undefined;
+    return {
+        indicators: computeIndicators(candles),
+        volume24hUsd: typeof lastVolume === "number" && lastVolume > 0 ? lastVolume : undefined,
+    };
 }
-function freshnessOf(block) {
-    const fr = asObj(block.freshness);
-    const status = asStr(fr.status);
-    return status ? { status, ageSeconds: asNum(fr.ageSeconds) } : undefined;
+// The fundamentals leg of a watch entry, read from the /market context the
+// entry is already built from (coin.categories, coin.marketCapRank,
+// price.marketCapUsd). Absent fields stay absent.
+function coinFundamentalsOf(m) {
+    const coin = asObj(m.coin);
+    const price = asObj(m.price);
+    const out = {};
+    const categories = asArr(coin.categories)
+        .map((c) => asStr(c))
+        .filter((c) => !!c)
+        .slice(0, 3);
+    if (categories.length > 0)
+        out.categories = categories;
+    const rank = asNum(coin.marketCapRank);
+    if (rank != null)
+        out.marketCapRank = rank;
+    const marketCapUsd = asNum(price.marketCapUsd);
+    if (marketCapUsd != null)
+        out.marketCapUsd = marketCapUsd;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+// Enrich a watch entry with what the candles fetch yields (indicators + 24h
+// volume) when the `indicators` capability is on. One call, both fields.
+async function enrichFromCandles(client, entry, coinId, trace) {
+    const cc = await fetchCandleContext(client, coinId, trace);
+    if (cc.indicators)
+        entry.indicators = cc.indicators;
+    if (cc.volume24hUsd != null) {
+        entry.fundamentals = {
+            ...(entry.fundamentals ?? {}),
+            volume24hUsd: cc.volume24hUsd,
+        };
+    }
+}
+const HEADLINES_PER_COIN = 3;
+const HEADLINE_TITLE_CHARS = 110;
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// Attribute the fetched news to the coins on watch: by the curated slug link
+// when the entry's slug is known (the graph, never a fuzzy match), else by a
+// case-insensitive coin-name or exact-case ticker mention in the title. At most
+// HEADLINES_PER_COIN per coin, in the API's importance-then-recency order.
+function attachHeadlines(watch, items) {
+    for (const w of watch) {
+        const slug = (w.slug ?? "").toLowerCase();
+        const name = (w.name ?? "").toLowerCase();
+        const tickerRe = new RegExp(`\\b${escapeRegExp(w.symbol)}\\b`);
+        const mine = items
+            .filter((it) => {
+            if (slug)
+                return (it.coins ?? []).some((c) => c.toLowerCase() === slug);
+            const title = it.title.toLowerCase();
+            return ((name.length >= 3 && title.includes(name)) || tickerRe.test(it.title));
+        })
+            .slice(0, HEADLINES_PER_COIN);
+        if (mine.length === 0)
+            continue;
+        w.fundamentals = {
+            ...(w.fundamentals ?? {}),
+            headlines: mine.map((it) => ({
+                title: it.title.slice(0, HEADLINE_TITLE_CHARS),
+                ...(it.publishedAt ? { at: it.publishedAt } : {}),
+                ...(it.importance != null ? { importance: it.importance } : {}),
+                ...(it.sentiment ? { sentiment: it.sentiment } : {}),
+            })),
+        };
+    }
 }
 // Does a market title reference the given watchlist coin? Matches on the PM coin
 // NAME ("Bitcoin") or the ticker ("BTC"), case-insensitively — the discover `q`
@@ -102,6 +199,11 @@ function expandPmMarkets(discData, heldPmKeys) {
     return (asArr(dd.data ?? dd.markets ?? dd.results)
         .map(asObj)
         .flatMap((ev) => {
+        // Explicit negative evidence removes only NEW-entry candidates. Unknown
+        // quality stays unknown; fresh quote + transactional guards remain final.
+        if (ev.eligible === false ||
+            asObj(ev.quality).decisionEligible === false)
+            return [];
         const source = (asStr(ev.source) ?? "").toLowerCase();
         const slug = (asStr(ev.slug) ?? "").toLowerCase();
         // Keep titles SHORT: the model only needs to recognise the market.
@@ -109,6 +211,8 @@ function expandPmMarkets(discData, heldPmKeys) {
         // prompt to ~69k tokens (413s on small-context free models).
         const title = (asStr(ev.title) ?? asStr(ev.question) ?? "").slice(0, 80);
         const freshness = freshnessOf(ev); // freshness is event-level
+        const quality = pmQualityOf(ev.quality);
+        const decisionSupport = pmDecisionSupportOf(ev.decisionSupport);
         // Event-level 24h volume (the discover payload's `volume24h`, USD). Feeds
         // the mechanical BENCHMARK agents' deterministic highest-volume pick rule.
         // Same for every outcome of the event; undefined on an older backend.
@@ -119,13 +223,17 @@ function expandPmMarkets(discData, heldPmKeys) {
         // model never bets a market that would fail the binary entry gate at
         // quote. Back-compat: an older backend omits `eligible` (undefined) ->
         // the outcome is kept (current behaviour).
-        const outcomes = asArr(ev.outcomes)
+        const outcomes = (Object.hasOwn(ev, "outcomes") ? asArr(ev.outcomes) : [ev])
             .map(asObj)
             .filter((o) => o.eligible !== false)
+            .filter((o) => {
+            const p = asNum(o.probability);
+            return p != null && p >= 0 && p <= 100;
+        })
             .slice(0, 3);
-        // A market with no outcomes array still round-trips a flat fallback row.
-        const rows = outcomes.length > 0 ? outcomes : [ev];
-        return rows.map((o) => ({
+        // Only an absent legacy outcomes field permits the flat fallback. A
+        // present empty/malformed/all-rejected array must never resurrect ev.
+        return outcomes.map((o) => ({
             source,
             slug,
             outcomeExternalMarketId: asStr(o.externalMarketId) ?? asStr(o.outcomeExternalMarketId) ?? "",
@@ -134,13 +242,22 @@ function expandPmMarkets(discData, heldPmKeys) {
             outcomeName: asStr(o.name) ?? asStr(o.outcomeName) ?? undefined,
             // Backend returns probability as 0..100 (percent) — normalise to 0..1
             // to match the prompt's "0..1" framing (probed 2026-06-24).
-            probability: ((p) => (p == null ? undefined : p > 1 ? p / 100 : p))(asNum(o.probability)),
+            probability: ((p) => p == null || p < 0 || p > 100 ? undefined : p / 100)(asNum(o.probability)),
             title,
             freshness,
+            quality,
+            decisionSupport,
             volumeUsd,
+            // Event-level fundamentals from the same payload (slice 2): the
+            // resolution date and the venue-reported liquidity (USD).
+            endDate: asStr(ev.endDate) ?? undefined,
+            liquidityUsd: asNum(ev.liquidity) ?? undefined,
         }));
     })
-        .filter((m) => m.source && m.slug && m.outcomeExternalMarketId)
+        .filter((m) => m.source &&
+        m.slug &&
+        m.outcomeExternalMarketId &&
+        m.probability != null)
         // Drop already-held markets so the model only sees markets it can actually
         // open — done BEFORE any slice so held positions don't consume candidate slots.
         .filter((m) => !heldPmKeys.has(`${m.source.toLowerCase()}|${m.slug.toLowerCase()}|${m.outcomeExternalMarketId}`)));
@@ -202,6 +319,7 @@ export async function observe(client, spec, state, trace) {
         return {
             venue: "futures",
             id: Number(asNum(p.id) ?? p.id),
+            ...(usesCapitalSizing(spec) ? { walletId: asNum(p.walletId) } : {}),
             coinId: asStr(coin.ucid) ?? asStr(p.coinId),
             symbol: asStr(coin.symbol) ?? asStr(p.symbol),
             side: asStr(p.side),
@@ -214,6 +332,7 @@ export async function observe(client, spec, state, trace) {
             liquidationPrice: asNum(p.liquidationPrice),
             stopLossPrice: asNum(p.stopLossPrice),
             takeProfitPrice: asNum(p.takeProfitPrice),
+            openedAt: asStr(p.openedAt),
         };
     });
     // Sync poll: /trades since the persisted cursor.
@@ -268,7 +387,14 @@ export async function observe(client, spec, state, trace) {
             sentimentBullishPct: asNum(asObj(m.sentiment).bullishPct) ?? undefined,
             // Freshness lives under the response's `observation` block.
             freshness: freshnessOf(asObj(m.observation)),
+            // Canonical slug (the news graph's key): from the resolve match, else
+            // the market context's observation.dataset.coinSlug.
+            slug: asStr(match.slug) ??
+                asStr(asObj(asObj(m.observation).dataset).coinSlug),
         };
+        const fundamentals = coinFundamentalsOf(m);
+        if (fundamentals)
+            entry.fundamentals = fundamentals;
         // Capture the market-wide Fear & Greed regime once (same across coins).
         if (!marketMood) {
             const fg = asObj(m.fearGreed);
@@ -279,11 +405,8 @@ export async function observe(client, spec, state, trace) {
         // `indicators` capability: enrich the observation with computed TA so the
         // model reasons over structure (trend/momentum/volatility/breakout) instead
         // of price + %change alone. Backed by the candles endpoint's shared cache.
-        if (wantIndicators) {
-            const ind = await fetchIndicators(client, coinId, trace);
-            if (ind)
-                entry.indicators = ind;
-        }
+        if (wantIndicators)
+            await enrichFromCandles(client, entry, coinId, trace);
         watch.push(entry);
     }
     // `universe_scan` capability (2026-08-18, direct user request): discover the
@@ -305,8 +428,12 @@ export async function observe(client, spec, state, trace) {
                 .map((r) => ({
                 symbol: (asStr(r.symbol) ?? "").toUpperCase(),
                 name: asStr(r.name),
-                change24hPct: asNum(r.change24h),
-                priceUsd: asNum(r.currentPrice),
+                // Both serialize as decimal STRINGS on the live feed (openapi
+                // PublicCryptoMover; probed 2026-09-02: "72.34"), so the strict
+                // asNum read left them undefined. Parse the numeric string.
+                change24hPct: asNumLoose(r.change24h),
+                priceUsd: asNumLoose(r.currentPrice),
+                slug: asStr(r.slug),
                 // The movers row already carries the ucid, which IS the coinId every
                 // downstream call takes. Kept so the resolve round-trip below can be
                 // skipped — see the comment there.
@@ -345,15 +472,23 @@ export async function observe(client, spec, state, trace) {
                     sentimentBullishPct: asNum(asObj(m.sentiment).bullishPct) ?? undefined,
                     freshness: freshnessOf(asObj(m.observation)),
                     discovered: true,
+                    slug: row.slug ?? asStr(asObj(asObj(m.observation).dataset).coinSlug),
                 };
-                if (wantIndicators) {
-                    const ind = await fetchIndicators(client, coinId, trace);
-                    if (ind)
-                        entry.indicators = ind;
-                }
+                const fundamentals = coinFundamentalsOf(m);
+                if (fundamentals)
+                    entry.fundamentals = fundamentals;
+                if (wantIndicators)
+                    await enrichFromCandles(client, entry, coinId, trace);
                 watch.push(entry);
             }
-            const context = rows.slice(UNIVERSE_RESOLVE_TOP);
+            const context = rows
+                .slice(UNIVERSE_RESOLVE_TOP)
+                .map(({ symbol, name, change24hPct, priceUsd }) => ({
+                symbol,
+                name,
+                change24hPct,
+                priceUsd,
+            }));
             if (context.length > 0)
                 universeMovers = context;
         }
@@ -382,6 +517,7 @@ export async function observe(client, spec, state, trace) {
     }
     // PM open positions + discovered quote-ready candidates — only if pm enabled.
     let pmPositions = [];
+    let capitalPmData;
     let pmResolutions = [];
     let pmMarkets = [];
     if (wantPm) {
@@ -412,11 +548,13 @@ export async function observe(client, spec, state, trace) {
                 pmDiscR = fb;
         }
         if (pmPosR.ok) {
+            capitalPmData = pmPosR.data;
             pmPositions = asArr(asObj(pmPosR.data).positions)
                 .map(asObj)
                 .filter((p) => (asStr(p.status) ?? "open") === "open")
                 .map((p) => ({
                 id: Number(asNum(p.id) ?? p.id),
+                ...(usesCapitalSizing(spec) ? { walletId: asNum(p.walletId) } : {}),
                 // The /positions/pm API returns `eventSlug` and the outcome id NESTED at
                 // outcome.externalMarketId — NOT `slug` / `outcomeExternalMarketId`.
                 // Reading the wrong keys left both undefined, which silently broke the
@@ -433,6 +571,14 @@ export async function observe(client, spec, state, trace) {
                 // down trips the stop too — not just futures.
                 unrealizedPnlMusd: asNum(p.unrealizedPnl) ?? asNum(p.unrealizedPnlMusd),
                 status: asStr(p.status) ?? "open",
+                // Slice 2: what the bet IS (title, side) and its entry vs CURRENT
+                // outcome probability (0..100 points; current only while open), so
+                // the model and the thesis evaluator can re-judge a held bet.
+                title: (asStr(p.eventTitle) ?? asStr(p.title))?.slice(0, 80),
+                side: asStr(p.side),
+                entryProbability: asNum(p.entryProbability),
+                currentProbability: asNum(p.currentProbability),
+                openedAt: asStr(p.openedAt),
             }));
             // Settlement-feedback loop: the SAME /positions/pm response carries an
             // additive `recentlyResolved` array — the agent's OWN bets that settled
@@ -549,9 +695,12 @@ export async function observe(client, spec, state, trace) {
         ...watch.map((w) => w.symbol.toUpperCase()),
     ]));
     if (wantNews && newsCoins.length > 0) {
-        const nr = await client.agentNews({ coins: newsCoins.join(","), limit: 8, hours: 48 }, trace);
+        // limit 12 (was 8): the same single cached call now also feeds up to 3
+        // headlines per coin (slice 2 fundamentals); the prompt's news block is
+        // still capped at 6 below.
+        const nr = await client.agentNews({ coins: newsCoins.join(","), limit: 12, hours: 48 }, trace);
         if (nr.ok) {
-            news = asArr(asObj(nr.data).items)
+            const fetched = asArr(asObj(nr.data).items)
                 .map(asObj)
                 .map((it) => ({
                 title: (asStr(it.title) ?? "").slice(0, 160),
@@ -559,12 +708,17 @@ export async function observe(client, spec, state, trace) {
                 sentiment: asStr(it.sentiment) ?? undefined,
                 importance: asNum(it.importance) ?? undefined,
                 ageHours: ((a) => a == null ? undefined : Math.round((a / 60) * 10) / 10)(asNum(it.ageMinutes)),
+                publishedAt: asStr(it.publishedAt) ?? undefined,
                 coins: asArr(it.coins)
                     .map((c) => asStr(c))
                     .filter((c) => !!c),
             }))
-                .filter((n) => n.title.length > 0)
-                .slice(0, 6);
+                .filter((n) => n.title.length > 0);
+            news = fetched.slice(0, 6);
+            // Per-coin headlines (with timestamps) on the watch entries themselves,
+            // drawn from the full fetched list so a busy BTC tape cannot crowd a
+            // second coin's story out of the fundamentals.
+            attachHeadlines(watch, fetched);
         }
     }
     const observation = {
@@ -572,6 +726,11 @@ export async function observe(client, spec, state, trace) {
         scopes,
         cashAvailableMusd,
         equityMusd,
+        ...(usesCapitalSizing(spec)
+            ? {
+                capitalBook: deriveCapitalBook(portR.data, walletR.data, posR.data, capitalPmData),
+            }
+            : {}),
         openPositions,
         openOrders,
         pmPositions,

package/dist/agent/pmContext.d.ts

@@ -0,0 +1,13 @@
+import type { Freshness, PmDecisionSupport, PmQuality } from "./types.js";
+export declare const PM_BLOCK_REASONS: readonly ["structurally_invalid", "stale_freshness", "freshness_unknown", "unpriced", "quote_dead", "dead_zero", "not_open", "source_degraded", "settlement_limbo"];
+export declare const PM_WARNING_REASONS: readonly ["lagging_freshness", "unproven_no_activity", "untraded_default", "play_money", "anomaly_flagged", "source_time_unverified", "sum_atypical_independent"];
+export declare const PM_FLAGS: readonly ["thinMarket", "inactiveMarket", "highAmbiguity", "nearResolution", "staleData"];
+export declare const FRESHNESS_BASES: readonly ["latest_snapshot", "source_update", "processed", "event_update", "unknown"];
+export declare const PM_TIERS: readonly ["high", "medium", "low", "unknown"];
+export declare const PM_SPREAD_TIERS: readonly ["tight", "moderate", "wide", "unknown"];
+export declare const PM_QUALITY_CAPS: readonly ["unassessable", "raw_book", "pinned_outcome"];
+export declare const knownCode: (value: unknown, allowed: readonly string[]) => string | undefined;
+export declare function sourceTimestamp(value: unknown): string | undefined;
+export declare function freshnessOf(block: Record<string, unknown>): Freshness | undefined;
+export declare function pmQualityOf(value: unknown): PmQuality | undefined;
+export declare function pmDecisionSupportOf(value: unknown): PmDecisionSupport | undefined;