polly-gamba 1.0.32 → 1.0.37

package/dist/claude-trader.js

@@ -115,7 +115,7 @@ RULES:
 
 ## POSITION DISCIPLINE:
 - 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.
+- 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. CRITICAL: Sportsbook odds movement is NOT a valid new catalyst — if your original thesis cited sportsbook lines and the proposed add-on also cites updated sportsbook odds, that is the same bet twice. Only factual real-world events qualify (injury, official announcement, standings change, political development). Sportsbook-only re-entry is prohibited even with a large price discount.
 - 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 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.`
                 }
@@ -311,8 +311,11 @@ CLOSE RULES — apply ALL that match, no thesis override allowed:
 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.
 8. CONCENTRATION VIOLATION: Count open positions by underlying theme (the single real-world event that resolves all of them). Examples: "Will Jesus return before GTA VI", "Will BTC hit $1M before GTA VI", "Will China invade Taiwan before GTA VI" all share the theme "GTA VI release date". Similarly "Will Spurs win NBA Finals", "Will OKC win NBA Finals", "Will Celtics win NBA Finals" all share the theme "2026 NBA Finals". If you have 3+ positions in the same theme, close the one with the smallest current edge (current price closest to 50/50 or furthest from your target) to reduce to 2 positions. Apply this BEFORE checking other rules.
+9. SPORTSBOOK THESIS DECAY: If the original reasoning cited a sportsbook cross-reference (e.g. "sportsbooks imply X%, Polymarket shows Y%") AND the position is currently down >20%: estimate current sportsbook consensus from your world knowledge. If the original sportsbook-Polymarket gap has narrowed by >60% (e.g. original 15pp gap is now ≤6pp), the arbitrage thesis is exhausted — CLOSE with reason "thesis_decayed". Do not continue holding through hard stops when the original edge is structurally gone.
 
-HOLD RULES: If NONE of the close rules apply and exit trigger NOT triggered, do nothing (no output needed).`;
+HOLD RULES: If NONE of the close rules apply and exit trigger NOT triggered, do nothing (no output needed).
+
+NOTE: Positions with no price data are automatically freed by the system after 24h (likely resolved or delisted). You will only receive positions with valid current prices.`;
         const msg = JSON.stringify({
             type: 'user',
             message: { role: 'user', content: prompt }

package/dist/lib/paper-trade.js

@@ -28,7 +28,7 @@ function validatePlaceOrder(params, openPositions) {
         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);
+    const sameMarketPositions = openPositions.filter(p => String(p.market_id) === String(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.`;

package/dist/mcp-server.js

@@ -126,19 +126,21 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
                 return false;
             return !closedIds.has(`${p.market_id}_${p.outcome}_${p.ts}`);
         });
+        // Normalize market_id to string to prevent type-mismatch bypasses
+        const marketId = String(a.market_id);
         // Block re-entry into previously closed market+outcome combos
-        const marketOutcomePrefix = `${a.market_id}_${a.outcome}_`;
+        const marketOutcomePrefix = `${marketId}_${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.` }] };
+            return { content: [{ type: 'text', text: `Error: Re-entry blocked. This market+outcome (${marketId} ${a.outcome}) was previously closed. Polly-gamba does not re-enter previously exited positions to prevent repeated losses on the same bet.` }] };
         }
         // 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);
+        const validationError = (0, paper_trade_1.validatePlaceOrder)({ market_id: marketId, 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,
+            market_id: marketId,
             market_question: a.market_question,
             token_id: a.token_id,
             outcome: a.outcome,
@@ -230,7 +232,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
         // 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)
+            if (String(p.market_id) !== String(a.market_id))
                 return false;
             if (p.outcome?.toLowerCase() !== String(a.outcome).toLowerCase())
                 return false;

package/dist/position-monitor.js

@@ -71,12 +71,34 @@ class PositionMonitor {
         }
         // Build review candidates with current price data for Claude
         const reviewCandidates = [];
+        // Track positions with no price data that have been CONTINUOUSLY unavailable for >24h — likely resolved/delisted
+        // We use a Redis hash to record when price data first went missing per position key.
+        // A transient API outage should NOT trigger closure — only sustained unavailability counts.
+        const noPriceDataStale = [];
+        const noPriceSinceKey = `${this.prefix}:no_price_since`;
         for (const pos of toCheck) {
             const currentPrice = marketPriceCache.get(`${pos.market_id}|${pos.outcome}`) ?? null;
+            const posKey = `${pos.market_id}_${pos.outcome}_${pos.ts}`;
             if (!currentPrice) {
-                console.warn(`[position-monitor] WARNING: no price data for ${pos.market_id} ${pos.outcome} — skipping review (market may be resolved or delisted)`);
+                // Record when we first noticed missing price data for this position
+                const existing = await this.redis.hget(noPriceSinceKey, posKey);
+                if (!existing) {
+                    await this.redis.hset(noPriceSinceKey, posKey, String(Date.now()));
+                    console.warn(`[position-monitor] WARNING: no price data for ${pos.market_id} ${pos.outcome} — first miss recorded, watching (market may be resolved or delisted)`);
+                }
+                else {
+                    const hoursMissing = (Date.now() - parseInt(existing, 10)) / (1000 * 60 * 60);
+                    if (hoursMissing >= 24) {
+                        noPriceDataStale.push(pos);
+                    }
+                    else {
+                        console.warn(`[position-monitor] WARNING: no price data for ${pos.market_id} ${pos.outcome} — missing ${hoursMissing.toFixed(1)}h (closes after 24h continuous)`);
+                    }
+                }
                 continue;
             }
+            // Price data available — clear any no-price-since tracker
+            await this.redis.hdel(noPriceSinceKey, posKey);
             const entryPrice = pos.price;
             const gain = (currentPrice.price - entryPrice) / entryPrice;
             const hoursToEnd = (new Date(currentPrice.endDate).getTime() - Date.now()) / (1000 * 60 * 60);
@@ -99,6 +121,24 @@ class PositionMonitor {
                 });
             }
         }
