@teamvibe/poller 0.1.57 → 0.1.59

package/dist/auth-provider.js

@@ -1,5 +1,6 @@
 import { POLLER_VERSION } from './config.js';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 let currentCredentials = null;
 let currentConfig = null;
 let currentPollerId = null;
@@ -19,10 +20,12 @@ async function sendHeartbeat(apiUrl, token, version) {
         });
         if (!response.ok) {
             logger.warn(`Heartbeat failed (${response.status})`);
+            emitError('auth', `Heartbeat failed (${response.status})`, { severity: 'warn' });
         }
     }
     catch (error) {
         logger.warn(`Heartbeat error: ${error instanceof Error ? error.message : error}`);
+        emitError('auth', `Heartbeat error: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
     }
 }
 async function fetchCredentials(apiUrl, token) {
@@ -62,6 +65,7 @@ export async function initAuth(apiUrl, token) {
         }
         catch (error) {
             logger.error(`Credential refresh failed: ${error instanceof Error ? error.message : error}`);
+            emitError('auth', `Credential refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }, REFRESH_INTERVAL_MS);
 }

package/dist/brain-manager.js

@@ -4,6 +4,7 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 const execAsync = promisify(exec);
 // Clean env for git commands:
 // - npm/npx sets GIT_ASKPASS which prevents credential helpers from working
@@ -42,10 +43,12 @@ async function reportBrainSync(brainId, workspaceId, event) {
         });
         if (!response.ok) {
             logger.warn(`Brain sync report failed (${response.status})`);
+            emitError('brain', `Brain sync report failed (${response.status})`, { severity: 'warn', context: { brainId, event } });
         }
     }
     catch (error) {
         logger.warn(`Brain sync report error: ${error instanceof Error ? error.message : error}`);
+        emitError('brain', `Brain sync report error: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn', context: { brainId } });
     }
 }
 export async function getBrainPath(brain, channelId, workspaceId) {
@@ -107,6 +110,7 @@ async function updateBrain(brainDir, brainId, branch) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logger.error(`Failed to update brain ${brainId}: ${errorMessage}`);
+        emitError('brain', `Failed to update brain ${brainId}: ${errorMessage}`, { context: { brainId, brainDir } });
     }
 }
 /**
@@ -170,6 +174,7 @@ export async function pushBrainChanges(brainDir, brainId, workspaceId) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logger.warn(`Failed to push brain ${brainId} changes: ${errorMessage}`);
+        emitError('brain', `Failed to push brain ${brainId} changes: ${errorMessage}`, { severity: 'warn', context: { brainId } });
     }
 }
 /**

package/dist/claude-spawner.d.ts

@@ -1,4 +1,4 @@
-import type { TeamVibeQueueMessage } from './types.js';
+import type { TeamVibeQueueMessage, SessionMetrics } from './types.js';
 import { type SessionLogger } from './logger.js';
 import type { TypingIndicator } from './slack-client.js';
 export interface SpawnResult {
@@ -6,7 +6,9 @@ export interface SpawnResult {
     output: string;
     exitCode: number | null;
     error?: string;
+    metrics?: SessionMetrics;
 }
+export declare function buildPrompt(msg: TeamVibeQueueMessage, resumeHint?: string): string;
 export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void, typingIndicator?: TypingIndicator): Promise<SpawnResult & {
     newSessionId?: string;
 }>;

package/dist/claude-spawner.js

@@ -6,6 +6,7 @@ import { config } from './config.js';
 import { logger } from './logger.js';
 import { getBaseBrainPath } from './brain-manager.js';
 import { getPollerId } from './auth-provider.js';
+import { emitError } from './event-queue.js';
 /**
  * Maps tool names (or prefixes) to human-readable status messages.
  * More specific patterns are checked first.
@@ -80,6 +81,7 @@ async function countNewThreadMessages(botToken, channel, threadTs, sinceTs) {
     }
     catch (error) {
         logger.warn(`Failed to count new thread messages: ${error}`);
+        emitError('slack', `Failed to count new thread messages: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
         return 0;
     }
 }
