@teamvibe/poller 0.1.64 → 0.1.66

package/dist/claude-spawner.js

@@ -109,7 +109,8 @@ export function buildPrompt(msg, resumeHint) {
         return 'heartbeat';
     }
     const isEmail = msg.source === 'email';
-    let prompt = isEmail ? '## Incoming Email\n\n' : '## Incoming Slack Message\n\n';
+    const isWebhook = msg.source === 'webhook';
+    let prompt = isEmail ? '## Incoming Email\n\n' : isWebhook ? '## Incoming Webhook\n\n' : '## Incoming Slack Message\n\n';
     prompt += `**From:** ${msg.sender.name}`;
     if (msg.sender.id && msg.sender.id !== msg.sender.name) {
         prompt += ` (${msg.sender.id})`;
@@ -226,7 +227,8 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
     const isCronMessage = msg.source === 'cron';
     const isHeartbeat = msg.source === 'heartbeat';
     const isEmailMessage = msg.source === 'email';
-    if (!slackContext && !isCronMessage && !isHeartbeat && !isEmailMessage) {
+    const isWebhookMessage = msg.source === 'webhook';
+    if (!slackContext && !isCronMessage && !isHeartbeat && !isEmailMessage && !isWebhookMessage) {
         throw new Error('No Slack context in message');
     }
     // Build resume hint
@@ -273,7 +275,11 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         }
         // Inbox protocol: instruct Claude to check for mid-task messages (thread-scoped)
         const inboxNewDir = `.inbox/${msg.thread_id}/new`;
+        const now = new Date();
+        const todayLine = `Today: ${now.toISOString().slice(0, 10)} (${now.toLocaleDateString('en-US', { weekday: 'long' })})`;
         args.push('--append-system-prompt', [
+            todayLine,
+            ``,
             `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.`,

package/dist/event-queue.d.ts

@@ -1,5 +1,6 @@
 export type ErrorCategory = 'sqs' | 'brain' | 'auth' | 'session' | 'slack' | 'maintenance';
 export type ErrorSeverity = 'warn' | 'error';
+export declare function emitEvent(eventType: string, channelId: string, metadata?: Record<string, unknown>): void;
 export declare function flush(): Promise<void>;
 export declare function startEventQueue(): void;
 export declare function stopEventQueue(): void;

package/dist/event-queue.js

@@ -10,16 +10,22 @@ let isFlushing = false;
 function dedupKey(channelId, category, message) {
     return `${channelId}:${category}:${message}`;
 }
+function isErrorEvent(event) {
+    return event.eventType === 'poller.error';
+}
 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;
+    // Dedup only applies to error events
+    if (isErrorEvent(event)) {
+        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) => isErrorEvent(e) &&
+            dedupKey(e.channelId, e.metadata.category, e.metadata.message) === key &&
+            e.timestamp >= windowStart);
+        if (existing && isErrorEvent(existing)) {
+            existing.metadata.count += 1;
+            return;
+        }
     }
     if (queue.length >= MAX_QUEUE_SIZE) {
         queue.shift(); // Drop oldest
@@ -47,6 +53,17 @@ async function flushOne(event) {
         return false;
     }
 }
+export function emitEvent(eventType, channelId, metadata) {
+    if (!config.TEAMVIBE_API_URL || !config.TEAMVIBE_POLLER_TOKEN) {
+        return;
+    }
+    enqueue({
+        eventType,
+        channelId,
+        metadata,
+        timestamp: new Date().toISOString(),
+    });
+}
 export async function flush() {
     if (queue.length === 0 || isFlushing)
         return;

package/dist/inbox-manager.d.ts

@@ -12,6 +12,10 @@ export declare function pickNextMessage(brainPath: string, threadId: string): {
     filename: string;
     content: string;
 } | null;
+/**
+ * Move a message from processing/ to failed/ after exhausting retries.
+ */
+export declare function markFailed(brainPath: string, threadId: string, filename: string): void;
 /**
  * Delete a message file from processing/ (marks it as done).
  */

package/dist/inbox-manager.js

@@ -4,6 +4,7 @@ import { logger } from './logger.js';
 const INBOX_DIR = '.inbox';
 const NEW_DIR = 'new';
 const PROCESSING_DIR = 'processing';
+const FAILED_DIR = 'failed';
 function getInboxPath(brainPath, threadId) {
     return join(brainPath, INBOX_DIR, threadId);
 }
@@ -56,6 +57,27 @@ export function pickNextMessage(brainPath, threadId) {
     }
     return null;
 }
+/**
+ * Move a message from processing/ to failed/ after exhausting retries.
+ */
+export function markFailed(brainPath, threadId, filename) {
+    const inbox = getInboxPath(brainPath, threadId);
+    const srcPath = join(inbox, PROCESSING_DIR, filename);
+    const failedDir = join(inbox, FAILED_DIR);
+    mkdirSync(failedDir, { recursive: true });
+    const dstPath = join(failedDir, filename);
+    try {
+        if (existsSync(srcPath)) {
+            renameSync(srcPath, dstPath);
+            logger.info(`[Inbox] Moved exhausted message to failed/: ${filename}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[Inbox] Failed to move ${filename} to failed/: ${error}`);
+        // Fallback: delete so the loop doesn't get stuck
+        markProcessed(brainPath, threadId, filename);
+    }
+}
 /**
  * Delete a message file from processing/ (marks it as done).
  */

package/dist/poller.js

@@ -8,8 +8,8 @@ import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } fr
 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';
+import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent } from './event-queue.js';
+import { writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed } from './inbox-manager.js';
 // Track active message processing
 const processingMessages = new Set();
 // Track which threads have an active processing loop
