fusesell 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

{fusesell-1.2.3.dist-info → fusesell-1.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusesell
-Version: 1.2.3
+Version: 1.2.5
 Summary: Local implementation of FuseSell AI sales automation pipeline
 Author-email: FuseSell Team <team@fusesell.ai>
 License-Expression: MIT
@@ -45,7 +45,9 @@ Dynamic: license-file
 
 FuseSell Local is a production-ready implementation of the FuseSell AI sales automation system, converted from server-based YAML workflows to a comprehensive Python command-line tool with full data ownership and privacy control.
 
-> Latest release: `fusesell==1.2.1` is available on PyPI via `pip install fusesell`.
+Latest release: `fusesell==1.2.1` is available on PyPI via `pip install fusesell`.
+
+Contributors should review the [Repository Guidelines](AGENTS.md) before opening a pull request.
 
 ## 🚀 Complete Pipeline Overview
 

{fusesell-1.2.3.dist-info → fusesell-1.2.5.dist-info}/RECORD

@@ -1,9 +1,9 @@
 fusesell.py,sha256=t5PjkhWEJGINp4k517u0EX0ge7lzuHOUHHro-BE1mGk,596
-fusesell-1.2.3.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
-fusesell_local/__init__.py,sha256=fEvogPM4NPOiL4oLU9oK0HWECKyTvAGB4rSUr1XI-So,966
+fusesell-1.2.5.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
+fusesell_local/__init__.py,sha256=_0lDJ4-RcAmyLE81anufpib0EESnvDjc_Q2-IK_xefg,966
 fusesell_local/api.py,sha256=AcPune5YJdgi7nsMeusCUqc49z5UiycsQb6n3yiV_No,10839
 fusesell_local/cli.py,sha256=MYnVxuEf5KTR4VcO3sc-VtP9NkWlSixJsYfOWST2Ds0,65859
-fusesell_local/pipeline.py,sha256=KO5oAIHZ3L_uAZWOszauJyv0QWlsQMIDNGRuwQSxNmQ,39531
+fusesell_local/pipeline.py,sha256=zhAy8dtfcfjmRFqW9Dxr5fCGuxqvejFrIrJFw7s7hVU,39664
 fusesell_local/config/__init__.py,sha256=0ErO7QiSDqKn-LHcjIRdLZzh5QaRTkRsIlwfgpkkDz8,209
 fusesell_local/config/prompts.py,sha256=5O3Y2v3GCi9d9FEyR6Ekc1UXVq2TcZp3Rrspvx4bkac,10164
 fusesell_local/config/settings.py,sha256=rbjGPLQTFFr7DiWrPnZDFaOSNsdEMMYFx6pn7b13xGs,10743
@@ -11,8 +11,8 @@ fusesell_local/stages/__init__.py,sha256=2mAmzcMlVKZdseOR5Jju4PaPdKGsBT1ePqvt5RS
 fusesell_local/stages/base_stage.py,sha256=ldo5xuHZto7ceEg3i_3rxAx0xPccK4n2jaxEJA96RUE,22069
 fusesell_local/stages/data_acquisition.py,sha256=Td3mwakJRoEYbi3od4v2ZzKOHLgLSgccZVxH3ezs1_4,71081
 fusesell_local/stages/data_preparation.py,sha256=XWLg9b1w2NrMxLcrWDqB95mRmLQmVIMXpKNaBNr98TQ,52751
-fusesell_local/stages/follow_up.py,sha256=2CSen5SHJ5k6KMHXpqoRBb3n3IrcMRdDnuyTsOeuRTA,74625
-fusesell_local/stages/initial_outreach.py,sha256=jox2caveSwI3xIfjn8FGYprkjTbW8YhDNvCzz9wNcBE,107503
+fusesell_local/stages/follow_up.py,sha256=H9Xek6EoIbHrerQvGTRswXDNFH6zq71DcRxxj0zpo2g,77747
+fusesell_local/stages/initial_outreach.py,sha256=Y-WLtIGAg6nRlrCIs91l22giRrraOF6AGc1RlMDNqAM,110236
 fusesell_local/stages/lead_scoring.py,sha256=ir3l849eMGrGLf0OYUcmA1F3FwyYhAplS4niU3R2GRY,60658
 fusesell_local/tests/conftest.py,sha256=TWUtlP6cNPVOYkTPz-j9BzS_KnXdPWy8D-ObPLHvXYs,366
 fusesell_local/tests/test_api.py,sha256=763rUVb5pAuAQOovug6Ka0T9eGK8-WVOC_J08M7TETo,1827
@@ -22,14 +22,14 @@ fusesell_local/tests/test_data_manager_sales_process.py,sha256=NbwxQ9oBKCZfrkRQY
 fusesell_local/tests/test_data_manager_teams.py,sha256=kjk4V4r9ja4EVREIiQMxkuZd470SSwRHJAvpHln9KO4,4578
 fusesell_local/utils/__init__.py,sha256=TVemlo0wpckhNUxP3a1Tky3ekswy8JdIHaXBlkKXKBQ,330
 fusesell_local/utils/birthday_email_manager.py,sha256=NKLoUyzPedyhewZPma21SOoU8p9wPquehloer7TRA9U,20478
-fusesell_local/utils/data_manager.py,sha256=w2Ed0HAdkTg23r_Fz_v8j3H_jcXbgD_Xk_lfeySi9bk,178447
-fusesell_local/utils/event_scheduler.py,sha256=rjtWwtYQoJP0YwoN1-43t6K9GpLfqRq3c7Fv4papvbI,25725
+fusesell_local/utils/data_manager.py,sha256=iG22AHat7rdz_tuhALagOCeHRVaBym6sl041ovVBlw0,185719
+fusesell_local/utils/event_scheduler.py,sha256=YwWIdkvRdWFdDLX-sepI5AXJOhEIullIclpk9njvZAA,38577
 fusesell_local/utils/llm_client.py,sha256=FVc25UlGt6hro7h5Iw7PHSXY3E3_67Xc-SUbHuMSRs0,10437
 fusesell_local/utils/logger.py,sha256=sWlV8Tjyz_Z8J4zXKOnNalh8_iD6ytfrwPZpD-wcEOs,6259
 fusesell_local/utils/timezone_detector.py,sha256=0cAE4c8ZXqCA8AvxRKm6PrFKmAmsbq3HOHR6w-mW3KQ,39997
 fusesell_local/utils/validators.py,sha256=Z1VzeoxFsnuzlIA_ZaMWoy-0Cgyqupd47kIdljlMDbs,15438
-fusesell-1.2.3.dist-info/METADATA,sha256=Izbft0CEbjY1O9NQebg5b6FxgMJpd8p24N8FDWE1e-o,34976
-fusesell-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fusesell-1.2.3.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
-fusesell-1.2.3.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
-fusesell-1.2.3.dist-info/RECORD,,
+fusesell-1.2.5.dist-info/METADATA,sha256=3tPP66Wc1jK9LWT3Bi6_rpK7rg1nxZ-yiSZ7ad2l1V4,35074
+fusesell-1.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fusesell-1.2.5.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
+fusesell-1.2.5.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
+fusesell-1.2.5.dist-info/RECORD,,

fusesell_local/__init__.py

@@ -32,6 +32,6 @@ __all__ = [
     "validate_config",
 ]
 
-__version__ = "1.2.3"
+__version__ = "1.2.5"
 __author__ = "FuseSell Team"
 __description__ = "Local implementation of FuseSell AI sales automation pipeline"

fusesell_local/pipeline.py

@@ -251,11 +251,17 @@ class FuseSellPipeline:
                 
                 self.logger.info("-" * 40)
                 self.logger.info("TIMING VALIDATION:")
-                if discrepancy_percentage < 5.0:
-                    self.logger.info(f"✅ Timing validation PASSED (discrepancy: {discrepancy_percentage:.1f}%)")
-                else:
-                    self.logger.warning(f"⚠️  Timing validation WARNING (discrepancy: {discrepancy_percentage:.1f}%)")
-                    self.logger.warning(f"   Expected ~{total_stage_time:.2f}s, got {total_duration:.2f}s")
+                if discrepancy_percentage < 5.0:
+                    self.logger.info(
+                        f"[OK] Timing validation PASSED (discrepancy: {discrepancy_percentage:.1f}%)"
+                    )
+                else:
+                    self.logger.warning(
+                        f"[WARN] Timing validation WARNING (discrepancy: {discrepancy_percentage:.1f}%)"
+                    )
+                    self.logger.warning(
+                        f"   Expected ~{total_stage_time:.2f}s, got {total_duration:.2f}s"
+                    )
             
             self.logger.info("=" * 60)
             

fusesell_local/stages/follow_up.py

@@ -877,22 +877,29 @@ Generate only the email content, no additional commentary:"""
             input_data = context.get('input_data', {})
             
             # Initialize event scheduler
-            scheduler = EventScheduler(self.config.get('data_dir', './fusesell_data'))
-            
-            # Check if immediate sending is requested
-            send_immediately = input_data.get('send_immediately', False)
-            
-            # Schedule the follow-up email event
-            schedule_result = scheduler.schedule_email_event(
-                draft_id=draft.get('draft_id'),
-                recipient_address=recipient_address,
-                recipient_name=recipient_name,
-                org_id=input_data.get('org_id', 'default'),
-                team_id=input_data.get('team_id'),
-                customer_timezone=input_data.get('customer_timezone'),
-                email_type='follow_up',
-                send_immediately=send_immediately
-            )
+            scheduler = EventScheduler(self.config.get('data_dir', './fusesell_data'))
+            
+            # Check if immediate sending is requested
+            send_immediately = input_data.get('send_immediately', False)
+            reminder_context = self._build_follow_up_reminder_context(
+                draft,
+                recipient_address,
+                recipient_name,
+                context
+            )
+            
+            # Schedule the follow-up email event
+            schedule_result = scheduler.schedule_email_event(
+                draft_id=draft.get('draft_id'),
+                recipient_address=recipient_address,
+                recipient_name=recipient_name,
+                org_id=input_data.get('org_id', 'default'),
+                team_id=input_data.get('team_id'),
+                customer_timezone=input_data.get('customer_timezone'),
+                email_type='follow_up',
+                send_immediately=send_immediately,
+                reminder_context=reminder_context
+            )
             
             if schedule_result['success']:
                 self.logger.info(f"Follow-up email event scheduled successfully: {schedule_result['event_id']} for {schedule_result['scheduled_time']}")
@@ -912,12 +919,81 @@ Generate only the email content, no additional commentary:"""
                 }
                 
         except Exception as e:
-            self.logger.error(f"Follow-up email scheduling failed: {str(e)}")
-            return {
-                'success': False,
-                'message': f'Follow-up email scheduling failed: {str(e)}',
-                'error': str(e)
-            } 
+            self.logger.error(f"Follow-up email scheduling failed: {str(e)}")
+            return {
+                'success': False,
+                'message': f'Follow-up email scheduling failed: {str(e)}',
+                'error': str(e)
+            } 
+
+    def _build_follow_up_reminder_context(
+        self,
+        draft: Dict[str, Any],
+        recipient_address: str,
+        recipient_name: str,
+        context: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Build reminder_task metadata for scheduled follow-up emails.
+        """
+        input_data = context.get('input_data', {})
+        org_id = input_data.get('org_id', 'default') or 'default'
+        customer_id = input_data.get('customer_id') or context.get('execution_id') or 'unknown'
+        task_id = context.get('execution_id') or input_data.get('task_id') or 'unknown_task'
+        team_id = input_data.get('team_id')
+        team_name = input_data.get('team_name')
+        language = input_data.get('language')
+        customer_name = input_data.get('customer_name')
+        staff_name = input_data.get('staff_name')
+        interaction_type = input_data.get('interaction_type', 'follow_up')
+        follow_up_iteration = input_data.get('current_follow_up_time') or 1
+        reminder_room = self.config.get('reminder_room_id') or input_data.get('reminder_room_id')
+        draft_id = draft.get('draft_id') or 'unknown_draft'
+        product_name = draft.get('product_name') or input_data.get('product_name')
+
+        customextra = {
+            'reminder_content': 'follow_up',
+            'org_id': org_id,
+            'customer_id': customer_id,
+            'task_id': task_id,
+            'customer_name': customer_name,
+            'language': language,
+            'recipient_address': recipient_address,
+            'recipient_name': recipient_name,
+            'staff_name': staff_name,
+            'team_id': team_id,
+            'team_name': team_name,
+            'interaction_type': interaction_type,
+            'action_status': 'scheduled',
+            'current_follow_up_time': follow_up_iteration,
+            'draft_id': draft_id,
+            'import_uuid': f"{org_id}_{customer_id}_{task_id}_{draft_id}"
+        }
+
+        if product_name:
+            customextra['product_name'] = product_name
+        if draft.get('approach'):
+            customextra['approach'] = draft.get('approach')
+        if draft.get('mail_tone'):
+            customextra['mail_tone'] = draft.get('mail_tone')
+        if draft.get('message_type'):
+            customextra['message_type'] = draft.get('message_type')
+
+        return {
+            'status': 'published',
+            'task': f"FuseSell follow-up {org_id}_{customer_id} - {task_id}",
+            'tags': ['fusesell', 'follow-up'],
+            'room_id': reminder_room,
+            'org_id': org_id,
+            'customer_id': customer_id,
+            'task_id': task_id,
+            'team_id': team_id,
+            'team_name': team_name,
+            'language': language,
+            'customer_name': customer_name,
+            'staff_name': staff_name,
+            'customextra': customextra
+        }
    # Data access methods (similar to initial outreach)
     def _get_customer_data(self, context: Dict[str, Any]) -> Dict[str, Any]:
         """Get customer data from previous stages or input."""

fusesell_local/stages/initial_outreach.py

@@ -250,23 +250,30 @@ class InitialOutreachStage(BaseStage):
             
             input_data = context.get('input_data', {})
             
-            # Initialize event scheduler
-            scheduler = EventScheduler(self.config.get('data_dir', './fusesell_data'))
-            
-            # Check if immediate sending is requested
-            send_immediately = input_data.get('send_immediately', False)
-            
-            # Schedule the email event
-            schedule_result = scheduler.schedule_email_event(
-                draft_id=draft.get('draft_id'),
-                recipient_address=recipient_address,
-                recipient_name=recipient_name,
-                org_id=input_data.get('org_id', 'default'),
-                team_id=input_data.get('team_id'),
-                customer_timezone=input_data.get('customer_timezone'),
-                email_type='initial',
-                send_immediately=send_immediately
-            )
+            # Initialize event scheduler
+            scheduler = EventScheduler(self.config.get('data_dir', './fusesell_data'))
+            
+            # Check if immediate sending is requested
+            send_immediately = input_data.get('send_immediately', False)
+            reminder_context = self._build_initial_reminder_context(
+                draft,
+                recipient_address,
+                recipient_name,
+                context
+            )
+            
+            # Schedule the email event
+            schedule_result = scheduler.schedule_email_event(
+                draft_id=draft.get('draft_id'),
+                recipient_address=recipient_address,
+                recipient_name=recipient_name,
+                org_id=input_data.get('org_id', 'default'),
+                team_id=input_data.get('team_id'),
+                customer_timezone=input_data.get('customer_timezone'),
+                email_type='initial',
+                send_immediately=send_immediately,
+                reminder_context=reminder_context
+            )
             
             if schedule_result['success']:
                 self.logger.info(f"Email event scheduled successfully: {schedule_result['event_id']} for {schedule_result['scheduled_time']}")
@@ -287,18 +294,80 @@ class InitialOutreachStage(BaseStage):
                 }
                 
         except Exception as e:
-            self.logger.error(f"Email scheduling failed: {str(e)}")
-            return {
-                'success': False,
-                'message': f'Email scheduling failed: {str(e)}',
-                'error': str(e)
-            }
-
-    def _handle_close(self, context: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Handle close action - Close outreach when customer feels negative.
-        
-        Args:
+            self.logger.error(f"Email scheduling failed: {str(e)}")
+            return {
+                'success': False,
+                'message': f'Email scheduling failed: {str(e)}',
+                'error': str(e)
+            }
+
+    def _build_initial_reminder_context(
+        self,
+        draft: Dict[str, Any],
+        recipient_address: str,
+        recipient_name: str,
+        context: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Build reminder_task metadata for scheduled initial outreach emails.
+        """
+        input_data = context.get('input_data', {})
+        org_id = input_data.get('org_id', 'default') or 'default'
+        customer_id = input_data.get('customer_id') or context.get('execution_id') or 'unknown'
+        task_id = context.get('execution_id') or input_data.get('task_id') or 'unknown_task'
+        team_id = input_data.get('team_id')
+        team_name = input_data.get('team_name')
+        language = input_data.get('language')
+        customer_name = input_data.get('customer_name')
+        staff_name = input_data.get('staff_name')
+        reminder_room = self.config.get('reminder_room_id') or input_data.get('reminder_room_id')
+        draft_id = draft.get('draft_id') or 'unknown_draft'
+
+        customextra = {
+            'reminder_content': 'draft_send',
+            'org_id': org_id,
+            'customer_id': customer_id,
+            'task_id': task_id,
+            'customer_name': customer_name,
+            'language': language,
+            'recipient_address': recipient_address,
+            'recipient_name': recipient_name,
+            'staff_name': staff_name,
+            'team_id': team_id,
+            'team_name': team_name,
+            'interaction_type': input_data.get('interaction_type'),
+            'draft_id': draft_id,
+            'import_uuid': f"{org_id}_{customer_id}_{task_id}_{draft_id}"
+        }
+
+        if draft.get('product_name'):
+            customextra['product_name'] = draft.get('product_name')
+        if draft.get('approach'):
+            customextra['approach'] = draft.get('approach')
+        if draft.get('mail_tone'):
+            customextra['mail_tone'] = draft.get('mail_tone')
+
+        return {
+            'status': 'published',
+            'task': f"FuseSell initial outreach {org_id}_{customer_id} - {task_id}",
+            'tags': ['fusesell', 'init-outreach'],
+            'room_id': reminder_room,
+            'org_id': org_id,
+            'customer_id': customer_id,
+            'task_id': task_id,
+            'team_id': team_id,
+            'team_name': team_name,
+            'language': language,
+            'customer_name': customer_name,
+            'staff_name': staff_name,
+            'customextra': customextra
+        }
+
+    def _handle_close(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle close action - Close outreach when customer feels negative.
+        
+        Args:
             context: Execution context
             
         Returns:

fusesell_local/utils/data_manager.py

@@ -4,10 +4,10 @@ Handles SQLite database operations and local file management
 """
 
 import sqlite3
-import json
-import os
-import uuid
-from typing import Dict, Any, List, Optional, Union
+import json
+import os
+import uuid
+from typing import Dict, Any, List, Optional, Sequence, Union
 from datetime import datetime
 import logging
 from pathlib import Path
@@ -454,11 +454,11 @@ class LocalDataManager:
                         submission_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                         retrieved_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                     )
-                """)
-
-                # Create scheduler_rules table (equivalent to gs_scheduler)
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS scheduler_rules (
+                """)
+
+                # Create scheduler_rules table (equivalent to gs_scheduler)
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS scheduler_rules (
                         id TEXT PRIMARY KEY,
                         org_id TEXT NOT NULL,
                         org_name TEXT,
@@ -478,14 +478,36 @@ class LocalDataManager:
                         username TEXT,
                         fullname TEXT,
                         instance_id TEXT,
-                        submission_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-
-                # Create extracted_files table (equivalent to gs_plan_setting_extracted_file)
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS extracted_files (
-                        id TEXT PRIMARY KEY,
+                        submission_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+
+                # Create reminder_task table (equivalent to Directus reminder_task)
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS reminder_task (
+                        id TEXT PRIMARY KEY,
+                        status TEXT NOT NULL,
+                        task TEXT NOT NULL,
+                        cron TEXT NOT NULL,
+                        room_id TEXT,
+                        tags TEXT,
+                        customextra TEXT,
+                        org_id TEXT,
+                        customer_id TEXT,
+                        task_id TEXT,
+                        import_uuid TEXT,
+                        scheduled_time TIMESTAMP,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        executed_at TIMESTAMP,
+                        error_message TEXT
+                    )
+                """)
+
+                # Create extracted_files table (equivalent to gs_plan_setting_extracted_file)
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS extracted_files (
+                        id TEXT PRIMARY KEY,
                         org_id TEXT NOT NULL,
                         plan_id TEXT,
                         team_id TEXT,
@@ -585,17 +607,25 @@ class LocalDataManager:
                     "CREATE INDEX IF NOT EXISTS idx_team_settings_team_id ON team_settings(team_id)")
                 cursor.execute(
                     "CREATE INDEX IF NOT EXISTS idx_products_org_id ON products(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_gs_customer_llmtask_task_id ON gs_customer_llmtask(task_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_prompts_org_id ON prompts(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_scheduler_rules_org_id ON scheduler_rules(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_extracted_files_org_id ON extracted_files(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_llm_worker_plan_org_id ON llm_worker_plan(org_id)")
-                cursor.execute(
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_gs_customer_llmtask_task_id ON gs_customer_llmtask(task_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_prompts_org_id ON prompts(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_scheduler_rules_org_id ON scheduler_rules(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_status ON reminder_task(status)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_org_id ON reminder_task(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_task_id ON reminder_task(task_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_cron ON reminder_task(cron)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_extracted_files_org_id ON extracted_files(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_llm_worker_plan_org_id ON llm_worker_plan(org_id)")
+                cursor.execute(
                     "CREATE INDEX IF NOT EXISTS idx_gs_company_criteria_org_id ON gs_company_criteria(org_id)")
 
                 # Create compatibility views for backward compatibility
@@ -1408,6 +1438,162 @@ class LocalDataManager:
             self.logger.error(f"Failed to get team settings: {str(e)}")
             raise
 
+    def build_team_settings_snapshot(
+        self,
+        team_id: str,
+        sections: Optional[Sequence[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Build a response payload containing team settings in the expected RealTimeX format.
+
+        Args:
+            team_id: Team identifier
+            sections: Optional sequence of section names to include. Accepts either
+                full keys (e.g. ``gs_team_product``) or shorthand without the prefix.
+
+        Returns:
+            Dictionary shaped as ``{"data": [{...}]}``. When no settings exist,
+            returns ``{"data": []}``.
+        """
+        settings = self.get_team_settings(team_id)
+        if not settings:
+            return {"data": []}
+
+        available_fields = [
+            'gs_team_organization',
+            'gs_team_rep',
+            'gs_team_product',
+            'gs_team_schedule_time',
+            'gs_team_initial_outreach',
+            'gs_team_follow_up',
+            'gs_team_auto_interaction',
+            'gs_team_followup_schedule_time',
+            'gs_team_birthday_email',
+        ]
+
+        if sections:
+            normalized = set()
+            for item in sections:
+                if not item:
+                    continue
+                item = item.strip()
+                if not item:
+                    continue
+                if item.startswith("gs_team_"):
+                    normalized.add(item)
+                else:
+                    normalized.add(f"gs_team_{item}")
+            fields_to_include = [field for field in available_fields if field in normalized]
+        else:
+            fields_to_include = available_fields
+
+        list_like_fields = {
+            'gs_team_organization',
+            'gs_team_rep',
+            'gs_team_product',
+            'gs_team_auto_interaction',
+        }
+        list_field_defaults = {
+            'gs_team_organization': {
+                'org_name': None,
+                'address': None,
+                'website': None,
+                'industry': None,
+                'description': None,
+                'logo': None,
+                'primary_email': None,
+                'primary_phone': None,
+                'primary_color': None,
+                'is_active': False,
+                'avg_rating': None,
+                'total_sales': None,
+                'total_products': None,
+                'date_joined': None,
+                'last_active': None,
+                'social_media_links': [],
+            },
+            'gs_team_rep': {
+                'name': None,
+                'email': None,
+                'phone': None,
+                'position': None,
+                'website': None,
+                'logo': None,
+                'username': None,
+                'is_primary': False,
+                'primary_color': None,
+                'primary_phone': None,
+            },
+            'gs_team_product': {
+                'product_id': None,
+                'product_name': None,
+                'image_url': None,
+                'enabled': True,
+                'priority': None,
+            },
+            'gs_team_auto_interaction': {
+                'from_email': '',
+                'from_name': '',
+                'from_number': '',
+                'tool_type': 'Email',
+                'email_cc': '',
+                'email_bcc': '',
+            },
+        }
+        alias_fields = {
+            'gs_team_organization': {
+                'name': 'org_name',
+                'brand_palette': 'primary_color',
+            },
+        }
+
+        snapshot: Dict[str, Any] = {}
+        for field in fields_to_include:
+            value = settings.get(field)
+            if value is None:
+                continue
+
+            if field in list_like_fields:
+                if isinstance(value, list):
+                    normalized_items = []
+                    defaults = list_field_defaults.get(field, {})
+                    aliases = alias_fields.get(field, {})
+                    for item in value:
+                        if not isinstance(item, dict):
+                            continue
+                        normalized = {}
+                        for key, default_val in defaults.items():
+                            if key == 'social_media_links':
+                                current = item.get(key)
+                                normalized[key] = current if isinstance(current, list) else []
+                            else:
+                                normalized[key] = item.get(key, default_val)
+                        for legacy_key, target_key in aliases.items():
+                            if normalized.get(target_key) in (None, '', []):
+                                if legacy_key in item:
+                                    normalized[target_key] = item[legacy_key]
+                        # include any additional keys that might exist
+                        normalized_items.append(normalized)
+                    snapshot[field] = normalized_items
+                elif value:
+                    defaults = list_field_defaults.get(field, {})
+                    aliases = alias_fields.get(field, {})
+                    normalized = {key: value.get(key, default_val) for key, default_val in defaults.items()}
+                    for legacy_key, target_key in aliases.items():
+                        if normalized.get(target_key) in (None, '', []):
+                            if legacy_key in value:
+                                normalized[target_key] = value[legacy_key]
+                    snapshot[field] = [normalized]
+                else:
+                    snapshot[field] = []
+            else:
+                snapshot[field] = value
+
+        if not snapshot:
+            return {"data": []}
+
+        return {"data": [snapshot]}
+
     def _deserialize_product_row(self, row: sqlite3.Row) -> Dict[str, Any]:
         """
         Convert a product row into a dictionary with JSON fields parsed.

fusesell_local/utils/event_scheduler.py

@@ -3,14 +3,14 @@ Event Scheduler - Database-based event scheduling system
 Creates scheduled events in database for external app to handle
 """
 
-import logging
-from datetime import datetime, timedelta
-from typing import Dict, Any, Optional, List
-import pytz
-import json
-import sqlite3
-import uuid
-from pathlib import Path
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, List, Union
+import pytz
+import json
+import sqlite3
+import uuid
+from pathlib import Path
 
 
 class EventScheduler:
@@ -73,15 +73,53 @@ class EventScheduler:
                 ON scheduled_events(scheduled_time, status)
             """)
             
-            cursor.execute("""
-                CREATE INDEX IF NOT EXISTS idx_scheduled_events_org_team 
-                ON scheduled_events(org_id, team_id)
-            """)
-            
-            conn.commit()
-            conn.close()
-            
-            self.logger.info("Scheduled events database initialized")
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_scheduled_events_org_team 
+                ON scheduled_events(org_id, team_id)
+            """)
+
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS reminder_task (
+                    id TEXT PRIMARY KEY,
+                    status TEXT NOT NULL,
+                    task TEXT NOT NULL,
+                    cron TEXT NOT NULL,
+                    room_id TEXT,
+                    tags TEXT,
+                    customextra TEXT,
+                    org_id TEXT,
+                    customer_id TEXT,
+                    task_id TEXT,
+                    import_uuid TEXT,
+                    scheduled_time TIMESTAMP,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    executed_at TIMESTAMP,
+                    error_message TEXT
+                )
+            """)
+
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_reminder_task_status 
+                ON reminder_task(status)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_reminder_task_org_id 
+                ON reminder_task(org_id)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_reminder_task_task_id 
+                ON reminder_task(task_id)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_reminder_task_cron 
+                ON reminder_task(cron)
+            """)
+            
+            conn.commit()
+            conn.close()
+            
+            self.logger.info("Scheduled events database initialized")
             
         except Exception as e:
             self.logger.error(f"Failed to initialize scheduled events DB: {str(e)}")
@@ -122,15 +160,225 @@ class EventScheduler:
             conn.commit()
             conn.close()
             
-            self.logger.info("Scheduling rules database initialized")
-            
-        except Exception as e:
-            self.logger.error(f"Failed to initialize scheduling rules DB: {str(e)}")
-            raise
+            self.logger.info("Scheduling rules database initialized")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize scheduling rules DB: {str(e)}")
+            raise
+
+    def _format_datetime(self, value: Union[str, datetime, None]) -> str:
+        """
+        Normalize datetime-like values to ISO 8601 strings.
+
+        Args:
+            value: Datetime, ISO string, or None.
+
+        Returns:
+            ISO 8601 formatted string.
+        """
+        if isinstance(value, datetime):
+            return value.isoformat()
+        if value is None:
+            return datetime.utcnow().isoformat()
+
+        value_str = str(value).strip()
+        if not value_str:
+            return datetime.utcnow().isoformat()
+
+        try:
+            parsed = datetime.fromisoformat(value_str)
+            return parsed.isoformat()
+        except ValueError:
+            return value_str
+
+    def _build_reminder_payload(
+        self,
+        base_context: Dict[str, Any],
+        *,
+        event_id: str,
+        send_time: datetime,
+        email_type: str,
+        org_id: str,
+        recipient_address: str,
+        recipient_name: str,
+        draft_id: str,
+        customer_timezone: str,
+        follow_up_iteration: Optional[int] = None
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Construct reminder_task payload mirroring server implementation.
+
+        Args:
+            base_context: Context data supplied by caller.
+            event_id: Scheduled event identifier.
+            send_time: Planned send time (UTC).
+            email_type: 'initial' or 'follow_up'.
+            org_id: Organization identifier.
+            recipient_address: Recipient email.
+            recipient_name: Recipient name.
+            draft_id: Draft identifier.
+            customer_timezone: Customer timezone.
+            follow_up_iteration: Optional follow-up iteration counter.
+
+        Returns:
+            Reminder payload dictionary or None if insufficient data.
+        """
+        if not base_context:
+            return None
+
+        context = dict(base_context)
+        customextra_raw = context.pop('customextra', {}) or {}
+        if isinstance(customextra_raw, str):
+            try:
+                customextra = json.loads(customextra_raw)
+            except (json.JSONDecodeError, TypeError):
+                customextra = {}
+        elif isinstance(customextra_raw, dict):
+            customextra = dict(customextra_raw)
+        else:
+            customextra = {}
+
+        status = context.pop('status', 'published') or 'published'
+        cron_value = context.pop('cron', None)
+        scheduled_time_value = context.pop('scheduled_time', None)
+        room_id = context.pop('room_id', context.pop('room', None))
+        tags = context.pop('tags', None)
+        task_label = context.pop('task', None)
+        org_id_override = context.pop('org_id', None) or org_id
+        customer_id = context.pop('customer_id', None) or customextra.get('customer_id')
+        task_id = context.pop('task_id', None) or context.pop('execution_id', None) or customextra.get('task_id')
+        customer_name = context.pop('customer_name', None)
+        language = context.pop('language', None)
+        team_id = context.pop('team_id', None)
+        team_name = context.pop('team_name', None)
+        staff_name = context.pop('staff_name', None)
+        import_uuid = context.pop('import_uuid', None) or customextra.get('import_uuid')
+
+        customextra.setdefault('reminder_content', 'draft_send' if email_type == 'initial' else 'follow_up')
+        customextra.setdefault('org_id', org_id_override)
+        customextra.setdefault('customer_id', customer_id)
+        customextra.setdefault('task_id', task_id)
+        customextra.setdefault('event_id', event_id)
+        customextra.setdefault('email_type', email_type)
+        customextra.setdefault('recipient_address', recipient_address)
+        customextra.setdefault('recipient_name', recipient_name)
+        customextra.setdefault('draft_id', draft_id)
+        customextra.setdefault('customer_timezone', customer_timezone)
+        customextra.setdefault('scheduled_time_utc', send_time.isoformat())
+
+        if team_id and 'team_id' not in customextra:
+            customextra['team_id'] = team_id
+        if team_name and 'team_name' not in customextra:
+            customextra['team_name'] = team_name
+        if language and 'language' not in customextra:
+            customextra['language'] = language
+        if staff_name and 'staff_name' not in customextra:
+            customextra['staff_name'] = staff_name
+        if customer_name and 'customer_name' not in customextra:
+            customextra['customer_name'] = customer_name
+
+        iteration = follow_up_iteration or context.pop('current_follow_up_time', None)
+        if iteration is not None and 'current_follow_up_time' not in customextra:
+            customextra['current_follow_up_time'] = iteration
+
+        if not import_uuid:
+            import_uuid = f"{customextra.get('org_id', '')}_{customextra.get('customer_id', '')}_{customextra.get('task_id', '')}_{event_id}"
+        customextra.setdefault('import_uuid', import_uuid)
+
+        if not tags:
+            tags = ['fusesell', 'init-outreach' if email_type == 'initial' else 'follow-up']
+
+        if not task_label:
+            readable_type = "Initial Outreach" if email_type == 'initial' else "Follow-up"
+            identifier = customextra.get('customer_name') or customextra.get('customer_id') or customer_id or 'customer'
+            tracking_id = customextra.get('task_id') or task_id or draft_id
+            task_label = f"FuseSell {readable_type} {identifier} - {tracking_id}"
+
+        cron_value = self._format_datetime(cron_value or send_time)
+        scheduled_time_str = self._format_datetime(scheduled_time_value or send_time)
+
+        return {
+            'status': status,
+            'task': task_label,
+            'cron': cron_value,
+            'room_id': room_id,
+            'tags': tags,
+            'customextra': customextra,
+            'org_id': customextra.get('org_id'),
+            'customer_id': customextra.get('customer_id'),
+            'task_id': customextra.get('task_id'),
+            'import_uuid': customextra.get('import_uuid'),
+            'scheduled_time': scheduled_time_str
+        }
+
+    def _insert_reminder_task(self, payload: Optional[Dict[str, Any]]) -> Optional[str]:
+        """
+        Insert reminder_task record into local database.
+
+        Args:
+            payload: Reminder payload produced by _build_reminder_payload.
+
+        Returns:
+            Reminder task identifier or None on failure.
+        """
+        if not payload:
+            return None
+
+        try:
+            reminder_id = payload.get('id') or f"uuid:{str(uuid.uuid4())}"
+
+            tags_value = payload.get('tags')
+            if isinstance(tags_value, (list, tuple)):
+                tags_str = json.dumps(list(tags_value))
+            elif isinstance(tags_value, str):
+                tags_str = tags_value
+            else:
+                tags_str = json.dumps([])
+
+            customextra_value = payload.get('customextra') or {}
+            if isinstance(customextra_value, dict):
+                customextra_str = json.dumps(customextra_value)
+            elif isinstance(customextra_value, str):
+                customextra_str = customextra_value
+            else:
+                customextra_str = json.dumps({})
+
+            conn = sqlite3.connect(self.main_db_path)
+            cursor = conn.cursor()
+
+            cursor.execute("""
+                INSERT INTO reminder_task
+                (id, status, task, cron, room_id, tags, customextra, org_id, customer_id, task_id, import_uuid, scheduled_time)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                reminder_id,
+                payload.get('status', 'published'),
+                payload.get('task') or 'FuseSell Reminder',
+                self._format_datetime(payload.get('cron')),
+                payload.get('room_id'),
+                tags_str,
+                customextra_str,
+                payload.get('org_id'),
+                payload.get('customer_id'),
+                payload.get('task_id'),
+                payload.get('import_uuid'),
+                self._format_datetime(payload.get('scheduled_time'))
+            ))
+
+            conn.commit()
+            conn.close()
+
+            self.logger.debug(f"Created reminder_task record {reminder_id}")
+            return reminder_id
+
+        except Exception as exc:
+            self.logger.error(f"Failed to create reminder_task record: {str(exc)}")
+            return None
 
-    def schedule_email_event(self, draft_id: str, recipient_address: str, recipient_name: str,
-                           org_id: str, team_id: str = None, customer_timezone: str = None,
-                           email_type: str = 'initial', send_immediately: bool = False) -> Dict[str, Any]:
+    def schedule_email_event(self, draft_id: str, recipient_address: str, recipient_name: str,
+                           org_id: str, team_id: str = None, customer_timezone: str = None,
+                           email_type: str = 'initial', send_immediately: bool = False,
+                           reminder_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """
         Schedule an email event in the database for external app to handle.
 
@@ -142,7 +390,8 @@ class EventScheduler:
             team_id: Team ID (optional)
             customer_timezone: Customer's timezone (optional)
             email_type: Type of email ('initial' or 'follow_up')
-            send_immediately: If True, schedule for immediate sending
+            send_immediately: If True, schedule for immediate sending
+            reminder_context: Optional metadata for reminder_task mirroring server behaviour
 
         Returns:
             Event creation result with event ID and scheduled time
@@ -180,40 +429,82 @@ class EventScheduler:
             conn = sqlite3.connect(self.main_db_path)
             cursor = conn.cursor()
             
-            cursor.execute("""
-                INSERT INTO scheduled_events 
-                (id, event_id, event_type, scheduled_time, org_id, team_id, draft_id,
-                 recipient_address, recipient_name, customer_timezone, event_data)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            cursor.execute("""
+                INSERT INTO scheduled_events 
+                (id, event_id, event_type, scheduled_time, org_id, team_id, draft_id,
+                 recipient_address, recipient_name, customer_timezone, event_data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """, (
                 f"uuid:{str(uuid.uuid4())}", event_id, 'email_send', send_time, org_id, team_id, draft_id,
                 recipient_address, recipient_name, customer_timezone, json.dumps(event_data)
             ))
             
-            conn.commit()
-            conn.close()
-            
-            # Log the scheduling
-            self.logger.info(f"Scheduled email event {event_id} for {send_time} (draft: {draft_id})")
-            
-            # Schedule follow-up if this is an initial email
-            follow_up_event_id = None
-            if email_type == 'initial' and not send_immediately:
-                follow_up_result = self._schedule_follow_up_event(
-                    draft_id, recipient_address, recipient_name, org_id, team_id, customer_timezone
-                )
-                follow_up_event_id = follow_up_result.get('event_id')
-            
-            return {
-                'success': True,
-                'event_id': event_id,
-                'scheduled_time': send_time.isoformat(),
-                'recipient_address': recipient_address,
-                'recipient_name': recipient_name,
-                'draft_id': draft_id,
-                'email_type': email_type,
-                'follow_up_event_id': follow_up_event_id
-            }
+            conn.commit()
+            conn.close()
+
+            reminder_task_id = None
+            if reminder_context:
+                reminder_payload = self._build_reminder_payload(
+                    dict(reminder_context),
+                    event_id=event_id,
+                    send_time=send_time,
+                    email_type=email_type,
+                    org_id=org_id,
+                    recipient_address=recipient_address,
+                    recipient_name=recipient_name,
+                    draft_id=draft_id,
+                    customer_timezone=customer_timezone
+                )
+                reminder_task_id = self._insert_reminder_task(reminder_payload)
+
+            # Log the scheduling
+            self.logger.info(f"Scheduled email event {event_id} for {send_time} (draft: {draft_id})")
+
+            # Schedule follow-up if this is an initial email
+            follow_up_event_id = None
+            follow_up_reminder_id = None
+            if email_type == 'initial' and not send_immediately:
+                follow_up_context = None
+                if reminder_context:
+                    follow_up_context = dict(reminder_context)
+                    follow_up_extra = dict(follow_up_context.get('customextra', {}) or {})
+                    follow_up_extra['reminder_content'] = 'follow_up'
+                    follow_up_extra.setdefault('current_follow_up_time', 1)
+                    follow_up_context['customextra'] = follow_up_extra
+                    follow_up_context['tags'] = follow_up_context.get('tags') or ['fusesell', 'follow-up']
+
+                follow_up_result = self._schedule_follow_up_event(
+                    draft_id,
+                    recipient_address,
+                    recipient_name,
+                    org_id,
+                    team_id,
+                    customer_timezone,
+                    reminder_context=follow_up_context
+                )
+
+                if follow_up_result.get('success'):
+                    follow_up_event_id = follow_up_result.get('event_id')
+                    follow_up_reminder_id = follow_up_result.get('reminder_task_id')
+                else:
+                    self.logger.warning(
+                        "Follow-up scheduling failed for event %s: %s",
+                        event_id,
+                        follow_up_result.get('error', 'unknown error')
+                    )
+
+            return {
+                'success': True,
+                'event_id': event_id,
+                'scheduled_time': send_time.isoformat(),
+                'recipient_address': recipient_address,
+                'recipient_name': recipient_name,
+                'draft_id': draft_id,
+                'email_type': email_type,
+                'reminder_task_id': reminder_task_id,
+                'follow_up_event_id': follow_up_event_id,
+                'follow_up_reminder_task_id': follow_up_reminder_id
+            }
             
         except Exception as e:
             self.logger.error(f"Failed to schedule email event: {str(e)}")
@@ -222,9 +513,10 @@ class EventScheduler:
                 'error': str(e)
             }
 
-    def _schedule_follow_up_event(self, original_draft_id: str, recipient_address: str, 
-                                recipient_name: str, org_id: str, team_id: str = None,
-                                customer_timezone: str = None) -> Dict[str, Any]:
+    def _schedule_follow_up_event(self, original_draft_id: str, recipient_address: str, 
+                                recipient_name: str, org_id: str, team_id: str = None,
+                                customer_timezone: str = None,
+                                reminder_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """
         Schedule follow-up email event after initial email.
 
@@ -234,7 +526,8 @@ class EventScheduler:
             recipient_name: Name of recipient
             org_id: Organization ID
             team_id: Team ID (optional)
-            customer_timezone: Customer's timezone (optional)
+            customer_timezone: Customer's timezone (optional)
+            reminder_context: Optional metadata for reminder_task rows
 
         Returns:
             Follow-up event creation result
@@ -275,24 +568,41 @@ class EventScheduler:
                 original_draft_id, recipient_address, recipient_name, 
                 customer_timezone, json.dumps(event_data)
             ))
-            
-            conn.commit()
-            conn.close()
-            
-            self.logger.info(f"Scheduled follow-up event {followup_event_id} for {follow_up_time}")
-            
-            return {
-                'success': True,
-                'event_id': followup_event_id,
-                'scheduled_time': follow_up_time.isoformat()
-            }
+            
+            conn.commit()
+            conn.close()
+            
+            reminder_task_id = None
+            if reminder_context:
+                reminder_payload = self._build_reminder_payload(
+                    dict(reminder_context),
+                    event_id=followup_event_id,
+                    send_time=follow_up_time,
+                    email_type='follow_up',
+                    org_id=org_id,
+                    recipient_address=recipient_address,
+                    recipient_name=recipient_name,
+                    draft_id=original_draft_id,
+                    customer_timezone=event_data['customer_timezone']
+                )
+                reminder_task_id = self._insert_reminder_task(reminder_payload)
+            
+            self.logger.info(f"Scheduled follow-up event {followup_event_id} for {follow_up_time}")
+            
+            return {
+                'success': True,
+                'event_id': followup_event_id,
+                'scheduled_time': follow_up_time.isoformat(),
+                'reminder_task_id': reminder_task_id
+            }
             
         except Exception as e:
-            self.logger.error(f"Failed to schedule follow-up event: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
+            self.logger.error(f"Failed to schedule follow-up event: {str(e)}")
+            return {
+                'success': False,
+                'error': str(e),
+                'reminder_task_id': None
+            }
 
     def _get_scheduling_rule(self, org_id: str, team_id: str = None) -> Dict[str, Any]:
         """
@@ -615,4 +925,4 @@ class EventScheduler:
             
         except Exception as e:
             self.logger.error(f"Failed to create scheduling rule: {str(e)}")
-            return False
+            return False