@teamvibe/poller 0.1.66 → 0.1.68

package/dist/claude-spawner.d.ts

@@ -13,5 +13,10 @@ export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: S
     newSessionId?: string;
 }>;
 export declare function getActiveProcessCount(): number;
+/**
+ * Kill a zombie process for a given thread ID.
+ * Returns true if a process was found and killed.
+ */
+export declare function killZombieForThread(threadId: string): boolean;
 export declare function isAtCapacity(): boolean;
 export declare function killAllActiveProcesses(): Promise<void>;

package/dist/claude-spawner.js

@@ -128,6 +128,14 @@ export function buildPrompt(msg, resumeHint) {
             : `Channel ${slack.channel}`;
         prompt += `**Channel:** ${channelType}\n`;
     }
+    // Inject human-readable timestamp from Slack message ts
+    if (msg.response_context.slack?.message_ts) {
+        const msgDate = new Date(parseFloat(msg.response_context.slack.message_ts) * 1000);
+        const dayOfWeek = msgDate.toLocaleDateString('en-US', { weekday: 'long', timeZone: 'UTC' });
+        const dateStr = msgDate.toISOString().slice(0, 10);
+        const timeStr = msgDate.toISOString().slice(11, 16);
+        prompt += `**Sent at:** ${dayOfWeek}, ${dateStr} ${timeStr} UTC\n`;
+    }
     prompt += `\n**Message:**\n${msg.text}`;
     if (msg.attachments.length > 0) {
         prompt += '\n\n**Attachments:**\n';
@@ -152,8 +160,8 @@ export function buildPrompt(msg, resumeHint) {
     if (msg.type === 'view_closed' && msg.modal) {
         prompt += `\n\n**Modal Dismissed:** User closed "${msg.modal.callbackId}" without submitting.`;
     }
-    if (msg.teamvibe.emailChannelPrompt) {
-        prompt += '\n\n**Channel Instructions:**\n' + msg.teamvibe.emailChannelPrompt + '\n';
+    if (msg.teamvibe.emailHookPrompt) {
+        prompt += '\n\n**Channel Instructions:**\n' + msg.teamvibe.emailHookPrompt + '\n';
     }
     if (resumeHint) {
         prompt += `\n\n${resumeHint}`;
@@ -333,8 +341,9 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
-        // Track active process
+        // Track active process by message ID and thread ID
         activeProcesses.set(msg.id, proc);
+        activeProcessesByThread.set(msg.thread_id, proc);
         proc.stdin?.write(prompt);
         proc.stdin?.end();
         let stdout = '';
@@ -342,6 +351,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         let stdoutBuffer = '';
         let metrics;
         let lastActivityTime = Date.now();
+        let networkErrorStart = null; // timestamp when continuous network errors began
         proc.stdout.on('data', (data) => {
             const chunk = data.toString();
             stdout += chunk;
@@ -406,10 +416,21 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 }
             }
         });
+        const NETWORK_ERROR_PATTERNS = /ETIMEDOUT|ECONNRESET|ENOTFOUND|ECONNREFUSED|fetch failed|getaddrinfo/i;
         proc.stderr.on('data', (data) => {
             const chunk = data.toString();
             stderr += chunk;
             sessionLog.claude('stderr', chunk.trimEnd());
+            // Track continuous network errors for early kill
+            if (NETWORK_ERROR_PATTERNS.test(chunk)) {
+                if (networkErrorStart === null) {
+                    networkErrorStart = Date.now();
+                }
+            }
+            else {
+                // Non-network stderr output resets the counter
+                networkErrorStart = null;
+            }
         });
         let timedOut = false;
         const timeoutMinutes = Math.round(config.CLAUDE_TIMEOUT_MS / 60000);
@@ -427,6 +448,21 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         let idleWarned = false;
         const idleWatchdog = setInterval(() => {
             const idleMs = Date.now() - lastActivityTime;
+            // Network error watchdog: kill faster if seeing sustained network errors with no productive stdout
+            if (networkErrorStart !== null) {
+                const networkErrorDuration = Date.now() - networkErrorStart;
+                if (networkErrorDuration > config.NETWORK_ERROR_KILL_MS) {
+                    const errorSec = Math.round(networkErrorDuration / 1000);
+                    logger.error(`Claude Code has sustained network errors for ${errorSec}s, killing process`);
+                    emitError('session', `Network errors for ${errorSec}s — killing process (likely network outage)`, {
+                        context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
+                        channelId: msg.teamvibe.channelId,
+                    });
+                    proc.kill('SIGTERM');
+                    setTimeout(() => proc.kill('SIGKILL'), 5000);
+                    return;
+                }
+            }
             if (idleMs > config.IDLE_WATCHDOG_KILL_MS) {
                 const idleMin = Math.round(idleMs / 60000);
                 logger.error(`Claude Code idle for ${idleMin} minutes, killing process`);
@@ -452,6 +488,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             clearTimeout(timeout);
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
+            activeProcessesByThread.delete(msg.thread_id);
             const result = {
                 success: code === 0,
                 output: stdout,
@@ -470,6 +507,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             clearTimeout(timeout);
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
+            activeProcessesByThread.delete(msg.thread_id);
             emitError('session', `Claude Code process spawn error: ${error.message}`, {
                 channelId: msg.teamvibe.channelId,
                 context: { threadId: msg.thread_id },
@@ -491,8 +529,15 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
         sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
         retryResult = await runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent, typingIndicator);
     }
-    // If session ID is "already in use" (stale lock file), retry with a fresh session ID
+    // If session ID is "already in use" (stale lock file), kill any zombie and retry with fresh ID
     if (!retryResult.success && sessionId && retryResult.error?.includes('already in use')) {
+        // Kill zombie process for this thread if still alive
+        const killed = killZombieForThread(msg.thread_id);
+        if (killed) {
+            sessionLog.info('Killed zombie process before fresh session retry');
+            // Give the process a moment to fully exit and release lock files
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
         sessionLog.info('Session ID already in use (stale lock), retrying with fresh session ID');
         const { randomUUID } = await import('crypto');
         const freshId = randomUUID();
@@ -502,9 +547,30 @@ export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMe
     return retryResult;
 }
 const activeProcesses = new Map();
+const activeProcessesByThread = new Map();
 export function getActiveProcessCount() {
     return activeProcesses.size;
 }
+/**
+ * Kill a zombie process for a given thread ID.
+ * Returns true if a process was found and killed.
+ */
+export function killZombieForThread(threadId) {
+    const proc = activeProcessesByThread.get(threadId);
+    if (!proc || proc.exitCode !== null) {
+        activeProcessesByThread.delete(threadId);
+        return false;
+    }
+    logger.warn(`Killing zombie process for thread ${threadId} (pid: ${proc.pid})`);
+    emitError('session', `Killing zombie process for thread ${threadId}`, { severity: 'warn' });
+    proc.kill('SIGTERM');
+    setTimeout(() => {
+        if (proc.exitCode === null) {
+            proc.kill('SIGKILL');
+        }
+    }, 5000);
+    return true;
+}
 export function isAtCapacity() {
     return activeProcesses.size >= config.MAX_CONCURRENT_SESSIONS;
 }

package/dist/config.d.ts

@@ -15,6 +15,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_WATCHDOG_WARN_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_WATCHDOG_KILL_MS: z.ZodDefault<z.ZodNumber>;
+    NETWORK_ERROR_KILL_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>;
@@ -41,6 +42,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS: number;
     IDLE_WATCHDOG_WARN_MS: number;
     IDLE_WATCHDOG_KILL_MS: number;
+    NETWORK_ERROR_KILL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;
@@ -73,6 +75,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS?: number | undefined;
     IDLE_WATCHDOG_WARN_MS?: number | undefined;
     IDLE_WATCHDOG_KILL_MS?: number | undefined;
+    NETWORK_ERROR_KILL_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
     BRAINS_PATH?: string | undefined;
     DEFAULT_BRAIN_PATH?: string | undefined;
@@ -102,6 +105,7 @@ export declare const config: {
     LOCK_RETRY_INTERVAL_MS: number;
     IDLE_WATCHDOG_WARN_MS: number;
     IDLE_WATCHDOG_KILL_MS: number;
+    NETWORK_ERROR_KILL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;

package/dist/config.js

@@ -20,10 +20,11 @@ const configSchema = z.object({
     VISIBILITY_TIMEOUT_SECONDS: z.coerce.number().default(60),
     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
+    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(900000), // 15 minutes (above idle watchdog kill time of 10 min)
     LOCK_RETRY_INTERVAL_MS: z.coerce.number().default(30000), // 30 seconds
     IDLE_WATCHDOG_WARN_MS: z.coerce.number().default(300000), // 5 minutes
     IDLE_WATCHDOG_KILL_MS: z.coerce.number().default(600000), // 10 minutes
+    NETWORK_ERROR_KILL_MS: z.coerce.number().default(120000), // 2 minutes of continuous network errors → kill
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/poller.js

@@ -1,7 +1,7 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { pollMessages, deleteMessage, } from './sqs-poller.js';
-import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses } from './claude-spawner.js';
+import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses, killZombieForThread } from './claude-spawner.js';
 import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
 import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
 import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
@@ -25,8 +25,17 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     try {
         let lockResult = await acquireSessionLock(threadId, kbPath);
         if (!lockResult.success) {
-            sessionLog.info(`Session ${threadId} is locked, inbox message will be picked up by active session`);
-            return;
+            // If lock acquisition failed, check for zombie processes holding the lock
+            const killed = killZombieForThread(threadId);
+            if (killed) {
+                sessionLog.info(`Killed zombie for thread ${threadId}, retrying lock acquisition`);
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                lockResult = await acquireSessionLock(threadId, kbPath);
+            }
+            if (!lockResult.success) {
+                sessionLog.info(`Session ${threadId} is locked, inbox message will be picked up by active session`);
+                return;
+            }
         }
         const { session, lockToken } = lockResult;
         let currentSessionId = session.session_id || undefined;

package/dist/types.d.ts

@@ -50,7 +50,7 @@ export interface TeamVibeQueueMessage {
             gitRepoUrl: string;
             branch: string;
         };
-        emailChannelPrompt?: string;
+        emailHookPrompt?: string;
     };
 }
 export interface SessionRecord {

package/package.json

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