polly-gamba 1.0.23 → 1.0.31

package/dist/claude-trader.js

@@ -30,6 +30,7 @@ function findClaudeBin() {
 }
 const CLAUDE_BIN = findClaudeBin();
 const CLAUDE_TOKEN = process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY || '';
+const PAPER_MODE = process.env.PAPER_MODE === 'true' || process.env.PAPER_MODE === '1';
 class ClaudeTrader {
     proc = null;
     redis;
@@ -100,12 +101,12 @@ class ClaudeTrader {
                 type: 'user',
                 message: {
                     role: 'user',
-                    content: `You are a Polymarket paper trader running a high-volume moneyball strategy. Your job is to place paper trades on EVERY market where you have ANY opinion on fair value — even slight.
-
-TOOLS: place_order, skip_all, get_budget_status
+                    content: `You are a Polymarket ${PAPER_MODE ? 'PAPER TRADING (no real money)' : 'paper'} trader running a high-volume moneyball strategy. Your job is to place paper trades on EVERY market where you have ANY opinion on fair value — even slight.
+${PAPER_MODE ? '\n⚠️ PAPER MODE: This is a test environment. Be AGGRESSIVE — trade more, skip less. Lower your threshold to 3% edge for any market resolving within 6 months.\n' : ''}
+TOOLS: place_order, skip_all, get_budget_status, get_positions
 RULES:
 - Output ONLY tool calls. Zero prose.
-- For EVERY market in the list: if current price differs from your estimated fair probability by more than 5%, place a trade.
+- For EVERY market in the list: if current price differs from your estimated fair probability by more than ${PAPER_MODE ? '3%' : '5%'}, place a trade.
 - YES is underpriced → BUY YES. NO is underpriced (YES overpriced) → BUY NO.
 - $10 USDC per trade (small size, many bets).
 - NO cap on number of trades — bet every market where you see any edge.
@@ -116,7 +117,7 @@ RULES:
 - Max $100 per market (20% of $500 budget). The MCP enforces this — don't fight it.
 - To add to an existing position with the SAME outcome: (1) you MUST cite a specific new catalyst (news published in last 24h, not price movement), AND (2) the current price must be ≥20% below your last entry price (e.g. if you bought YES at 0.15, new entry only valid at ≤0.12). The MCP enforces this — attempts at a smaller discount will be rejected. Price dipping alone is NOT a catalyst. New information is a catalyst.
 - exit_trigger is required on every trade. Be specific: "Exit when price hits 0.X" or "Exit when [specific news event]" — not "when narrative converges."
-- Call get_budget_status at the start of each scan to know available capital.`
+- Call get_budget_status AND get_positions at the start of each scan to know available capital and your current open positions. get_positions returns {"positions": [...], "closed_markets": [...]}. You MUST review BOTH before trading to apply concentration AND closed-market discipline correctly.`
                 }
             }));
             this.ready = true;
@@ -184,7 +185,7 @@ Call place_order on any market you have edge on. $10 per trade. No cap.`;
         const prefix = this.config.redisPrefix;
         await this.redis.lpush(`${prefix}:scans`, JSON.stringify({ scanId, markets_count: markets.length, ts: Date.now() }));
         await this.redis.ltrim(`${prefix}:scans`, 0, 9999);
-        const tradeable = markets.filter(m => m.tokens?.some(t => t.price > 0.02 && t.price < 0.98));
+        const tradeable = markets.filter(m => m.tokens?.some(t => t.price >= 0.10 && t.price <= 0.90));
         const prompt = `## Autonomous Scan ${scanId}
 
 Time: ${new Date().toISOString()}
@@ -198,7 +199,35 @@ ${tradeable.map((m, i) => `### ${i + 1}. ${m.question}
 - Tokens: ${m.tokens?.map(t => `${t.outcome}@${t.price}`).join(', ') || 'none'}
 ${m.description ? `- Description: ${m.description.slice(0, 200)}` : ''}`).join('\n\n')}
 
