polly-gamba 1.0.22 → 1.0.27

package/dist/claude-trader.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaudeTrader = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const path_1 = require("path");
 const readline_1 = require("readline");
 const ioredis_1 = __importDefault(require("ioredis"));
 function findClaudeBin() {
@@ -29,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;
@@ -66,6 +68,11 @@ class ClaudeTrader {
             '--verbose',
             '--dangerously-skip-permissions',
         ];
+        // Explicitly load MCP config — --print mode doesn't auto-discover settings.json
+        const settingsPath = (0, path_1.join)(this.config.cwd, 'settings.json');
+        if ((0, fs_1.existsSync)(settingsPath)) {
+            args.push('--mcp-config', settingsPath);
+        }
         if (this.config.model) {
             args.push('--model', this.config.model);
         }
@@ -94,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.
-
+                    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
 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.
@@ -178,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()}
@@ -192,7 +199,21 @@ ${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.
+
+For EVERY market above: apply horizon discipline AND concentration discipline first, then if price differs from your fair probability by the required edge, 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 }
@@ -273,6 +294,7 @@ 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.
 
 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,10 @@ 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)}.`
-                    }]
-            };
-        }
-        // 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,
@@ -239,6 +198,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
     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 +207,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

@@ -65,8 +65,10 @@ class PositionMonitor {
         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);
@@ -127,6 +129,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' };

package/dist/test/stress.d.ts

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