@@ -21,6 +21,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     }
     activeLoops.add(threadId);
     let iteration = 0;
+    const failureCounts = new Map();
     try {
         let lockResult = await acquireSessionLock(threadId, kbPath);
         if (!lockResult.success) {
@@ -28,6 +29,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
             return;
         }
         const { session, lockToken } = lockResult;
+        let currentSessionId = session.session_id || undefined;
         while (true) {
             const message = pickNextMessage(kbPath, threadId);
             if (!message) {
@@ -44,6 +46,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 ? startTypingIndicator(queueMessage)
                 : undefined;
             let succeeded = false;
+            let lastExitCode = null;
             try {
                 // Reconstruct queue message from stored inbox data
                 const storedData = JSON.parse(message.content);
@@ -51,10 +54,21 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                     ...queueMessage,
                     ...storedData,
                 };
-                const result = await spawnClaudeCode(inboxMsg, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
+                const result = await spawnClaudeCode(inboxMsg, sessionLog, kbPath, currentSessionId, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
                 typing?.stop();
-                if (result.newSessionId && lockToken) {
-                    await updateSessionId(threadId, lockToken, result.newSessionId);
+                if (result.newSessionId) {
+                    // Update local state first — DynamoDB writes may fail (expired token,
+                    // network), but subsequent iterations MUST use the fresh session ID
+                    // to avoid "session already in use" retry loops.
+                    currentSessionId = result.newSessionId;
+                    if (lockToken) {
+                        try {
+                            await updateSessionId(threadId, lockToken, result.newSessionId);
+                        }
+                        catch (err) {
+                            sessionLog.error(`[Loop] Failed to persist new session ID to DynamoDB: ${err instanceof Error ? err.message : err}`);
+                        }
+                    }
                 }
                 if (result.metrics) {
                     sessionLog.info(`[Loop] Iteration #${iteration} complete — ` +
@@ -64,12 +78,27 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 if (result.success) {
                     succeeded = true;
                     sessionLog.info(`[Loop] Claude completed iteration #${iteration}`);
+                    if (result.metrics) {
+                        emitEvent('session.completed', queueMessage.teamvibe.channelId, {
+                            threadId: queueMessage.thread_id,
+                            total_cost_usd: result.metrics.total_cost_usd,
+                            input_tokens: result.metrics.input_tokens,
+                            output_tokens: result.metrics.output_tokens,
+                            cache_read_input_tokens: result.metrics.cache_read_input_tokens,
+                            cache_creation_input_tokens: result.metrics.cache_creation_input_tokens,
+                            duration_ms: result.metrics.duration_ms,
+                            duration_api_ms: result.metrics.duration_api_ms,
+                            num_turns: result.metrics.num_turns,
+                            model: result.metrics.model,
+                        });
+                    }
                     if (queueMessage.teamvibe.brain?.brainId) {
                         await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId, queueMessage.teamvibe.workspaceId);
                     }
                     await postMaintenanceReports(kbPath, queueMessage.teamvibe.channelId);
                 }
                 else {
+                    lastExitCode = result.exitCode;
                     sessionLog.error(`[Loop] Claude failed iteration #${iteration}: ${result.error}`);
                     if (hasSlackContext) {
                         const errorMessage = result.error || `Process exited with code ${result.exitCode}`;
@@ -83,10 +112,27 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 typing?.stop();
                 sessionLog.error(`[Loop] Error in iteration #${iteration}: ${error instanceof Error ? error.message : error}`);
             }
-            // Only delete processing file on success — failed/killed sessions get retried
             if (succeeded) {
                 markProcessed(kbPath, threadId, message.filename);
             }
+            else {
+                // SIGTERM (143) or SIGKILL (137) = intentional kill → retry immediately, no backoff
+                const isKilledSignal = lastExitCode === 143 || lastExitCode === 137;
+                if (!isKilledSignal) {
+                    const failures = (failureCounts.get(message.filename) || 0) + 1;
+                    failureCounts.set(message.filename, failures);
+                    const MAX_RETRIES = 3;
+                    if (failures >= MAX_RETRIES) {
+                        sessionLog.error(`[Loop] Message ${message.filename} failed ${failures} times, giving up`);
+                        markFailed(kbPath, threadId, message.filename);
+                    }
+                    else {
+                        const backoffMs = Math.min(10_000 * Math.pow(2, failures - 1), 60_000);
+                        sessionLog.info(`[Loop] Retry ${failures}/${MAX_RETRIES - 1} for ${message.filename}, backing off ${backoffMs}ms`);
+                        await sleep(backoffMs);
+                    }
+                }
+            }
             if (!hasUnprocessed(kbPath, threadId)) {
                 break;
             }

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export interface TeamVibeQueueMessage {
     id: string;
-    source: 'slack' | 'email' | 'cron' | 'heartbeat';
+    source: 'slack' | 'email' | 'cron' | 'heartbeat' | 'webhook';
     thread_id: string;
     sender: {
         id: string;

package/package.json

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