From aa96eac8633db58928c2626040ffaed0e59eb2c1 Mon Sep 17 00:00:00 2001
From: multipleof4 <planetrenox@protonmail.com>
Date: Sun, 15 Mar 2026 18:35:54 -0700
Subject: [PATCH] Fix: Setup background task to poll delayed results

---
 worker.js | 74 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 46 insertions(+), 28 deletions(-)

diff --git a/worker.js b/worker.js
index 42482d7..ffe6995 100644
--- a/worker.js
+++ b/worker.js
@@ -25,22 +25,41 @@ async function main() {
     new ThresholdStrategy({ triggerPct: 65, betSize: 1 })
   ];
 
-  // Ensure each strategy has a paper account initialized
   for (const s of strategies) {
     paper._getAccount(s.name);
   }
 
   console.log(`[Worker] Loaded ${strategies.length} strategies: ${strategies.map((s) => s.name).join(', ')}`);
 
-  // Settle any orphaned positions from previous runs before starting
-  try {
-    await paper.settleOrphans(getMarket);
-  } catch (e) {
-    console.error('[Worker] Orphan settlement error:', e.message);
+  let latestMarketState = null;
+
+  async function processOrphans() {
+    if (paper._resetting) return;
+    try {
+      const { settled, expired } = await paper.checkOrphans(getMarket);
+      const allResolved = [...settled, ...expired];
+      if (allResolved.length > 0) {
+        for (const strategy of strategies) {
+          for (const trade of allResolved) {
+            if (trade.strategy === strategy.name) {
+              strategy.onSettlement(trade.result, trade);
+            }
+          }
+        }
+        writeState(latestMarketState, paper, strategies);
+      }
+    } catch (e) {
+      console.error('[Worker] Orphan check error:', e.message);
+    }
   }
 
+  // Settle delayed positions before continuing
+  await processOrphans();
+  
+  // Continuously check open positions every 60s for delayed results
+  setInterval(processOrphans, 60000);
+
   const tracker = new MarketTracker();
-  let latestMarketState = null;
   let heartbeatTimer = null;
 
   writeState(latestMarketState, paper, strategies);
@@ -49,8 +68,7 @@ async function main() {
     latestMarketState = state || null;
     writeState(latestMarketState, paper, strategies);
 
-    if (!state) return;
-    if (paper._resetting) return;
+    if (!state || paper._resetting) return;
 
     for (const strategy of strategies) {
       if (!strategy.enabled) continue;
@@ -69,29 +87,30 @@ async function main() {
   });
 
   tracker.on('settled', async ({ ticker, result }) => {
-    console.log(`[Worker] Market ${ticker} settled: ${result}`);
+    console.log(`[Worker] Market ${ticker} rotated/closed. Result: ${result || 'pending'}`);
 
-    if (paper._resetting) {
-      console.log(`[Worker] Skipping settlement for ${ticker} — reset in progress`);
-      return;
-    }
+    if (paper._resetting) return;
 
-    const settledPositions = await paper.settle(ticker, result);
-
-    for (const strategy of strategies) {
-      if (!settledPositions) continue;
-      for (const trade of settledPositions) {
-        strategy.onSettlement(trade.result, trade);
+    // Only attempt to settle and notify if the result is already available
+    if (result) {
+      const settledPositions = await paper.settle(ticker, result);
+      if (settledPositions) {
+        for (const strategy of strategies) {
+          for (const trade of settledPositions) {
+            strategy.onSettlement(trade.result, trade);
+          }
+        }
+        await notify(
+          `Market ${ticker} settled: ${result.toUpperCase()}`,
+          'Market Settled',
+          'default',
+          'chart_with_upwards_trend'
+        );
       }
+    } else {
+      console.log(`[Worker] Result for ${ticker} pending. Background poller will handle it when Kalshi publishes the outcome.`);
     }
 
-    await notify(
-      `Market ${ticker} settled: ${result?.toUpperCase() || 'unknown'}`,
-      'Market Settled',
-      'default',
-      'chart_with_upwards_trend'
-    );
-
     writeState(latestMarketState, paper, strategies);
   });
 
@@ -102,7 +121,6 @@ async function main() {
     writeState(latestMarketState, paper, strategies);
   }, HEARTBEAT_MS);
 
-  // Check for reset flag periodically
   setInterval(async () => {
     try {
       if (fs.existsSync('/tmp/kalbot-reset-flag')) {