@coinrithm/mcp-trading 0.3.0 → 0.5.0

package/dist/agent/observe.js

@@ -3,10 +3,31 @@
 // required read fails, or no watchlist symbol resolves, the cycle SKIPS writes.
 import { asObj, asArr, asNum, asStr } from "./extract.js";
 import { computeIndicators } from "./indicators.js";
+import { scanSetups } from "./setups.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.
 const INDICATOR_RANGE = "1D";
+// 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 = {
+    BTC: "Bitcoin",
+    ETH: "Ethereum",
+    SOL: "Solana",
+    XRP: "XRP",
+    DOGE: "Dogecoin",
+    ADA: "Cardano",
+    AVAX: "Avalanche",
+    LINK: "Chainlink",
+    BNB: "BNB",
+    MATIC: "Polygon",
+    DOT: "Polkadot",
+    LTC: "Litecoin",
+    SHIB: "Shiba",
+    TRX: "Tron",
+    UNI: "Uniswap",
+    SUI: "Sui",
+};
 // 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.
@@ -42,8 +63,10 @@ function emptyObservation(state, scopes = []) {
         openPositions: [],
         openOrders: [],
         pmPositions: [],
+        pmResolutions: [],
         pmMarkets: [],
         watch: [],
+        setups: [],
         syncCursor: state.cursor,
         newClosedTrades: [],
         polledBeforeWrite: false,
@@ -75,21 +98,41 @@ export async function observe(client, spec, state, trace) {
     const openPositions = asArr(asObj(posR.data).positions)
         .map(asObj)
         .filter((p) => (asStr(p.status) ?? "open") === "open")
-        .map((p) => ({
-        venue: "futures",
-        id: Number(asNum(p.id) ?? p.id),
-        coinId: asStr(p.coinId),
-        symbol: asStr(p.symbol),
-        side: asStr(p.side),
-        status: asStr(p.status) ?? "open",
-        marginMusd: asNum(p.marginMusd),
-        unrealizedPnlMusd: asNum(p.unrealizedPnlMusd),
-    }));
+        .map((p) => {
+        // /positions/futures returns the coin NESTED ({ucid,symbol,name}); the old
+        // p.coinId/p.symbol reads were undefined (same field-drift class as the PM
+        // dup-guard bug) — the model couldn't tell which coin a position was on.
+        // It ALSO dropped every per-position price the backend already returns, so
+        // the model proposed SL/TP blind to mark + liquidation (→ the
+        // take_profit_not_*_mark + stop_loss_not_above_liquidation reject waves)
+        // and could not tell a winner from a small loser before a manual close.
+        // Tolerant fallbacks keep older/mocked shapes working.
+        const coin = asObj(p.coin);
+        return {
+            venue: "futures",
+            id: Number(asNum(p.id) ?? p.id),
+            coinId: asStr(coin.ucid) ?? asStr(p.coinId),
+            symbol: asStr(coin.symbol) ?? asStr(p.symbol),
+            side: asStr(p.side),
+            status: asStr(p.status) ?? "open",
+            leverage: asNum(p.leverage),
+            marginMusd: asNum(p.marginMusd),
+            unrealizedPnlMusd: asNum(p.unrealizedPnlMusd),
+            entryPrice: asNum(p.entryPrice),
+            markPrice: asNum(p.markPrice),
+            liquidationPrice: asNum(p.liquidationPrice),
+            stopLossPrice: asNum(p.stopLossPrice),
+            takeProfitPrice: asNum(p.takeProfitPrice),
+        };
+    });
     // Sync poll: /trades since the persisted cursor.
     const tradesR = await client.trades({
         venue: "futures",
         updatedSince: state.cursor ?? undefined,
-        limit: state.cursor ? undefined : 1,
+        // Cap the sync poll: an unbounded fetch against a SHARED trade book (or an
+        // old cursor) could pull thousands of rows into the prompt. 50 newest is
+        // ample for the agent to react to its own fills/stops since last cycle.
+        limit: state.cursor ? 50 : 1,
     }, trace);
     let polledBeforeWrite = false;
     let newClosedTrades = [];
@@ -105,7 +148,11 @@ export async function observe(client, spec, state, trace) {
     // Watchlist market context.
     const watch = [];
     let resolvedAny = false;
+    // Bounded RAG: the market-wide Fear & Greed regime, captured once from the first
+    // coin's /market context (it's market-wide, identical across coins).
+    let marketMood;
     const wantIndicators = spec.capabilities.includes("indicators");
+    const wantNews = spec.capabilities.includes("news");
     for (const symbol of spec.risk.watchlist) {
         const rs = await client.resolve(symbol, trace);
         const match = asObj(asObj(rs.data).match);
@@ -126,9 +173,18 @@ export async function observe(client, spec, state, trace) {
             change1h: asNum(price.change1h),
             change24h: asNum(price.change24h),
             change7d: asNum(price.change7d),
+            // Community sentiment (already in the /market context, was stripped).
+            sentimentBullishPct: asNum(asObj(m.sentiment).bullishPct) ?? undefined,
             // Freshness lives under the response's `observation` block.
             freshness: freshnessOf(asObj(m.observation)),
         };
+        // Capture the market-wide Fear & Greed regime once (same across coins).
+        if (!marketMood) {
+            const fg = asObj(m.fearGreed);
+            const v = asNum(fg.value);
+            if (v != null)
+                marketMood = { fearGreed: v, label: asStr(fg.label) ?? "" };
+        }
         // `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.
@@ -163,27 +219,94 @@ export async function observe(client, spec, state, trace) {
     }
     // PM open positions + discovered quote-ready candidates — only if pm enabled.
     let pmPositions = [];
+    let pmResolutions = [];
     let pmMarkets = [];
     if (wantPm) {
-        const [pmPosR, pmDiscR] = await Promise.all([
+        // Bias PM discovery toward CRYPTO markets the agent has a price view on — the
+        // only PM edge a price agent reliably has (probed 2026-06-24: the default board
+        // is World Cup / elections / F1, which an agent has no edge on). The discover
+        // `q` is an AND/phrase match, so query ONE coin — the agent's TOP watchlist coin,
+        // where its price view is sharpest — never the joined list (matches ~nothing).
+        // Fall back to Bitcoin (always plentiful) — NEVER the general non-crypto board.
+        const topCoin = (spec.risk.watchlist[0] ?? "").toUpperCase();
+        const pmQuery = PM_COIN_NAMES[topCoin] ?? spec.risk.watchlist[0] ?? "Bitcoin";
+        const [pmPosR, pmDiscFirst] = await Promise.all([
             client.pmPositions(undefined, trace),
-            client.discoverPmMarkets({ limit: 8 }, trace),
+            client.discoverPmMarkets({ q: pmQuery, limit: 12 }, trace),
         ]);
+        let pmDiscR = pmDiscFirst;
+        const firstCount = pmDiscR.ok
+            ? asArr(asObj(pmDiscR.data).data ??
+                asObj(pmDiscR.data).markets ??
+                asObj(pmDiscR.data).results).length
+            : 0;
+        if (firstCount < 3 && pmQuery !== "Bitcoin") {
+            const fb = await client.discoverPmMarkets({ q: "Bitcoin", limit: 12 }, trace);
+            if (fb.ok)
+                pmDiscR = fb;
+        }
         if (pmPosR.ok) {
             pmPositions = asArr(asObj(pmPosR.data).positions)
                 .map(asObj)
                 .filter((p) => (asStr(p.status) ?? "open") === "open")
                 .map((p) => ({
                 id: Number(asNum(p.id) ?? p.id),
+                // 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
+                // PM anti-churn guard (it could never match a held position) AND the
+                // model's view of what it holds. Tolerant fallbacks keep older/mocked
+                // shapes working.
                 source: asStr(p.source),
-                slug: asStr(p.slug),
-                outcomeExternalMarketId: asStr(p.outcomeExternalMarketId),
+                slug: asStr(p.eventSlug) ?? asStr(p.slug),
+                outcomeExternalMarketId: asStr(asObj(p.outcome).externalMarketId) ??
+                    asStr(p.outcomeExternalMarketId),
                 stakeMusd: asNum(p.stakeMusd),
+                // Mark-to-market unrealized (field is `unrealizedPnl` on /positions/pm).
+                // Feeds the equity-drawdown kill-switch so a large PM book that marks
+                // down trips the stop too — not just futures.
+                unrealizedPnlMusd: asNum(p.unrealizedPnl) ?? asNum(p.unrealizedPnlMusd),
                 status: asStr(p.status) ?? "open",
             }));
+            // Settlement-feedback loop: the SAME /positions/pm response carries an
+            // additive `recentlyResolved` array — the agent's OWN bets that settled
+            // win/loss/void since last cycle, with realized pnl. Surface it as reflective
+            // context so the model learns from how its predictions actually resolved
+            // (reinforce what worked, avoid what didn't). NOT an action — the runner never
+            // bets off this. Fail-safe: an absent/old backend omits the key → [] (the
+            // ?? [] in asArr + the guarded map), so this never breaks the open feed.
+            pmResolutions = asArr(asObj(pmPosR.data).recentlyResolved)
+                .map(asObj)
+                .map((r) => ({
+                id: Number(asNum(r.id) ?? r.id),
+                // The backend nests the outcome label/title; carry the human-readable
+                // title (or fall back to the slug) so the prompt can name the market.
+                eventTitle: asStr(r.eventTitle) ?? asStr(asObj(r.event).title) ?? undefined,
+                slug: asStr(r.eventSlug) ?? asStr(r.slug),
+                side: asStr(r.side),
+                status: asStr(r.status),
+                pnlMusd: asNum(r.pnlMusd),
+                stakeMusd: asNum(r.stakeMusd),
+            }))
+                // A resolution with no id is unusable for the model's reflection; drop it.
+                .filter((r) => Number.isFinite(r.id))
+                // Bound the block: a short recent window is enough reflective context, and
+                // the backend already caps at ~25; cap again so a noisy response can't bloat
+                // the prompt.
+                .slice(0, 25);
         }
         if (pmDiscR.ok) {
             const dd = asObj(pmDiscR.data);
+            // Anti-churn: exclude markets the agent ALREADY holds an open position in
+            // from the candidate list BEFORE it reaches the prompt — so the model never
+            // sees (and re-picks) a held market only to have the runner/server reject it
+            // as a duplicate, burning a whole cycle. Keyed source|slug|outcomeExternalMarketId
+            // (lower-cased to match the discover rows below). The runner preflight guard
+            // (duplicate_intent) + server dedup (duplicate_open) remain the backstops.
+            // Side-agnostic = no re-bet/hedge on a held outcome, matching the runner policy.
+            const heldPmKeys = new Set(pmPositions
+                .filter((p) => (p.status ?? "open") === "open")
+                .map((p) => `${(p.source ?? "").toLowerCase()}|${(p.slug ?? "").toLowerCase()}|${p.outcomeExternalMarketId ?? ""}`));
             // Real /api/agent/pm/discover payload: { data: [event], pagination, meta }.
             // Each EVENT carries source/slug/title/freshness at the top level and the
             // quoteable id NESTED at outcomes[].externalMarketId — so expand one
@@ -194,9 +317,21 @@ export async function observe(client, spec, state, trace) {
                 .flatMap((ev) => {
                 const source = (asStr(ev.source) ?? "").toLowerCase();
                 const slug = (asStr(ev.slug) ?? "").toLowerCase();
-                const title = asStr(ev.title) ?? asStr(ev.question);
+                // Keep titles SHORT: the model only needs to recognise the market.
+                // Untrimmed titles, one per outcome across many events, ballooned the
+                // 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 outcomes = asArr(ev.outcomes).map(asObj);
+                // At most a few outcomes per event so a wide multi-outcome market
+                // (e.g. dozens of price buckets) can't explode the prompt. Drop
+                // outcomes the backend flagged NOT openable (eligible === false) so the
+                // 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)
+                    .map(asObj)
+                    .filter((o) => o.eligible !== false)
+                    .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) => ({
@@ -205,11 +340,51 @@ export async function observe(client, spec, state, trace) {
                     outcomeExternalMarketId: asStr(o.externalMarketId) ??
                         asStr(o.outcomeExternalMarketId) ??
                         "",
+                    // Carry the odds through: the model needs the outcome label + current
+                    // probability to spot a mispriced market and bet it (was stripped).
+                    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)),
                     title,
                     freshness,
                 }));
             })
-                .filter((m) => m.source && m.slug && m.outcomeExternalMarketId);
+                .filter((m) => m.source && m.slug && m.outcomeExternalMarketId)
+                // Drop already-held markets (see heldPmKeys above) so the model only sees
+                // markets it can actually open — done BEFORE the slice so held positions
+                // don't consume the limited candidate slots.
+                .filter((m) => !heldPmKeys.has(`${m.source.toLowerCase()}|${m.slug.toLowerCase()}|${m.outcomeExternalMarketId}`))
+                // Hard cap the PM block: a handful of fresh markets is plenty to pick from.
+                .slice(0, 12)
+                // Stamp a short, stable per-cycle ref (pm1…pmN) the model copies instead of
+                // the long outcomeExternalMarketId. Assigned AFTER the slice so refs are a
+                // contiguous 1..N matching exactly what the prompt shows.
+                .map((m, i) => ({ ...m, ref: `pm${i + 1}` }));
+        }
+    }
+    // News context (only with the `news` capability): recent high-importance news
+    // for the watchlist coins, fed into the decide prompt as a market-catalyst
+    // layer the price chart can't show. One cached call; degrades to no news on
+    // failure (never blocks a cycle).
+    let news;
+    if (wantNews && spec.risk.watchlist.length > 0) {
+        const nr = await client.agentNews({ coins: spec.risk.watchlist.join(","), limit: 8, hours: 48 }, trace);
+        if (nr.ok) {
+            news = asArr(asObj(nr.data).items)
+                .map(asObj)
+                .map((it) => ({
+                title: (asStr(it.title) ?? "").slice(0, 160),
+                source: asStr(it.source) ?? undefined,
+                sentiment: asStr(it.sentiment) ?? undefined,
+                importance: asNum(it.importance) ?? undefined,
+                ageHours: ((a) => a == null ? undefined : Math.round((a / 60) * 10) / 10)(asNum(it.ageMinutes)),
+                coins: asArr(it.coins)
+                    .map((c) => asStr(c))
+                    .filter((c) => !!c),
+            }))
+                .filter((n) => n.title.length > 0)
+                .slice(0, 6);
         }
     }
     const observation = {
@@ -220,8 +395,16 @@ export async function observe(client, spec, state, trace) {
         openPositions,
         openOrders,
         pmPositions,
+        pmResolutions,
         pmMarkets,
         watch,
+        news,
+        // Deterministic structure flags computed from the watch indicators — the
+        // model acts on these instead of re-deciding "is there a setup?" from scratch.
+        // openPositions are passed so setups on a held symbol are tagged "manage,
+        // don't re-open".
+        setups: scanSetups(watch, openPositions),
+        marketMood,
         syncCursor,
         newClosedTrades,
         polledBeforeWrite,

package/dist/agent/prompt.d.ts

@@ -1,3 +1,7 @@
-import { AgentSpec, Observation } from "./types.js";
+import { AgentSpec, Observation, PmResolution } from "./types.js";
+export declare function formatPmResolutions(resolutions: PmResolution[]): string[];
 export declare function buildSystemPrompt(spec: AgentSpec, mergedProse: string): string;
-export declare function buildUserPrompt(obs: Observation): string;
+export declare function buildUserPrompt(obs: Observation, journal?: Array<{
+    at: string;
+    did: string;
+}>): string;

package/dist/agent/prompt.js

@@ -2,18 +2,49 @@
 // static character (cached prefix); the user prompt is the fresh observation.
 // The model only PROPOSES — the runner re-checks every action against the caps,
 // so the prompt states the caps but never relies on the model to honor them.
+// Format the settlement-feedback block: a concise, natural-language recap of the
+// agent's OWN PM bets that resolved since the last cycle, so the model can REFLECT
+// (reinforce what worked, avoid what didn't). Capped + compact — this is context,
+// not a new action. Returns [] when there is nothing to show. Example line:
+//   - "Will BTC top $80k?" — YES, WON +320 mUSD; "ETH flips SOL by Fri?" — NO,
+//     LOST -100 mUSD; "Election tie?" — VOID (stake refunded).
+export function formatPmResolutions(resolutions) {
+    if (!resolutions || resolutions.length === 0)
+        return [];
+    // Cap defensively (the backend + observe already cap at ~25); a handful is the
+    // useful reflective window and keeps the prompt small.
+    const items = resolutions.slice(0, 12).map((r) => {
+        const title = (r.eventTitle ?? r.slug ?? "(market)").slice(0, 70);
+        const side = (r.side ?? "").toUpperCase();
+        const sidePart = side ? `${side}, ` : "";
+        if (r.status === "void_refunded") {
+            return `"${title}" — ${sidePart}VOID (stake refunded)`;
+        }
+        const outcome = r.status === "settled_win" ? "WON" : "LOST";
+        const pnl = typeof r.pnlMusd === "number"
+            ? ` ${r.pnlMusd >= 0 ? "+" : ""}${Math.round(r.pnlMusd)} mUSD`
+            : "";
+        return `"${title}" — ${sidePart}${outcome}${pnl}`;
+    });
+    return [
+        "",
+        "## Your prediction markets that just resolved (settlement feedback — learn from these)",
+        "These are YOUR OWN PM bets that settled since last cycle. Reflect: where your read was RIGHT, lean into that edge; where it was WRONG, adjust. This is context to learn from, NOT a position to manage (they are closed).",
+        `Resolved since last cycle: ${items.join("; ")}.`,
+    ];
+}
 export function buildSystemPrompt(spec, mergedProse) {
     const r = spec.risk;
     const v = spec.venues;
     const actions = [];
     if (v.includes("futures")) {
-        actions.push('{"type":"futures_open","symbol","side":"long"|"short","leverage","marginMusd","stopLossPrice","takeProfitPrice","confidence":0..1}', '{"type":"futures_close","positionId","fraction"}', '{"type":"futures_set_sltp","positionId","stopLossPrice","takeProfitPrice"}');
+        actions.push('{"type":"futures_open","symbol","side":"long"|"short","leverage","marginMusd","stopLossPrice","takeProfitPrice","confidence":0..1}', '{"type":"futures_close","positionId","fraction"}', '{"type":"futures_set_sltp","positionId","stopLossPrice","takeProfitPrice"}', 'FUTURES TRIGGER RULES (the server rejects the WHOLE open otherwise): a LONG\'s takeProfitPrice must be ABOVE the current mark and stopLossPrice BELOW it (and above liquidationPrice); a SHORT is inverted (TP below mark, SL above). Every open position in observation.openPositions shows entryPrice, markPrice, liquidationPrice, stopLossPrice, takeProfitPrice — read them and place triggers on the correct side. NEVER attach stopLossPrice/takeProfitPrice to a futures_open for a symbol you ALREADY hold (the server treats it as an add and rejects it) — adjust that position with futures_set_sltp on its positionId instead.');
     }
     if (v.includes("spot")) {
         actions.push('{"type":"spot_order","symbol","side":"buy"|"sell","orderType":"market"|"limit"|"stop","quantity","limitPrice","stopPrice","confidence":0..1}', '{"type":"spot_cancel","orderId"}');
     }
     if (v.includes("pm")) {
-        actions.push('{"type":"pm_open","source","slug","outcomeExternalMarketId","stakeMusd","confidence":0..1}  (ONLY a market from observation.pmMarkets; stakeMusd >= 10)');
+        actions.push('{"type":"pm_open","ref":"pmN","stakeMusd","confidence":0..1}  (set "ref" to the `ref` of the ONE observation.pmMarkets entry you are betting — e.g. "pm3" — copied EXACTLY; stakeMusd >= 10)');
     }
     return [
         "You operate a CoinRithm PAPER-TRADING agent (simulated 50,000 mUSD; not real money, not financial advice).",
@@ -32,8 +63,10 @@ export function buildSystemPrompt(spec, mergedProse) {
                 `- deny-list (NEVER open these, even if on the watchlist): ${r.blocklist.join(", ")}`,
             ]
             : []),
-        "- prediction markets: pick ONLY a market listed in observation.pmMarkets; minimum stake 10 mUSD",
-        `- abstention.minConfidence ${spec.abstention.minConfidence}; a skipped cycle is correct and cheap`,
+        "- prediction markets are a FIRST-CLASS venue for you — a pm_open is as real a trade as a futures/spot open, not an afterthought. Each observation.pmMarkets entry carries a short `ref` (pm1, pm2, …), an `outcome` label, and `prob` (0..1, the market's CURRENT odds). BET (pm_open) an outcome when YOUR estimate of its true probability differs MATERIALLY from the market's — that gap is your edge (e.g. prob 0.35 but you think it's really ~0.55 -> buy). Skip only markets pinned near 0 or 1 (no edge left). Every entry in observation.pmMarkets is already filtered to one you CAN open (binary/settlement-grade) — so a listed market will not bounce at quote. Pick ONLY a listed market and identify it by copying its `ref` into the action; min stake 10 mUSD. Do NOT re-bet a market+outcome you ALREADY hold (check observation.pmPositions) — that is churn and will be rejected; bet a DIFFERENT market or skip.",
+        "- PM stake is a SEPARATE budget from your futures margin: the futures margin cap (maxOpenMarginMusd) does NOT limit pm_open. So when your futures are at the margin/position cap — you hold the max, or a futures_open keeps getting REJECTED with open_margin_exceeds_cap — prediction markets are STILL fully open to you. PIVOT to pm_open on a mispriced market instead of re-proposing a futures_open that will just be rejected: a rejected open wastes the entire cycle, an eligible PM bet does not.",
+        "- YOUR SHARPEST PM EDGE is the crypto price view you JUST formed: crypto PM markets resolve on the very prices you analyse, so you have a genuine information edge there that you do NOT have on coin futures alone. EVERY cycle you reach a price conviction, it is REQUIRED that you scan observation.pmMarkets for a crypto market that same view prices wrong and, if one is materially mispriced, open it with pm_open — treat that mispricing exactly like a flagged coin setup (an ACT, not a skip). If you are bearish BTC, a 'BTC above $X by <date>' priced high is a NO; if bullish ETH, an 'ETH above $Y' priced low is a YES. Leaving a clearly mispriced crypto market untraded is the same mistake as ignoring a flagged setup. (For non-crypto events you have no special edge; skip unless the odds are obviously off.)",
+        `- abstention.minConfidence ${spec.abstention.minConfidence}: opens below this are rejected, so act with genuine conviction — but routine caution is no reason to sit out a clear setup`,
         ...(spec.capabilities.includes("indicators")
             ? [
                 "",
@@ -43,34 +76,91 @@ export function buildSystemPrompt(spec, mergedProse) {
                 "- a null field = not enough data; ignore it. These INFORM your decision; they never widen a cap.",
             ]
             : []),
+        ...(spec.capabilities.includes("news")
+            ? [
+                "",
+                "## Market news (observation.news) — catalysts the price chart can't show",
+                "Each item has `importance` (0..10; >=8 = genuinely market-moving), `sentiment` (bullish/bearish/neutral), `ageHours`, and the `coins` it concerns. Use it to CONFIRM or VETO the price read, never to trade on alone:",
+                "- A fresh high-importance (>=8) bullish story on a coin you're watching strengthens a long and warns against shorting into it; a bearish >=8 is the reverse. A surprise catalyst can matter more than the chart.",
+                "- Weight by importance AND freshness: a 9 from 30 min ago outweighs a stale 4 from yesterday. Old or low-importance news is noise — don't over-react.",
+                "- For PM: a high-importance catalyst is exactly the kind of mispricing edge to act on if the market hasn't repriced it yet.",
+            ]
+            : []),
         "",
         "## Output contract — return ONLY this JSON object, nothing else:",
-        '{"decision":"skip"|"act","confidence":0..1,"reason":"short","actions":[]}',
+        '{"decision":"skip"|"act","confidence":0..1,"reason":"short","rationale":"1-2 sentences","actions":[]}',
         "Each action is one of:",
         ...actions.map((a) => `- ${a}`),
         `Set each opening action's "confidence" (0..1) to your honest conviction — the runner REJECTS any open below abstention.minConfidence (${spec.abstention.minConfidence}). The decision-level "confidence" is the fallback when an action omits its own.`,
-        "Prefer skip when the signal is weak or data is stale.",
-    ].join("\n");
-}
-export function buildUserPrompt(obs) {
-    return [
-        "Decide for THIS cycle using only the observation below (data available now — no look-ahead).",
         "",
-        "```json",
-        JSON.stringify({
-            asOf: obs.asOf,
-            cashAvailableMusd: obs.cashAvailableMusd,
-            equityMusd: obs.equityMusd,
-            openPositions: obs.openPositions,
-            openOrders: obs.openOrders,
-            pmPositions: obs.pmPositions,
-            pmMarkets: obs.pmMarkets,
-            watch: obs.watch,
-            newClosedTrades: obs.newClosedTrades,
-            polledBeforeWrite: obs.polledBeforeWrite,
-        }, null, 2),
-        "```",
+        "## How to act — a decisive trader in character, not a bystander",
+        "You ARE the character in the strategy above; trade like it. When you have a clear read — even a moderate-confidence one — TAKE THE POSITION, sized within your caps and protected with a stop. You wake every cycle and people watch you live: an agent that watches forever and never commits is useless to them and to itself.",
+        'Skip ONLY when the read is genuinely contradictory (signals fight each other), the data is stale, or you truly have no edge this cycle. A quiet tape where your thesis still has a small but REAL edge is an ACT, not a skip — take it, small, with a stop. Do not confuse caution with paralysis.',
+        'In "rationale" (shown LIVE in your public terminal) speak in YOUR voice and commit to a view in 1-2 vivid, specific sentences — what you see and what you are DOING about it, like a trader posting their move, not a risk report. Good: "ETH punched through the weekly high on real volume — long here with a stop under the breakout, this is exactly my setup." Weak: "conditions are mixed, waiting for clarity." Keep "reason" a short label.',
+        "",
+        "## Flagged setups this cycle — your wake-up list (observation.setups)",
+        "A deterministic scan already checked every watchlist coin and put the ones with real, tradeable structure RIGHT NOW into observation.setups — each has symbol, kind, bias, strength, and a factual note (trend / RSI / breakout / ATR reads). This is your shortlist; you do NOT need to re-derive whether a setup exists.",
+        '- If observation.setups is NON-EMPTY: act on the strongest one that fits YOUR strategy. The `bias` is the trend-following read; if you are a contrarian / mean-reversion trader, FADE it with the same facts (e.g. a downtrend that is also "RSI oversold" is YOUR long). Skipping a flagged setup needs a SPECIFIC reason tied to your thesis — "no clear setup" is NOT a valid skip when setups are listed.',
+        "- If observation.setups is EMPTY: no coin has a flagged structure right now — but BEFORE you skip, check observation.pmMarkets for a crypto market your current read prices wrong (a PM mispricing is a valid ACT even with zero coin setups). Only then, if nothing is mispriced, skip new entries and just manage any open positions.",
+        '- A setup tagged `held` (held: long|short) is a position you ALREADY hold. Do NOT propose a new open on it — that only hits the margin cap and wastes the cycle. MANAGE it instead: trail the stop toward your target, ADD only if you have margin room AND fresh conviction, or cut if the thesis broke.',
+        "",
+        "## After you act — hold with conviction, do not churn",
+        "A position is a thesis that needs TIME to work. Once you are in WITH a stop, let the stop or your target close it: do NOT bail on the next cycle over a small adverse tick, and do NOT manually close a fresh position unless the thesis is structurally invalidated (the level broke, the trend flipped) — not merely because price wiggled against you. A trade opened and closed minutes later just donates the round-trip fee + spread to noise.",
+        "Place each stop at a real structural level with ROOM to breathe — past the swing or extreme by a sensible margin — and size the position DOWN to keep the risk small. A stop hugging your entry gets clipped by normal volatility and bleeds you a cut at a time. After a stop-out, do not immediately re-enter the same name and direction (that level is hot — wait for a genuinely fresh setup). Decisive entries, patient holds.",
         "",
-        "Return ONLY the JSON decision object.",
+        "## Manage your open positions — ride winners, cut losers",
+        "Each cycle, look at your OPEN positions FIRST, not just new entries. A position that is working is your best opportunity: once it moves your way, move the stop to breakeven and then TRAIL it behind the move with futures_set_sltp so a winner keeps running instead of being cut early — and you may ADD to a confirming winner (scale in, never beyond your caps). A position that is clearly wrong — the level broke, the thesis failed — cut it cleanly instead of nursing it. Riding one good trade beats opening ten fresh ones.",
     ].join("\n");
 }
+export function buildUserPrompt(obs, journal) {
+    const lines = [
+        "Decide for THIS cycle using only the observation below (data available now — no look-ahead).",
+    ];
+    // Flat-state steer: when the agent holds NOTHING, weaker models (Llama 3.1 8B)
+    // still emit futures_close / futures_set_sltp / spot_cancel with a hallucinated
+    // positionId/orderId — which fails the whole cycle's strict parse (one bad id
+    // zeroes the cycle). There is nothing to manage when flat, so say so plainly and
+    // point the model at OPENING. (Observed: an 8B agent dead 36/60 cycles this way.)
+    if ((obs.openPositions?.length ?? 0) === 0 &&
+        (obs.pmPositions?.length ?? 0) === 0) {
+        lines.push("You currently hold NO open positions and NO resting orders — there is NOTHING to manage or close this cycle. Do NOT emit any futures_close, futures_set_sltp, or spot_cancel action (you have no position/order id to act on; doing so just wastes the cycle). Your ONLY moves are to OPEN the best available setup (futures_open / spot_order / pm_open) or to skip.");
+    }
+    // Slice-3 memory: the agent's own recent moves, so it manages with continuity —
+    // remembers the thesis behind each open position and does not re-open an idea it
+    // just acted on.
+    if (journal && journal.length > 0) {
+        lines.push("", "## Your recent moves (memory, newest last) — manage these with continuity; do NOT churn by re-opening an idea you just acted on:", ...journal.slice(-6).map((j) => `- ${j.did}`));
+    }
+    // Settlement-feedback loop: surface the agent's recently-RESOLVED PM bets so the
+    // model can reflect and adapt. Reflective context only — never a new action.
+    lines.push(...formatPmResolutions(obs.pmResolutions ?? []));
+    lines.push("", "```json", 
+    // Compact (no pretty-print indentation — ~40% fewer tokens, still valid JSON)
+    // and the trade ledger is capped so a busy shared book can't bloat the prompt.
+    JSON.stringify({
+        asOf: obs.asOf,
+        cashAvailableMusd: obs.cashAvailableMusd,
+        equityMusd: obs.equityMusd,
+        openPositions: obs.openPositions,
+        openOrders: obs.openOrders,
+        pmPositions: obs.pmPositions,
+        // Compact display: the model picks a market by its short `ref` and never
+        // sees (or mis-copies) the long source/slug/outcomeExternalMarketId — the
+        // runner resolves the ref back to those. Also ~halves the PM block's tokens.
+        pmMarkets: obs.pmMarkets.map((m) => ({
+            ref: m.ref,
+            source: m.source,
+            title: m.title,
+            outcome: m.outcomeName,
+            prob: m.probability,
+            freshness: m.freshness?.status,
+        })),
+        watch: obs.watch,
+        setups: obs.setups,
+        news: obs.news,
+        marketMood: obs.marketMood,
+        newClosedTrades: obs.newClosedTrades.slice(0, 20),
+        polledBeforeWrite: obs.polledBeforeWrite,
+    }), "```", "", "Return ONLY the JSON decision object.");
+    return lines.join("\n");
+}

package/dist/agent/providers.d.ts

@@ -3,10 +3,15 @@ export interface DecideInput {
     system: string;
     user: string;
     maxTokens?: number;
+    timeoutMs?: number;
 }
 export type DecideResult = {
     ok: true;
     text: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
 } | {
     ok: false;
     error: string;
@@ -20,6 +25,7 @@ export interface ProviderEnv {
     OPENAI_API_KEY?: string;
     GROQ_API_KEY?: string;
     NVIDIA_API_KEY?: string;
+    GEMINI_API_KEY?: string;
     MODEL_API_KEY?: string;
 }
 export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;