@teamvibe/poller 0.1.46 → 0.1.47

package/dist/config.d.ts

@@ -12,6 +12,7 @@ declare const configSchema: z.ZodObject<{
     HEARTBEAT_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     CLAUDE_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     STALE_LOCK_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
+    LOCK_RETRY_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     TEAMVIBE_DATA_DIR: z.ZodDefault<z.ZodString>;
     BRAINS_PATH: z.ZodDefault<z.ZodString>;
     DEFAULT_BRAIN_PATH: z.ZodDefault<z.ZodString>;
@@ -34,6 +35,7 @@ declare const configSchema: z.ZodObject<{
     HEARTBEAT_INTERVAL_MS: number;
     CLAUDE_TIMEOUT_MS: number;
     STALE_LOCK_TIMEOUT_MS: number;
+    LOCK_RETRY_INTERVAL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;
@@ -62,6 +64,7 @@ declare const configSchema: z.ZodObject<{
     HEARTBEAT_INTERVAL_MS?: number | undefined;
     CLAUDE_TIMEOUT_MS?: number | undefined;
     STALE_LOCK_TIMEOUT_MS?: number | undefined;
+    LOCK_RETRY_INTERVAL_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
     BRAINS_PATH?: string | undefined;
     DEFAULT_BRAIN_PATH?: string | undefined;
@@ -87,6 +90,7 @@ export declare const config: {
     HEARTBEAT_INTERVAL_MS: number;
     CLAUDE_TIMEOUT_MS: number;
     STALE_LOCK_TIMEOUT_MS: number;
+    LOCK_RETRY_INTERVAL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;

package/dist/config.js

@@ -21,6 +21,7 @@ const configSchema = z.object({
     HEARTBEAT_INTERVAL_MS: z.coerce.number().default(40000), // 40 seconds
     CLAUDE_TIMEOUT_MS: z.coerce.number().default(3600000), // 60 minutes
     STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(3900000), // 65 minutes
+    LOCK_RETRY_INTERVAL_MS: z.coerce.number().default(30000), // 30 seconds
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/poller.js

@@ -28,7 +28,9 @@ function logQueueState(context) {
     logger.info(`[Queue] ${context} | Processing: ${stats.processing}, Threads with waiting: ${stats.threadsWithWaiting}, Total waiting: ${stats.totalWaiting}`);
 }
 function waitForThreadCompletion(threadId) {
-    return new Promise((resolve) => {
+    let resolveFn;
+    const promise = new Promise((resolve) => {
+        resolveFn = resolve;
         const signals = threadCompletionSignals.get(threadId) || [];
         signals.push(resolve);
         threadCompletionSignals.set(threadId, signals);
@@ -37,6 +39,25 @@ function waitForThreadCompletion(threadId) {
         logger.info(`[Queue] Thread ${threadId}: ${currentCount + 1} message(s) now waiting`);
         logQueueState('After enqueue');
     });
+    const cancel = () => {
+        // Remove this specific resolve from the signals array
+        const signals = threadCompletionSignals.get(threadId);
+        if (signals) {
+            const idx = signals.indexOf(resolveFn);
+            if (idx !== -1)
+                signals.splice(idx, 1);
+            if (signals.length === 0)
+                threadCompletionSignals.delete(threadId);
+        }
+        const count = waitingCountByThread.get(threadId) || 0;
+        if (count <= 1) {
+            waitingCountByThread.delete(threadId);
+        }
+        else {
+            waitingCountByThread.set(threadId, count - 1);
+        }
+    };
+    return { promise, cancel };
 }
 function signalThreadCompletion(threadId) {
     const signals = threadCompletionSignals.get(threadId);
@@ -110,13 +131,27 @@ async function processMessage(received) {
         sessionLog.info(`Session ${threadId} is processing, waiting for completion...`);
         const waitHeartbeat = startHeartbeat(receiptHandle, sessionLog);
         try {
-            await waitForThreadCompletion(threadId);
-            sessionLog.info(`Thread ${threadId} completed, retrying lock acquisition`);
-            lockResult = await acquireSessionLock(threadId, kbPath);
+            const maxWaitMs = config.STALE_LOCK_TIMEOUT_MS;
+            const retryIntervalMs = config.LOCK_RETRY_INTERVAL_MS;
+            const waitStart = Date.now();
+            while (Date.now() - waitStart < maxWaitMs) {
+                const waiter = waitForThreadCompletion(threadId);
+                // Wait for either: completion signal OR retry interval timeout
+                await Promise.race([
+                    waiter.promise,
+                    sleep(retryIntervalMs),
+                ]);
+                // Clean up the waiter (handles the timeout case where signal didn't fire)
+                waiter.cancel();
+                lockResult = await acquireSessionLock(threadId, kbPath);
+                if (lockResult.success)
+                    break;
+                sessionLog.info(`Lock still held for ${threadId}, retrying in ${retryIntervalMs / 1000}s...`);
+            }
             if (!lockResult.success) {
-                sessionLog.info('Lock still held, re-queuing for next completion');
-                clearInterval(waitHeartbeat);
-                return processMessage(received);
+                sessionLog.error(`Gave up waiting for lock on ${threadId} after ${maxWaitMs / 1000}s`);
+                await deleteMessage(receiptHandle);
+                return;
             }
         }
         finally {
@@ -205,6 +240,25 @@ async function processMessage(received) {
         signalThreadCompletion(threadId);
     }
 }
+function deduplicateMessages(messages) {
+    const byThread = new Map();
+    for (const msg of messages) {
+        const threadId = msg.queueMessage.thread_id;
+        const existing = byThread.get(threadId) || [];
+        existing.push(msg);
+        byThread.set(threadId, existing);
+    }
+    const unique = [];
+    const duplicates = [];
+    for (const [, msgs] of byThread) {
+        // Keep the last message (most recent), mark rest as duplicates
+        unique.push(msgs[msgs.length - 1]);
+        for (let i = 0; i < msgs.length - 1; i++) {
+            duplicates.push(msgs[i]);
+        }
+    }
+    return { unique, duplicates };
+}
 async function pollLoop() {
     logger.info('Poll loop started');
     while (!shuttingDown) {
@@ -222,7 +276,16 @@ async function pollLoop() {
             }
             logger.info(`Received ${messages.length} message(s) from SQS`);
             logQueueState('After SQS poll');
-            const processPromises = messages.map((msg) => processMessage(msg).catch((error) => {
+            // Deduplicate: if multiple messages for the same thread, keep only the latest
+            const { unique, duplicates } = deduplicateMessages(messages);
+            for (const dup of duplicates) {
+                logger.info(`Deleting duplicate message for thread ${dup.queueMessage.thread_id} (messageId: ${dup.messageId})`);
+                await deleteMessage(dup.receiptHandle);
+            }
+            if (duplicates.length > 0) {
+                logger.info(`Deduplicated: ${messages.length} -> ${unique.length} message(s)`);
+            }
+            const processPromises = unique.map((msg) => processMessage(msg).catch((error) => {
                 logger.error(`Failed to process message ${msg.messageId}:`, error);
             }));
             // Don't await - let them run in parallel
@@ -286,5 +349,21 @@ export async function startPoller() {
     await ensureDirectories();
     await ensureBaseBrain();
     startHeartbeatLoop(processMessage);
-    await pollLoop();
+    // Periodic queue health check — surfaces stuck messages in logs
+    const healthCheckInterval = setInterval(() => {
+        const stats = getQueueStats();
+        if (stats.totalWaiting > 0) {
+            logger.warn(`[Queue Health] ${stats.totalWaiting} message(s) waiting across ${stats.threadsWithWaiting} thread(s), ` +
+                `${stats.processing} actively processing`);
+            for (const [threadId, count] of waitingCountByThread.entries()) {
+                logger.warn(`[Queue Health]   Thread ${threadId}: ${count} waiting`);
+            }
+        }
+    }, 60000);
+    try {
+        await pollLoop();
+    }
+    finally {
+        clearInterval(healthCheckInterval);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.46",
+  "version": "0.1.47",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {