@teamvibe/poller 0.1.46 → 0.1.48

package/dist/claude-spawner.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import { join } from 'path';
+import { readFileSync, existsSync } from 'fs';
 import { WebClient } from '@slack/web-api';
 import { config } from './config.js';
 import { logger } from './logger.js';
@@ -81,6 +82,23 @@ async function countNewThreadMessages(botToken, channel, threadTs, sinceTs) {
         return 0;
     }
 }
+/**
+ * Read brain settings.json from the brain working directory.
+ * Returns parsed settings or empty object if not found.
+ */
+function readBrainSettings(cwd) {
+    const settingsPath = join(cwd, 'settings.json');
+    if (!existsSync(settingsPath))
+        return {};
+    try {
+        const raw = readFileSync(settingsPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        logger.warn(`Failed to read brain settings at ${settingsPath}: ${error}`);
+        return {};
+    }
+}
 function buildPrompt(msg, resumeHint) {
     // Heartbeat messages get a minimal prompt — CLAUDE.md/MAINTENANCE.md handle the rest
     if (msg.source === 'heartbeat') {
@@ -203,6 +221,8 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 'teamvibe-api': { command: 'node', args: [teamvibeApiServerPath] },
             },
         });
+        // Read per-brain settings (e.g. model override)
+        const brainSettings = readBrainSettings(cwd);
         const args = [
             '--print',
             '--verbose',
@@ -215,6 +235,12 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             '--disallowedTools',
             'NotebookEdit',
         ];
+        // Model override: brain settings.json takes priority, then CLAUDE_MODEL env var
+        const model = (typeof brainSettings['model'] === 'string' && brainSettings['model']) || config.CLAUDE_MODEL;
+        if (model) {
+            args.push('--model', model);
+            sessionLog.info(`Using model: ${model}`);
+        }
         // Handle session continuity
         if (sessionId) {
             if (isFirstMessage) {

package/dist/config.d.ts

@@ -12,10 +12,12 @@ 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>;
     CLAUDE_CLI_PATH: z.ZodDefault<z.ZodString>;
+    CLAUDE_MODEL: z.ZodDefault<z.ZodString>;
     PERSISTENT_STORAGE_PATH: z.ZodDefault<z.ZodString>;
     BASE_BRAIN_REPO: z.ZodDefault<z.ZodString>;
     BASE_BRAIN_BRANCH: z.ZodDefault<z.ZodString>;
@@ -34,10 +36,12 @@ 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;
     CLAUDE_CLI_PATH: string;
+    CLAUDE_MODEL: string;
     PERSISTENT_STORAGE_PATH: string;
     BASE_BRAIN_REPO: string;
     BASE_BRAIN_BRANCH: string;
@@ -62,10 +66,12 @@ 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;
     CLAUDE_CLI_PATH?: string | undefined;
+    CLAUDE_MODEL?: string | undefined;
     PERSISTENT_STORAGE_PATH?: string | undefined;
     BASE_BRAIN_REPO?: string | undefined;
     BASE_BRAIN_BRANCH?: string | undefined;
@@ -87,10 +93,12 @@ 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;
     CLAUDE_CLI_PATH: string;
+    CLAUDE_MODEL: string;
     PERSISTENT_STORAGE_PATH: string;
     BASE_BRAIN_REPO: string;
     BASE_BRAIN_BRANCH: string;

package/dist/config.js

@@ -21,11 +21,13 @@ 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(''),
     DEFAULT_BRAIN_PATH: z.string().default(''),
     CLAUDE_CLI_PATH: z.string().default('claude'),
+    CLAUDE_MODEL: z.string().default('claude-opus-4-6'),
     PERSISTENT_STORAGE_PATH: z.string().default(''),
     // Base brain repo (user-scope config for Claude Code)
     BASE_BRAIN_REPO: z.string().default('https://github.com/teamvibeai/poller-brain.git'),

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.48",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {