@realtimex/email-automator 2.3.7 → 2.4.0

package/api/src/middleware/validation.ts

@@ -69,11 +69,14 @@ export const schemas = {
         accountId: z.string().uuid('Invalid account ID'),
     }),
 
-    // Action schemas
+    // Action schemas - supports both single action (legacy) and actions array
     executeAction: z.object({
         emailId: z.string().uuid('Invalid email ID'),
-        action: z.enum(['delete', 'archive', 'draft', 'flag', 'none']),
+        action: z.enum(['delete', 'archive', 'draft', 'flag', 'read', 'star', 'none']).optional(),
+        actions: z.array(z.enum(['delete', 'archive', 'draft', 'flag', 'read', 'star', 'none'])).optional(),
         draftContent: z.string().optional(),
+    }).refine(data => data.action || (data.actions && data.actions.length > 0), {
+        message: 'Either action or actions must be provided',
     }),
 
     // Migration schemas
@@ -83,19 +86,23 @@ export const schemas = {
         accessToken: z.string().optional(),
     }),
 
-    // Rule schemas
+    // Rule schemas - supports both single action (legacy) and actions array
     createRule: z.object({
         name: z.string().min(1).max(100),
         condition: z.record(z.unknown()),
-        action: z.enum(['delete', 'archive', 'draft', 'star', 'read']),
+        action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
+        actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
         instructions: z.string().optional(),
         is_enabled: z.boolean().default(true),
+    }).refine(data => data.action || (data.actions && data.actions.length > 0), {
+        message: 'Either action or actions must be provided',
     }),
 
     updateRule: z.object({
         name: z.string().min(1).max(100).optional(),
         condition: z.record(z.unknown()).optional(),
         action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
+        actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
         instructions: z.string().optional(),
         is_enabled: z.boolean().optional(),
     }),

package/api/src/routes/actions.ts

@@ -11,15 +11,24 @@ import { createLogger } from '../utils/logger.js';
 const router = Router();
 const logger = createLogger('ActionRoutes');
 