-For EVERY market above: if price differs from your fair probability by >5%, place a trade ($10 USDC). Call skip_all only if you have zero opinion on all markets.`;
+## HORIZON DISCIPLINE (required — applied before edge check):
+- Markets resolving WITHIN 6 months: ${PAPER_MODE ? '>3% edge required (PAPER MODE — be aggressive)' : 'standard >5% edge required'}.
+- Markets resolving 6–12 months out: require >${PAPER_MODE ? '7' : '10'}% edge. Long-horizon bets tie up capital without near-term price catalysts.
+- Markets resolving MORE than 12 months out: require >${PAPER_MODE ? '12' : '15'}% edge. Only trade if the mispricing is extreme and obvious.
+- If the end date is unknown or ambiguous, treat it as >12 months. Do NOT guess short horizon.
+- These thresholds stack: if the market already has an open position, do not add unless it meets the horizon threshold AND the 20%-discount re-entry rule.
+
+## CONCENTRATION DISCIPLINE (required — applied before edge check):
+- Count your existing open positions by underlying theme. A "theme" is the single real-world event that resolves the bet (e.g. "GTA VI release", "Hungary 2026 election", "NBA 2026 Finals").
+- MAX 2 open positions per underlying theme. If you already have 2+ open positions in the same theme, SKIP all new markets in that theme regardless of apparent edge.
+- Correlation examples: "Will Jesus return before GTA VI", "Will BTC hit $1M before GTA VI", "Will China invade Taiwan before GTA VI" — all three resolve based on GTA VI's release date. They are the SAME theme.
+- Similarly: "Will Orbán be PM" and "Will Magyar be PM" are both the Hungary 2026 election — treat as same theme (you may hold both as a hedge pair, but do not add a third Hungary position).
+- If you're uncertain whether a market correlates to an existing theme, assume it does and skip.
+
+## CLOSED MARKET DISCIPLINE (absolute rule — never override):
+- get_positions returns a JSON object with two keys: "positions" (open) and "closed_markets" (previously exited).
+- NEVER place a new order for any market_id+outcome combination that appears in closed_markets. This is enforced server-side and will be rejected anyway.
+- The reason: re-entering a market you already exited is a sign of anchoring bias. If the thesis was wrong once, sportsbook odds movement is not sufficient justification. Accept the loss and redeploy capital elsewhere.
+
+## SPORTSBOOK CROSS-CHECK DISCIPLINE (apply when estimating fair value):
+- Sportsbooks measure betting DEMAND, not calibrated probability. Polymarket is often better calibrated on liquid markets (>$50k volume).
+- When fair value is primarily derived from sportsbook lines (e.g. "DraftKings has X at +225 implying 30%"), apply a 50% haircut to the apparent cross-market edge. Example: sportsbooks imply 30%, Polymarket shows 15% → effective edge = (30%×0.8 − 15%) = 9pp, not 15pp.
+- Sportsbook-derived estimates MUST exceed the horizon threshold AFTER the 50% haircut. Do not enter based purely on sportsbook arbitrage at small gaps.
+- Anchor fair value on base rates and world knowledge first; use sportsbooks to adjust by ±5pp only. If you cannot defend the estimate without the sportsbook line, the edge is too speculative.
+- Exception: if both Polymarket AND sportsbooks agree with your base-rate analysis, the convergence strengthens the thesis.
+
+STEP 1: Call get_positions to see your current open positions AND closed_markets — required before evaluating any market.
+STEP 2: For each market, apply horizon discipline, concentration discipline, AND closed market discipline (using the data from step 1).
+STEP 3: If price differs from your fair probability by the required edge (accounting for sportsbook haircut if applicable), place a trade ($10 USDC). Call skip_all only if you have zero opinion on all markets.`;
         const msg = JSON.stringify({
             type: 'user',
             message: { role: 'user', content: prompt }
@@ -279,6 +308,8 @@ CLOSE RULES — apply ALL that match, no thesis override allowed:
 3. Your side of the position is priced below 10% — HARD CLOSE. The market has strongly repriced against you. Do NOT override this with "thesis not disproven yet." At <10%, expected value of holding is near zero.
 4. Position is down >50% — HARD CLOSE regardless of thesis. Cut losses. No exceptions.
 5. You have 2+ open positions in the SAME market with the SAME outcome — close the NEWER entry (higher ts value) regardless of P&L. Duplicate same-outcome positions double exposure without incremental edge. Keep the original entry.
+6. Position is UP >25% from entry AND has been held >48h — CLOSE to lock in profits. The market has moved significantly in your favor; gains are now vulnerable to reversion. Use take_profit reason. Exception: if the resolution event is within 7 days AND the position is still clearly on the right side, you may hold until resolution.
+7. STALE POSITION: Position held >7 days AND price has moved <5% from entry AND resolution event is >30 days away — CLOSE to redeploy capital. A position that doesn't move over 7 days means the mispricing wasn't as large as estimated. Cut it, accept the small loss/gain, and redeploy to markets with active price movement.
 
 HOLD RULES: If NONE of the close rules apply and exit trigger NOT triggered, do nothing (no output needed).`;
         const msg = JSON.stringify({

package/dist/lib/paper-trade.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Core business logic for paper trading.
+ * Extracted so it can be unit-tested independently of the MCP server.
+ */
+export interface Position {
+    market_id: string;
+    market_question: string;
+    outcome: string;
+    side: string;
+    size_usdc: number;
+    price: number;
+    ts: number;
+    status: 'open' | 'closed';
+    exit_price?: number;
+    pnl?: number;
+    closed_at?: number;
+    reason?: string;
+    exit_trigger?: string;
+    reasoning?: string;
+    new_catalyst?: string | null;
+    token_id?: string;
+}
+export interface PlaceOrderParams {
+    market_id: string;
+    outcome: string;
+    size_usdc: number;
+    price: number;
+    new_catalyst?: string;
+}
+export declare const TOTAL_BUDGET = 500;
+export declare const MARKET_CAP = 100;
+/**
+ * Validate a place_order request against the current set of open positions.
+ * Returns an error message string if validation fails, or null if OK.
+ */
+export declare function validatePlaceOrder(params: PlaceOrderParams, openPositions: Position[]): string | null;
+/**
+ * Compute P&L for closing a position at a given exit price.
+ * Returns null if the entry price is zero or invalid (prevents division by zero).
+ *
+ * Formula: shares = size_usdc / entry_price; pnl = shares * exit_price - size_usdc
+ */
+export declare function computePnl(position: Position, exitPrice: number): number | null;

package/dist/lib/paper-trade.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Core business logic for paper trading.
+ * Extracted so it can be unit-tested independently of the MCP server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKET_CAP = exports.TOTAL_BUDGET = void 0;
+exports.validatePlaceOrder = validatePlaceOrder;
+exports.computePnl = computePnl;
+exports.TOTAL_BUDGET = 500;
+exports.MARKET_CAP = 100;
+/**
+ * Validate a place_order request against the current set of open positions.
+ * Returns an error message string if validation fails, or null if OK.
+ */
+function validatePlaceOrder(params, openPositions) {
+    // Input validation — guard against bad LLM output
+    if (params.size_usdc == null ||
+        typeof params.size_usdc !== 'number' ||
+        isNaN(params.size_usdc) ||
+        params.size_usdc <= 0) {
+        return `Error: size_usdc must be a positive number. Got: ${params.size_usdc}`;
+    }
+    if (params.price == null ||
+        typeof params.price !== 'number' ||
+        isNaN(params.price) ||
+        params.price <= 0 ||
+        params.price > 1) {
+        return `Error: price must be in range (0, 1]. Got: ${params.price}`;
+    }
+    const sameMarketPositions = openPositions.filter(p => p.market_id === params.market_id);
+    // Check 1: Existing position for same market requires new_catalyst
+    if (sameMarketPositions.length > 0 && !params.new_catalyst) {
+        return `Error: Position already exists for this market. Provide new_catalyst (specific new information from last 24h) to add.`;
+    }
+    // Check 1b: Same-outcome re-entry requires ≥20% price improvement
+    const sameOutcomePositions = sameMarketPositions.filter(p => String(p.outcome).toLowerCase() === String(params.outcome).toLowerCase());
+    if (sameOutcomePositions.length > 0) {
+        const lastEntry = Math.max(...sameOutcomePositions.map(p => p.price || 0));
+        const requiredPrice = lastEntry * 0.80;
+        if (params.price > requiredPrice) {
+            return `Error: Re-entry blocked. Last ${params.outcome} entry at ${lastEntry.toFixed(4)}. Require price ≤ ${requiredPrice.toFixed(4)} (20% better) to add same-direction position. Current price ${params.price.toFixed(4)} is too close to last entry. Wait for a larger dislocation before averaging.`;
+        }
+    }
+    // Check 2: $500 total budget cap
+    const totalDeployed = openPositions.reduce((s, p) => s + (p.size_usdc || 0), 0);
+    if (totalDeployed + params.size_usdc > exports.TOTAL_BUDGET) {
+        const available = Math.max(0, exports.TOTAL_BUDGET - totalDeployed);
+        return `Error: Budget cap reached. $${exports.TOTAL_BUDGET} paper budget. Currently deployed: $${totalDeployed.toFixed(2)}. Available: $${available.toFixed(2)}.`;
+    }
+    // Check 3: $100 per-market concentration cap
+    const marketDeployed = sameMarketPositions.reduce((s, p) => s + (p.size_usdc || 0), 0);
+    if (marketDeployed + params.size_usdc > exports.MARKET_CAP) {
+        return `Error: Single-market cap: max $${exports.MARKET_CAP} per market (20% of $${exports.TOTAL_BUDGET} budget). Already deployed $${marketDeployed.toFixed(2)} in this market.`;
+    }
+    return null; // valid
+}
+/**
+ * Compute P&L for closing a position at a given exit price.
+ * Returns null if the entry price is zero or invalid (prevents division by zero).
+ *
+ * Formula: shares = size_usdc / entry_price; pnl = shares * exit_price - size_usdc
+ */
+function computePnl(position, exitPrice) {
+    if (!position.price || position.price <= 0 || isNaN(position.price)) {
+        return null;
+    }
+    const shares = position.size_usdc / position.price;
+    return shares * exitPrice - position.size_usdc;
+}
+//# sourceMappingURL=paper-trade.js.map

package/dist/mcp-server.js

@@ -8,6 +8,7 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const ioredis_1 = __importDefault(require("ioredis"));
+const paper_trade_1 = require("./lib/paper-trade");
 const REDIS_PREFIX = process.env.POLLY_REDIS_PREFIX || 'polly';
 const redis = new ioredis_1.default(process.env.REDIS_URL || 'redis://localhost:6379', {
     retryStrategy: (times) => Math.min(times * 500, 5000),
@@ -110,8 +111,6 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
     const ts = Date.now();
     if (name === 'place_order') {
         const a = args;
-        const TOTAL_BUDGET = 500;
-        const MARKET_CAP = 100;
         // Load all open positions for enforcement checks
         const rawPositions = await redis.lrange(`${REDIS_PREFIX}:positions`, 0, -1);
         const closedIds = new Set(await redis.smembers(`${REDIS_PREFIX}:closed_ids`));
@@ -127,50 +126,16 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
                 return false;
             return !closedIds.has(`${p.market_id}_${p.outcome}_${p.ts}`);
         });
-        // Check 1: Existing position for same market_id requires new_catalyst
-        const sameMarketPositions = openPositions.filter((p) => p.market_id === a.market_id);
-        if (sameMarketPositions.length > 0 && !a.new_catalyst) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error: Position already exists for this market. Provide new_catalyst (specific new information from last 24h) to add.`
-                    }]
-            };
-        }
-        // Check 1b: Same-outcome re-entry requires ≥20% price improvement (prevents pyramiding into losers)
-        const sameOutcomePositions = sameMarketPositions.filter((p) => String(p.outcome).toLowerCase() === String(a.outcome).toLowerCase());
-        if (sameOutcomePositions.length > 0) {
-            const lastEntry = Math.max(...sameOutcomePositions.map((p) => p.price || 0));
-            const requiredPrice = lastEntry * 0.80;
-            if (a.price > requiredPrice) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Error: Re-entry blocked. Last ${a.outcome} entry at ${lastEntry.toFixed(4)}. Require price ≤ ${requiredPrice.toFixed(4)} (20% better) to add same-direction position. Current price ${a.price.toFixed(4)} is too close to last entry. Wait for a larger dislocation before averaging.`
-                        }]
-                };
-            }
-        }
-        // Check 2: $500 total budget cap
-        const totalDeployed = openPositions.reduce((s, p) => s + (p.size_usdc || 0), 0);
-        if (totalDeployed + a.size_usdc > TOTAL_BUDGET) {
-            const available = Math.max(0, TOTAL_BUDGET - totalDeployed);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error: Budget cap reached. $500 paper budget. Currently deployed: $${totalDeployed.toFixed(2)}. Available: $${available.toFixed(2)}.`
-                    }]
-            };
+        // Block re-entry into previously closed market+outcome combos
+        const marketOutcomePrefix = `${a.market_id}_${a.outcome}_`;
+        const wasClosedBefore = Array.from(closedIds).some(id => id.startsWith(marketOutcomePrefix));
+        if (wasClosedBefore) {
+            return { content: [{ type: 'text', text: `Error: Re-entry blocked. This market+outcome (${a.market_id} ${a.outcome}) was previously closed. Polly-gamba does not re-enter previously exited positions to prevent repeated losses on the same bet.` }] };
         }
