@teamvibe/poller 0.1.67 → 0.1.69

package/dist/auto-update.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compare two semver versions. Returns:
+ * - 'patch' if only patch differs (1.2.3 → 1.2.4)
+ * - 'minor' if minor differs (1.2.3 → 1.3.0)
+ * - 'major' if major differs (1.2.3 → 2.0.0)
+ * - null if same or current is newer
+ */
+export declare function classifyUpdate(current: string, latest: string): 'patch' | 'minor' | 'major' | null;
+/**
+ * Check for updates and apply if within policy.
+ * Called by the cron job defined in poller.ts.
+ *
+ * Returns true if an update was applied and poller should restart (exit 0).
+ */
+export declare function checkForUpdate(): Promise<boolean>;

package/dist/auto-update.js

@@ -0,0 +1,151 @@
+import { execSync } from 'child_process';
+import { config, POLLER_VERSION } from './config.js';
+import { logger } from './logger.js';
+import { emitEvent } from './event-queue.js';
+import { doctor } from './cli/doctor.js';
+const UPDATE_TIMEOUT_MS = 120_000; // 2 minutes
+const MAX_CONSECUTIVE_FAILURES = 3;
+let consecutiveFailures = 0;
+/**
+ * Compare two semver versions. Returns:
+ * - 'patch' if only patch differs (1.2.3 → 1.2.4)
+ * - 'minor' if minor differs (1.2.3 → 1.3.0)
+ * - 'major' if major differs (1.2.3 → 2.0.0)
+ * - null if same or current is newer
+ */
+export function classifyUpdate(current, latest) {
+    const [curMajor, curMinor, curPatch] = current.split('.').map(Number);
+    const [latMajor, latMinor, latPatch] = latest.split('.').map(Number);
+    if (latMajor > curMajor)
+        return 'major';
+    if (latMajor < curMajor)
+        return null;
+    if (latMinor > curMinor)
+        return 'minor';
+    if (latMinor < curMinor)
+        return null;
+    if (latPatch > curPatch)
+        return 'patch';
+    return null;
+}
+/**
+ * Fetch the latest version from npm registry.
+ */
+function getLatestVersion() {
+    try {
+        const output = execSync('npm view @teamvibe/poller version', {
+            encoding: 'utf-8',
+            timeout: 15_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.trim();
+    }
+    catch (error) {
+        logger.warn(`[AutoUpdate] Failed to check npm registry: ${error instanceof Error ? error.message : error}`);
+        return null;
+    }
+}
+/**
+ * Check for updates and apply if within policy.
+ * Called by the cron job defined in poller.ts.
+ *
+ * Returns true if an update was applied and poller should restart (exit 0).
+ */
+export async function checkForUpdate() {
+    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        logger.warn(`[AutoUpdate] Disabled — ${consecutiveFailures} consecutive failures`);
+        emitEvent('poller.autoupdate.disabled', 'system', {
+            reason: 'max-failures-reached',
+            failures: consecutiveFailures,
+            currentVersion: POLLER_VERSION,
+        });
+        return false;
+    }
+    logger.info(`[AutoUpdate] Checking for updates (current: ${POLLER_VERSION}, policy: ${config.AUTO_UPDATE_POLICY})`);
+    // Check npm registry for latest version
+    const latestVersion = getLatestVersion();
+    if (!latestVersion) {
+        return false;
+    }
+    const updateType = classifyUpdate(POLLER_VERSION, latestVersion);
+    if (!updateType) {
+        logger.info(`[AutoUpdate] Already on latest version (${POLLER_VERSION})`);
+        return false;
+    }
+    // Check if update type is within policy
+    const policyAllows = config.AUTO_UPDATE_POLICY === 'minor'
+        ? updateType === 'patch' || updateType === 'minor'
+        : updateType === 'patch'; // policy === 'patch'
+    if (!policyAllows) {
+        logger.info(`[AutoUpdate] ${updateType} update available (${POLLER_VERSION} → ${latestVersion}) but policy is "${config.AUTO_UPDATE_POLICY}", skipping`);
+        return false;
+    }
+    logger.info(`[AutoUpdate] ${updateType} update available: ${POLLER_VERSION} → ${latestVersion}`);
+    // Step 1: Pre-check
+    logger.info('[AutoUpdate] Running pre-update health check...');
+    const preCheckOk = await doctor();
+    if (!preCheckOk) {
+        logger.warn('[AutoUpdate] Pre-check failed, skipping update');
+        consecutiveFailures++;
+        emitEvent('poller.autoupdate.failed', 'system', {
+            reason: 'pre-check-failed',
+            currentVersion: POLLER_VERSION,
+            targetVersion: latestVersion,
+        });
+        return false;
+    }
+    // Step 2: Install
+    logger.info(`[AutoUpdate] Installing @teamvibe/poller@${latestVersion}...`);
+    try {
+        execSync(`npm install -g @teamvibe/poller@${latestVersion}`, {
+            timeout: UPDATE_TIMEOUT_MS,
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`[AutoUpdate] Install failed: ${errorMsg}`);
+        consecutiveFailures++;
+        emitEvent('poller.autoupdate.failed', 'system', {
+            reason: 'install-failed',
+            currentVersion: POLLER_VERSION,
+            targetVersion: latestVersion,
+            error: errorMsg,
+        });
+        return false;
+    }
+    // Step 3: Post-check
+    logger.info('[AutoUpdate] Running post-update health check...');
+    const postCheckOk = await doctor();
+    if (!postCheckOk) {
+        logger.warn(`[AutoUpdate] Post-check failed, rolling back to ${POLLER_VERSION}...`);
+        try {
+            execSync(`npm install -g @teamvibe/poller@${POLLER_VERSION}`, {
+                timeout: UPDATE_TIMEOUT_MS,
+                stdio: 'pipe',
+                encoding: 'utf-8',
+            });
+            logger.info(`[AutoUpdate] Rolled back to ${POLLER_VERSION}`);
+        }
+        catch (rollbackError) {
+            logger.error(`[AutoUpdate] CRITICAL: Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : rollbackError}`);
+        }
+        consecutiveFailures++;
+        emitEvent('poller.autoupdate.rolledback', 'system', {
+            currentVersion: POLLER_VERSION,
+            targetVersion: latestVersion,
+            reason: 'post-check-failed',
+        });
+        return false;
+    }
+    // Success
+    consecutiveFailures = 0;
+    logger.info(`[AutoUpdate] Successfully updated ${POLLER_VERSION} → ${latestVersion}. Restart required.`);
+    emitEvent('poller.autoupdate.success', 'system', {
+        previousVersion: POLLER_VERSION,
+        newVersion: latestVersion,
+        updateType,
+    });
+    return true;
+}

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';
@@ -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/cli/commands.js

@@ -5,6 +5,7 @@ import { update } from './update.js';
 import { logs } from './logs.js';
 import { start, stop, restart, status } from './service.js';
 import { reset } from './reset.js';
+import { doctor } from './doctor.js';
 function showHelp() {
     console.log(`TeamVibe Poller
 
@@ -16,6 +17,7 @@ Commands:
                   Flags: --token <token> --claude-token <token> [--api-url <url>] [--max-concurrent <n>]
   uninstall       Remove the launchd service
   update          Update to the latest version and restart
+  doctor          Run health checks (verify installation & configuration)
   start           Start the installed service
   stop            Stop the installed service
   restart         Restart the installed service
@@ -57,6 +59,11 @@ export async function handleCommand(command) {
         case 'restart':
             restart();
             break;
+        case 'doctor': {
+            const healthy = await doctor();
+            process.exit(healthy ? 0 : 1);
+            break;
+        }
         case 'reset':
             await reset();
             break;

package/dist/cli/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(): Promise<boolean>;

package/dist/cli/doctor.js

@@ -0,0 +1,195 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { PLIST_PATH, SERVICE_LABEL, TEAMVIBE_DIR, LOGS_DIR } from './plist.js';
+function check(name, fn) {
+    try {
+        const result = fn();
+        if (result === true) {
+            return { name, ok: true, message: 'OK' };
+        }
+        return { name, ok: true, message: result };
+    }
+    catch (error) {
+        return { name, ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function checkNodeVersion() {
+    return check('Node.js version', () => {
+        const version = process.version;
+        const major = parseInt(version.slice(1).split('.')[0], 10);
+        if (major < 18) {
+            throw new Error(`Node.js ${version} is below minimum (v18). Please upgrade.`);
+        }
+        return `${version} (>= v18)`;
+    });
+}
+function checkTeamVibeDir() {
+    return check('TeamVibe directory', () => {
+        if (!fs.existsSync(TEAMVIBE_DIR)) {
+            throw new Error(`${TEAMVIBE_DIR} does not exist. Run 'poller install' first.`);
+        }
+        return TEAMVIBE_DIR;
+    });
+}
+function checkEnvFile() {
+    return check('Environment config', () => {
+        const envPath = path.join(TEAMVIBE_DIR, '.env');
+        if (!fs.existsSync(envPath)) {
+            throw new Error(`${envPath} not found. Run 'poller install' to configure.`);
+        }
+        const content = fs.readFileSync(envPath, 'utf-8');
+        const hasToken = content.includes('TEAMVIBE_POLLER_TOKEN');
+        const hasDirect = content.includes('SQS_QUEUE_URL') && content.includes('SESSIONS_TABLE');
+        if (!hasToken && !hasDirect) {
+            throw new Error('Missing auth configuration (TEAMVIBE_POLLER_TOKEN or SQS_QUEUE_URL + SESSIONS_TABLE)');
+        }
+        return hasToken ? 'Token mode configured' : 'Direct mode configured';
+    });
+}
+function checkLaunchdPlist() {
+    return check('Launchd plist', () => {
+        if (process.platform !== 'darwin') {
+            return 'Skipped (not macOS)';
+        }
+        if (!fs.existsSync(PLIST_PATH)) {
+            throw new Error(`Plist not found at ${PLIST_PATH}. Run 'poller install'.`);
+        }
+        const content = fs.readFileSync(PLIST_PATH, 'utf-8');
+        if (!content.includes('<key>KeepAlive</key>')) {
+            throw new Error('KeepAlive not set in plist — poller will not auto-restart on exit');
+        }
+        if (content.includes('/_npx/')) {
+            throw new Error('Plist references stale npx cache path. Run \'poller update\' to fix.');
+        }
+        return 'Installed with KeepAlive';
+    });
+}
+function checkServiceRunning() {
+    return check('Service status', () => {
+        if (process.platform !== 'darwin') {
+            return 'Skipped (not macOS)';
+        }
+        try {
+            const output = execSync(`launchctl list | grep ${SERVICE_LABEL}`, { encoding: 'utf-8' });
+            if (output.trim()) {
+                const parts = output.trim().split('\t');
+                const pid = parts[0];
+                const lastExitStatus = parts[1];
+                if (pid === '-') {
+                    throw new Error(`Service loaded but not running (last exit: ${lastExitStatus})`);
+                }
+                return `Running (PID: ${pid})`;
+            }
+            throw new Error('Service not loaded');
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Service')) {
+                throw error;
+            }
+            throw new Error('Service not loaded in launchd');
+        }
+    });
+}
+function checkLogsDir() {
+    return check('Logs directory', () => {
+        if (!fs.existsSync(LOGS_DIR)) {
+            throw new Error(`${LOGS_DIR} does not exist`);
+        }
+        const stdoutLog = path.join(LOGS_DIR, 'poller.stdout.log');
+        const stderrLog = path.join(LOGS_DIR, 'poller.stderr.log');
+        const hasStdout = fs.existsSync(stdoutLog);
+        const hasStderr = fs.existsSync(stderrLog);
+        if (!hasStdout && !hasStderr) {
+            return 'Directory exists but no log files yet';
+        }
+        return 'OK';
+    });
+}
+function checkClaudeCli() {
+    return check('Claude CLI', () => {
+        try {
+            const output = execSync('which claude', { encoding: 'utf-8' }).trim();
+            if (!output) {
+                throw new Error('Claude CLI not found in PATH');
+            }
+            // Try to get version
+            try {
+                const version = execSync('claude --version 2>/dev/null', { encoding: 'utf-8' }).trim();
+                return `${output} (${version})`;
+            }
+            catch {
+                return output;
+            }
+        }
+        catch {
+            throw new Error('Claude CLI not found in PATH. Install Claude Code first.');
+        }
+    });
+}
+function checkBrainsDir() {
+    return check('Brains directory', () => {
+        const brainsPath = path.join(TEAMVIBE_DIR, 'brains');
+        if (!fs.existsSync(brainsPath)) {
+            return 'Not yet created (will be created on first message)';
+        }
+        const brains = fs.readdirSync(brainsPath).filter(f => {
+            const stat = fs.statSync(path.join(brainsPath, f));
+            return stat.isDirectory();
+        });
+        return `${brains.length} brain(s) cloned`;
+    });
+}
+function checkDiskSpace() {
+    return check('Disk space', () => {
+        try {
+            const output = execSync(`df -h "${TEAMVIBE_DIR}" | tail -1`, { encoding: 'utf-8' }).trim();
+            const parts = output.split(/\s+/);
+            const available = parts[3];
+            const capacityStr = parts[4]?.replace('%', '');
+            const capacity = parseInt(capacityStr || '0', 10);
+            if (capacity > 95) {
+                throw new Error(`Disk ${capacity}% full — only ${available} available`);
+            }
+            if (capacity > 85) {
+                return `Warning: ${capacity}% used (${available} available)`;
+            }
+            return `${available} available (${capacity}% used)`;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Disk'))
+                throw error;
+            throw new Error('Could not check disk space');
+        }
+    });
+}
+export async function doctor() {
+    console.log('TeamVibe Poller - Health Check\n');
+    const results = [
+        checkNodeVersion(),
+        checkTeamVibeDir(),
+        checkEnvFile(),
+        checkLaunchdPlist(),
+        checkServiceRunning(),
+        checkLogsDir(),
+        checkClaudeCli(),
+        checkBrainsDir(),
+        checkDiskSpace(),
+    ];
+    let hasFailure = false;
+    for (const result of results) {
+        const icon = result.ok ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+        console.log(`  ${icon} ${result.name}: ${result.message}`);
+        if (!result.ok)
+            hasFailure = true;
+    }
+    console.log('');
+    if (hasFailure) {
+        console.log('\x1b[31mSome checks failed. Fix the issues above before proceeding.\x1b[0m');
+        return false;
+    }
+    else {
+        console.log('\x1b[32mAll checks passed. Poller is healthy.\x1b[0m');
+        return true;
+    }
+}

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>;
@@ -29,6 +30,8 @@ declare const configSchema: z.ZodObject<{
     MAINTENANCE_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     MAINTENANCE_CHECK_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     MAINTENANCE_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
+    AUTO_UPDATE_POLICY: z.ZodDefault<z.ZodEnum<["patch", "minor", "off"]>>;
+    AUTO_UPDATE_SCHEDULE: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     AWS_REGION: string;
     TEAMVIBE_API_URL: string;
@@ -41,6 +44,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;
@@ -55,6 +59,8 @@ declare const configSchema: z.ZodObject<{
     MAINTENANCE_INTERVAL_MS: number;
     MAINTENANCE_CHECK_INTERVAL_MS: number;
     MAINTENANCE_ENABLED: boolean;
+    AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
+    AUTO_UPDATE_SCHEDULE: string;
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;
@@ -73,6 +79,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;
@@ -87,6 +94,8 @@ declare const configSchema: z.ZodObject<{
     MAINTENANCE_INTERVAL_MS?: number | undefined;
     MAINTENANCE_CHECK_INTERVAL_MS?: number | undefined;
     MAINTENANCE_ENABLED?: string | undefined;
+    AUTO_UPDATE_POLICY?: "patch" | "minor" | "off" | undefined;
+    AUTO_UPDATE_SCHEDULE?: string | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;
 export declare function loadConfig(): Config;
@@ -102,6 +111,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;
@@ -116,6 +126,8 @@ export declare const config: {
     MAINTENANCE_INTERVAL_MS: number;
     MAINTENANCE_CHECK_INTERVAL_MS: number;
     MAINTENANCE_ENABLED: boolean;
+    AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
+    AUTO_UPDATE_SCHEDULE: string;
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;

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(''),
@@ -45,6 +46,9 @@ const configSchema = z.object({
     MAINTENANCE_INTERVAL_MS: z.coerce.number().default(21600000), // 6 hours between maintenance per brain
     MAINTENANCE_CHECK_INTERVAL_MS: z.coerce.number().default(300000), // 5 min check loop
     MAINTENANCE_ENABLED: z.string().default('true').transform((v) => v.toLowerCase() === 'true'),
+    // Auto-update settings
+    AUTO_UPDATE_POLICY: z.enum(['patch', 'minor', 'off']).default('patch'),
+    AUTO_UPDATE_SCHEDULE: z.string().default('03:00'), // HH:MM in UTC — daily check time
 });
 export function loadConfig() {
     const result = configSchema.safeParse(process.env);

package/dist/control-handler.d.ts

@@ -0,0 +1,4 @@
+import type { ControlMessage } from './types.js';
+export type { ControlMessage };
+export declare function isControlMessage(message: unknown): message is ControlMessage;
+export declare function handleControlMessage(control: ControlMessage): Promise<void>;

package/dist/control-handler.js

@@ -0,0 +1,143 @@
+import { execSync } from 'child_process';
+import { createRequire } from 'module';
+import { logger } from './logger.js';
+import { emitEvent, flush as flushEventQueue } from './event-queue.js';
+import { doctor } from './cli/doctor.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const UPDATE_TIMEOUT_MS = 120_000; // 2 minutes
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+export function isControlMessage(message) {
+    if (typeof message !== 'object' || message === null)
+        return false;
+    const msg = message;
+    return msg['source'] === 'control' && (msg['action'] === 'restart' || msg['action'] === 'update');
+}
+export async function handleControlMessage(control) {
+    logger.info(`[Control] Received action: ${control.action}`);
+    if (control.action === 'restart') {
+        await handleRestart();
+    }
+    else if (control.action === 'update') {
+        await handleUpdate(control.targetVersion);
+    }
+}
+async function handleRestart() {
+    logger.info('[Control] Initiating graceful restart...');
+    emitEvent('poller.restart', 'system', { version: pkg.version });
+    await flushEventQueue();
+    process.exit(0);
+}
+async function handleUpdate(targetVersion) {
+    const currentVersion = pkg.version;
+    logger.info(`[Control] Starting safe update. Current version: ${currentVersion}`);
+    // Defense-in-depth: sanitize targetVersion even though resolver validates too
+    if (targetVersion && !SEMVER_RE.test(targetVersion)) {
+        logger.error(`[Control] Invalid targetVersion "${targetVersion}" — must be semver (e.g. 1.2.3)`);
+        emitEvent('poller.update.failed', 'system', { reason: 'invalid-version', currentVersion, targetVersion });
+        await flushEventQueue();
+        return;
+    }
+    // Step 1: Pre-check — verify current state is healthy
+    logger.info('[Control] Running pre-update health check...');
+    const preCheckOk = await doctor();
+    if (!preCheckOk) {
+        logger.error('[Control] Pre-update doctor check failed. Aborting update.');
+        emitEvent('poller.update.failed', 'system', {
+            reason: 'pre-check-failed',
+            currentVersion,
+        });
+        await flushEventQueue();
+        return;
+    }
+    // Step 2: Determine target version
+    // Without explicit targetVersion, find latest and only allow patch updates
+    let resolvedVersion = targetVersion;
+    if (!resolvedVersion) {
+        try {
+            resolvedVersion = execSync('npm view @teamvibe/poller version', {
+                encoding: 'utf-8',
+                timeout: 15_000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            logger.error('[Control] Failed to check npm registry for latest version');
+            emitEvent('poller.update.failed', 'system', { reason: 'registry-check-failed', currentVersion });
+            await flushEventQueue();
+            return;
+        }
+        if (!SEMVER_RE.test(resolvedVersion)) {
+            logger.error(`[Control] npm returned invalid version: "${resolvedVersion}"`);
+            return;
+        }
+        if (resolvedVersion === currentVersion) {
+            logger.info(`[Control] Already on latest version (${currentVersion})`);
+            return;
+        }
+    }
+    const packageSpec = `@teamvibe/poller@${resolvedVersion}`;
+    logger.info(`[Control] Installing ${packageSpec}...`);
+    try {
+        execSync(`npm install -g ${packageSpec}`, {
+            timeout: UPDATE_TIMEOUT_MS,
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+        logger.info('[Control] npm install completed');
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`[Control] Update failed: ${errorMsg}`);
+        // Update failed — no rollback needed (original version still in place)
+        emitEvent('poller.update.failed', 'system', {
+            reason: 'install-failed',
+            currentVersion,
+            targetVersion: resolvedVersion,
+            error: errorMsg,
+        });
+        await flushEventQueue();
+        return;
+    }
+    // Step 3: Post-update doctor check
+    logger.info('[Control] Running post-update health check...');
+    const postCheckOk = await doctor();
+    if (!postCheckOk) {
+        logger.warn(`[Control] Post-update doctor failed. Rolling back to ${currentVersion}...`);
+        // Step 4: Rollback
+        try {
+            execSync(`npm install -g @teamvibe/poller@${currentVersion}`, {
+                timeout: UPDATE_TIMEOUT_MS,
+                stdio: 'pipe',
+                encoding: 'utf-8',
+            });
+            logger.info(`[Control] Rolled back to ${currentVersion}`);
+            emitEvent('poller.update.rolledback', 'system', {
+                currentVersion,
+                targetVersion: resolvedVersion,
+                reason: 'post-check-failed',
+            });
+        }
+        catch (rollbackError) {
+            const errMsg = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+            logger.error(`[Control] CRITICAL: Rollback failed: ${errMsg}`);
+            emitEvent('poller.update.rollback-failed', 'system', {
+                currentVersion,
+                targetVersion: resolvedVersion,
+                error: errMsg,
+            });
+        }
+        await flushEventQueue();
+        // Restart anyway — launchd will bring us back (exit 1 to signal failure)
+        process.exit(1);
+        return;
+    }
+    // Step 5: Success — restart with new version
+    logger.info('[Control] Update successful. Restarting with new version...');
+    emitEvent('poller.update.success', 'system', {
+        previousVersion: currentVersion,
+        targetVersion: resolvedVersion,
+    });
+    await flushEventQueue();
+    process.exit(0);
+}

package/dist/control-handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/control-handler.test.js

@@ -0,0 +1,74 @@
+import { describe, test, expect } from 'bun:test';
+import { isControlMessage } from './control-handler.js';
+import { classifyUpdate } from './auto-update.js';
+describe('isControlMessage', () => {
+    test('valid restart message', () => {
+        expect(isControlMessage({ source: 'control', action: 'restart' })).toBe(true);
+    });
+    test('valid update message', () => {
+        expect(isControlMessage({ source: 'control', action: 'update' })).toBe(true);
+    });
+    test('valid update with targetVersion', () => {
+        expect(isControlMessage({ source: 'control', action: 'update', targetVersion: '1.2.3' })).toBe(true);
+    });
+    test('rejects non-control source', () => {
+        expect(isControlMessage({ source: 'slack', action: 'restart' })).toBe(false);
+    });
+    test('rejects unknown action', () => {
+        expect(isControlMessage({ source: 'control', action: 'delete' })).toBe(false);
+    });
+    test('rejects null', () => {
+        expect(isControlMessage(null)).toBe(false);
+    });
+    test('rejects undefined', () => {
+        expect(isControlMessage(undefined)).toBe(false);
+    });
+    test('rejects string', () => {
+        expect(isControlMessage('control')).toBe(false);
+    });
+    test('rejects empty object', () => {
+        expect(isControlMessage({})).toBe(false);
+    });
+    test('rejects regular queue message', () => {
+        expect(isControlMessage({
+            id: '123',
+            source: 'cron',
+            thread_id: 'thread1',
+            sender: { id: 'user1', name: 'Test' },
+            text: 'hello',
+        })).toBe(false);
+    });
+});
+describe('classifyUpdate', () => {
+    test('detects patch update', () => {
+        expect(classifyUpdate('1.2.3', '1.2.4')).toBe('patch');
+    });
+    test('detects minor update', () => {
+        expect(classifyUpdate('1.2.3', '1.3.0')).toBe('minor');
+    });
+    test('detects major update', () => {
+        expect(classifyUpdate('1.2.3', '2.0.0')).toBe('major');
+    });
+    test('returns null for same version', () => {
+        expect(classifyUpdate('1.2.3', '1.2.3')).toBeNull();
+    });
+    test('returns null for downgrade (patch)', () => {
+        expect(classifyUpdate('1.2.4', '1.2.3')).toBeNull();
+    });
+    test('returns null for downgrade (minor)', () => {
+        expect(classifyUpdate('1.3.0', '1.2.5')).toBeNull();
+    });
+    test('returns null for downgrade (major)', () => {
+        expect(classifyUpdate('2.0.0', '1.9.9')).toBeNull();
+    });
+    test('handles zero versions', () => {
+        expect(classifyUpdate('0.0.1', '0.0.2')).toBe('patch');
+        expect(classifyUpdate('0.1.0', '0.2.0')).toBe('minor');
+    });
+    test('minor update with different patch', () => {
+        expect(classifyUpdate('1.2.3', '1.3.5')).toBe('minor');
+    });
+    test('major update with different minor/patch', () => {
+        expect(classifyUpdate('1.2.3', '2.1.0')).toBe('major');
+    });
+});

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const command = process.argv[2];
-if (command && ['install', 'uninstall', 'update', 'logs', 'status', 'start', 'stop', 'restart', 'reset', '--help', '-h', '--version', '-v'].includes(command)) {
+if (command && ['install', 'uninstall', 'update', 'doctor', 'logs', 'status', 'start', 'stop', 'restart', 'reset', '--help', '-h', '--version', '-v'].includes(command)) {
     const { handleCommand } = await import('./cli/commands.js');
     await handleCommand(command);
 }

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';
@@ -10,8 +10,45 @@ import { initAuth, stopRefresh } from './auth-provider.js';
 import { registerBrain, startHeartbeatLoop, stopHeartbeatLoop } from './heartbeat-manager.js';
 import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent } from './event-queue.js';
 import { writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed } from './inbox-manager.js';
+import { Cron } from 'croner';
+import { isControlMessage, handleControlMessage } from './control-handler.js';
+import { checkForUpdate } from './auto-update.js';
 // Track active message processing
 const processingMessages = new Set();
+// Poller auto-update cron (separate from brain heartbeats)
+let autoUpdateJob = null;
+function startAutoUpdateCron() {
+    const schedule = config.AUTO_UPDATE_SCHEDULE;
+    const match = schedule.match(/^(\d{2}):(\d{2})$/);
+    if (!match || config.AUTO_UPDATE_POLICY === 'off') {
+        if (config.AUTO_UPDATE_POLICY !== 'off') {
+            logger.warn(`[AutoUpdate] Invalid AUTO_UPDATE_SCHEDULE: "${schedule}", expected "HH:MM"`);
+        }
+        return;
+    }
+    // Convert "HH:MM" to cron expression: "MM HH * * *"
+    const cronExpr = `${match[2]} ${match[1]} * * *`;
+    logger.info(`[AutoUpdate] Scheduled daily at ${schedule} UTC (cron: ${cronExpr}), policy: ${config.AUTO_UPDATE_POLICY}`);
+    autoUpdateJob = new Cron(cronExpr, { timezone: 'UTC' }, async () => {
+        try {
+            const shouldRestart = await checkForUpdate();
+            if (shouldRestart) {
+                logger.info('[AutoUpdate] Update applied, restarting...');
+                await flushEventQueue();
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            logger.error(`[AutoUpdate] Check error: ${error instanceof Error ? error.message : error}`);
+        }
+    });
+}
+function stopAutoUpdateCron() {
+    if (autoUpdateJob) {
+        autoUpdateJob.stop();
+        autoUpdateJob = null;
+    }
+}
 // Track which threads have an active processing loop
 const activeLoops = new Set();
 async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
@@ -25,8 +62,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;
@@ -281,7 +327,20 @@ async function pollLoop() {
             if (duplicates.length > 0) {
                 logger.info(`Deduplicated: ${messages.length} -> ${unique.length} message(s)`);
             }
-            const processPromises = unique.map((msg) => processMessage(msg).catch((error) => {
+            // Handle control messages immediately (restart/update) — no Claude session needed
+            const regularMessages = [];
+            for (const msg of unique) {
+                const raw = msg.queueMessage;
+                if (isControlMessage(raw)) {
+                    logger.info(`[Control] Received control message: ${raw.action}`);
+                    await deleteMessage(msg.receiptHandle);
+                    await handleControlMessage(raw);
+                    // If we get here, the action didn't trigger an exit (e.g. update failed pre-check)
+                    continue;
+                }
+                regularMessages.push(msg);
+            }
+            const processPromises = regularMessages.map((msg) => processMessage(msg).catch((error) => {
                 logger.error(`Failed to process message ${msg.messageId}:`, error);
             }));
             // Don't await - let them run in parallel
@@ -305,6 +364,7 @@ async function shutdown(signal) {
     logger.info(`${signal} received, shutting down gracefully...`);
     stopRefresh();
     stopHeartbeatLoop();
+    stopAutoUpdateCron();
     stopEventQueue();
     // Kill all active Claude child processes
     await killAllActiveProcesses();
@@ -342,5 +402,6 @@ export async function startPoller() {
     await ensureDirectories();
     await ensureBaseBrain();
     startHeartbeatLoop(processMessage);
+    startAutoUpdateCron();
     await pollLoop();
 }

package/dist/types.d.ts

@@ -1,3 +1,10 @@
+export interface ControlMessage {
+    id: string;
+    source: 'control';
+    action: 'restart' | 'update';
+    targetVersion?: string;
+}
+export type QueueMessage = TeamVibeQueueMessage | ControlMessage;
 export interface TeamVibeQueueMessage {
     id: string;
     source: 'slack' | 'email' | 'cron' | 'heartbeat' | 'webhook';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
@@ -24,6 +24,7 @@
     "@aws-sdk/client-sqs": "^3.470.0",
     "@aws-sdk/lib-dynamodb": "^3.470.0",
     "@slack/web-api": "^7.0.0",
+    "croner": "^10.0.1",
     "dotenv": "^17.2.3",
     "zod": "^3.22.0"
   },