@teamvibe/poller 0.1.65 → 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/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

@@ -9,7 +9,7 @@ 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, emitEvent } from './event-queue.js';
-import { writeMessage, pickNextMessage, markProcessed, hasUnprocessed } from './inbox-manager.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 — ` +
@@ -84,6 +98,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                     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}`;
@@ -97,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.65",
+  "version": "0.1.66",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {