@teamvibe/poller 0.1.10 → 0.1.12

package/dist/claude-spawner.d.ts

@@ -6,6 +6,8 @@ export interface SpawnResult {
     exitCode: number | null;
     error?: string;
 }
-export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void): Promise<SpawnResult>;
+export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void): Promise<SpawnResult & {
+    newSessionId?: string;
+}>;
 export declare function getActiveProcessCount(): number;
 export declare function isAtCapacity(): boolean;

package/dist/claude-spawner.js

@@ -275,6 +275,14 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
 }
 export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent) {
     const result = await runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage, lastMessageTs, onMessageSent);
+    // If session ID is "already in use" (stale lock file), retry with no session ID (let Claude generate a new one)
+    if (!result.success && sessionId && result.error?.includes('already in use')) {
+        sessionLog.info('Session ID already in use (stale lock), retrying without session ID');
+        const { randomUUID } = await import('crypto');
+        const freshId = randomUUID();
+        const retryResult = await runClaudeCode(msg, sessionLog, cwd, freshId, true, lastMessageTs, onMessageSent);
+        return { ...retryResult, newSessionId: freshId };
+    }
     // If --resume failed, retry as a fresh session (session files may have been lost on container restart)
     if (!result.success && sessionId && !isFirstMessage) {
         sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');

package/dist/index.js

@@ -4,7 +4,7 @@ import { logger } from './logger.js';
 import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js';
 import { spawnClaudeCode, isAtCapacity, getActiveProcessCount } from './claude-spawner.js';
 import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
-import { acquireSessionLock, releaseSessionLock } from './session-store.js';
+import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
 import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
 import { initAuth, stopRefresh } from './auth-provider.js';
 logger.info('TeamVibe Poller starting...');
@@ -135,6 +135,10 @@ async function processMessage(received) {
     try {
         const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => stopTyping?.());
         stopTyping?.();
+        // 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

package/dist/session-store.d.ts

@@ -7,5 +7,6 @@ export interface AcquireLockResult {
     lockToken: string | null;
 }
 export declare function acquireSessionLock(threadId: string, workspacePath: string): Promise<AcquireLockResult>;
+export declare function updateSessionId(threadId: string, lockToken: string, newSessionId: string): Promise<void>;
 export declare function releaseSessionLock(threadId: string, lockToken: string, newStatus?: SessionStatus, lastMessageTs?: string): Promise<void>;
 export declare function forceReleaseStalelock(threadId: string, maxAgeMs: number): Promise<boolean>;

package/dist/session-store.js

@@ -106,33 +106,26 @@ export async function acquireSessionLock(threadId, workspacePath) {
     // Session is idle/waiting - try to acquire lock
     const newLockToken = generateLockToken();
     const now = Date.now();
-    const hasOldToken = existingSession.lock_token != null;
-    const conditionExpression = hasOldToken
-        ? '#status IN (:idle, :waiting) AND (lock_token = :oldToken OR attribute_not_exists(lock_token))'
-        : '#status IN (:idle, :waiting) AND attribute_not_exists(lock_token)';
-    const expressionValues = {
-        ':processing': 'processing',
-        ':idle': 'idle',
-        ':waiting': 'waiting_for_input',
-        ':newToken': newLockToken,
-        ':now': now,
-        ':one': 1,
-        ':ttl': calculateTTL(),
-    };
-    if (hasOldToken) {
-        expressionValues[':oldToken'] = existingSession.lock_token;
-    }
     try {
         await createDocClient().send(new UpdateCommand({
             TableName: getTableName(),
             Key: buildKey(threadId),
             UpdateExpression: 'SET #status = :processing, lock_token = :newToken, last_activity = :now, message_count = message_count + :one, #ttl = :ttl',
-            ConditionExpression: conditionExpression,
+            ConditionExpression: '#status IN (:idle, :waiting) AND (lock_token = :oldToken OR attribute_not_exists(lock_token))',
             ExpressionAttributeNames: {
                 '#status': 'status',
                 '#ttl': 'ttl',
             },
-            ExpressionAttributeValues: expressionValues,
+            ExpressionAttributeValues: {
+                ':processing': 'processing',
+                ':idle': 'idle',
+                ':waiting': 'waiting_for_input',
+                ':newToken': newLockToken,
+                ':oldToken': existingSession.lock_token,
+                ':now': now,
+                ':one': 1,
+                ':ttl': calculateTTL(),
+            },
         }));
         const updatedSession = {
             ...existingSession,
@@ -154,6 +147,28 @@ export async function acquireSessionLock(threadId, workspacePath) {
         throw error;
     }
 }
+export async function updateSessionId(threadId, lockToken, newSessionId) {
+    try {
+        await createDocClient().send(new UpdateCommand({
+            TableName: getTableName(),
+            Key: buildKey(threadId),
+            UpdateExpression: 'SET session_id = :newSessionId',
+            ConditionExpression: 'lock_token = :lockToken',
+            ExpressionAttributeValues: {
+                ':newSessionId': newSessionId,
+                ':lockToken': lockToken,
+            },
+        }));
+        logger.info(`Updated session_id for thread ${threadId} to ${newSessionId}`);
+    }
+    catch (error) {
+        if (error.name === 'ConditionalCheckFailedException') {
+            logger.warn(`Lock token mismatch when updating session_id for ${threadId}`);
+            return;
+        }
+        throw error;
+    }
+}
 export async function releaseSessionLock(threadId, lockToken, newStatus = 'idle', lastMessageTs) {
     const now = Date.now();
     const updateExpression = lastMessageTs

package/package.json

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