-        // Check 3: $100 per-market concentration cap
-        const marketDeployed = sameMarketPositions.reduce((s, p) => s + (p.size_usdc || 0), 0);
-        if (marketDeployed + a.size_usdc > MARKET_CAP) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error: Single-market cap: max $100 per market (20% of $500 budget). Already deployed $${marketDeployed.toFixed(2)} in this market.`
-                    }]
-            };
+        // Validate using extracted business logic (includes input validation + budget checks)
+        const validationError = (0, paper_trade_1.validatePlaceOrder)({ market_id: a.market_id, outcome: a.outcome, size_usdc: a.size_usdc, price: a.price, new_catalyst: a.new_catalyst }, openPositions);
+        if (validationError) {
+            return { content: [{ type: 'text', text: validationError }] };
         }
         const position = {
             market_id: a.market_id,
@@ -232,13 +197,28 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
             const key = `${p.market_id}_${p.outcome}_${p.ts}`;
             return !closedIds.has(key);
         });
+        // Expose previously-closed market+outcome combos so Claude can avoid re-entry
+        const closedMarkets = Array.from(closedIds).map(key => {
+            const parts = key.split('_');
+            return { market_id: parts[0], outcome: parts[1] };
+        });
+        // Deduplicate
+        const seen = new Set();
+        const uniqueClosedMarkets = closedMarkets.filter(m => {
+            const k = `${m.market_id}_${m.outcome}`;
+            if (seen.has(k))
+                return false;
+            seen.add(k);
+            return true;
+        });
         return {
-            content: [{ type: 'text', text: JSON.stringify(positions, null, 2) }]
+            content: [{ type: 'text', text: JSON.stringify({ positions, closed_markets: uniqueClosedMarkets }, null, 2) }]
         };
     }
     if (name === 'close_position') {
         const a = args;
         const raw = await redis.lrange(`${REDIS_PREFIX}:positions`, 0, -1);
+        const closedIdsForClose = new Set(await redis.smembers(`${REDIS_PREFIX}:closed_ids`));
         const positions = raw.map(r => {
             try {
                 return JSON.parse(r);
@@ -247,15 +227,24 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
                 return null;
             }
         }).filter(Boolean);
-        // Find matching open position
-        const match = positions.find((p) => p.market_id === a.market_id &&
-            p.outcome?.toLowerCase() === String(a.outcome).toLowerCase() &&
-            p.status !== 'closed');
+        // Find matching open position — must check BOTH status field AND closedIds set
+        // (hard stops add to closedIds but cannot update the list entry's status field)
+        const match = positions.find((p) => {
+            if (p.market_id !== a.market_id)
+                return false;
+            if (p.outcome?.toLowerCase() !== String(a.outcome).toLowerCase())
+                return false;
+            if (p.status === 'closed')
+                return false;
+            return !closedIdsForClose.has(`${p.market_id}_${p.outcome}_${p.ts}`);
+        });
         if (!match) {
             return { content: [{ type: 'text', text: `No open position found for market ${a.market_id} outcome ${a.outcome}` }] };
         }
-        const shares = match.size_usdc / match.price;
-        const pnl = shares * a.exit_price - match.size_usdc;
+        const pnl = (0, paper_trade_1.computePnl)(match, a.exit_price);
+        if (pnl === null) {
+            return { content: [{ type: 'text', text: `Error: Cannot compute P&L — entry price is zero or invalid for position ${a.market_id} ${a.outcome}` }] };
+        }
         const closed = {
             ...match,
             status: 'closed',

package/dist/position-monitor.js

@@ -52,26 +52,38 @@ class PositionMonitor {
             return;
         }
         // Deduplicate market fetches keyed by marketId_outcome
+        // Throttle to 5 concurrent fetches to avoid Gamma API rate limiting
         const marketPriceCache = new Map();
         const uniqueKeys = [...new Set(toCheck.map(p => `${p.market_id}|${p.outcome}`))];
-        await Promise.all(uniqueKeys.map(async (key) => {
-            const sep = key.indexOf('|');
-            const marketId = key.slice(0, sep);
-            const outcome = key.slice(sep + 1);
-            const result = await this.fetchCurrentPrice(marketId, outcome).catch(() => null);
-            marketPriceCache.set(key, result);
-        }));
+        const BATCH_SIZE = 5;
+        for (let i = 0; i < uniqueKeys.length; i += BATCH_SIZE) {
+            const batch = uniqueKeys.slice(i, i + BATCH_SIZE);
+            await Promise.all(batch.map(async (key) => {
+                const sep = key.indexOf('|');
+                const marketId = key.slice(0, sep);
+                const outcome = key.slice(sep + 1);
+                const result = await this.fetchCurrentPrice(marketId, outcome).catch(() => null);
+                marketPriceCache.set(key, result);
+            }));
+            if (i + BATCH_SIZE < uniqueKeys.length) {
+                await new Promise(resolve => setTimeout(resolve, 200));
+            }
+        }
         // Build review candidates with current price data for Claude
         const reviewCandidates = [];
         for (const pos of toCheck) {
             const currentPrice = marketPriceCache.get(`${pos.market_id}|${pos.outcome}`) ?? null;
-            if (!currentPrice)
+            if (!currentPrice) {
+                console.warn(`[position-monitor] WARNING: no price data for ${pos.market_id} ${pos.outcome} — skipping review (market may be resolved or delisted)`);
                 continue;
+            }
             const entryPrice = pos.price;
             const gain = (currentPrice.price - entryPrice) / entryPrice;
             const hoursToEnd = (new Date(currentPrice.endDate).getTime() - Date.now()) / (1000 * 60 * 60);
-            // Only send to Claude if something notable: moved >5% either way, or <72h to expiry
-            if (Math.abs(gain) >= 0.05 || hoursToEnd <= 72) {
+            const hoursHeld = (Date.now() - pos.ts) / (1000 * 60 * 60);
+            const isStale = hoursHeld >= 168 && Math.abs(gain) < 0.05; // held >7d with <5% movement
+            // Send to Claude if: moved >5% either way, <72h to expiry, or stale (>7d no movement)
+            if (Math.abs(gain) >= 0.05 || hoursToEnd <= 72 || isStale) {
                 reviewCandidates.push({
                     market_id: pos.market_id,
                     market_question: pos.market_question,
@@ -127,6 +139,10 @@ class PositionMonitor {
         const closedIds = await this.redis.smembers(`${prefix}:closed_ids`);
         if (closedIds.includes(posKey))
             return;
+        if (!match.price || match.price <= 0) {
+            console.error(`[position-monitor] HARD STOP skipped for "${String(match.market_question).slice(0, 50)}" — entry price is zero/invalid`);
+            return;
+        }
         const shares = match.size_usdc / match.price;
         const pnl = shares * candidate.current_price - match.size_usdc;
         const closed = { ...match, status: 'closed', exit_price: candidate.current_price, pnl, closed_at: Date.now(), reason: 'stop_loss' };
@@ -141,7 +157,9 @@ class PositionMonitor {
     }
     async fetchCurrentPrice(marketId, outcome) {
         try {
-            const res = await fetch(`https://gamma-api.polymarket.com/markets/${marketId}`);
+            const res = await fetch(`https://gamma-api.polymarket.com/markets/${marketId}`, {
+                headers: { 'User-Agent': 'Mozilla/5.0 (compatible; polly-gamba/1.0)' }
+            });
             if (!res.ok)
                 return null;
             const data = await res.json();

package/dist/test/stress.d.ts

@@ -0,0 +1 @@
+export {};