polly-gamba 1.0.2 → 1.0.3

package/package.json

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

package/src/claude-trader.ts

@@ -112,7 +112,7 @@ export class ClaudeTrader {
           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
+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.
@@ -120,7 +120,13 @@ RULES:
 - $10 USDC per trade (small size, many bets).
 - NO cap on number of trades — bet every market where you see any edge.
 - Only skip_all if you genuinely have zero opinion on any market (rare).
-- Use your world knowledge: sports standings, political context, recent events, base rates.`
+- Use your world knowledge: sports standings, political context, recent events, base rates.
+
+## POSITION DISCIPLINE:
+- Max $100 per market (20% of $500 budget). The MCP enforces this — don't fight it.
+- To add to an existing position: you MUST cite a specific new catalyst (news published in last 24h, not price movement). Price dipping is NOT a catalyst. Price rising 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.`
         }
       }))
       this.ready = true
@@ -227,6 +233,54 @@ For EVERY market above: if price differs from your fair probability by >5%, plac
     }
   }
 
+  async onPositionReview(positions: Array<{
+    market_id: string
+    market_question: string
+    outcome: string
+    side: string
+    price: number
+    size_usdc: number
+    exit_trigger?: string
+    ts: number
+    current_price?: number
+    hours_to_expiry?: number
+  }>) {
+    const prefix = this.config.redisPrefix
+
+    await this.redis.lpush(`${prefix}:reviews`, JSON.stringify({ ts: Date.now(), positions_count: positions.length }))
+    await this.redis.ltrim(`${prefix}:reviews`, 0, 9999)
+
+    const positionLines = positions.map(p => {
+      const gainPct = p.current_price != null && p.price > 0
+        ? (((p.current_price - p.price) / p.price) * 100).toFixed(1)
+        : 'N/A'
+      return `### ${p.market_id} ${p.market_question}
+- Side: ${p.side} ${p.outcome} | Entry: ${p.price} | Now: ${p.current_price ?? 'N/A'} | Gain: ${gainPct}%
+- Exit trigger: ${p.exit_trigger || '(none set)'}
+- Size: $${p.size_usdc} | Hours to expiry: ${p.hours_to_expiry ?? 'N/A'}h`
+    }).join('\n\n')
+
+    const prompt = `## Position Review — ${new Date().toISOString()}
+
+Review each open position against its stated exit trigger. Call close_position for any position that has hit its exit condition.
+
+${positionLines}
+
+For each position that has reached its exit_trigger condition: call close_position immediately.
+For positions still within bounds: do nothing (no output needed).`
+
+    const msg = JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: prompt }
+    })
+
+    if (this.ready) {
+      this.sendRaw(msg)
+    } else {
+      this.queue.push(msg)
+    }
+  }
+
   private async log(type: string, data: any) {
     const prefix = this.config.redisPrefix
     const entry = JSON.stringify({ type, data, ts: Date.now(), model: this.config.label })

package/src/mcp-server.ts

@@ -33,9 +33,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
           side: { type: 'string', enum: ['BUY', 'SELL'] },
           size_usdc: { type: 'number', description: 'Size in USDC (virtual)' },
           price: { type: 'number', description: 'Current price (0-1)' },
-          reasoning: { type: 'string', description: 'Why you are making this trade' }
+          reasoning: { type: 'string', description: 'Why you are making this trade' },
+          exit_trigger: { type: 'string', description: 'Specific condition that would cause an exit (e.g. "price hits 0.25 or Wemby drops off MVP ladder top 3")' },
+          new_catalyst: { type: 'string', description: 'Required if a position already exists for this market_id. Must be specific new information published in last 24h — not price movement.' }
         },
-        required: ['market_id', 'market_question', 'outcome', 'side', 'size_usdc', 'price', 'reasoning']
+        required: ['market_id', 'market_question', 'outcome', 'side', 'size_usdc', 'price', 'reasoning', 'exit_trigger']
       }
     },
     {
@@ -93,6 +95,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: {},
         required: []
       }
+    },
+    {
+      name: 'get_budget_status',
+      description: 'Returns current $500 paper budget status: deployed capital, available capital, and per-market breakdown.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: []
+      }
     }
   ]
 }))