@@ -97,10 +99,11 @@ function readBrainSettings(cwd) {
     }
     catch (error) {
         logger.warn(`Failed to read brain settings at ${settingsPath}: ${error}`);
+        emitError('brain', `Failed to read brain settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
         return {};
     }
 }
-function buildPrompt(msg, resumeHint) {
+export function buildPrompt(msg, resumeHint) {
     // Heartbeat messages get a minimal prompt — CLAUDE.md/MAINTENANCE.md handle the rest
     if (msg.source === 'heartbeat') {
         return 'heartbeat';
@@ -268,6 +271,8 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             args.push('--model', model);
             sessionLog.info(`Using model: ${model}`);
         }
+        // Mailbox protocol: instruct Claude to check for mid-task messages
+        args.push('--append-system-prompt', 'Between major steps, check for new user messages: run `ls .mailbox/new/ 2>/dev/null`. If files exist, read each (oldest first), delete it, and act on the message immediately. If empty, continue your current work. Check before starting, every 2-3 tool calls, and after finishing.');
         // Handle session continuity
         if (sessionId) {
             if (isFirstMessage) {
@@ -319,6 +324,8 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         let stdout = '';
         let stderr = '';
         let stdoutBuffer = '';
+        let metrics;
+        let lastActivityTime = Date.now();
         proc.stdout.on('data', (data) => {
             const chunk = data.toString();
             stdout += chunk;
@@ -332,6 +339,26 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             for (const line of lines) {
                 try {
                     const event = JSON.parse(line);
+                    // Track activity for idle watchdog
+                    lastActivityTime = Date.now();
+                    // Extract metrics from result event
+                    if (event.type === 'result') {
+                        metrics = {
+                            duration_ms: event.duration_ms || 0,
+                            duration_api_ms: event.duration_api_ms || 0,
+                            num_turns: event.num_turns || 0,
+                            total_cost_usd: event.total_cost_usd || 0,
+                            input_tokens: event.usage?.input_tokens || 0,
+                            output_tokens: event.usage?.output_tokens || 0,
+                            cache_read_input_tokens: event.usage?.cache_read_input_tokens || 0,
+                            cache_creation_input_tokens: event.usage?.cache_creation_input_tokens || 0,
+                            model: Object.keys(event.modelUsage || {})[0] || 'unknown',
+                        };
+                        sessionLog.info(`[Metrics] Cost: $${metrics.total_cost_usd.toFixed(4)}, ` +
+                            `Duration: ${metrics.duration_ms}ms, ` +
+                            `Turns: ${metrics.num_turns}, ` +
+                            `Tokens: ${metrics.input_tokens}in/${metrics.output_tokens}out`);
+                    }
                     const formatted = formatStreamEvent(event);
                     if (formatted) {
                         sessionLog.claude('stdout', formatted);
@@ -373,16 +400,47 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         const timeout = setTimeout(() => {
             timedOut = true;
             logger.error(`Claude Code process timed out after ${timeoutMinutes} minutes`);
+            emitError('session', `Claude Code process timed out after ${timeoutMinutes} minutes`, {
+                context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
+                channelId: msg.teamvibe.channelId,
+            });
             proc.kill('SIGTERM');
             setTimeout(() => proc.kill('SIGKILL'), 5000);
         }, config.CLAUDE_TIMEOUT_MS);
+        // Idle watchdog: kill if no stdout activity for too long
+        let idleWarned = false;
+        const idleWatchdog = setInterval(() => {
+            const idleMs = Date.now() - lastActivityTime;
+            if (idleMs > config.IDLE_WATCHDOG_KILL_MS) {
+                const idleMin = Math.round(idleMs / 60000);
+                logger.error(`Claude Code idle for ${idleMin} minutes, killing process`);
+                emitError('session', `Claude Code idle for ${idleMin} minutes — killing hung process`, {
+                    context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
+                    channelId: msg.teamvibe.channelId,
+                });
+                proc.kill('SIGTERM');
+                setTimeout(() => proc.kill('SIGKILL'), 5000);
+            }
+            else if (!idleWarned && idleMs > config.IDLE_WATCHDOG_WARN_MS) {
+                const idleMin = Math.round(idleMs / 60000);
+                logger.warn(`Claude Code idle for ${idleMin} minutes (will kill at ${Math.round(config.IDLE_WATCHDOG_KILL_MS / 60000)} min)`);
+                emitError('session', `Claude Code idle for ${idleMin} minutes`, {
+                    severity: 'warn',
+                    context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
+                    channelId: msg.teamvibe.channelId,
+                });
+                idleWarned = true;
+            }
+        }, 30000); // Check every 30 seconds
         proc.on('close', (code) => {
             clearTimeout(timeout);
+            clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
             const result = {
                 success: code === 0,
                 output: stdout,
                 exitCode: code,
+                metrics,
             };
             if (timedOut) {
                 result.error = `Session timed out after ${timeoutMinutes} minutes. The task was still running when the time limit was reached. Consider breaking complex tasks into smaller steps.`;
@@ -394,7 +452,12 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         });
         proc.on('error', (error) => {
             clearTimeout(timeout);
+            clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
+            emitError('session', `Claude Code process spawn error: ${error.message}`, {
+                channelId: msg.teamvibe.channelId,
+                context: { threadId: msg.thread_id },
+            });
             resolve({
                 success: false,
                 output: stdout,
@@ -440,6 +503,7 @@ export function killAllActiveProcesses() {
         }
         const forceKillTimer = setTimeout(() => {
             logger.warn(`Process ${id} did not exit after SIGTERM, sending SIGKILL`);
+            emitError('session', `Process ${id} did not exit after SIGTERM, sending SIGKILL`, { severity: 'warn' });
             proc.kill('SIGKILL');
         }, 5000);
         proc.once('close', () => {

package/dist/config.d.ts

@@ -13,6 +13,8 @@ declare const configSchema: z.ZodObject<{
     CLAUDE_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     STALE_LOCK_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     LOCK_RETRY_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
+    IDLE_WATCHDOG_WARN_MS: z.ZodDefault<z.ZodNumber>;
+    IDLE_WATCHDOG_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>;
@@ -37,6 +39,8 @@ declare const configSchema: z.ZodObject<{
     CLAUDE_TIMEOUT_MS: number;
     STALE_LOCK_TIMEOUT_MS: number;
     LOCK_RETRY_INTERVAL_MS: number;
+    IDLE_WATCHDOG_WARN_MS: number;
+    IDLE_WATCHDOG_KILL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;
@@ -67,6 +71,8 @@ declare const configSchema: z.ZodObject<{
     CLAUDE_TIMEOUT_MS?: number | undefined;
     STALE_LOCK_TIMEOUT_MS?: number | undefined;
     LOCK_RETRY_INTERVAL_MS?: number | undefined;
+    IDLE_WATCHDOG_WARN_MS?: number | undefined;
+    IDLE_WATCHDOG_KILL_MS?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
     BRAINS_PATH?: string | undefined;
     DEFAULT_BRAIN_PATH?: string | undefined;
@@ -94,6 +100,8 @@ export declare const config: {
     CLAUDE_TIMEOUT_MS: number;
     STALE_LOCK_TIMEOUT_MS: number;
     LOCK_RETRY_INTERVAL_MS: number;
+    IDLE_WATCHDOG_WARN_MS: number;
+    IDLE_WATCHDOG_KILL_MS: number;
     TEAMVIBE_DATA_DIR: string;
     BRAINS_PATH: string;
     DEFAULT_BRAIN_PATH: string;

package/dist/config.js

@@ -22,6 +22,8 @@ const configSchema = z.object({
     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
+    IDLE_WATCHDOG_WARN_MS: z.coerce.number().default(300000), // 5 minutes
+    IDLE_WATCHDOG_KILL_MS: z.coerce.number().default(600000), // 10 minutes
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/event-queue.d.ts

@@ -0,0 +1,14 @@
+export type ErrorCategory = 'sqs' | 'brain' | 'auth' | 'session' | 'slack' | 'maintenance';
+export type ErrorSeverity = 'warn' | 'error';
+export declare function flush(): Promise<void>;
+export declare function startEventQueue(): void;
+export declare function stopEventQueue(): void;
+export declare function emitError(category: ErrorCategory, message: string, options?: {
+    severity?: ErrorSeverity;
+    channelId?: string;
+    context?: Record<string, unknown>;
+}): void;
+/** For testing: get current queue length */
+export declare function getQueueLength(): number;
+/** For testing: clear the queue */
+export declare function clearQueue(): void;

package/dist/event-queue.js

@@ -0,0 +1,113 @@
+// packages/poller/src/event-queue.ts
+import { config } from './config.js';
+import { logger } from './logger.js';
+const MAX_QUEUE_SIZE = 200;
+const FLUSH_INTERVAL_MS = 30_000;
+const DEDUP_WINDOW_MS = 60_000;
+let queue = [];
+let flushTimer = null;
+let isFlushing = false;
+function dedupKey(channelId, category, message) {
+    return `${channelId}:${category}:${message}`;
+}
+function enqueue(event) {
+    // Dedup: collapse identical category+message within window
+    const key = dedupKey(event.channelId, event.metadata.category, event.metadata.message);
+    const now = Date.now();
+    const windowStart = new Date(now - DEDUP_WINDOW_MS).toISOString();
+    const existing = queue.find((e) => dedupKey(e.channelId, e.metadata.category, e.metadata.message) === key &&
+        e.timestamp >= windowStart);
+    if (existing) {
+        existing.metadata.count += 1;
+        return;
+    }
+    if (queue.length >= MAX_QUEUE_SIZE) {
+        queue.shift(); // Drop oldest
+    }
+    queue.push(event);
+}
+async function flushOne(event) {
+    try {
+        const response = await fetch(`${config.TEAMVIBE_API_URL}/events`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.TEAMVIBE_POLLER_TOKEN}`,
+            },
+            body: JSON.stringify({
+                eventType: event.eventType,
+                channelId: event.channelId,
+                metadata: event.metadata,
+                error: event.error,
+            }),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function flush() {
+    if (queue.length === 0 || isFlushing)
+        return;
+    isFlushing = true;
+    try {
+        const batch = [...queue];
+        const failed = [];
+        for (const event of batch) {
+            const ok = await flushOne(event);
+            if (!ok) {
+                failed.push(event);
+            }
+        }
+        queue = failed;
+        if (failed.length > 0) {
+            logger.debug(`[EventQueue] ${failed.length} event(s) failed to flush, will retry`);
+        }
+    }
+    finally {
+        isFlushing = false;
+    }
+}
+export function startEventQueue() {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        return; // No-op in direct mode
+    }
+    flushTimer = setInterval(() => {
+        flush().catch(() => { });
+    }, FLUSH_INTERVAL_MS);
+}
+export function stopEventQueue() {
+    if (flushTimer) {
+        clearInterval(flushTimer);
+        flushTimer = null;
+    }
+}
+export function emitError(category, message, options) {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        return; // No-op in direct mode
+    }
+    const severity = options?.severity ?? 'error';
+    const channelId = options?.channelId ?? '_system';
+    enqueue({
+        eventType: 'poller.error',
+        channelId,
+        metadata: {
+            category,
+            severity,
+            message,
+            count: 1,
+            context: options?.context,
+        },
+        error: { code: category, message },
+        timestamp: new Date().toISOString(),
+    });
+}
+/** For testing: get current queue length */
+export function getQueueLength() {
+    return queue.length;
+}
+/** For testing: clear the queue */
+export function clearQueue() {
+    queue = [];
+}