-// Execute action on email
+// Execute action(s) on email - supports both single action and array of actions
 router.post('/execute',
     apiRateLimit,
     authMiddleware,
     validateBody(schemas.executeAction),
     asyncHandler(async (req, res) => {
-        const { emailId, action, draftContent } = req.body;
+        const { emailId, action, actions, draftContent } = req.body;
         const userId = req.user!.id;
 
+        // Support both single action (legacy) and actions array
+        const actionsToExecute: string[] = actions && actions.length > 0
+            ? actions
+            : (action ? [action] : []);
+
+        if (actionsToExecute.length === 0) {
+            return res.status(400).json({ error: 'No actions specified' });
+        }
+
         // Fetch email with account info
         const { data: email, error } = await req.supabase!
             .from('emails')
@@ -37,59 +46,85 @@ router.post('/execute',
         }
 
         const account = email.email_accounts;
-        let actionResult = { success: true, details: '' };
-
-        if (action === 'none') {
-            // Just mark as reviewed
-            await req.supabase!
-                .from('emails')
-                .update({ action_taken: 'none' })
-                .eq('id', emailId);
-        } else if (account.provider === 'gmail') {
-            const gmailService = getGmailService();
-            
-            if (action === 'delete') {
-                await gmailService.trashMessage(account, email.external_id);
-            } else if (action === 'archive') {
-                await gmailService.archiveMessage(account, email.external_id);
-            } else if (action === 'draft') {
-                const content = draftContent || email.ai_analysis?.draft_response || '';
-                if (content) {
-                    const draftId = await gmailService.createDraft(account, email.external_id, content);
-                    actionResult.details = `Draft created: ${draftId}`;
-                }
-            } else if (action === 'flag') {
-                await gmailService.addLabel(account, email.external_id, ['STARRED']);
-            }
+        const actionResults: { action: string; success: boolean; details?: string }[] = [];
+
+        for (const currentAction of actionsToExecute) {
+            try {
+                let details = '';
+
+                if (currentAction === 'none') {
+                    // Just mark as reviewed, no provider action needed
+                } else if (account.provider === 'gmail') {
+                    const gmailService = getGmailService();
+
+                    if (currentAction === 'delete') {
+                        await gmailService.trashMessage(account, email.external_id);
+                    } else if (currentAction === 'archive') {
+                        await gmailService.archiveMessage(account, email.external_id);
+                    } else if (currentAction === 'draft') {
+                        const content = draftContent || email.ai_analysis?.draft_response || '';
+                        if (content) {
+                            const draftId = await gmailService.createDraft(account, email.external_id, content);
+                            details = `Draft created: ${draftId}`;
+                        }
+                    } else if (currentAction === 'flag') {
+                        await gmailService.addLabel(account, email.external_id, ['STARRED']);
+                    } else if (currentAction === 'read') {
+                        await gmailService.markAsRead(account, email.external_id);
+                    } else if (currentAction === 'star') {
+                        await gmailService.starMessage(account, email.external_id);
+                    }
+                } else if (account.provider === 'outlook') {
+                    const microsoftService = getMicrosoftService();
 
-            await req.supabase!
-                .from('emails')
-                .update({ action_taken: action })
-                .eq('id', emailId);
-        } else if (account.provider === 'outlook') {
-            const microsoftService = getMicrosoftService();
-            
-            if (action === 'delete') {
-                await microsoftService.trashMessage(account, email.external_id);
-            } else if (action === 'archive') {
-                await microsoftService.archiveMessage(account, email.external_id);
-            } else if (action === 'draft') {
-                const content = draftContent || email.ai_analysis?.draft_response || '';
-                if (content) {
-                    const draftId = await microsoftService.createDraft(account, email.external_id, content);
-                    actionResult.details = `Draft created: ${draftId}`;
+                    if (currentAction === 'delete') {
+                        await microsoftService.trashMessage(account, email.external_id);
+                    } else if (currentAction === 'archive') {
+                        await microsoftService.archiveMessage(account, email.external_id);
+                    } else if (currentAction === 'draft') {
+                        const content = draftContent || email.ai_analysis?.draft_response || '';
+                        if (content) {
+                            const draftId = await microsoftService.createDraft(account, email.external_id, content);
+                            details = `Draft created: ${draftId}`;
+                        }
+                    } else if (currentAction === 'read') {
+                        await microsoftService.markAsRead(account, email.external_id);
+                    } else if (currentAction === 'star' || currentAction === 'flag') {
+                        await microsoftService.flagMessage(account, email.external_id);
+                    }
                 }
-            }
 
-            await req.supabase!
-                .from('emails')
-                .update({ action_taken: action })
-                .eq('id', emailId);
+                // Record this action using atomic append
+                await req.supabase!.rpc('append_email_action', {
+                    p_email_id: emailId,
+                    p_action: currentAction
+                });
+
+                actionResults.push({ action: currentAction, success: true, details: details || undefined });
+            } catch (err) {
+                logger.error('Action failed', err, { emailId, action: currentAction });
+                actionResults.push({
+                    action: currentAction,
+                    success: false,
+                    details: err instanceof Error ? err.message : 'Unknown error'
+                });
+            }
         }
 
-        logger.info('Action executed', { emailId, action, userId });
+        // Update legacy column with first action for backward compatibility
+        await req.supabase!
+            .from('emails')
+            .update({ action_taken: actionsToExecute[0] })
+            .eq('id', emailId);
+
+        logger.info('Actions executed', { emailId, actions: actionsToExecute, userId });
 
-        res.json(actionResult);
+        res.json({
+            success: actionResults.every(r => r.success),
+            results: actionResults,
+            // Legacy field for backward compatibility
+            details: actionResults.map(r => r.details).filter(Boolean).join('; ')
+        });
     })
 );
 

package/api/src/routes/rules.ts

@@ -31,7 +31,11 @@ router.post('/',
     authMiddleware,
     validateBody(schemas.createRule),
     asyncHandler(async (req, res) => {
-        const { name, condition, action, is_enabled, instructions, attachments } = req.body;
+        const { name, condition, action, actions, is_enabled, instructions, attachments } = req.body;
+
+        // Use actions array if provided, otherwise use single action for backward compatibility
+        const ruleActions = actions && actions.length > 0 ? actions : (action ? [action] : []);
+        const primaryAction = ruleActions[0] || 'archive'; // For legacy column
 
         const { data, error } = await req.supabase!
             .from('rules')
@@ -39,7 +43,8 @@ router.post('/',
                 user_id: req.user!.id,
                 name,
                 condition,
-                action,
+                action: primaryAction, // Legacy column
+                actions: ruleActions,  // New multi-action column
                 is_enabled,
                 instructions,
                 attachments,
@@ -49,7 +54,7 @@ router.post('/',
 
         if (error) throw error;
 
-        logger.info('Rule created', { ruleId: data.id, userId: req.user!.id });
+        logger.info('Rule created', { ruleId: data.id, actions: ruleActions, userId: req.user!.id });
 
         res.status(201).json({ rule: data });
     })

package/api/src/services/gmail.ts

@@ -21,6 +21,7 @@ export interface GmailMessage {
     sender: string;
     recipient: string;
     date: string;
+    internalDate: string; // Gmail's internal timestamp (ms since epoch) - use this for checkpointing
     body: string;
     snippet: string;
     headers: {
@@ -224,6 +225,132 @@ export class GmailService {
         };
     }
 
+    /**
+     * Fetch messages in OLDEST-FIRST order using "Fetch IDs → Sort → Hydrate" strategy.
+     *
+     * Gmail API always returns newest first and doesn't support sorting.
+     * To process oldest emails first (critical for checkpoint-based sync), we:
+     * 1. Fetch ALL message IDs matching the query (lightweight, paginated)
+     * 2. Sort by internalDate ascending (oldest first)
+     * 3. Take first N messages (limit)
+     * 4. Hydrate only those N messages with full details
+     *
+     * This ensures we never skip emails when using max_emails pagination.
+     */
+    async fetchMessagesOldestFirst(
+        account: EmailAccount,
+        options: { limit: number; query?: string; maxIdsToFetch?: number }
+    ): Promise<{ messages: GmailMessage[]; hasMore: boolean }> {
+        const { limit, query, maxIdsToFetch = 1000 } = options;
+
+        // Step 1: Fetch all message IDs (lightweight)
+        const allIds = await this.fetchAllMessageIds(account, query, maxIdsToFetch);
+
+        if (allIds.length === 0) {
+            return { messages: [], hasMore: false };
+        }
+
+        logger.debug('Fetched message IDs', { count: allIds.length, query });
+
+        // Step 2: Sort by internalDate ascending (oldest first)
+        allIds.sort((a, b) => parseInt(a.internalDate) - parseInt(b.internalDate));
+
+        // Step 3: Take first N IDs
+        const idsToHydrate = allIds.slice(0, limit);
+        const hasMore = allIds.length > limit;
+
+        // Step 4: Hydrate those specific messages
+        const messages = await this.hydrateMessages(account, idsToHydrate.map(m => m.id));
+
+        // Re-sort hydrated messages by internalDate (maintain order)
+        messages.sort((a, b) => parseInt(a.internalDate) - parseInt(b.internalDate));
+
+        return { messages, hasMore };
+    }
+
+    /**
+     * Fetch all message IDs matching a query (lightweight, paginated).
+     * Uses minimal fields for speed: only id and internalDate.
+     */
+    private async fetchAllMessageIds(
+        account: EmailAccount,
+        query: string | undefined,
+        maxIds: number
+    ): Promise<{ id: string; internalDate: string }[]> {
+        const gmail = await this.getAuthenticatedClient(account);
+        const results: { id: string; internalDate: string }[] = [];
+        let pageToken: string | undefined;
+
+        do {
+            const response = await gmail.users.messages.list({
+                userId: 'me',
+                q: query,
+                pageToken,
+                maxResults: 500, // Max allowed per page
+                // Note: messages.list only returns id and threadId, not internalDate
+                // We need to fetch internalDate separately with minimal format
+            });
+
+            const messageRefs = response.data.messages || [];
+
+            // Fetch internalDate for each message (using metadata format for speed)
+            for (const ref of messageRefs) {
+                if (!ref.id || results.length >= maxIds) break;
+
+                try {
+                    const msg = await gmail.users.messages.get({
+                        userId: 'me',
+                        id: ref.id,
+                        format: 'minimal', // Only returns id, threadId, labelIds, snippet, internalDate
+                    });
+
+                    if (msg.data.id && msg.data.internalDate) {
+                        results.push({
+                            id: msg.data.id,
+                            internalDate: msg.data.internalDate,
+                        });
+                    }
+                } catch (error) {
+                    logger.warn('Failed to fetch message metadata', { messageId: ref.id });
+                }
+            }
+
+            pageToken = response.data.nextPageToken ?? undefined;
+        } while (pageToken && results.length < maxIds);
+
+        return results;
+    }
+
+    /**
+     * Hydrate specific messages by ID (fetch full details).
+     */
+    private async hydrateMessages(
+        account: EmailAccount,
+        messageIds: string[]
+    ): Promise<GmailMessage[]> {
+        const gmail = await this.getAuthenticatedClient(account);
+        const messages: GmailMessage[] = [];
+
+        for (const id of messageIds) {
+            try {
+                const detail = await gmail.users.messages.get({
+                    userId: 'me',
+                    id,
+                    format: 'full',
+                });
+
+                const parsed = this.parseMessage(detail.data);
+                if (parsed) {
+                    messages.push(parsed);
+                }
+            } catch (error) {
+                logger.warn('Failed to hydrate message', { messageId: id, error });
+            }
+        }
+
+        return messages;
+    }
+
     private parseMessage(message: gmail_v1.Schema$Message): GmailMessage | null {
         if (!message.id || !message.threadId) return null;
 
@@ -250,6 +377,7 @@ export class GmailService {
             sender: getHeader('From'),
             recipient: getHeader('To'),
             date: getHeader('Date'),
+            internalDate: message.internalDate || '', // Gmail's internal timestamp (ms since epoch)
             body,
             snippet: message.snippet || '',
             headers: {

package/api/src/services/intelligence.ts

@@ -48,13 +48,13 @@ export interface EmailContext {
 
 export class IntelligenceService {
     private client: OpenAI | null = null;
-    private model: string;
+    private model: string = 'gpt-4o-mini';
     private isConfigured: boolean = false;
 
     constructor(overrides?: { model?: string; baseUrl?: string; apiKey?: string }) {
         const apiKey = overrides?.apiKey || config.llm.apiKey;
         const baseUrl = overrides?.baseUrl || config.llm.baseUrl;
-        this.model = overrides?.model || config.llm.model;
+        this.model = overrides?.model || config.llm.model || 'gpt-4o-mini';
 
         // Allow local LLM servers (LM Studio, Ollama) or custom endpoints that don't need API keys
         // We assume any custom baseUrl might be a local/private instance.
@@ -111,12 +111,16 @@ Do NOT include any greetings, chatter, or special tokens like <|channel|> in you
 Return ONLY a valid JSON object.
 
 Definitions for Categories:
-- "important": Work-related, urgent, from known contacts
+- "spam": Junk, suspicious, unwanted
+- "newsletter": Subscribed content, digests
 - "promotional": Marketing, sales, discounts
 - "transactional": Receipts, shipping, confirmations
 - "social": LinkedIn, friends, social updates
-- "newsletter": Subscribed content
-- "spam": Junk, suspicious
+- "support": Help desk, customer service
+- "client": Business clients, customers
+- "internal": Company internal communications
+- "personal": Friends, family, personal matters
+- "other": Anything else
 
 Context:
 - Current Date: ${new Date().toISOString()}
@@ -156,13 +160,14 @@ REQUIRED JSON STRUCTURE:
 
         let rawResponse = '';
         try {
-            // Using raw completion call to handle garbage characters and strip tokens manually
+            // Request JSON response format for reliable parsing
             const response = await this.client!.chat.completions.create({
                 model: this.model,
                 messages: [
                     { role: 'system', content: systemPrompt },
                     { role: 'user', content: cleanedContent || '[Empty email body]' },
                 ],
+                response_format: { type: 'json_object' },
                 temperature: 0.1,
             });
 

package/api/src/services/microsoft.ts

@@ -160,7 +160,9 @@ export class MicrosoftService {
         const accessToken = account.access_token || '';
         const { top = 20, skip = 0, filter } = options;
 
-        let url = `https://graph.microsoft.com/v1.0/me/messages?$top=${top}&$skip=${skip}&$orderby=receivedDateTime desc&$select=id,conversationId,subject,from,toRecipients,receivedDateTime,body,bodyPreview,importance`;
+        // IMPORTANT: Use ascending order to fetch OLDEST emails first
+        // This ensures checkpoint-based pagination works correctly and doesn't skip emails
+        let url = `https://graph.microsoft.com/v1.0/me/messages?$top=${top}&$skip=${skip}&$orderby=receivedDateTime asc&$select=id,conversationId,subject,from,toRecipients,receivedDateTime,body,bodyPreview,importance`;
         if (filter) {
             url += `&$filter=${encodeURIComponent(filter)}`;
         }

package/api/src/services/processor.ts

@@ -167,7 +167,7 @@ export class EmailProcessorService {
         if (account.sync_start_date) {
             effectiveStartMs = new Date(account.sync_start_date).getTime();
         }
-        
+
         if (account.last_sync_checkpoint) {
             const checkpointMs = parseInt(account.last_sync_checkpoint);
             if (checkpointMs > effectiveStartMs) {
@@ -177,33 +177,40 @@ export class EmailProcessorService {
 
         let query = '';
         if (effectiveStartMs > 0) {
-            const startSeconds = Math.floor(effectiveStartMs / 1000);
+            // Subtract 1 second to make query inclusive (Gmail's after: is exclusive)
+            // This ensures we don't miss emails at the exact checkpoint timestamp
+            const startSeconds = Math.floor(effectiveStartMs / 1000) - 1;
             query = `after:${startSeconds}`;
         }
-        
-        if (eventLogger) await eventLogger.info('Fetching', 'Fetching emails from Gmail', { query, batchSize });
 
-        const { messages } = await this.gmailService.fetchMessages(account, {
-            maxResults: batchSize,
+        if (eventLogger) await eventLogger.info('Fetching', 'Fetching emails from Gmail (oldest first)', { query, batchSize });
+
+        // Use "Fetch IDs → Sort → Hydrate" strategy to get OLDEST emails first
+        // Gmail API always returns newest first, so we must fetch all IDs, sort, then hydrate
+        // This prevents skipping emails when using max_emails pagination
+        const { messages, hasMore } = await this.gmailService.fetchMessagesOldestFirst(account, {
+            limit: batchSize,
             query: query || undefined,
+            maxIdsToFetch: 1000, // Safety limit for ID fetching
         });
-        
-        if (eventLogger) await eventLogger.info('Fetching', `Fetched ${messages.length} emails`);
 
-        // We process in ASCENDING order (oldest to newest) to move checkpoint forward correctly
-        const sortedMessages = [...messages].reverse();
+        if (eventLogger) {
+            await eventLogger.info('Fetching', `Fetched ${messages.length} emails (oldest first)${hasMore ? ', more available' : ''}`);
+        }
 
+        // Messages are already sorted oldest-first by fetchMessagesOldestFirst
         let maxInternalDate = account.last_sync_checkpoint ? parseInt(account.last_sync_checkpoint) : 0;
 
-        for (const message of sortedMessages) {
+        for (const message of messages) {
             try {
                 await this.processMessage(account, message, rules, settings, result, eventLogger);
 
-                // Checkpoint tracking
-                const msgDate = new Date(message.date).getTime();
-                if (msgDate > maxInternalDate) {
-                    maxInternalDate = msgDate;
-                    
+                // Checkpoint tracking: Use Gmail's internalDate for accurate checkpoint
+                // internalDate is when Gmail received the email, which matches what after: query uses
+                const msgInternalDate = message.internalDate ? parseInt(message.internalDate) : new Date(message.date).getTime();
+                if (msgInternalDate > maxInternalDate) {
+                    maxInternalDate = msgInternalDate;
+
                     await this.supabase
                         .from('email_accounts')
                         .update({ last_sync_checkpoint: maxInternalDate.toString() })
@@ -240,23 +247,28 @@ export class EmailProcessorService {
 
         let filter = '';
         if (effectiveStartIso) {
-            filter = `receivedDateTime gt ${effectiveStartIso}`;
+            // Use 'ge' (>=) instead of 'gt' (>) to ensure we don't miss emails at exact checkpoint
+            // The duplicate check in processMessage() will skip already-processed emails
+            filter = `receivedDateTime ge ${effectiveStartIso}`;
         }
 
-        if (eventLogger) await eventLogger.info('Fetching', 'Fetching emails from Outlook', { filter, batchSize });
+        if (eventLogger) await eventLogger.info('Fetching', 'Fetching emails from Outlook (oldest first)', { filter, batchSize });
 
-        const { messages } = await this.microsoftService.fetchMessages(account, {
+        // Outlook API now returns messages sorted by receivedDateTime ascending (oldest first)
+        // This ensures checkpoint-based pagination works correctly
+        const { messages, hasMore } = await this.microsoftService.fetchMessages(account, {
             top: batchSize,
             filter: filter || undefined,
         });
-        
-        if (eventLogger) await eventLogger.info('Fetching', `Fetched ${messages.length} emails`);
 
-        const sortedMessages = [...messages].reverse();
+        if (eventLogger) {
+            await eventLogger.info('Fetching', `Fetched ${messages.length} emails (oldest first)${hasMore ? ', more available' : ''}`);
+        }
 
+        // Messages are already sorted oldest-first by the API
         let latestCheckpoint = account.last_sync_checkpoint || '';
 
-        for (const message of sortedMessages) {
+        for (const message of messages) {
             try {
                 await this.processMessage(account, message, rules, settings, result, eventLogger);
 
@@ -387,37 +399,49 @@ export class EmailProcessorService {
         // User-defined and System rules (Unified)
         for (const rule of rules) {
             if (this.matchesCondition(email, analysis, rule.condition as any)) {
-                let draftContent = undefined;
-                
-                // If the rule is to draft, and it has specific instructions, generate it now
-                if (rule.action === 'draft' && rule.instructions) {
-                    if (eventLogger) await eventLogger.info('Thinking', `Generating customized draft based on rule: ${rule.name}`, undefined, email.id);
-                    
-                    const intelligenceService = getIntelligenceService(
-                        settings?.llm_model || settings?.llm_base_url || settings?.llm_api_key
-                            ? {
-                                model: settings.llm_model,
-                                baseUrl: settings.llm_base_url,
-                                apiKey: settings.llm_api_key,
-                            }
-                            : undefined
-                    );
-                    
-                    const customizedDraft = await intelligenceService.generateDraftReply({
-                        subject: email.subject || '',
-                        sender: email.sender || '',
-                        body: email.body_snippet || '' // Note: body_snippet is used here, might want full body if available
-                    }, rule.instructions);
-                    
-                    if (customizedDraft) {
-                        draftContent = customizedDraft;
-                    }
+                // Get actions array (fallback to single action for backward compatibility)
+                const actions = rule.actions && rule.actions.length > 0
+                    ? rule.actions
+                    : (rule.action ? [rule.action] : []);
+
+                if (eventLogger && actions.length > 1) {
+                    await eventLogger.info('Multi-Action', `Executing ${actions.length} actions for rule: ${rule.name}`, { actions }, email.id);
                 }
 
-                await this.executeAction(account, email, rule.action, draftContent, eventLogger, `Rule: ${rule.name}`, rule.attachments);
+                // Execute each action in the rule
+                for (const action of actions) {
+                    let draftContent = undefined;
+
+                    // If the action is to draft, and it has specific instructions, generate it now
+                    if (action === 'draft' && rule.instructions) {
+                        if (eventLogger) await eventLogger.info('Thinking', `Generating customized draft based on rule: ${rule.name}`, undefined, email.id);
+
+                        const intelligenceService = getIntelligenceService(
+                            settings?.llm_model || settings?.llm_base_url || settings?.llm_api_key
+                                ? {
+                                    model: settings.llm_model,
+                                    baseUrl: settings.llm_base_url,
+                                    apiKey: settings.llm_api_key,
+                                }
+                                : undefined
+                        );
+
+                        const customizedDraft = await intelligenceService.generateDraftReply({
+                            subject: email.subject || '',
+                            sender: email.sender || '',
+                            body: email.body_snippet || ''
+                        }, rule.instructions);
+
+                        if (customizedDraft) {
+                            draftContent = customizedDraft;
+                        }
+                    }
+
+                    await this.executeAction(account, email, action, draftContent, eventLogger, `Rule: ${rule.name}`, rule.attachments);
 
-                if (rule.action === 'delete') result.deleted++;
-                else if (rule.action === 'draft') result.drafted++;
+                    if (action === 'delete') result.deleted++;
+                    else if (action === 'draft') result.drafted++;
+                }
             }
         }
     }
@@ -511,13 +535,20 @@ export class EmailProcessorService {
             for (const rule of retentionRules) {
                 if (this.matchesCondition(email, email.ai_analysis as any, rule.condition as any)) {
                     if (eventLogger) await eventLogger.info('Retention', `Applying retention rule: ${rule.name} to ${email.subject}`);
-                    
-                    // We don't support custom drafts in retention yet (usually retention is for delete/archive)
-                    await this.executeAction(account, email, rule.action, undefined, eventLogger, `Retention Rule: ${rule.name}`);
-                    
-                    if (rule.action === 'delete') result.deleted++;
-                    else if (rule.action === 'draft') result.drafted++;
-                    
+
+                    // Get actions array (fallback to single action for backward compatibility)
+                    const actions = rule.actions && rule.actions.length > 0
+                        ? rule.actions
+                        : (rule.action ? [rule.action] : []);
+
+                    // Execute each action
+                    for (const action of actions) {
+                        await this.executeAction(account, email, action, undefined, eventLogger, `Retention Rule: ${rule.name}`);
+
+                        if (action === 'delete') result.deleted++;
+                        else if (action === 'draft') result.drafted++;
+                    }
+
                     break; // Only one rule per email
                 }
             }