@@ -103,7 +114,68 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
 
   if (name === 'place_order') {
     const a = args as any
-    const position = { ...a, ts, status: 'open', pnl: null }
+    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`))
+    const openPositions = rawPositions.map(r => {
+      try { return JSON.parse(r) } catch { return null }
+    }).filter(Boolean).filter((p: any) => {
+      if (p.status === 'closed') 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: any) => 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 2: $500 total budget cap
+    const totalDeployed = openPositions.reduce((s: number, p: any) => 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: number, p: any) => 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.`
+        }]
+      }
+    }
+
+    const position = {
+      market_id: a.market_id,
+      market_question: a.market_question,
+      token_id: a.token_id,
+      outcome: a.outcome,
+      side: a.side,
+      size_usdc: a.size_usdc,
+      price: a.price,
+      reasoning: a.reasoning,
+      exit_trigger: a.exit_trigger,
+      new_catalyst: a.new_catalyst || null,
+      ts,
+      status: 'open',
+      pnl: null,
+    }
     await redis.lpush(`${REDIS_PREFIX}:positions`, JSON.stringify(position))
     await redis.ltrim(`${REDIS_PREFIX}:positions`, 0, 9999)
     await redis.publish(`${REDIS_PREFIX}:events`, JSON.stringify({ type: 'trade', ...position }))
@@ -111,7 +183,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
     return {
       content: [{
         type: 'text',
-        text: `Paper trade logged: ${a.side} ${a.outcome} on "${a.market_question}" @ ${a.price} for $${a.size_usdc} USDC. Position recorded in Redis.`
+        text: `Paper trade logged: ${a.side} ${a.outcome} on "${a.market_question}" @ ${a.price} for $${a.size_usdc} USDC. Exit trigger: ${a.exit_trigger}. Position recorded in Redis.`
       }]
     }
   }
@@ -218,6 +290,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       byReason[r] = (byReason[r] || 0) + 1
     }
 
+    const TOTAL_BUDGET = 500
     const summary = {
       open_positions: openPositions.length,
       closed_positions: closedPositions.length,
@@ -225,11 +298,52 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       total_realized_pnl: Math.round(totalRealized * 100) / 100,
       win_rate: Math.round(winRate * 100) / 100,
       by_reason: byReason,
+      budget_total: TOTAL_BUDGET,
+      budget_deployed: Math.round(totalInvested * 100) / 100,
+      budget_available: Math.round((TOTAL_BUDGET - totalInvested) * 100) / 100,
     }
 
     return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] }
   }
 
+  if (name === 'get_budget_status') {
+    const TOTAL_BUDGET = 500
+    const rawPositions = await redis.lrange(`${REDIS_PREFIX}:positions`, 0, -1)
+    const closedIds = new Set(await redis.smembers(`${REDIS_PREFIX}:closed_ids`))
+    const openPositions = rawPositions.map(r => {
+      try { return JSON.parse(r) } catch { return null }
+    }).filter(Boolean).filter((p: any) => {
+      if (p.status === 'closed') return false
+      return !closedIds.has(`${p.market_id}_${p.outcome}_${p.ts}`)
+    })
+
+    const deployed = openPositions.reduce((s: number, p: any) => s + (p.size_usdc || 0), 0)
+
+    // Per-market breakdown
+    const perMarket: Record<string, { market_question: string; total_deployed: number }> = {}
+    for (const p of openPositions as any[]) {
+      if (!perMarket[p.market_id]) {
+        perMarket[p.market_id] = { market_question: p.market_question || p.market_id, total_deployed: 0 }
+      }
+      perMarket[p.market_id].total_deployed += p.size_usdc || 0
+    }
+
+    // Round per-market values
+    for (const key of Object.keys(perMarket)) {
+      perMarket[key].total_deployed = Math.round(perMarket[key].total_deployed * 100) / 100
+    }
+
+    const status = {
+      total_budget: TOTAL_BUDGET,
+      deployed: Math.round(deployed * 100) / 100,
+      available: Math.round((TOTAL_BUDGET - deployed) * 100) / 100,
+      positions_count: openPositions.length,
+      per_market: perMarket,
+    }
+
+    return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] }
+  }
+
   throw new Error(`Unknown tool: ${name}`)
 })