package/dist/heartbeat-manager.js

@@ -1,6 +1,7 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { isAtCapacity } from './claude-spawner.js';
+import { emitError } from './event-queue.js';
 const trackedBrains = new Map();
 let heartbeatInterval = null;
 /**
@@ -85,6 +86,10 @@ export function startHeartbeatLoop(processMessageFn) {
             }
             catch (error) {
                 logger.error(`[Heartbeat] Failed maintenance for ${brainId}: ${error instanceof Error ? error.message : error}`);
+                emitError('session', `Heartbeat maintenance failed for ${brainId}: ${error instanceof Error ? error.message : String(error)}`, {
+                    channelId: info.channelId,
+                    context: { brainId },
+                });
             }
         }
     }, config.MAINTENANCE_CHECK_INTERVAL_MS);

package/dist/mailbox-manager.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Write a new message to the mailbox.
+ * Returns the filename of the created message file.
+ */
+export declare function writeMessage(brainPath: string, content: string): string;
+/**
+ * Pick the oldest message from processing/ (crash recovery) or new/.
+ * If found in new/, moves it to processing/.
+ * Returns { filename, content } or null if no messages.
+ */
+export declare function pickNextMessage(brainPath: string): {
+    filename: string;
+    content: string;
+} | null;
+/**
+ * Delete a message file from processing/ (marks it as done).
+ */
+export declare function markProcessed(brainPath: string, filename: string): void;
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export declare function hasUnprocessed(brainPath: string): boolean;