+        // Close positions with no price data held >24h — market is likely resolved or delisted
+        for (const pos of noPriceDataStale) {
+            const posKey = `${pos.market_id}_${pos.outcome}_${pos.ts}`;
+            const alreadyClosed = await this.redis.sismember(`${this.prefix}:closed_ids`, posKey);
+            if (alreadyClosed)
+                continue;
+            const closed = { ...pos, status: 'closed', exit_price: pos.price, pnl: 0, closed_at: Date.now(), reason: 'market_unavailable' };
+            await this.redis.sadd(`${this.prefix}:closed_ids`, posKey);
+            await this.redis.hdel(noPriceSinceKey, posKey); // clean up tracker
+            await this.redis.lpush(`${this.prefix}:closed_positions`, JSON.stringify(closed));
+            await this.redis.ltrim(`${this.prefix}:closed_positions`, 0, 9999);
+            await this.redis.lpush(`${this.prefix}:log`, JSON.stringify({ type: 'position_closed', data: closed, ts: Date.now(), trigger: 'market_unavailable' }));
+            await this.redis.ltrim(`${this.prefix}:log`, 0, 9999);
+            console.log(`[position-monitor] CLOSED [market_unavailable] "${String(pos.market_question).slice(0, 50)}" ${pos.outcome} — no price data for >24h continuously, freeing capital`);
+        }
+        if (noPriceDataStale.length > 0) {
+            console.log(`[position-monitor] freed ${noPriceDataStale.length} stale no-price-data positions`);
+        }
         // Execute programmatic hard stops BEFORE sending to Claude
         // These are deterministic rules — no judgment needed
         const hardStopClosed = [];

package/dist/test/stress.js

@@ -376,6 +376,29 @@ async function runConcentrationTests() {
         assert(err.includes('Budget cap'), `expected Budget cap error (not market cap), got: ${err}`);
     });
 }
+async function runTypeCoercionTests() {
+    console.log('\n## I) Type Coercion — market_id string vs number');
+    await test('I1: numeric market_id in params matches string market_id in position', async () => {
+        // Simulates Claude passing market_id as a number (e.g., 564166) while
+        // Redis stores it as a string ("564166"). Without String() coercion,
+        // sameMarketPositions would be empty → 20% discount check bypassed.
+        const openPositions = [
+            makePosition({ market_id: '564166', outcome: 'YES', price: 0.30, ts: 1 })
+        ];
+        const err = (0, paper_trade_1.validatePlaceOrder)({ market_id: 564166, outcome: 'YES', size_usdc: 10, price: 0.29, new_catalyst: 'New result' }, openPositions);
+        // 0.29 > 0.30 * 0.80 = 0.24 → should be blocked (not a 20% discount)
+        assert(err !== null, 'expected re-entry blocked: numeric market_id must match string in position');
+        assert(err.includes('Re-entry blocked'), `expected Re-entry blocked error, got: ${err}`);
+    });
+    await test('I2: numeric market_id with sufficient discount is allowed', async () => {
+        const openPositions = [
+            makePosition({ market_id: '564166', outcome: 'YES', price: 0.30, ts: 1 })
+        ];
+        const err = (0, paper_trade_1.validatePlaceOrder)({ market_id: 564166, outcome: 'YES', size_usdc: 10, price: 0.23, new_catalyst: 'Sportsbook update' }, openPositions);
+        // 0.23 <= 0.30 * 0.80 = 0.24 → allowed (>20% discount)
+        assert(err === null, `expected success with 20%+ discount even with numeric market_id, got: ${err}`);
+    });
+}
 // ─── Main ─────────────────────────────────────────────────────────────────────
 async function main() {
     console.log('\n[stress] polly-gamba paper trading system — stress tests');
@@ -389,6 +412,7 @@ async function main() {
     await runHardStopTests();
     await runDoubleCloseBugTests();
     await runConcentrationTests();
+    await runTypeCoercionTests();
     console.log(`\n[stress] ─── Results ─── ${passed} passed, ${failed} failed\n`);
     if (bugReport.length > 0) {
         console.log('[stress] Bug findings:');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polly-gamba",
-  "version": "1.0.32",
+  "version": "1.0.37",
   "description": "Coinbase price signal → Claude brain → Polymarket CLOB execution",
   "main": "dist/index.js",
   "bin": {