@coinrithm/mcp-trading 0.7.7 → 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
@@ -273,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,4 +1,5 @@
 export { runCycle, type RunnerDeps } from "./runner.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";

package/dist/agent/engine.js

@@ -6,6 +6,7 @@
 // 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 { 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

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.
@@ -31,6 +33,16 @@ const INDICATOR_RANGE = "1D";
 // that declare universe_scan.
 const UNIVERSE_SCAN_LIMIT = 15;
 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 = {
@@ -61,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).
@@ -73,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)) {
@@ -89,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`
@@ -120,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.
@@ -127,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.
@@ -137,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) ?? "",
@@ -152,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}`)));
@@ -220,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),
@@ -232,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.
@@ -286,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);
@@ -297,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
@@ -323,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.
@@ -363,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;
         }
@@ -400,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) {
@@ -430,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
@@ -451,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
@@ -567,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),
@@ -577,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 = {
@@ -590,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;

package/dist/agent/pmContext.js

@@ -0,0 +1,136 @@
+import { asArr, asNum, asObj } from "./extract.js";
+export const PM_BLOCK_REASONS = [
+    "structurally_invalid",
+    "stale_freshness",
+    "freshness_unknown",
+    "unpriced",
+    "quote_dead",
+    "dead_zero",
+    "not_open",
+    "source_degraded",
+    "settlement_limbo",
+];
+export const PM_WARNING_REASONS = [
+    "lagging_freshness",
+    "unproven_no_activity",
+    "untraded_default",
+    "play_money",
+    "anomaly_flagged",
+    "source_time_unverified",
+    "sum_atypical_independent",
+];
+export const PM_FLAGS = [
+    "thinMarket",
+    "inactiveMarket",
+    "highAmbiguity",
+    "nearResolution",
+    "staleData",
+];
+export const FRESHNESS_BASES = [
+    "latest_snapshot",
+    "source_update",
+    "processed",
+    "event_update",
+    "unknown",
+];
+export const PM_TIERS = ["high", "medium", "low", "unknown"];
+export const PM_SPREAD_TIERS = [
+    "tight",
+    "moderate",
+    "wide",
+    "unknown",
+];
+export const PM_QUALITY_CAPS = [
+    "unassessable",
+    "raw_book",
+    "pinned_outcome",
+];
+export const knownCode = (value, allowed) => typeof value === "string" && allowed.includes(value) ? value : undefined;
+export function sourceTimestamp(value) {
+    if (typeof value !== "string" ||
+        value.length > 30 ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value))
+        return undefined;
+    const ms = Date.parse(value);
+    if (!Number.isFinite(ms))
+        return undefined;
+    const iso = new Date(ms).toISOString();
+    const normalized = value.replace(/(?:\.(\d{1,3}))?Z$/, (_match, fraction) => `.${(fraction ?? "").padEnd(3, "0")}Z`);
+    // Date.parse otherwise silently rolls impossible calendar dates forward.
+    return iso === normalized ? iso : undefined;
+}
+export function freshnessOf(block) {
+    const fr = asObj(block.freshness);
+    const status = knownCode(fr.status, [
+        "fresh",
+        "stale",
+        "lagging",
+        "never_ingested",
+        "unknown",
+    ]);
+    if (!status)
+        return undefined;
+    const seconds = asNum(fr.ageSeconds);
+    const minutes = asNum(fr.ageMinutes);
+    const age = seconds ?? (minutes == null ? undefined : minutes * 60);
+    return {
+        status,
+        ...(age != null && Number.isFinite(age) && age >= 0
+            ? { ageSeconds: age }
+            : {}),
+        ...(sourceTimestamp(fr.asOf) ? { asOf: sourceTimestamp(fr.asOf) } : {}),
+        ...(knownCode(fr.basis, FRESHNESS_BASES)
+            ? { basis: knownCode(fr.basis, FRESHNESS_BASES) }
+            : {}),
+    };
+}
+export function pmQualityOf(value) {
+    const raw = asObj(value);
+    if (Object.keys(raw).length === 0)
+        return undefined;
+    const reasons = (v, allowed) => [
+        ...new Set(asArr(v)
+            .slice(0, 32)
+            .filter((r) => !!knownCode(r, allowed))),
+    ];
+    const warningReasons = reasons(raw.warningReasons, PM_WARNING_REASONS);
+    const blockReasons = reasons(raw.blockReasons, PM_BLOCK_REASONS);
+    const omitted = (v, allowed) => !Array.isArray(v) || v.length > 32 || v.some((r) => !knownCode(r, allowed));
+    return {
+        ...(typeof raw.decisionEligible === "boolean"
+            ? { decisionEligible: raw.decisionEligible }
+            : {}),
+        warningReasons,
+        blockReasons,
+        ...(typeof raw.policyVersion === "string" &&
+            /^pm-quality-\d{1,3}$/.test(raw.policyVersion)
+            ? { policyVersion: raw.policyVersion }
+            : {}),
+        ...(sourceTimestamp(raw.assessedAt)
+            ? { assessedAt: sourceTimestamp(raw.assessedAt) }
+            : {}),
+        reasonsOmitted: raw.reasonsOmitted === true ||
+            omitted(raw.warningReasons, PM_WARNING_REASONS) ||
+            omitted(raw.blockReasons, PM_BLOCK_REASONS),
+    };
+}
+export function pmDecisionSupportOf(value) {
+    const raw = asObj(value);
+    if (Object.keys(raw).length === 0)
+        return undefined;
+    const score = asNum(raw.qualityScore);
+    const rawFlags = asObj(raw.flags);
+    return {
+        ...(score != null && score >= 0 && score <= 100
+            ? { qualityScore: score }
+            : {}),
+        qualityTier: knownCode(raw.qualityTier, PM_TIERS),
+        qualityCapReason: raw.qualityCapReason === null
+            ? null
+            : knownCode(raw.qualityCapReason, PM_QUALITY_CAPS),
+        spreadTier: knownCode(raw.spreadTier, PM_SPREAD_TIERS),
+        liquidityTier: knownCode(raw.liquidityTier, PM_TIERS),
+        volumeTier: knownCode(raw.volumeTier, PM_TIERS),
+        flags: Object.fromEntries(PM_FLAGS.filter((key) => typeof rawFlags[key] === "boolean").map((key) => [key, rawFlags[key]])),
+    };
+}