package/dist/mailbox-manager.js

@@ -0,0 +1,86 @@
+import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { logger } from './logger.js';
+const MAILBOX_DIR = '.mailbox';
+const NEW_DIR = 'new';
+const PROCESSING_DIR = 'processing';
+function ensureMailboxDirs(brainPath) {
+    const mailbox = join(brainPath, MAILBOX_DIR);
+    const newDir = join(mailbox, NEW_DIR);
+    const processingDir = join(mailbox, PROCESSING_DIR);
+    mkdirSync(newDir, { recursive: true });
+    mkdirSync(processingDir, { recursive: true });
+}
+/**
+ * Write a new message to the mailbox.
+ * Returns the filename of the created message file.
+ */
+export function writeMessage(brainPath, content) {
+    ensureMailboxDirs(brainPath);
+    const timestamp = process.hrtime.bigint().toString();
+    const filename = `${timestamp}.txt`;
+    const filepath = join(brainPath, MAILBOX_DIR, NEW_DIR, filename);
+    writeFileSync(filepath, content, 'utf-8');
+    logger.info(`[Mailbox] Wrote message: ${filename} (${content.length} chars)`);
+    return filename;
+}
+/**
+ * Pick the oldest message from processing/ (crash recovery) or new/.
+ * If found in new/, moves it to processing/.
+ * Returns { filename, content } or null if no messages.
+ */
+export function pickNextMessage(brainPath) {
+    ensureMailboxDirs(brainPath);
+    const processingDir = join(brainPath, MAILBOX_DIR, PROCESSING_DIR);
+    const newDir = join(brainPath, MAILBOX_DIR, NEW_DIR);
+    // First check processing/ (crash recovery)
+    const processingFiles = readdirSync(processingDir).filter(f => f.endsWith('.txt')).sort();
+    if (processingFiles.length > 0) {
+        const filename = processingFiles[0];
+        const content = readFileSync(join(processingDir, filename), 'utf-8');
+        logger.info(`[Mailbox] Resuming processing message: ${filename}`);
+        return { filename, content };
+    }
+    // Then check new/
+    const newFiles = readdirSync(newDir).filter(f => f.endsWith('.txt')).sort();
+    if (newFiles.length > 0) {
+        const filename = newFiles[0];
+        const srcPath = join(newDir, filename);
+        const dstPath = join(processingDir, filename);
+        const content = readFileSync(srcPath, 'utf-8');
+        renameSync(srcPath, dstPath);
+        logger.info(`[Mailbox] Picked message: ${filename} (moved to processing)`);
+        return { filename, content };
+    }
+    return null;
+}
+/**
+ * Delete a message file from processing/ (marks it as done).
+ */
+export function markProcessed(brainPath, filename) {
+    const filepath = join(brainPath, MAILBOX_DIR, PROCESSING_DIR, filename);
+    try {
+        if (existsSync(filepath)) {
+            unlinkSync(filepath);
+            logger.info(`[Mailbox] Deleted processed message: ${filename}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[Mailbox] Failed to delete ${filename}: ${error}`);
+    }
+}
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export function hasUnprocessed(brainPath) {
+    const newDir = join(brainPath, MAILBOX_DIR, NEW_DIR);
+    const processingDir = join(brainPath, MAILBOX_DIR, PROCESSING_DIR);
+    try {
+        const newCount = existsSync(newDir) ? readdirSync(newDir).filter(f => f.endsWith('.txt')).length : 0;
+        const procCount = existsSync(processingDir) ? readdirSync(processingDir).filter(f => f.endsWith('.txt')).length : 0;
+        return (newCount + procCount) > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/maintenance-reporter.js

@@ -4,6 +4,7 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { config } from './config.js';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 const execFileAsync = promisify(execFile);
 const OPERATION_TO_EVENT_TYPE = {
     consolidation: 'maintenance.consolidation',
@@ -32,11 +33,13 @@ export async function postMaintenanceReports(brainPath, channelId) {
                 const report = JSON.parse(content);
                 if (!report.operationType) {
                     logger.warn(`[MaintenanceReporter] Skipping ${file}: missing operationType`);
+                    emitError('maintenance', `Skipping report ${file}: missing operationType`, { severity: 'warn' });
                     continue;
                 }
                 const eventType = OPERATION_TO_EVENT_TYPE[report.operationType];
                 if (!eventType) {
                     logger.warn(`[MaintenanceReporter] Skipping ${file}: unknown operationType "${report.operationType}"`);
+                    emitError('maintenance', `Skipping report ${file}: unknown operationType "${report.operationType}"`, { severity: 'warn' });
                     continue;
                 }
                 const payload = {
@@ -60,10 +63,12 @@ export async function postMaintenanceReports(brainPath, channelId) {
                 else {
                     const errorBody = await response.text().catch(() => 'unknown');
                     logger.warn(`[MaintenanceReporter] Failed to POST ${file}: ${response.status} ${errorBody}`);
+                    emitError('maintenance', `Failed to POST report ${file}: ${response.status}`, { severity: 'warn', channelId });
                 }
             }
             catch (err) {
                 logger.warn(`[MaintenanceReporter] Error processing ${file}: ${err instanceof Error ? err.message : err}`);
+                emitError('maintenance', `Error processing report ${file}: ${err instanceof Error ? err.message : String(err)}`, { severity: 'warn', channelId });
             }
         }
         // Remove posted JSON reports from git so they don't resurrect on next pull
@@ -80,5 +85,6 @@ export async function postMaintenanceReports(brainPath, channelId) {
     }
     catch (err) {
         logger.warn(`[MaintenanceReporter] Error scanning reports: ${err instanceof Error ? err.message : err}`);
+        emitError('maintenance', `Error scanning reports: ${err instanceof Error ? err.message : String(err)}`, { severity: 'warn' });
     }
 }

package/dist/poller.js

@@ -1,86 +1,101 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
-import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js';
-import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses } from './claude-spawner.js';
+import { pollMessages, deleteMessage, } from './sqs-poller.js';
+import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses, buildPrompt } 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';
 import { postMaintenanceReports } from './maintenance-reporter.js';
 import { initAuth, stopRefresh } from './auth-provider.js';
 import { registerBrain, startHeartbeatLoop, stopHeartbeatLoop } from './heartbeat-manager.js';
+import { startEventQueue, stopEventQueue, flush as flushEventQueue } from './event-queue.js';
+import { writeMessage, pickNextMessage, markProcessed, hasUnprocessed } from './mailbox-manager.js';
 // Track active message processing
 const processingMessages = new Set();
-// Per-thread completion signals
-const threadCompletionSignals = new Map();
-const waitingCountByThread = new Map();
-function getQueueStats() {
-    let totalWaiting = 0;
-    waitingCountByThread.forEach((count) => {
-        totalWaiting += count;
-    });
-    return {
-        processing: processingMessages.size,
-        threadsWithWaiting: waitingCountByThread.size,
-        totalWaiting,
-    };
-}
-function logQueueState(context) {
-    const stats = getQueueStats();
-    logger.info(`[Queue] ${context} | Processing: ${stats.processing}, Threads with waiting: ${stats.threadsWithWaiting}, Total waiting: ${stats.totalWaiting}`);
-}
-function waitForThreadCompletion(threadId) {
-    let resolveFn;
-    const promise = new Promise((resolve) => {
-        resolveFn = resolve;
-        const signals = threadCompletionSignals.get(threadId) || [];
-        signals.push(resolve);
-        threadCompletionSignals.set(threadId, signals);
-        const currentCount = waitingCountByThread.get(threadId) || 0;
-        waitingCountByThread.set(threadId, currentCount + 1);
-        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);
+// Track which threads have an active processing loop
+const activeLoops = new Set();
+async function runMailboxLoop(threadId, kbPath, queueMessage, sessionLog) {
+    if (activeLoops.has(threadId)) {
+        sessionLog.info(`Loop already running for thread ${threadId}, skipping`);
+        return;
+    }
+    activeLoops.add(threadId);
+    let iteration = 0;
+    try {
+        let lockResult = await acquireSessionLock(threadId, kbPath);
+        if (!lockResult.success) {
+            sessionLog.info(`Session ${threadId} is locked, mailbox message will be picked up by active session`);
+            return;
         }
-        const count = waitingCountByThread.get(threadId) || 0;
-        if (count <= 1) {
-            waitingCountByThread.delete(threadId);
+        const { session, lockToken } = lockResult;
+        while (true) {
+            const message = pickNextMessage(kbPath);
+            if (!message) {
+                sessionLog.info(`[Loop] No more messages for thread ${threadId}`);
+                break;
+            }
+            iteration++;
+            const isFirstMessage = session.message_count === 1 && iteration === 1;
+            sessionLog.info(`[Loop] Iteration #${iteration} — processing: ${message.filename}`);
+            await ensureBaseBrain();
+            const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
+                queueMessage.response_context.slack?.message_ts);
+            const typing = hasSlackContext
+                ? startTypingIndicator(queueMessage)
+                : undefined;
+            try {
+                // Build a temporary message with the mailbox content as text
+                const mailboxMsg = {
+                    ...queueMessage,
+                    text: message.content,
+                };
+                const result = await spawnClaudeCode(mailboxMsg, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
+                typing?.stop();
+                if (result.newSessionId && lockToken) {
+                    await updateSessionId(threadId, lockToken, result.newSessionId);
+                }
+                if (result.metrics) {
+                    sessionLog.info(`[Loop] Iteration #${iteration} complete — ` +
+                        `cost: $${result.metrics.total_cost_usd.toFixed(4)}, ` +
+                        `duration: ${result.metrics.duration_ms}ms`);
+                }
+                if (result.success) {
+                    sessionLog.info(`[Loop] Claude completed iteration #${iteration}`);
+                    if (queueMessage.teamvibe.brain?.brainId) {
+                        await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId, queueMessage.teamvibe.workspaceId);
+                    }
+                    await postMaintenanceReports(kbPath, queueMessage.teamvibe.channelId);
+                }
+                else {
+                    sessionLog.error(`[Loop] Claude failed iteration #${iteration}: ${result.error}`);
+                    if (hasSlackContext) {
+                        const errorMessage = result.error || `Process exited with code ${result.exitCode}`;
+                        const isTimeout = errorMessage.includes('timed out');
+                        await sendSlackError(queueMessage, errorMessage);
+                        await addReaction(queueMessage, isTimeout ? 'hourglass' : 'x');
+                    }
+                }
+            }
+            catch (error) {
+                typing?.stop();
+                sessionLog.error(`[Loop] Error in iteration #${iteration}: ${error instanceof Error ? error.message : error}`);
+            }
+            // Safety net: ensure the processing file is cleaned up
+            markProcessed(kbPath, message.filename);
+            if (!hasUnprocessed(kbPath)) {
+                break;
+            }
+            sessionLog.info(`[Loop] More messages found, continuing...`);
         }
-        else {
-            waitingCountByThread.set(threadId, count - 1);
+        if (lockToken) {
+            const lastMessageTs = queueMessage.response_context.slack?.message_ts;
+            await releaseSessionLock(threadId, lockToken, 'idle', lastMessageTs);
         }
-    };
-    return { promise, cancel };
-}
-function signalThreadCompletion(threadId) {
-    const signals = threadCompletionSignals.get(threadId);
-    const waitingCount = signals?.length || 0;
-    if (signals && signals.length > 0) {
-        logger.info(`[Queue] Thread ${threadId} completed, waking ${waitingCount} waiting message(s)`);
-        signals.forEach((resolve) => resolve());
-        threadCompletionSignals.delete(threadId);
-        waitingCountByThread.delete(threadId);
-        logQueueState('After signal');
+        sessionLog.info(`[Loop] Complete. Iterations: ${iteration}`);
+    }
+    finally {
+        activeLoops.delete(threadId);
     }
-}
-function startHeartbeat(receiptHandle, sessionLog) {
-    return setInterval(async () => {
-        try {
-            await extendVisibility(receiptHandle, config.VISIBILITY_TIMEOUT_SECONDS);
-            sessionLog.info(`Heartbeat: extended visibility by ${config.VISIBILITY_TIMEOUT_SECONDS}s`);
-        }
-        catch (error) {
-            sessionLog.error(`Heartbeat failed: ${error instanceof Error ? error.message : error}`);
-        }
-    }, config.HEARTBEAT_INTERVAL_MS);
 }
 async function processMessage(received) {
     const { queueMessage, receiptHandle, messageId } = received;
@@ -126,99 +141,21 @@ async function processMessage(received) {
     }
     // Register brain for heartbeat tracking
     registerBrain(queueMessage);
-    // Try to acquire session lock
-    let lockResult = await acquireSessionLock(threadId, kbPath);
-    if (!lockResult.success) {
-        sessionLog.info(`Session ${threadId} is processing, waiting for completion...`);
-        const waitHeartbeat = startHeartbeat(receiptHandle, sessionLog);
-        try {
-            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.error(`Gave up waiting for lock on ${threadId} after ${maxWaitMs / 1000}s`);
-                await deleteMessage(receiptHandle);
-                return;
-            }
-        }
-        finally {
-            clearInterval(waitHeartbeat);
-        }
+    // Build prompt and write to mailbox
+    const prompt = buildPrompt(queueMessage);
+    writeMessage(kbPath, prompt);
+    sessionLog.info(`Wrote message to mailbox (${prompt.length} chars)`);
+    // Delete SQS message immediately — it's now persisted in the mailbox
+    if (receiptHandle) {
+        await deleteMessage(receiptHandle);
+        sessionLog.info('SQS message deleted (persisted in mailbox)');
     }
-    const { session, lockToken } = lockResult;
-    const isFirstMessage = session.message_count === 1;
-    sessionLog.info(`Acquired lock on session ${threadId}, Claude session: ${session.session_id}, mode: ${isFirstMessage ? 'new' : 'resume'}, message #${session.message_count}`);
-    logQueueState(`Lock acquired for ${threadId}`);
     processingMessages.add(messageId);
-    const heartbeat = startHeartbeat(receiptHandle, sessionLog);
-    // Start typing indicator
-    const typing = hasSlackContext
-        ? startTypingIndicator(queueMessage)
-        : undefined;
     try {
-        // Refresh base brain if cooldown has elapsed (5 min default)
-        await ensureBaseBrain();
-        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
-        typing?.stop();
-        // If Claude generated a new session ID (stale lock recovery), persist it
-        if (result.newSessionId && lockToken) {
-            await updateSessionId(threadId, lockToken, result.newSessionId);
-        }
-        if (result.success) {
-            sessionLog.info('Claude Code completed successfully');
-            // Push any changes in the channel brain repo
-            if (queueMessage.teamvibe.brain?.brainId) {
-                await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId, queueMessage.teamvibe.workspaceId);
-            }
-            // Post any pending maintenance reports (fire-and-forget)
-            await postMaintenanceReports(kbPath, queueMessage.teamvibe.channelId);
-            if (lockToken) {
-                const lastMessageTs = queueMessage.response_context.slack?.message_ts;
-                await releaseSessionLock(threadId, lockToken, 'idle', lastMessageTs);
-            }
-        }
-        else {
-            sessionLog.error(`Claude Code failed: ${result.error}`);
-            if (hasSlackContext) {
-                const errorMessage = result.error || `Process exited with code ${result.exitCode}`;
-                const isTimeout = errorMessage.includes('timed out');
-                await sendSlackError(queueMessage, errorMessage);
-                await addReaction(queueMessage, isTimeout ? 'hourglass' : 'x');
-            }
-            if (lockToken) {
-                await releaseSessionLock(threadId, lockToken, 'idle');
-            }
-        }
-        if (receiptHandle) {
-            await deleteMessage(receiptHandle);
-        }
-        sessionLog.info('Message processed and deleted');
+        await runMailboxLoop(threadId, kbPath, queueMessage, sessionLog);
     }
     catch (error) {
-        typing?.stop();
-        sessionLog.error(`Error processing message: ${error instanceof Error ? error.message : error}`);
-        if (lockToken) {
-            try {
-                await releaseSessionLock(threadId, lockToken, 'idle');
-            }
-            catch (releaseError) {
-                sessionLog.error(`Failed to release lock: ${releaseError}`);
-            }
-        }
+        sessionLog.error(`Error in mailbox loop: ${error instanceof Error ? error.message : error}`);
         if (hasSlackContext) {
             try {
                 const errMsg = error instanceof Error ? error.message : 'Unknown error';
@@ -238,9 +175,7 @@ async function processMessage(received) {
         throw error;
     }
     finally {
-        clearInterval(heartbeat);
         processingMessages.delete(messageId);
-        signalThreadCompletion(threadId);
     }
 }
 function deduplicateMessages(messages) {
@@ -278,7 +213,6 @@ async function pollLoop() {
                 continue;
             }
             logger.info(`Received ${messages.length} message(s) from SQS`);
-            logQueueState('After SQS poll');
             // Deduplicate: if multiple messages for the same thread, keep only the latest
             const { unique, duplicates } = deduplicateMessages(messages);
             for (const dup of duplicates) {
@@ -312,13 +246,7 @@ async function shutdown(signal) {
     logger.info(`${signal} received, shutting down gracefully...`);
     stopRefresh();
     stopHeartbeatLoop();
-    // Unblock all messages waiting on thread completion so they can exit
-    for (const [threadId, signals] of threadCompletionSignals.entries()) {
-        logger.info(`Unblocking ${signals.length} waiting message(s) on thread ${threadId}`);
-        signals.forEach((resolve) => resolve());
-    }
-    threadCompletionSignals.clear();
-    waitingCountByThread.clear();
+    stopEventQueue();
     // Kill all active Claude child processes
     await killAllActiveProcesses();
     // Wait for processingMessages to drain (with timeout)
@@ -332,6 +260,8 @@ async function shutdown(signal) {
         logger.info(`Waiting for ${processingMessages.size} message(s) to complete...`);
         await sleep(1000);
     }
+    // Final flush after all processes stopped — captures errors emitted during shutdown
+    await flushEventQueue();
     logger.info('Shutdown complete');
     process.exit(0);
 }
@@ -349,24 +279,9 @@ export async function startPoller() {
         logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);
         logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
     }
+    startEventQueue();
     await ensureDirectories();
     await ensureBaseBrain();
     startHeartbeatLoop(processMessage);
-    // 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);
-    }
+    await pollLoop();
 }

package/dist/session-store.js

@@ -4,6 +4,7 @@ import { randomUUID } from 'crypto';
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { isTokenMode, getCredentials, getAuthConfig } from './auth-provider.js';
+import { emitError } from './event-queue.js';
 function createDocClient() {
     if (isTokenMode()) {
         const creds = getCredentials();
@@ -94,6 +95,7 @@ export async function acquireSessionLock(threadId, workspacePath) {
         const staleLockTimeout = config.STALE_LOCK_TIMEOUT_MS;
         if (lockAge > staleLockTimeout) {
             logger.warn(`Session ${threadId} has stale lock (age: ${Math.round(lockAge / 1000)}s), attempting recovery...`);
+            emitError('session', `Stale lock detected on session ${threadId} (age: ${Math.round(lockAge / 1000)}s)`, { severity: 'warn' });
             const released = await forceReleaseStalelock(threadId, staleLockTimeout);
             if (released) {
                 logger.info(`Stale lock released for ${threadId}, retrying acquisition`);
@@ -164,6 +166,7 @@ export async function updateSessionId(threadId, lockToken, newSessionId) {
     catch (error) {
         if (error.name === 'ConditionalCheckFailedException') {
             logger.warn(`Lock token mismatch when updating session_id for ${threadId}`);
+            emitError('session', `Lock token mismatch when updating session_id for ${threadId}`, { severity: 'warn' });
             return;
         }
         throw error;
@@ -201,6 +204,7 @@ export async function releaseSessionLock(threadId, lockToken, newStatus = 'idle'
     catch (error) {
         if (error.name === 'ConditionalCheckFailedException') {
             logger.warn(`Lock token mismatch when releasing session ${threadId}`);
+            emitError('session', `Lock token mismatch when releasing session ${threadId}`, { severity: 'warn' });
             return;
         }
         throw error;
@@ -232,6 +236,7 @@ export async function forceReleaseStalelock(threadId, maxAgeMs) {
             },
         }));
         logger.warn(`Force released stale lock on session ${threadId} (age: ${lockAge}ms)`);
+        emitError('session', `Force released stale lock on session ${threadId}`, { severity: 'warn' });
         return true;
     }
     catch (error) {

package/dist/slack-client.js

@@ -1,5 +1,6 @@
 import { WebClient } from '@slack/web-api';
 import { logger } from './logger.js';
+import { emitError } from './event-queue.js';
 // Cache user info to avoid repeated API calls
 const userCache = new Map();
 // Per-token Slack client cache
@@ -34,6 +35,7 @@ export async function getUserInfo(botToken, userId) {
         }
         else {
             logger.warn(`Failed to fetch user info for ${userId}:`, error?.data?.error || error);
+            emitError('slack', `Failed to fetch user info for ${userId}`, { severity: 'warn' });
         }
     }
     const fallback = { name: userId, realName: userId };
@@ -84,6 +86,7 @@ export async function addReaction(msg, emoji) {
     }
     catch (error) {
         logger.warn(`Failed to add reaction ${emoji}:`, error);
+        emitError('slack', `Failed to add reaction ${emoji}`, { severity: 'warn' });
     }
 }
 export async function setThreadStatus(msg, status) {
@@ -100,6 +103,7 @@ export async function setThreadStatus(msg, status) {
     }
     catch (error) {
         logger.warn(`Failed to set thread status: ${error}`);
+        emitError('slack', `Failed to set thread status`, { severity: 'warn' });
     }
 }
 export function startTypingIndicator(msg, statusText = 'is thinking...') {

package/dist/sqs-poller.js

@@ -2,6 +2,7 @@ import { SQSClient, ReceiveMessageCommand, DeleteMessageCommand, ChangeMessageVi
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { isTokenMode, getCredentials, getAuthConfig } from './auth-provider.js';
+import { emitError } from './event-queue.js';
 function createSqsClient() {
     if (isTokenMode()) {
         const creds = getCredentials();
@@ -42,12 +43,14 @@ export async function pollMessages(maxMessages = 10) {
     }
     catch (error) {
         logger.error('Error polling SQS:', error);
+        emitError('sqs', `Error polling SQS: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
 }
 function parseMessage(msg) {
     if (!msg.Body || !msg.ReceiptHandle || !msg.MessageId) {
         logger.error('Invalid SQS message - missing required fields');
+        emitError('sqs', 'Invalid SQS message - missing required fields');
         return null;
     }
     try {
@@ -60,6 +63,7 @@ function parseMessage(msg) {
     }
     catch (error) {
         logger.error('Failed to parse message body:', error);
+        emitError('sqs', `Failed to parse message body: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }

package/dist/types.d.ts

@@ -67,3 +67,14 @@ export interface SessionRecord {
     ttl: number;
 }
 export type SessionStatus = 'processing' | 'idle' | 'waiting_for_input';
+export interface SessionMetrics {
+    duration_ms: number;
+    duration_api_ms: number;
+    num_turns: number;
+    total_cost_usd: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens: number;
+    cache_creation_input_tokens: number;
+    model: string;
+}

package/package.json

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