@teamvibe/poller 0.1.58 → 0.1.61

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

@@ -103,7 +103,7 @@ function readBrainSettings(cwd) {
         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';
@@ -271,6 +271,17 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             args.push('--model', model);
             sessionLog.info(`Using model: ${model}`);
         }
+        // Inbox protocol: instruct Claude to check for mid-task messages (thread-scoped)
+        const inboxNewDir = `.inbox/${msg.thread_id}/new`;
+        args.push('--append-system-prompt', [
+            `CRITICAL — INBOX PROTOCOL: You MUST check for new user messages after EVERY tool call.`,
+            `Run: ls ${inboxNewDir}/ 2>/dev/null`,
+            `If files exist: read each file (oldest first), delete it, and act on the message IMMEDIATELY — it takes priority over your current task.`,
+            `If the message says "stop", finish your current step and stop.`,
+            `If empty: continue your work.`,
+            `You MUST check the inbox: (1) before starting work, (2) after EVERY tool call, (3) after finishing all work.`,
+            `Never skip an inbox check. This is how the user communicates with you during long tasks.`,
+        ].join('\n'));
         // Handle session continuity
         if (sessionId) {
             if (isFirstMessage) {
@@ -312,6 +323,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 TEAMVIBE_CHANNEL_ID: msg.teamvibe.channelId,
                 TEAMVIBE_BOT_ID: msg.teamvibe.botId,
                 TEAMVIBE_POLLER_ID: getPollerId() || '',
+                INBOX_THREAD_ID: msg.thread_id,
             },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
@@ -322,6 +334,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;
@@ -335,6 +349,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);
@@ -383,13 +417,40 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             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.`;
@@ -401,6 +462,7 @@ 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,

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/inbox-manager.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Write a new message to the inbox.
+ * Returns the filename of the created message file.
+ */
+export declare function writeMessage(brainPath: string, threadId: 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, threadId: string): {
+    filename: string;
+    content: string;
+} | null;
+/**
+ * Delete a message file from processing/ (marks it as done).
+ */
+export declare function markProcessed(brainPath: string, threadId: string, filename: string): void;
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export declare function hasUnprocessed(brainPath: string, threadId: string): boolean;

package/dist/inbox-manager.js

@@ -0,0 +1,89 @@
+import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { logger } from './logger.js';
+const INBOX_DIR = '.inbox';
+const NEW_DIR = 'new';
+const PROCESSING_DIR = 'processing';
+function getInboxPath(brainPath, threadId) {
+    return join(brainPath, INBOX_DIR, threadId);
+}
+function ensureInboxDirs(brainPath, threadId) {
+    const inbox = getInboxPath(brainPath, threadId);
+    mkdirSync(join(inbox, NEW_DIR), { recursive: true });
+    mkdirSync(join(inbox, PROCESSING_DIR), { recursive: true });
+}
+/**
+ * Write a new message to the inbox.
+ * Returns the filename of the created message file.
+ */
+export function writeMessage(brainPath, threadId, content) {
+    ensureInboxDirs(brainPath, threadId);
+    const timestamp = process.hrtime.bigint().toString();
+    const filename = `${timestamp}.txt`;
+    const filepath = join(getInboxPath(brainPath, threadId), NEW_DIR, filename);
+    writeFileSync(filepath, content, 'utf-8');
+    logger.info(`[Inbox] 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, threadId) {
+    ensureInboxDirs(brainPath, threadId);
+    const inbox = getInboxPath(brainPath, threadId);
+    const processingDir = join(inbox, PROCESSING_DIR);
+    const newDir = join(inbox, 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(`[Inbox] 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(`[Inbox] 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, threadId, filename) {
+    const filepath = join(getInboxPath(brainPath, threadId), PROCESSING_DIR, filename);
+    try {
+        if (existsSync(filepath)) {
+            unlinkSync(filepath);
+            logger.info(`[Inbox] Deleted processed message: ${filename}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[Inbox] Failed to delete ${filename}: ${error}`);
+    }
+}
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export function hasUnprocessed(brainPath, threadId) {
+    const inbox = getInboxPath(brainPath, threadId);
+    const newDir = join(inbox, NEW_DIR);
+    const processingDir = join(inbox, 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/mailbox-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Write a new message to the mailbox.
+ * Returns the filename of the created message file.
+ */
+export declare function writeMessage(brainPath: string, threadId: 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, threadId: string): {
+    filename: string;
+    content: string;
+} | null;
+/**
+ * Delete a message file from processing/ (marks it as done).
+ */
+export declare function markProcessed(brainPath: string, threadId: string, filename: string): void;
+/**
+ * Check if there are unprocessed messages in new/ or processing/.
+ */
+export declare function hasUnprocessed(brainPath: string, threadId: string): boolean;
+/**
+ * Get the mailbox new/ directory path for use in Claude's system prompt.
+ */
+export declare function getMailboxNewPath(brainPath: string, threadId: string): string;

package/dist/mailbox-manager.js

@@ -0,0 +1,95 @@
+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 getMailboxPath(brainPath, threadId) {
+    return join(brainPath, MAILBOX_DIR, threadId);
+}
+function ensureMailboxDirs(brainPath, threadId) {
+    const mailbox = getMailboxPath(brainPath, threadId);
+    mkdirSync(join(mailbox, NEW_DIR), { recursive: true });
+    mkdirSync(join(mailbox, PROCESSING_DIR), { recursive: true });
+}
+/**
+ * Write a new message to the mailbox.
+ * Returns the filename of the created message file.
+ */
+export function writeMessage(brainPath, threadId, content) {
+    ensureMailboxDirs(brainPath, threadId);
+    const timestamp = process.hrtime.bigint().toString();
+    const filename = `${timestamp}.txt`;
+    const filepath = join(getMailboxPath(brainPath, threadId), NEW_DIR, filename);
+    writeFileSync(filepath, content, 'utf-8');
+    logger.info(`[Mailbox] Wrote message: ${filename} to ${getMailboxPath(brainPath, threadId)}/new/ (${content.length} chars, threadId=${threadId})`);
+    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, threadId) {
+    ensureMailboxDirs(brainPath, threadId);
+    const mailbox = getMailboxPath(brainPath, threadId);
+    const processingDir = join(mailbox, PROCESSING_DIR);
+    const newDir = join(mailbox, 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, threadId, filename) {
+    const filepath = join(getMailboxPath(brainPath, threadId), 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, threadId) {
+    const mailbox = getMailboxPath(brainPath, threadId);
+    const newDir = join(mailbox, NEW_DIR);
+    const processingDir = join(mailbox, 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;
+    }
+}
+/**
+ * Get the mailbox new/ directory path for use in Claude's system prompt.
+ */
+export function getMailboxNewPath(brainPath, threadId) {
+    return join(getMailboxPath(brainPath, threadId), NEW_DIR);
+}

package/dist/poller.js

@@ -1,6 +1,6 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
-import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js';
+import { pollMessages, deleteMessage, } from './sqs-poller.js';
 import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses } from './claude-spawner.js';
 import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
 import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
@@ -9,79 +9,94 @@ 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 './inbox-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 runInboxLoop(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, inbox 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, threadId);
+            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 {
+                // Reconstruct queue message from stored inbox data
+                const storedData = JSON.parse(message.content);
+                const inboxMsg = {
+                    ...queueMessage,
+                    ...storedData,
+                };
+                const result = await spawnClaudeCode(inboxMsg, 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, threadId, message.filename);
+            if (!hasUnprocessed(kbPath, threadId)) {
+                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;
@@ -127,99 +142,29 @@ 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);
-        }
+    // Write raw message to inbox (spawnClaudeCode handles prompt formatting)
+    writeMessage(kbPath, threadId, JSON.stringify({
+        text: queueMessage.text,
+        sender: queueMessage.sender,
+        type: queueMessage.type,
+        source: queueMessage.source,
+        attachments: queueMessage.attachments,
+        approval: queueMessage.approval,
+        button: queueMessage.button,
+        modal: queueMessage.modal,
+    }));
+    sessionLog.info(`Wrote message to inbox`);
+    // Delete SQS message immediately — it's now persisted in the inbox
+    if (receiptHandle) {
+        await deleteMessage(receiptHandle);
+        sessionLog.info('SQS message deleted (persisted in inbox)');
     }
-    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 runInboxLoop(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 inbox loop: ${error instanceof Error ? error.message : error}`);
         if (hasSlackContext) {
             try {
                 const errMsg = error instanceof Error ? error.message : 'Unknown error';
@@ -239,9 +184,7 @@ async function processMessage(received) {
         throw error;
     }
     finally {
-        clearInterval(heartbeat);
         processingMessages.delete(messageId);
-        signalThreadCompletion(threadId);
     }
 }
 function deduplicateMessages(messages) {
@@ -279,7 +222,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) {
@@ -314,13 +256,6 @@ async function shutdown(signal) {
     stopRefresh();
     stopHeartbeatLoop();
     stopEventQueue();
-    // 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();
     // Kill all active Claude child processes
     await killAllActiveProcesses();
     // Wait for processingMessages to drain (with timeout)
@@ -357,21 +292,5 @@ export async function startPoller() {
     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/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.58",
+  "version": "0.1.61",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {