@teamvibe/poller 0.1.59 → 0.1.61

package/dist/claude-spawner.js

@@ -271,8 +271,17 @@ 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.');
+        // 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) {
@@ -314,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'],
         });

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

@@ -2,21 +2,25 @@
  * Write a new message to the mailbox.
  * Returns the filename of the created message file.
  */
-export declare function writeMessage(brainPath: string, content: string): string;
+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): {
+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, filename: string): void;
+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): boolean;
+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

@@ -4,24 +4,25 @@ 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 });
+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, content) {
-    ensureMailboxDirs(brainPath);
+export function writeMessage(brainPath, threadId, content) {
+    ensureMailboxDirs(brainPath, threadId);
     const timestamp = process.hrtime.bigint().toString();
     const filename = `${timestamp}.txt`;
-    const filepath = join(brainPath, MAILBOX_DIR, NEW_DIR, filename);
+    const filepath = join(getMailboxPath(brainPath, threadId), NEW_DIR, filename);
     writeFileSync(filepath, content, 'utf-8');
-    logger.info(`[Mailbox] Wrote message: ${filename} (${content.length} chars)`);
+    logger.info(`[Mailbox] Wrote message: ${filename} to ${getMailboxPath(brainPath, threadId)}/new/ (${content.length} chars, threadId=${threadId})`);
     return filename;
 }
 /**
@@ -29,10 +30,11 @@ export function writeMessage(brainPath, content) {
  * 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);
+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) {
@@ -57,8 +59,8 @@ export function pickNextMessage(brainPath) {
 /**
  * Delete a message file from processing/ (marks it as done).
  */
-export function markProcessed(brainPath, filename) {
-    const filepath = join(brainPath, MAILBOX_DIR, PROCESSING_DIR, filename);
+export function markProcessed(brainPath, threadId, filename) {
+    const filepath = join(getMailboxPath(brainPath, threadId), PROCESSING_DIR, filename);
     try {
         if (existsSync(filepath)) {
             unlinkSync(filepath);
@@ -72,9 +74,10 @@ export function markProcessed(brainPath, filename) {
 /**
  * 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);
+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;
@@ -84,3 +87,9 @@ export function hasUnprocessed(brainPath) {
         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,7 +1,7 @@
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { pollMessages, deleteMessage, } from './sqs-poller.js';
-import { spawnClaudeCode, isAtCapacity, getActiveProcessCount, killAllActiveProcesses, buildPrompt } from './claude-spawner.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';
 import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
@@ -9,12 +9,12 @@ 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';
+import { writeMessage, pickNextMessage, markProcessed, hasUnprocessed } from './inbox-manager.js';
 // Track active message processing
 const processingMessages = new Set();
 // Track which threads have an active processing loop
 const activeLoops = new Set();
-async function runMailboxLoop(threadId, kbPath, queueMessage, sessionLog) {
+async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     if (activeLoops.has(threadId)) {
         sessionLog.info(`Loop already running for thread ${threadId}, skipping`);
         return;
@@ -24,12 +24,12 @@ async function runMailboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     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`);
+            sessionLog.info(`Session ${threadId} is locked, inbox message will be picked up by active session`);
             return;
         }
         const { session, lockToken } = lockResult;
         while (true) {
-            const message = pickNextMessage(kbPath);
+            const message = pickNextMessage(kbPath, threadId);
             if (!message) {
                 sessionLog.info(`[Loop] No more messages for thread ${threadId}`);
                 break;
@@ -44,12 +44,13 @@ async function runMailboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 ? startTypingIndicator(queueMessage)
                 : undefined;
             try {
-                // Build a temporary message with the mailbox content as text
-                const mailboxMsg = {
+                // Reconstruct queue message from stored inbox data
+                const storedData = JSON.parse(message.content);
+                const inboxMsg = {
                     ...queueMessage,
-                    text: message.content,
+                    ...storedData,
                 };
-                const result = await spawnClaudeCode(mailboxMsg, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
+                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);
@@ -81,8 +82,8 @@ async function runMailboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 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)) {
+            markProcessed(kbPath, threadId, message.filename);
+            if (!hasUnprocessed(kbPath, threadId)) {
                 break;
             }
             sessionLog.info(`[Loop] More messages found, continuing...`);
@@ -141,21 +142,29 @@ async function processMessage(received) {
     }
     // Register brain for heartbeat tracking
     registerBrain(queueMessage);
-    // 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
+    // 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 mailbox)');
+        sessionLog.info('SQS message deleted (persisted in inbox)');
     }
     processingMessages.add(messageId);
     try {
-        await runMailboxLoop(threadId, kbPath, queueMessage, sessionLog);
+        await runInboxLoop(threadId, kbPath, queueMessage, sessionLog);
     }
     catch (error) {
-        sessionLog.error(`Error in mailbox loop: ${error instanceof Error ? error.message : error}`);
+        sessionLog.error(`Error in inbox loop: ${error instanceof Error ? error.message : error}`);
         if (hasSlackContext) {
             try {
                 const errMsg = error instanceof Error ? error.message : 'Unknown error';

package/package.json

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