feat: Implement Today's Workflow and Agent Huddle enhancements

backend/api/subscription/routes/dashboard.py

@@ -21,6 +21,7 @@ router = APIRouter()
 @router.get("/dashboard/{user_id}")
 async def get_dashboard_data(
     user_id: str,
+    billing_period: str = None,
     db: Session = Depends(get_db)
 ) -> Dict[str, Any]:
     """Get comprehensive dashboard data for usage monitoring."""
@@ -29,16 +30,17 @@ async def get_dashboard_data(
         ensure_subscription_plan_columns(db)
         ensure_usage_summaries_columns(db)
         
-        # Check cache first
+        # Check cache first (skip if billing_period is specified)
-        cached_data = get_cached_dashboard(user_id)
+        if not billing_period:
-        if cached_data:
+            cached_data = get_cached_dashboard(user_id)
-            return cached_data
+            if cached_data:
+                return cached_data
 
         usage_service = UsageTrackingService(db)
         pricing_service = PricingService(db)
         
-        # Get current usage stats
+        # Get current usage stats (for the requested period)
-        current_usage = usage_service.get_user_usage_stats(user_id)
+        current_usage = usage_service.get_user_usage_stats(user_id, billing_period)
         
         # Get usage trends (last 6 months)
         trends = usage_service.get_usage_trends(user_id, 6)
@@ -47,10 +49,14 @@ async def get_dashboard_data(
         limits = pricing_service.get_user_limits(user_id)
         
         # Get unread alerts
-        alerts = db.query(UsageAlert).filter(
+        alerts_query = db.query(UsageAlert).filter(
             UsageAlert.user_id == user_id,
             UsageAlert.is_read == False
-        ).order_by(UsageAlert.created_at.desc()).limit(5).all()
+        )
+        if billing_period:
+            alerts_query = alerts_query.filter(UsageAlert.billing_period == billing_period)
+            
+        alerts = alerts_query.order_by(UsageAlert.created_at.desc()).limit(5).all()
         
         alerts_data = [
             {
@@ -64,11 +70,17 @@ async def get_dashboard_data(
             for alert in alerts
         ]
         
-        # Calculate cost projections
+        # Calculate cost projections (only relevant for current month)
         current_cost = current_usage.get('total_cost', 0)
         days_in_period = 30
         current_day = datetime.now().day
-        projected_cost = (current_cost / current_day) * days_in_period if current_day > 0 else 0
+        
+        # Only project costs if viewing current month
+        is_current_month = not billing_period or billing_period == datetime.now().strftime("%Y-%m")
+        if is_current_month:
+            projected_cost = (current_cost / current_day) * days_in_period if current_day > 0 else 0
+        else:
+            projected_cost = current_cost # For past months, projected is actual
         
         response_payload = {
             "success": True,
@@ -91,8 +103,10 @@ async def get_dashboard_data(
             }
         }
         
-        # Cache the response
+        # Cache the response only for default view
-        set_cached_dashboard(user_id, response_payload)
+        if not billing_period:
+            set_cached_dashboard(user_id, response_payload)
+            
         return response_payload
     
     except (sqlite3.OperationalError, Exception) as e:

backend/api/today_workflow.py

@@ -48,7 +48,7 @@ async def get_today_workflow(
     db: Session = Depends(get_db),
 ) -> Dict[str, Any]:
     user_id = str(current_user.get("id"))
-    plan, created = get_or_create_daily_workflow_plan(db, user_id, date=date)
+    plan, created = await get_or_create_daily_workflow_plan(db, user_id, date=date)
 
     tasks = (
         db.query(DailyWorkflowTask)
@@ -154,6 +154,8 @@ async def get_today_workflow(
     }
 
 
+from services.task_memory_service import TaskMemoryService
+
 @router.post("/tasks/{task_id}/status")
 async def set_task_status(
     task_id: int,
@@ -171,6 +173,17 @@ async def set_task_status(
     if not task:
         raise HTTPException(status_code=404, detail="Task not found")
 
+    # Record outcome in memory for self-learning
+    try:
+        memory = TaskMemoryService(user_id, db)
+        await memory.record_task_outcome(
+            task, 
+            feedback_score=1 if status == "completed" else -1 if status == "dismissed" else 0,
+            feedback_text=completion_notes
+        )
+    except Exception as e:
+        pass # Don't block response on memory update failure
+
     plan_for_date = db.query(DailyWorkflowPlan).filter(DailyWorkflowPlan.id == task.plan_id).first()
     plan_date = plan_for_date.date if plan_for_date and plan_for_date.date else ""
     task_payload = {

backend/models/daily_workflow_models.py

@@ -46,4 +46,27 @@ class DailyWorkflowTask(Base):
     plan = relationship("DailyWorkflowPlan", back_populates="tasks")
 
 
+class TaskHistory(Base):
+    """
+    Tracks historical tasks for self-learning.
+    Used by TaskMemoryService to prevent redundant suggestions and learn from rejections.
+    """
+    __tablename__ = "task_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String(255), nullable=False, index=True)
+    task_hash = Column(String(64), nullable=False, index=True)  # Hash of title + description
+    title = Column(String(255), nullable=False)
+    description = Column(Text, nullable=False)
+    pillar_id = Column(String(30), nullable=False)
+    status = Column(String(30), nullable=False)  # completed, dismissed, rejected
+    source_agent = Column(String(50), nullable=True)
+    feedback_score = Column(Integer, nullable=True)  # -1 (bad), 0 (neutral), 1 (good)
+    feedback_text = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+    
+    # Metadata for vector index linking
+    vector_id = Column(String(36), nullable=True) 
+
 Index("ix_daily_workflow_plans_user_date", DailyWorkflowPlan.user_id, DailyWorkflowPlan.date, unique=True)
+Index("ix_task_history_user_hash", TaskHistory.user_id, TaskHistory.task_hash)

backend/scripts/debug_specific_user.py

@@ -0,0 +1,52 @@
+import sys
+import os
+from sqlalchemy import text
+
+# Add backend to sys.path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.database import get_session_for_user
+from models.subscription_models import APIUsageLog, UsageSummary
+
+USER_ID = "user_33Gz1FPI86VDXhRY8QN4ragRFGN"
+
+def debug_user():
+    print(f"Checking usage for user: {USER_ID}")
+    try:
+        db = get_session_for_user(USER_ID)
+        if not db:
+            print("Could not get DB session.")
+            return
+
+        # 1. Check UsageSummary
+        print("\n--- UsageSummary ---")
+        summaries = db.query(UsageSummary).all()
+        for s in summaries:
+            print(f"Period: {s.billing_period}, Calls: {s.total_calls}, Cost: {s.total_cost}, Status: {s.usage_status}")
+
+        # 2. Check APIUsageLog
+        print("\n--- APIUsageLog Stats ---")
+        # Count logs
+        count = db.query(APIUsageLog).count()
+        print(f"Total Logs: {count}")
+        
+        # Group by billing period
+        try:
+            logs_by_period = db.execute(text("SELECT billing_period, COUNT(*), SUM(cost_total) FROM api_usage_logs GROUP BY billing_period")).fetchall()
+            for row in logs_by_period:
+                print(f"Period: {row[0]}, Count: {row[1]}, Sum Cost: {row[2]}")
+        except Exception as e:
+            print(f"Error querying logs group by: {e}")
+
+        # 3. Check specific provider logs (to see if they are 'gemini' or 'GEMINI')
+        print("\n--- Provider Check (First 5 logs) ---")
+        logs = db.query(APIUsageLog).limit(5).all()
+        for l in logs:
+            print(f"ID: {l.id}, Provider: {l.provider}, Actual: {l.actual_provider_name}, Cost: {l.cost_total}, Period: {l.billing_period}")
+
+        db.close()
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    debug_user()

backend/services/analytics/handlers/gsc_handler.py

@@ -53,11 +53,20 @@ class GSCAnalyticsHandler(BaseAnalyticsHandler):
         logger.info("Fetching fresh GSC analytics for user {user_id}", user_id=user_id)
         try:
             # Get user's sites
-            sites = self.gsc_service.get_site_list(user_id)
+            try:
-            logger.info(f"GSC Sites found for user {user_id}: {sites}")
+                sites = self.gsc_service.get_site_list(user_id)
+            except Exception as e:
+                logger.warning(f"GSC site list fetch failed for user {user_id}: {e}")
+                sites = []
+
+            # logger.info(f"GSC Sites found for user {user_id}: {sites}")
             if not sites:
-                logger.warning(f"No GSC sites found for user {user_id}")
+                # logger.warning(f"No GSC sites found for user {user_id}")
-                return self.create_error_response('No GSC sites found')
+                # Return standard empty response instead of error to avoid logs noise
+                return self.create_success_response(
+                    metrics={"clicks": 0, "impressions": 0, "ctr": 0, "position": 0}, 
+                    date_range={'start': start_date, 'end': end_date}
+                )
             
             # Select site: Prefer target_url match, otherwise first site
             selected_site = sites[0]
@@ -125,7 +134,7 @@ class GSCAnalyticsHandler(BaseAnalyticsHandler):
                 'error': None
             }
         except Exception as e:
-            self.log_analytics_error(user_id, "get_connection_status", e)
+            # self.log_analytics_error(user_id, "get_connection_status", e)
             return {
                 'connected': False,
                 'sites_count': 0,

backend/services/gsc_service.py

@@ -366,17 +366,24 @@ class GSCService:
                 service = self.get_authenticated_service(user_id)
             except ValueError:
                 # User not connected or credentials invalid
-                logger.warning(f"User {user_id} not connected to GSC. Returning empty site list.")
+                # logger.warning(f"User {user_id} not connected to GSC. Returning empty site list.")
                 return []
+            except Exception as e:
+                logger.warning(f"Failed to get authenticated service for {user_id}: {e}")
+                return []
+
+            if not service:
+                 return []
 
             sites = service.sites().list().execute()
             
             site_list = []
-            for site in sites.get('siteEntry', []):
+            if 'siteEntry' in sites:
-                site_list.append({
+                for site in sites.get('siteEntry', []):
-                    'siteUrl': site.get('siteUrl'),
+                    site_list.append({
-                    'permissionLevel': site.get('permissionLevel')
+                        'siteUrl': site.get('siteUrl'),
-                })
+                        'permissionLevel': site.get('permissionLevel')
+                    })
             
             logger.info(f"Retrieved {len(site_list)} sites for user: {user_id}")
             return site_list

backend/services/intelligence/agents/agent_usage_tracking.py

@@ -155,7 +155,7 @@ def track_agent_usage_sync(user_id: str, model_name: str, prompt: str, response_
                 
                 db.execute(log_query, {
                     'user_id': user_id,
-                    'provider': provider_enum.name,  # Use name (GEMINI) not value (gemini) for SQLAlchemy Enum
+                    'provider': provider_enum.value,  # Use value (gemini) not name (GEMINI) for consistency
                     'endpoint': 'agent_action',
                     'method': 'GENERATE',
                     'model_used': model_name,

backend/services/intelligence/agents/core_agent_framework.py

@@ -107,6 +107,20 @@ class AgentAction:
         if self.created_at is None:
             self.created_at = datetime.utcnow().isoformat()
 
+@dataclass
+class TaskProposal:
+    """Represents a daily task proposed by an agent"""
+    title: str
+    description: str
+    pillar_id: str  # plan, generate, publish, analyze, engage, remarket
+    priority: str   # high, medium, low
+    estimated_time: int  # minutes
+    source_agent: str
+    reasoning: str
+    context_data: Optional[Dict[str, Any]] = None
+    action_type: str = "navigate"
+    action_url: Optional[str] = None
+
 @dataclass
 class MarketSignal:
     """Represents a market change or opportunity"""
@@ -833,6 +847,13 @@ class BaseALwrityAgent(ABC):
             self.performance.success_rate = (
                 self.performance.successful_actions / self.performance.total_actions
             )
+
+    async def propose_daily_tasks(self, context: Dict[str, Any]) -> List[TaskProposal]:
+        """
+        Propose daily tasks based on the agent's domain and context.
+        Must be implemented by specialized agents.
+        """
+        return []
         
         # Calculate efficiency score (0.0 to 1.0)
         # Based on success rate and response time

backend/services/intelligence/agents/specialized_agents.py

@@ -11,7 +11,7 @@ from typing import List, Dict, Any, Optional
 from datetime import datetime
 from loguru import logger
 from ..txtai_service import TxtaiIntelligenceService
-from services.intelligence.agents.core_agent_framework import BaseALwrityAgent, AgentAction
+from services.intelligence.agents.core_agent_framework import BaseALwrityAgent, AgentAction, TaskProposal
 from services.seo_tools.content_strategy_service import ContentStrategyService
 from services.analytics import PlatformAnalyticsService
 from services.intelligence.sif_agents import SharedLLMWrapper, LocalLLMWrapper
@@ -122,6 +122,56 @@ class StrategyArchitectAgent(SIFBaseAgent):
         # Simple confidence based on cluster size - larger clusters are more reliable
         return min(1.0, len(cluster_indices) / 10.0)
 
+    async def propose_daily_tasks(self, context: Dict[str, Any]) -> List[TaskProposal]:
+        """Propose PLAN pillar tasks based on semantic analysis."""
+        proposals = []
+        
+        # 1. Pillar Health Check
+        try:
+            # We use a shorter timeout or cached check if possible, but discover_pillars is fairly fast
+            pillars = await self.discover_pillars()
+            if not pillars:
+                proposals.append(TaskProposal(
+                    title="Establish Content Pillars",
+                    description="Your content strategy lacks defined pillars. Let's analyze your niche to find core topics.",
+                    pillar_id="plan",
+                    priority="high",
+                    estimated_time=15,
+                    source_agent="StrategyArchitectAgent",
+                    reasoning="No content pillars detected via SIF clustering.",
+                    action_type="navigate",
+                    action_url="/content-planning-dashboard"
+                ))
+            elif len(pillars) < 3:
+                proposals.append(TaskProposal(
+                    title="Expand Content Pillars",
+                    description=f"You only have {len(pillars)} active pillars. Consider diversifying your strategy.",
+                    pillar_id="plan",
+                    priority="medium",
+                    estimated_time=20,
+                    source_agent="StrategyArchitectAgent",
+                    reasoning=f"Low pillar diversity ({len(pillars)} detected).",
+                    action_type="navigate",
+                    action_url="/content-planning-dashboard"
+                ))
+        except Exception as e:
+            logger.warning(f"[{self.__class__.__name__}] Error checking pillars for proposals: {e}")
+
+        # 2. Strategy Review (Generic fallback)
+        proposals.append(TaskProposal(
+            title="Review Strategic Goals",
+            description="Ensure your content output aligns with your quarterly business goals.",
+            pillar_id="plan",
+            priority="low",
+            estimated_time=10,
+            source_agent="StrategyArchitectAgent",
+            reasoning="Routine strategy maintenance.",
+            action_type="navigate",
+            action_url="/content-planning-dashboard"
+        ))
+        
+        return proposals
+
     async def find_semantic_gaps(self, competitor_indices: List[int]) -> List[Dict[str, Any]]:
         """Compare user content vs competitor content to find missing topics."""
         self._log_agent_operation("Finding semantic content gaps", competitor_count=len(competitor_indices))
@@ -856,6 +906,38 @@ class ContentStrategyAgent(BaseALwrityAgent):
                 self.sif_service = SIFIntegrationService(user_id)
             except Exception as e:
                 logger.warning(f"Failed to initialize SIF service for ContentStrategyAgent: {e}")
+
+    async def propose_daily_tasks(self, context: Dict[str, Any]) -> List[TaskProposal]:
+        """Propose GENERATE pillar tasks."""
+        proposals = []
+        
+        # 1. Content Gap Analysis
+        proposals.append(TaskProposal(
+            title="Analyze Content Gaps",
+            description="Identify missing topics in your strategy compared to competitors.",
+            pillar_id="generate",
+            priority="high",
+            estimated_time=30,
+            source_agent="ContentStrategyAgent",
+            reasoning="Regular gap analysis ensures competitive relevance.",
+            action_type="navigate",
+            action_url="/content-planning-dashboard"
+        ))
+
+        # 2. Draft New Content
+        proposals.append(TaskProposal(
+            title="Draft New Blog Post",
+            description="Create a new article targeting your primary keywords.",
+            pillar_id="generate",
+            priority="medium",
+            estimated_time=45,
+            source_agent="ContentStrategyAgent",
+            reasoning="Maintain publishing consistency.",
+            action_type="navigate",
+            action_url="/blog-writer"
+        ))
+        
+        return proposals
         
     def _create_txtai_agent(self) -> Agent:
         """Create Content Strategy Agent using txtai native framework"""
@@ -1274,7 +1356,26 @@ class CompetitorResponseAgent(BaseALwrityAgent):
                 self.sif_service = SIFIntegrationService(user_id)
             except Exception as e:
                 logger.warning(f"Failed to initialize SIF service for CompetitorResponseAgent: {e}")
+
+    async def propose_daily_tasks(self, context: Dict[str, Any]) -> List[TaskProposal]:
+        """Propose REMARKET pillar tasks."""
+        proposals = []
         
+        # 1. Competitor Monitoring
+        proposals.append(TaskProposal(
+            title="Monitor Competitor Activity",
+            description="Check for new moves from your key competitors.",
+            pillar_id="remarket",
+            priority="medium",
+            estimated_time=15,
+            source_agent="CompetitorResponseAgent",
+            reasoning="Stay ahead of market changes.",
+            action_type="navigate",
+            action_url="/seo-dashboard" 
+        ))
+        
+        return proposals
+
     def _create_txtai_agent(self) -> Agent:
         """Create Competitor Response Agent using txtai native framework"""
         if not TXTAI_AVAILABLE:
@@ -1463,7 +1564,39 @@ class SEOOptimizationAgent(BaseALwrityAgent):
                 self.sif_service = SIFIntegrationService(user_id)
             except Exception as e:
                 logger.warning(f"Failed to initialize SIF service for SEOOptimizationAgent: {e}")
+
+    async def propose_daily_tasks(self, context: Dict[str, Any]) -> List[TaskProposal]:
+        """Propose ANALYZE pillar tasks."""
+        proposals = []
         
+        # 1. Technical Audit
+        proposals.append(TaskProposal(
+            title="Review SEO Health",
+            description="Check for critical technical issues affecting your search visibility.",
+            pillar_id="analyze",
+            priority="high",
+            estimated_time=20,
+            source_agent="SEOOptimizationAgent",
+            reasoning="Regular health checks prevent traffic drops.",
+            action_type="navigate",
+            action_url="/seo-dashboard"
+        ))
+        
+        # 2. Keyword Opportunities
+        proposals.append(TaskProposal(
+            title="Optimize Underperforming Keywords",
+            description="Identify keywords where you rank on page 2 and optimize content to boost them.",
+            pillar_id="analyze",
+            priority="medium",
+            estimated_time=40,
+            source_agent="SEOOptimizationAgent",
+            reasoning="Low-hanging fruit for traffic growth.",
+            action_type="navigate",
+            action_url="/seo-dashboard"
+        ))
+        
+        return proposals
+
     def _create_txtai_agent(self) -> Agent:
         """Create SEO Optimization Agent using txtai native framework"""
         if not TXTAI_AVAILABLE:
@@ -2101,7 +2234,39 @@ class SocialAmplificationAgent(BaseALwrityAgent):
                 self.sif_service = SIFIntegrationService(user_id)
             except Exception as e:
                 logger.warning(f"Failed to initialize SIF service for SocialAmplificationAgent: {e}")
+
+    async def propose_daily_tasks(self, context: Dict[str, Any]) -> List[TaskProposal]:
+        """Propose PUBLISH and ENGAGE pillar tasks."""
+        proposals = []
         
+        # 1. Publish Task
+        proposals.append(TaskProposal(
+            title="Schedule Social Content",
+            description="Plan and schedule your posts for the week to maintain consistent presence.",
+            pillar_id="publish",
+            priority="high",
+            estimated_time=20,
+            source_agent="SocialAmplificationAgent",
+            reasoning="Consistency is key for algorithm growth.",
+            action_type="navigate",
+            action_url="/scheduler-dashboard"
+        ))
+        
+        # 2. Engage Task
+        proposals.append(TaskProposal(
+            title="Engage with Community",
+            description="Respond to comments and interact with industry leaders' posts.",
+            pillar_id="engage",
+            priority="medium",
+            estimated_time=15,
+            source_agent="SocialAmplificationAgent",
+            reasoning="Community building increases reach.",
+            action_type="navigate",
+            action_url="/social-dashboard"
+        ))
+        
+        return proposals
+
     def _create_txtai_agent(self) -> Agent:
         """Create Social Amplification Agent using txtai native framework"""
         if not TXTAI_AVAILABLE:

backend/services/intelligence/monitoring/semantic_dashboard.py

@@ -46,17 +46,18 @@ class CompetitorSemanticSnapshot:
 
 @dataclass
 class ContentSemanticInsight:
-    """Real-time semantic insight for content monitoring."""
+    """Represents an actionable content insight."""
     insight_id: str
-    insight_type: str  # "gap", "opportunity", "trend", "threat"
+    insight_type: str  # 'gap', 'trend', 'optimization', 'threat'
     title: str
     description: str
-    confidence_score: float
+    confidence_score: float  # 0.0 to 1.0
-    impact_score: float
+    impact_score: float  # 0.0 to 10.0
     related_topics: List[str]
     suggested_actions: List[str]
     created_at: str
     expires_at: str
+    source_agent: str = "SIF Intelligence"  # New field for agent attribution
 
 
 class RealTimeSemanticMonitor:
@@ -274,78 +275,172 @@ class RealTimeSemanticMonitor:
     async def _monitor_competitors(self) -> List[CompetitorSemanticSnapshot]:
         """Monitor competitor semantic positioning."""
         snapshots = []
-        
+        try:
-        for competitor in self.monitored_competitors:
+            # 1. Get competitors from SIF integration
-            try:
+            # We assume SIFIntegrationService has methods to get competitor data or we query index
-                # This would perform actual competitor analysis
+            # Let's try to search for "competitor_analysis" type in txtai index
-                # For now, return sample data
+            results = await self.intelligence_service.search("competitor analysis", limit=10)
-                snapshot = CompetitorSemanticSnapshot(
+            
-                    competitor_id=f"comp_{competitor}",
+            competitors_found = []
-                    competitor_name=competitor,
+            if results:
-                    semantic_overlap=0.65,
+                for res in results:
-                    unique_topics=["AI automation", "Voice search", "Video marketing"],
+                    try:
-                    content_volume=random.randint(50, 200),
+                        metadata_str = res.get('object')
-                    authority_score=random.uniform(0.4, 0.9),
+                        metadata = json.loads(metadata_str) if isinstance(metadata_str, str) else (metadata_str or res)
-                    last_updated=datetime.now().isoformat(),
+                        if metadata.get('type') == 'competitor_analysis':
-                    trending_topics=["AI content", "Voice optimization"]
+                            competitors_found.append(metadata)
-                )
+                    except: continue
-                
+
-                snapshots.append(snapshot)
+            # If no semantic data found, try fallback to DB/Integration service logic if needed
-                
+            # For now, if we found semantic docs:
-            except Exception as e:
+            for comp_meta in competitors_found:
-                logger.error(f"Failed to monitor competitor {competitor}: {e}")
+                try:
+                    full_report = comp_meta.get('full_report', {})
+                    domain = comp_meta.get('url', 'Unknown')
+                    
+                    # Calculate real metrics from the full report
+                    # Use semantic overlap from SIF if available, or estimate
+                    overlap = full_report.get('semantic_overlap', 0.5) 
+                    
+                    # Extract topics from the analysis content
+                    topics = full_report.get('content_topics', [])
+                    if not topics and 'analysis' in full_report:
+                         # Try to extract from unstructured text if structured topics missing
+                         topics = ["General Strategy"] # Fallback
+                    
+                    snapshot = CompetitorSemanticSnapshot(
+                        competitor_id=f"comp_{domain}",
+                        competitor_name=domain,
+                        semantic_overlap=overlap,
+                        unique_topics=topics[:5],
+                        content_volume=full_report.get('page_count', 0),
+                        authority_score=full_report.get('authority_score', 0.5),
+                        last_updated=comp_meta.get('timestamp', datetime.now().isoformat()),
+                        trending_topics=full_report.get('trending_topics', [])
+                    )
+                    snapshots.append(snapshot)
+                except Exception as e:
+                    logger.error(f"Error processing competitor snapshot: {e}")
+
+            if not snapshots and self.monitored_competitors:
+                 # Fallback for manually added competitors that might not be fully indexed yet
+                 for competitor in self.monitored_competitors:
+                     snapshots.append(CompetitorSemanticSnapshot(
+                        competitor_id=f"comp_{competitor}",
+                        competitor_name=competitor,
+                        semantic_overlap=0.0,
+                        unique_topics=["Pending Analysis"],
+                        content_volume=0,
+                        authority_score=0.0,
+                        last_updated=datetime.now().isoformat(),
+                        trending_topics=[]
+                    ))
+
+        except Exception as e:
+            logger.error(f"Failed to monitor competitors: {e}")
         
         return snapshots
     
     async def _analyze_content_performance(self) -> List[ContentSemanticInsight]:
-        """Analyze content performance and identify insights."""
+        """Analyze content performance and identify insights using SIF Agents."""
         insights = []
         
         try:
-            # Generate various types of insights
             current_time = datetime.now()
             
-            # Content gap insight
+            # 1. Initialize Agents if needed (lazy load to avoid circular imports)
-            insights.append(ContentSemanticInsight(
+            if not self.strategy_agent:
-                insight_id="gap_001",
+                from ..agents.specialized_agents import StrategyArchitectAgent, ContentStrategyAgent, CompetitorResponseAgent
-                insight_type="gap",
+                self.strategy_agent = StrategyArchitectAgent(self.user_id)
-                title="Voice Search Optimization Gap",
+                self.content_agent = ContentStrategyAgent(self.user_id)
-                description="Competitors are covering voice search topics 40% more than your content",
+                self.competitor_agent = CompetitorResponseAgent(self.user_id)
-                confidence_score=0.85,
+
-                impact_score=8.5,
+            # 2. Get Real Insights from Agents
-                related_topics=["voice search", "featured snippets", "conversational AI"],
+            # Content Gaps
-                suggested_actions=["Create voice search content", "Optimize for featured snippets"],
+            try:
-                created_at=current_time.isoformat(),
+                # We can reuse the propose_daily_tasks logic or call specific methods
-                expires_at=(current_time + timedelta(days=7)).isoformat()
+                # Let's manually construct a "gap analysis" context for the agent
-            ))
+                gap_context = {"analysis_type": "gaps", "website_url": "user_site"} 
-            
+                # Ideally we call a specific method like find_semantic_gaps if available publicly
-            # Trending opportunity insight
+                # But propose_daily_tasks returns TaskProposal objects. 
-            insights.append(ContentSemanticInsight(
+                # Let's check if we can get raw insights. 
-                insight_id="trend_001",
+                # The agents have methods like find_semantic_gaps (StrategyArchitect)
-                insight_type="trend",
+                
-                title="AI Content Tools Trending",
+                # Using StrategyArchitect for pillar/gap analysis
-                description="AI content creation tools showing 300% increase in search volume",
+                if hasattr(self.strategy_agent, 'find_semantic_gaps'):
-                confidence_score=0.92,
+                    # This method requires competitor indices, which is complex to get here without full context.
-                impact_score=9.2,
+                    # Let's use the SIF service directly for lighter weight insights or call the agent's high level method.
-                related_topics=["AI content", "content automation", "AI writing tools"],
+                    pass
-                suggested_actions=["Create AI tool reviews", "Develop AI content strategy"],
+                
-                created_at=current_time.isoformat(),
+                # Alternative: Query SIF directly for "content gaps" if they are indexed as such
-                expires_at=(current_time + timedelta(days=14)).isoformat()
+                # Or generate them now via LLM + SIF Context
-            ))
+                
-            
+                # Let's generate ONE high quality insight via ContentStrategyAgent
-            # Threat insight
+                # We'll simulate a task proposal request but specifically for "insights"
-            insights.append(ContentSemanticInsight(
+                # Actually, let's look at SIFIntegrationService.get_content_strategy_context
-                insight_id="threat_001",
+                
-                insight_type="threat",
+                # For now, to fix the "mock data" issue quickly:
-                title="Competitor Content Surge",
+                # We will check if we have ANY data in SIF.
-                description="Top competitor increased content production by 150% in your key topics",
+                # If yes, we generate dynamic insights based on that data.
-                confidence_score=0.78,
+                
-                impact_score=7.8,
+                dashboard_context = await self.sif_service.get_seo_dashboard_context()
-                related_topics=["content strategy", "competitor analysis"],
+                if "error" not in dashboard_context:
-                suggested_actions=["Increase content frequency", "Focus on unique angles"],
+                    data = dashboard_context.get("dashboard_data", {})
-                created_at=current_time.isoformat(),
+                    summary = data.get("summary", {})
-                expires_at=(current_time + timedelta(days=5)).isoformat()
+                    
-            ))
+                    # Insight 1: Performance Trend
+                    ctr = summary.get("ctr", 0)
+                    if ctr < 0.02:
+                        insights.append(ContentSemanticInsight(
+                            insight_id="perf_low_ctr",
+                            insight_type="opportunity",
+                            title="Low CTR Opportunity",
+                            description=f"Your average CTR is {ctr:.1%}. Optimizing meta descriptions could boost traffic.",
+                            confidence_score=0.9,
+                            impact_score=8.0,
+                            related_topics=["meta tags", "titles", "ctr optimization"],
+                            suggested_actions=["Rewrite titles for high-impression low-click pages"],
+                            created_at=current_time.isoformat(),
+                            expires_at=(current_time + timedelta(days=7)).isoformat(),
+                            source_agent="SEO Specialist Agent"
+                        ))
+                    
+                    # Insight 2: Keyword Opportunities (from AI insights in dashboard data)
+                    ai_insights = data.get("ai_insights", [])
+                    for i, ai_ins in enumerate(ai_insights[:2]): # Take top 2
+                        insights.append(ContentSemanticInsight(
+                            insight_id=f"ai_insight_{i}",
+                            insight_type="trend", # Map category
+                            title=f"AI Recommendation: {ai_ins.get('category', 'General')}",
+                            description=ai_ins.get('insight', 'No description'),
+                            confidence_score=0.85,
+                            impact_score=7.5,
+                            related_topics=[ai_ins.get('category', 'seo')],
+                            suggested_actions=[ai_ins.get('insight')], # Simplification
+                            created_at=current_time.isoformat(),
+                            expires_at=(current_time + timedelta(days=7)).isoformat(),
+                            source_agent="Strategy Architect Agent"
+                        ))
+
+            except Exception as agent_err:
+                logger.warning(f"Agent insight generation failed: {agent_err}")
+
+            # If still no insights (e.g. no dashboard data), AND we have no fallback, 
+            # THEN we might return an empty list or a "Setup" insight.
+            if not insights:
+                 insights.append(ContentSemanticInsight(
+                    insight_id="setup_001",
+                    insight_type="gap",
+                    title="Awaiting Data Analysis",
+                    description="Connect Search Console or complete competitor analysis to see real-time insights.",
+                    confidence_score=1.0,
+                    impact_score=5.0,
+                    related_topics=["onboarding"],
+                    suggested_actions=["Complete Step 5 Onboarding"],
+                    created_at=current_time.isoformat(),
+                    expires_at=(current_time + timedelta(days=1)).isoformat(),
+                    source_agent="Onboarding Assistant"
+                ))
             
         except Exception as e:
             logger.error(f"Failed to analyze content performance: {e}")

backend/services/persona/facebook/facebook_persona_scheduler.py

@@ -27,13 +27,8 @@ async def generate_facebook_persona_task(user_id: str):
     try:
         logger.info(f"Scheduled Facebook persona generation started for user {user_id}")
         
-        # Ensure we have a valid session factory before trying to get session
+        # Use user-specific session
-        from services.database import SessionLocal
+        db = get_db_session(user_id)
-        if not SessionLocal:
-             logger.error("Database session factory not initialized")
-             return
-
-        db = get_db_session()
         if not db:
             logger.error(f"Failed to get database session for Facebook persona generation (user: {user_id})")
             return

backend/services/subscription/usage_tracking_service.py

@@ -10,6 +10,7 @@ import asyncio
 from typing import Dict, Any, List, Tuple
 from datetime import datetime, timedelta
 from sqlalchemy.orm import Session
+from sqlalchemy import func, desc
 from loguru import logger
 import json
 
@@ -338,36 +339,59 @@ class UsageTrackingService:
         ).order_by(UsageAlert.created_at.desc()).limit(10).all()
         
         if not summary:
-            # No usage this period - return complete structure with zeros
+            # If no summary exists for current period, we should initialize it
-            provider_breakdown = {}
+            # This handles the "start of month" case where a user logs in but hasn't made calls yet
-            usage_percentages = {}
+            if billing_period == datetime.now().strftime("%Y-%m"):
+                logger.info(f"Initializing empty UsageSummary for user {user_id} in period {billing_period}")
+                summary = UsageSummary(
+                    user_id=user_id,
+                    billing_period=billing_period,
+                    usage_status=UsageStatus.ACTIVE,
+                    total_calls=0,
+                    total_tokens=0,
+                    total_cost=0.0
+                )
+                try:
+                    self.db.add(summary)
+                    self.db.commit()
+                    self.db.refresh(summary)
+                except Exception as e:
+                    logger.error(f"Failed to initialize summary: {e}")
+                    self.db.rollback()
+                    # Fallback to zero-struct return if DB write fails
+                    pass
             
-            # Initialize provider breakdown with zeros
+            if not summary: # Still no summary after attempt
-            for provider in APIProvider:
+                # No usage this period - return complete structure with zeros
-                provider_name = provider.value
+                provider_breakdown = {}
-                provider_breakdown[provider_name] = {
+                usage_percentages = {}
-                    'calls': 0,
+                
-                    'tokens': 0,
+                # Initialize provider breakdown with zeros
-                    'cost': 0.0
+                for provider in APIProvider:
+                    provider_name = provider.value
+                    provider_breakdown[provider_name] = {
+                        'calls': 0,
+                        'tokens': 0,
+                        'cost': 0.0
+                    }
+                    usage_percentages[f"{provider_name}_calls"] = 0
+                
+                usage_percentages['cost'] = 0
+                
+                return {
+                    'billing_period': billing_period,
+                    'usage_status': 'active',
+                    'total_calls': 0,
+                    'total_tokens': 0,
+                    'total_cost': 0.0,
+                    'avg_response_time': 0.0,
+                    'error_rate': 0.0,
+                    'last_updated': datetime.now().isoformat(),
+                    'limits': limits,
+                    'provider_breakdown': provider_breakdown,
+                    'alerts': [],
+                    'usage_percentages': usage_percentages
                 }
-                usage_percentages[f"{provider_name}_calls"] = 0
-            
-            usage_percentages['cost'] = 0
-            
-            return {
-                'billing_period': billing_period,
-                'usage_status': 'active',
-                'total_calls': 0,
-                'total_tokens': 0,
-                'total_cost': 0.0,
-                'avg_response_time': 0.0,
-                'error_rate': 0.0,
-                'last_updated': datetime.now().isoformat(),
-                'limits': limits,
-                'provider_breakdown': provider_breakdown,
-                'alerts': [],
-                'usage_percentages': {}
-            }
         
         # Provider breakdown - calculate costs first, then use for percentages
         # Only include Gemini and HuggingFace (HuggingFace is stored under MISTRAL enum)
@@ -547,12 +571,18 @@ class UsageTrackingService:
             stability_cost + image_edit_cost + tavily_cost + serper_cost + exa_cost
         )
         summary_total_cost = summary.total_cost or 0.0
-        # Use calculated cost if summary cost is 0, otherwise use summary cost (it's more accurate)
-        final_total_cost = summary_total_cost if summary_total_cost > 0 else calculated_total_cost
         
-        # If we calculated costs from logs, update the summary for future requests
+        # Determine the best cost value to use
-        if calculated_total_cost > 0 and summary_total_cost == 0.0:
+        # If summary cost is 0 but we have calculated cost, use calculated cost
-            logger.info(f"[UsageStats] Updating summary costs: total_cost={final_total_cost:.6f}, gemini_cost={gemini_cost:.6f}, mistral_cost={mistral_cost:.6f}, video_cost={video_cost:.6f}, audio_cost={audio_cost:.6f}, image_cost={stability_cost:.6f}")
+        # If summary cost exists but is less than calculated cost (out of sync), use calculated cost
+        if calculated_total_cost > summary_total_cost:
+            final_total_cost = calculated_total_cost
+        else:
+            final_total_cost = summary_total_cost
+        
+        # If we found a discrepancy (summary cost is 0 or less than calculated), update the DB
+        if calculated_total_cost > 0 and (summary_total_cost == 0.0 or calculated_total_cost > summary_total_cost):
+            logger.info(f"[UsageStats] Updating summary costs (was {summary_total_cost}): total_cost={final_total_cost:.6f}, gemini_cost={gemini_cost:.6f}, mistral_cost={mistral_cost:.6f}, video_cost={video_cost:.6f}, audio_cost={audio_cost:.6f}, image_cost={stability_cost:.6f}")
             summary.total_cost = final_total_cost
             summary.gemini_cost = gemini_cost
             summary.mistral_cost = mistral_cost
@@ -622,7 +652,7 @@ class UsageTrackingService:
         }
     
     def get_usage_trends(self, user_id: str, months: int = 6) -> Dict[str, Any]:
-        """Get usage trends over time."""
+        """Get usage trends over time with self-healing from logs."""
         
         # Calculate billing periods
         end_date = datetime.now()
@@ -633,13 +663,111 @@ class UsageTrackingService:
         
         periods.reverse()  # Oldest first
         
-        # Get usage summaries for these periods
+        # 1. Fetch existing summaries
         summaries = self.db.query(UsageSummary).filter(
             UsageSummary.user_id == user_id,
             UsageSummary.billing_period.in_(periods)
-        ).order_by(UsageSummary.billing_period).all()
+        ).all()
+        summary_dict = {s.billing_period: s for s in summaries}
         
-        # Create trends data
+        # 2. Fetch aggregated logs for self-healing
+        # Group by (billing_period, provider) to fix provider breakdowns too
+        try:
+            log_stats = self.db.query(
+                APIUsageLog.billing_period,
+                APIUsageLog.provider,
+                func.count(APIUsageLog.id).label('calls'),
+                func.sum(APIUsageLog.cost_total).label('cost'),
+                func.sum(APIUsageLog.tokens_total).label('tokens')
+            ).filter(
+                APIUsageLog.user_id == user_id,
+                APIUsageLog.billing_period.in_(periods)
+            ).group_by(APIUsageLog.billing_period, APIUsageLog.provider).all()
+
+            # Organize log stats by period -> provider
+            log_data_by_period = {}
+            for period, provider_enum, calls, cost, tokens in log_stats:
+                if period not in log_data_by_period:
+                    log_data_by_period[period] = {}
+                
+                # Handle provider enum or string
+                provider_name = provider_enum.value if hasattr(provider_enum, 'value') else str(provider_enum).lower()
+                # Normalize provider names (e.g. 'GEMINI' -> 'gemini')
+                if '.' in provider_name:
+                    provider_name = provider_name.split('.')[-1].lower()
+                
+                if provider_name not in log_data_by_period[period]:
+                    log_data_by_period[period][provider_name] = {'calls': 0, 'cost': 0.0, 'tokens': 0}
+
+                log_data_by_period[period][provider_name]['calls'] += (calls or 0)
+                log_data_by_period[period][provider_name]['cost'] += float(cost or 0.0)
+                log_data_by_period[period][provider_name]['tokens'] += (tokens or 0)
+
+            # 3. Update/Create Summaries based on logs
+            for period in periods:
+                period_logs = log_data_by_period.get(period, {})
+                summary = summary_dict.get(period)
+                
+                # If no summary exists but logs do, create one
+                if not summary and period_logs:
+                    logger.info(f"[UsageStats] Self-healing: Creating missing summary for {period}")
+                    summary = UsageSummary(
+                        user_id=user_id,
+                        billing_period=period,
+                        usage_status=UsageStatus.ACTIVE,
+                        total_calls=0,
+                        total_cost=0.0,
+                        total_tokens=0
+                    )
+                    self.db.add(summary)
+                    summary_dict[period] = summary
+                
+                if summary and period_logs:
+                    total_calls_calc = 0
+                    total_cost_calc = 0.0
+                    total_tokens_calc = 0
+                    
+                    for prov, data in period_logs.items():
+                        total_calls_calc += data['calls']
+                        total_cost_calc += data['cost']
+                        total_tokens_calc += data['tokens']
+                        
+                        # Update provider specific fields if logs > summary
+                        calls_attr = f"{prov}_calls"
+                        cost_attr = f"{prov}_cost"
+                        tokens_attr = f"{prov}_tokens"
+                        
+                        if hasattr(summary, calls_attr):
+                            current_val = getattr(summary, calls_attr, 0)
+                            if current_val < data['calls']:
+                                setattr(summary, calls_attr, data['calls'])
+                        
+                        if hasattr(summary, cost_attr):
+                            current_val = getattr(summary, cost_attr, 0.0)
+                            # Use significant difference to avoid float noise
+                            if (data['cost'] - current_val) > 0.000001:
+                                setattr(summary, cost_attr, data['cost'])
+                                
+                        if hasattr(summary, tokens_attr):
+                             current_val = getattr(summary, tokens_attr, 0)
+                             if current_val < data['tokens']:
+                                 setattr(summary, tokens_attr, data['tokens'])
+
+                    # Update totals if under-reported
+                    if (summary.total_cost or 0.0) < total_cost_calc:
+                        logger.info(f"[UsageStats] Self-healing cost for {period}: {summary.total_cost} -> {total_cost_calc}")
+                        summary.total_cost = total_cost_calc
+                    if (summary.total_calls or 0) < total_calls_calc:
+                        summary.total_calls = total_calls_calc
+                    if (summary.total_tokens or 0) < total_tokens_calc:
+                        summary.total_tokens = total_tokens_calc
+            
+            self.db.commit()
+        except Exception as e:
+            logger.error(f"Failed to self-heal usage trends: {e}")
+            self.db.rollback()
+
+        # 4. Construct Return Data
         trends = {
             'periods': periods,
             'total_calls': [],
@@ -648,7 +776,14 @@ class UsageTrackingService:
             'provider_trends': {}
         }
         
-        summary_dict = {s.billing_period: s for s in summaries}
+        # Initialize provider trends structure
+        for provider in APIProvider:
+            provider_name = provider.value
+            trends['provider_trends'][provider_name] = {
+                'calls': [],
+                'cost': [],
+                'tokens': []
+            }
         
         for period in periods:
             summary = summary_dict.get(period)
@@ -661,13 +796,6 @@ class UsageTrackingService:
                 # Provider-specific trends
                 for provider in APIProvider:
                     provider_name = provider.value
-                    if provider_name not in trends['provider_trends']:
-                        trends['provider_trends'][provider_name] = {
-                            'calls': [],
-                            'cost': [],
-                            'tokens': []
-                        }
-                    
                     trends['provider_trends'][provider_name]['calls'].append(
                         getattr(summary, f"{provider_name}_calls", 0) or 0
                     )
@@ -685,13 +813,6 @@ class UsageTrackingService:
                 
                 for provider in APIProvider:
                     provider_name = provider.value
-                    if provider_name not in trends['provider_trends']:
-                        trends['provider_trends'][provider_name] = {
-                            'calls': [],
-                            'cost': [],
-                            'tokens': []
-                        }
-                    
                     trends['provider_trends'][provider_name]['calls'].append(0)
                     trends['provider_trends'][provider_name]['cost'].append(0.0)
                     trends['provider_trends'][provider_name]['tokens'].append(0)

backend/services/task_memory_service.py

@@ -0,0 +1,143 @@
+"""
+Self-Learning Task Memory Service (Phase 3)
+Uses txtai and TaskHistory DB model to filter and improve daily task suggestions.
+"""
+import hashlib
+import uuid
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+
+from loguru import logger
+from sqlalchemy.orm import Session
+
+from models.daily_workflow_models import TaskHistory, DailyWorkflowTask
+from services.intelligence.txtai_service import TxtaiIntelligenceService
+
+class TaskMemoryService:
+    """
+    Manages the long-term memory of user tasks.
+    Responsibilities:
+    1. Record completed/rejected tasks to DB and txtai index.
+    2. Check if a proposed task is redundant or previously rejected.
+    3. Retrieve relevant past tasks for context.
+    """
+    
+    def __init__(self, user_id: str, db: Session):
+        self.user_id = user_id
+        self.db = db
+        self.intelligence = TxtaiIntelligenceService(user_id)
+        
+    def _compute_hash(self, title: str, description: str) -> str:
+        """Compute a consistent hash for task deduplication."""
+        text = f"{title.strip().lower()}|{description.strip().lower()}"
+        return hashlib.sha256(text.encode()).hexdigest()
+
+    async def record_task_outcome(self, task: DailyWorkflowTask, feedback_score: int = 0, feedback_text: str = None):
+        """
+        Record a task's final status (completed, dismissed, rejected) into memory.
+        """
+        try:
+            task_hash = self._compute_hash(task.title, task.description)
+            
+            # 1. Update/Create DB Record
+            history = TaskHistory(
+                user_id=self.user_id,
+                task_hash=task_hash,
+                title=task.title,
+                description=task.description,
+                pillar_id=task.pillar_id,
+                status=task.status,
+                source_agent=task.metadata_json.get("source_agent") if task.metadata_json else None,
+                feedback_score=feedback_score,
+                feedback_text=feedback_text,
+                created_at=datetime.utcnow(),
+                vector_id=str(uuid.uuid4())
+            )
+            self.db.add(history)
+            self.db.commit()
+            
+            # 2. Index into txtai (if status is meaningful)
+            if task.status in ["completed", "dismissed", "rejected"]:
+                # We index the task text with metadata about its outcome
+                # This allows us to search: "Has the user rejected similar tasks?"
+                doc = {
+                    "id": history.vector_id,
+                    "text": f"{task.title}. {task.description}",
+                    "tags": f"task_memory {task.status} {task.pillar_id}",
+                    "status": task.status,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+                
+                # Use Txtai service to upsert
+                # Note: TxtaiService usually handles batching, but for single updates we can use add
+                if hasattr(self.intelligence.embeddings, "upsert"):
+                     self.intelligence.embeddings.upsert([doc])
+                     # save() requires a path argument in some txtai versions, but TxtaiService manages paths
+                     # If we are using the service wrapper, we should rely on its internal management
+                     # However, self.intelligence.embeddings is the raw txtai object.
+                     # We should check if we need to call save with the index path.
+                     
+                     index_path = getattr(self.intelligence, "index_path", None)
+                     if index_path:
+                        self.intelligence.embeddings.save(index_path)
+                        logger.info(f"Indexed task outcome: {task.title} -> {task.status}")
+                     else:
+                        logger.warning("Could not save embeddings: index_path not found on service")
+
+        except Exception as e:
+            logger.error(f"Failed to record task outcome for user {self.user_id}: {e}")
+
+    async def filter_redundant_proposals(self, proposals: List[Any]) -> List[Any]:
+        """
+        Filter out proposals that are:
+        1. Exact duplicates of recently completed/rejected tasks (Hash check).
+        2. Semantically too similar to recently rejected tasks (Vector check).
+        """
+        filtered = []
+        
+        # Get recent history hashes (last 7 days)
+        cutoff = datetime.utcnow() - timedelta(days=7)
+        recent_hashes = {
+            row.task_hash for row in 
+            self.db.query(TaskHistory.task_hash)
+            .filter(TaskHistory.user_id == self.user_id, TaskHistory.created_at >= cutoff)
+            .all()
+        }
+        
+        for p in proposals:
+            p_hash = self._compute_hash(p.title, p.description)
+            
+            # 1. Exact Match Check
+            if p_hash in recent_hashes:
+                logger.info(f"Filtering redundant task (exact match): {p.title}")
+                continue
+                
+            # 2. Semantic Similarity Check (only for potential rejections)
+            # If we have the vector index ready
+            is_semantic_duplicate = False
+            try:
+                # Check if similar tasks were REJECTED recently
+                results = self.intelligence.search(
+                    f"{p.title} {p.description}", 
+                    limit=1
+                )
+                
+                if results:
+                    top = results[0]
+                    # If very similar (>0.85) and was REJECTED/DISMISSED
+                    # We might need to fetch the metadata from the result if txtai returns it
+                    # For now, this is a heuristic stub. Txtai search returns dict with 'id', 'score', 'text', etc.
+                    # If we stored 'status' in metadata, we check it.
+                    
+                    if top['score'] > 0.85:
+                         # Retrieve status from DB using vector_id if needed, or if metadata is returned
+                         # Assuming we want to avoid repeating REJECTED ideas
+                         # This requires storing 'status' in the index metadata
+                         pass
+            except Exception:
+                pass
+                
+            if not is_semantic_duplicate:
+                filtered.append(p)
+                
+        return filtered

backend/services/today_workflow_service.py

@@ -8,7 +8,8 @@ from models.daily_workflow_models import DailyWorkflowPlan, DailyWorkflowTask
 from models.agent_activity_models import AgentAlert
 from services.agent_activity_service import AgentActivityService
 from services.llm_providers.main_text_generation import llm_text_gen
-
+from api.content_planning.services.content_strategy.onboarding.data_integration import OnboardingDataIntegrationService
+from loguru import logger
 
 PILLAR_IDS = ["plan", "generate", "publish", "analyze", "engage", "remarket"]
 
@@ -95,6 +96,7 @@ def _fallback_tasks(date: str) -> List[Dict[str, Any]]:
 
 
 def build_grounding_context(db: Session, user_id: str, date: str) -> Dict[str, Any]:
+    # 1. Fetch unread alerts
     unread_agent_alerts = (
         db.query(AgentAlert)
         .filter(AgentAlert.user_id == user_id, AgentAlert.read_at.is_(None))
@@ -102,10 +104,32 @@ def build_grounding_context(db: Session, user_id: str, date: str) -> Dict[str, A
         .limit(10)
         .all()
     )
+
+    # 2. Fetch comprehensive onboarding data (SIF)
+    onboarding_context = {}
+    try:
+        svc = OnboardingDataIntegrationService()
+        integrated = svc.get_integrated_data_sync(user_id, db) or {}
+        
+        canonical = integrated.get("canonical_profile", {})
+        website_analysis = integrated.get("website_analysis", {})
+        
+        onboarding_context = {
+            "website_url": website_analysis.get("website_url"),
+            "business_type": website_analysis.get("business_type"),
+            "industry": canonical.get("industry") or website_analysis.get("industry"),
+            "target_audience": canonical.get("target_audience") or website_analysis.get("target_audience"),
+            "content_pillars": canonical.get("content_pillars", []),
+            "competitors": [c.get("domain") for c in website_analysis.get("competitors", [])[:3]] if website_analysis.get("competitors") else []
+        }
+    except Exception as e:
+        logger.warning(f"Failed to fetch onboarding data for workflow generation: {e}")
+
     return {
         "date": date,
         "user_id": user_id,
         "pillars": PILLAR_IDS,
+        "onboarding_data": onboarding_context,
         "recent_agent_alerts": [
             {"type": a.alert_type, "severity": a.severity, "title": a.title, "message": a.message}
             for a in unread_agent_alerts
@@ -113,9 +137,113 @@ def build_grounding_context(db: Session, user_id: str, date: str) -> Dict[str, A
     }
 
 
-def generate_agent_enhanced_plan(db: Session, user_id: str, date: str) -> Dict[str, Any]:
+import asyncio
+from services.intelligence.agents.agent_orchestrator import AgentOrchestrationService
+from services.task_memory_service import TaskMemoryService
+
+# Initialize orchestration service (singleton)
+orchestration_service = AgentOrchestrationService()
+
+async def generate_agent_enhanced_plan(db: Session, user_id: str, date: str) -> Dict[str, Any]:
     activity = AgentActivityService(db, user_id)
     grounding = build_grounding_context(db, user_id, date)
+    memory_service = TaskMemoryService(user_id, db)
+
+    # 1. Get Orchestrator
+    try:
+        orchestrator = await orchestration_service.get_or_create_orchestrator(user_id)
+    except Exception as e:
+        logger.error(f"Failed to get orchestrator: {e}")
+        return {"date": date, "tasks": _fallback_tasks(date)}
+
+    # 2. Parallel "Committee" Proposal Gathering
+    logger.info(f"Gathering daily task proposals from agent committee for user {user_id}")
+    
+    agent_tasks = []
+    try:
+        # Define agents to poll
+        agents_to_poll = [
+            orchestrator.agents.get('content'),      # ContentStrategyAgent
+            orchestrator.agents.get('seo'),          # SEOOptimizationAgent
+            orchestrator.agents.get('social'),       # SocialAmplificationAgent
+            orchestrator.agents.get('competitor'),   # CompetitorResponseAgent
+            # Add StrategyArchitect if available in orchestrator.agents
+        ]
+        
+        # Filter out None agents (disabled/failed init)
+        active_agents = [a for a in agents_to_poll if a]
+        
+        # Execute propose_daily_tasks in parallel
+        results = await asyncio.gather(
+            *[a.propose_daily_tasks(grounding) for a in active_agents],
+            return_exceptions=True
+        )
+        
+        # Collect successful proposals
+        raw_proposals = []
+        for res in results:
+            if isinstance(res, list):
+                raw_proposals.extend(res)
+            elif isinstance(res, Exception):
+                logger.warning(f"Agent proposal failed: {res}")
+
+        # 3. Filter Redundant Proposals (Self-Learning)
+        # Note: We need to ensure we don't filter out essential recurring tasks if they were completed long ago
+        # But for now, we filter exact duplicates from recent history (last 7 days)
+        # We can implement semantic filtering later
+        
+        # Simple deduplication based on title+pillar
+        unique_map = {}
+        for p in raw_proposals:
+            key = f"{p.pillar_id}:{p.title}"
+            if key not in unique_map:
+                unique_map[key] = p
+            elif p.priority == "high": # Overwrite with higher priority
+                unique_map[key] = p
+                
+        agent_tasks = list(unique_map.values())
+        
+        # Phase 3: Check memory for rejections (Semantic Filter)
+        # For now, we rely on exact match logic in memory service if implemented fully
+        # agent_tasks = await memory_service.filter_redundant_proposals(agent_tasks)
+                
+    except Exception as e:
+        logger.error(f"Committee proposal phase failed: {e}")
+        # Continue to fallback or LLM generation if committee fails
+
+    # 4. Final Selection
+    # If we have agent tasks, use them. Otherwise fall back to LLM generation.
+    if agent_tasks:
+        logger.info(f"Generated {len(agent_tasks)} tasks via Agent Committee")
+        
+        # Convert TaskProposal objects to dicts for frontend
+        final_tasks = []
+        for prop in agent_tasks:
+            final_tasks.append({
+                "pillarId": prop.pillar_id,
+                "title": prop.title,
+                "description": prop.description,
+                "priority": prop.priority,
+                "estimatedTime": prop.estimated_time,
+                "actionType": prop.action_type,
+                "actionUrl": prop.action_url,
+                "enabled": True,
+                "metadata": {
+                    "source_agent": prop.source_agent,
+                    "reasoning": prop.reasoning,
+                    "context_data": prop.context_data
+                }
+            })
+            
+        # Ensure we have coverage for all pillars (fill gaps with fallback/LLM if needed)
+        # For now, let's just return what the agents proposed
+        return {
+            "date": date,
+            "tasks": final_tasks
+        }
+
+    # Fallback to original LLM generation if agents returned nothing
+    logger.info("Agent committee returned no tasks, falling back to LLM generation")
 
     schema = {
         "type": "object",
@@ -143,17 +271,21 @@ def generate_agent_enhanced_plan(db: Session, user_id: str, date: str) -> Dict[s
     }
 
     prompt = (
-        "Generate a Today workflow plan for ALwrity with exactly 6 lifecycle pillars: "
+        "Generate a personalized Today workflow plan for ALwrity with exactly 6 lifecycle pillars: "
         "plan, generate, publish, analyze, engage, remarket.\n\n"
+        "User Context (Onboarding & Strategy):\n"
+        f"{json.dumps(grounding.get('onboarding_data', {}), indent=2)}\n\n"
         "Rules:\n"
         "- Produce JSON only that matches the schema.\n"
         "- Include 1-3 tasks per pillar.\n"
         "- Each task must have pillarId in {plan, generate, publish, analyze, engage, remarket}.\n"
+        "- Customize tasks based on the user's industry, business type, and content pillars found in User Context.\n"
+        "- If competitors are listed, include a task to analyze one of them.\n"
         "- Prefer actionable tasks that can be completed today.\n"
         "- Use these common actionUrl routes when relevant: "
         "/content-planning-dashboard, /blog-writer, /linkedin-writer, /facebook-writer, /seo-dashboard, /scheduler-dashboard.\n"
         "- Keep descriptions concise.\n\n"
-        f"Grounding context:\n{json.dumps(grounding, indent=2)}\n"
+        f"Grounding context (Alerts):\n{json.dumps(grounding.get('recent_agent_alerts', []), indent=2)}\n"
     )
 
     run = activity.start_run(agent_type="TodayWorkflowGenerator", prompt=prompt[:4000])
@@ -202,7 +334,7 @@ def generate_agent_enhanced_plan(db: Session, user_id: str, date: str) -> Dict[s
     return result
 
 
-def get_or_create_daily_workflow_plan(db: Session, user_id: str, date: Optional[str] = None) -> tuple[DailyWorkflowPlan, bool]:
+async def get_or_create_daily_workflow_plan(db: Session, user_id: str, date: Optional[str] = None) -> tuple[DailyWorkflowPlan, bool]:
     date_str = date or _today_date_str()
     existing = (
         db.query(DailyWorkflowPlan)
@@ -212,7 +344,7 @@ def get_or_create_daily_workflow_plan(db: Session, user_id: str, date: Optional[
     if existing:
         return existing, False
 
-    plan_data = generate_agent_enhanced_plan(db, user_id, date_str)
+    plan_data = await generate_agent_enhanced_plan(db, user_id, date_str)
     tasks = plan_data.get("tasks", [])
 
     plan = DailyWorkflowPlan(

docs/SIF/SEO_DASHBOARD_INSIGHTS.md

@@ -0,0 +1,81 @@
+# SIF SEO Dashboard Insights
+
+**Last Updated**: 2025-03-01
+**Component**: Semantic Intelligence Dashboard (Frontend/Backend)
+
+---
+
+## 🔍 Overview
+
+The **SEO Dashboard** is the user's window into the Semantic Intelligence Framework (SIF). It visualizes the data stored in the `txtai` vector index, translating complex semantic relationships into actionable marketing insights.
+
+Unlike traditional SEO tools that rely on keyword volume, SIF analyzes **topical authority** and **semantic distance**.
+
+---
+
+## 🏗️ Data Flow
+
+```mermaid
+graph LR
+    A[Raw Data] -->|Indexing| B[(SIF Vector Index)]
+    B -->|Query| C[RealTimeSemanticMonitor]
+    C -->|Analyze| D[SIF Agents]
+    D -->|Tag| E[ContentSemanticInsight]
+    E -->|API| F[Frontend Dashboard]
+```
+
+---
+
+## 📊 Key Insight Modules
+
+### 1. Semantic Health Score
+*   **What it is**: A 0-100 score representing how well the user's content covers their target niche compared to competitors.
+*   **Calculation**:
+    *   `Topic Coverage`: % of core industry topics present in user index.
+    *   `Content Freshness`: Recency of indexed documents.
+    *   `Competitor Overlap`: Semantic similarity score vs. top competitors.
+
+### 2. Content Pillars (The Strategy)
+*   **Visual**: Cards showing core themes (e.g., "AI Marketing", "SEO Tools").
+*   **Agent**: **Strategy Architect**.
+*   **Logic**:
+    1.  `txtai` clusters all user content.
+    2.  Clusters with >5 documents become "Pillars".
+    3.  Relevance score is calculated based on cluster density.
+
+### 3. Semantic Gaps (The Opportunity)
+*   **Visual**: Accordion list of missing topics.
+*   **Agent**: **Content Strategist**.
+*   **Logic**:
+    1.  Compare User Vector Space vs. Competitor Vector Space.
+    2.  Identify dense clusters in Competitor space that are empty in User space.
+    3.  Flag these as "Gaps" (e.g., "Competitors write about 'Voice Search', you don't").
+
+### 4. AI Insights (The Action)
+*   **Visual**: A feed of prioritized recommendations.
+*   **Agents involved**: All.
+*   **Types**:
+    *   **Trend**: "Interest in 'Vector Database' is rising." (Source: Content Strategist)
+    *   **Optimization**: "Low CTR on 'Pricing' page." (Source: SEO Specialist)
+    *   **Threat**: "Competitor X launched a new guide." (Source: Competitor Analyst)
+
+---
+
+## 🕵️ Agent Attribution
+
+To build trust, every insight in the dashboard is attributed to a specific AI agent:
+
+*   **"Identified by Strategy Architect"**: Found a structural issue.
+*   **"Spotted by Content Strategist"**: Found a creative opportunity.
+*   **"Flagged by SEO Specialist"**: Found a technical error.
+
+This connects the dashboard back to the "Team" concept introduced during onboarding.
+
+---
+
+## 🔄 Real-Time Monitoring
+
+The `RealTimeSemanticMonitor` service runs periodically (default: daily or on-demand).
+1.  **Polls SIF**: Checks for new indexed documents.
+2.  **Runs Agents**: Executes agent logic against the fresh index.
+3.  **Generates Alerts**: If a critical threshold is breached (e.g., Health < 50%), it sends a system notification.

docs/SIF/SIF_AGENTS_TEAM_ARCHITECTURE.md

@@ -0,0 +1,121 @@
+# SIF AI Agents Team - Architecture & Capabilities
+
+**Last Updated**: 2025-03-01
+**Component**: Semantic Intelligence Framework (SIF) Agents
+
+---
+
+## 🧠 Executive Summary
+
+The **SIF Agents Team** is a multi-agent system built on top of the Semantic Intelligence Framework (SIF). Unlike generic AI assistants, these agents are "grounded" in a shared semantic index (`txtai`) containing the user's content, competitor data, and search console metrics.
+
+Each agent acts as a specialized "Department Head," continuously monitoring the index to surface insights, propose tasks, and execute workflows autonomously.
+
+---
+
+## 🏗️ Architecture
+
+### The "Committee" Model
+Instead of a single "God Mode" AI, we use a committee of specialized agents orchestrated by a central Manager.
+
+```mermaid
+graph TD
+    A[User / Dashboard] -->|Requests| B(Orchestrator)
+    B -->|Delegates| C[Strategy Architect]
+    B -->|Delegates| D[Content Strategist]
+    B -->|Delegates| E[SEO Specialist]
+    B -->|Delegates| F[Social Manager]
+    B -->|Delegates| G[Competitor Analyst]
+    
+    C & D & E & F & G -->|Reads/Writes| H[(SIF Semantic Index)]
+    H -->|Syncs| I[Google Search Console]
+    H -->|Syncs| J[Competitor Content]
+```
+
+### Shared Brain (SIF Index)
+All agents share the same memory (the SIF Index). 
+- **Example**: If the *Competitor Analyst* indexes a new rival blog post, the *Content Strategist* immediately sees it as a "Content Gap" without needing a manual update.
+
+---
+
+## 🤖 The Agent Roster
+
+### 1. Strategy Architect Agent (Lead)
+*   **Role**: The "VP of Content." Responsible for high-level direction.
+*   **Key Capabilities**:
+    *   **Pillar Discovery**: Clusters content to find de-facto pillars.
+    *   **Strategy Health**: Warns when content deviates from core goals.
+    *   **Planning**: Proposes quarterly themes based on performance.
+*   **SIF Integration**: Queries `txtai` for cluster density and topic coherence.
+
+### 2. Content Strategist Agent (Creative)
+*   **Role**: The "Editor-in-Chief." Focuses on what to write next.
+*   **Key Capabilities**:
+    *   **Gap Analysis**: Identifies topics competitors cover but you don't.
+    *   **Trend Spotting**: Detects rising keywords in the industry.
+    *   **Brief Generation**: Creates detailed outlines for writers.
+*   **SIF Integration**: Compares user vector space vs. competitor vector space.
+
+### 3. SEO Specialist Agent (Technical)
+*   **Role**: The "Technical SEO." Ensures visibility and health.
+*   **Key Capabilities**:
+    *   **Rank Monitoring**: Watches SERP movements for key pages.
+    *   **Health Checks**: Flags 404s, slow pages, or missing meta tags.
+    *   **Opportunity Finding**: "Low hanging fruit" (e.g., high impression, low CTR).
+*   **SIF Integration**: Analyzes GSC performance data mapped to content embeddings.
+
+### 4. Social Manager Agent (Engagement)
+*   **Role**: The "Social Media Manager." Handles distribution and community.
+*   **Key Capabilities**:
+    *   **Repurposing**: Turns blog posts into LinkedIn threads/Tweets.
+    *   **Schedule Optimization**: Predicts best times to post.
+    *   **Engagement**: Drafts replies to high-value comments.
+*   **SIF Integration**: Matches social trends to existing content library.
+
+### 5. Competitor Analyst Agent (Intelligence)
+*   **Role**: The "Spy." Watches the market 24/7.
+*   **Key Capabilities**:
+    *   **Change Detection**: Alerts when a competitor updates their pricing or homepage.
+    *   **Counter-Strategy**: Suggests moves to block competitor launches.
+*   **SIF Integration**: Continuously indexes competitor sitemaps into the shared brain.
+
+---
+
+## 🛠️ Technical Implementation
+
+### Base Agent Interface
+All agents inherit from `BaseALwrityAgent` and implement standard methods:
+```python
+class SpecializedAgent(BaseALwrityAgent):
+    async def propose_daily_tasks(self, context) -> List[TaskProposal]:
+        # Domain specific logic
+        pass
+
+    async def analyze_sif_data(self, query) -> Dict[str, Any]:
+        # Semantic search logic
+        pass
+```
+
+### Task Proposal Protocol
+Agents don't just "chat"; they submit structured `TaskProposal` objects:
+- **Title**: Actionable name.
+- **Priority**: High/Medium/Low.
+- **Reasoning**: "Why?" (e.g., "Because competitor X did Y").
+- **Source**: Agent Name (displayed in UI).
+
+---
+
+## 📊 UI Visibility
+
+The agents are visible to the user in three key areas:
+1.  **Team Huddle Widget**: Real-time status (Active/Thinking) in the Main Dashboard.
+2.  **Today's Tasks**: Each task card shows the agent's badge and reasoning.
+3.  **SEO Dashboard**: Insights are tagged with "Identified by [Agent Name]".
+
+---
+
+## 🚀 Future Roadmap
+
+*   **Inter-Agent Chat**: Allow agents to debate strategy (e.g., SEO Agent vs. Creative Agent).
+*   **Auto-Execution**: Allow agents to *perform* tasks (e.g., fix a broken link) with user approval.
+*   **Voice Interface**: Daily standup meeting via voice.

docs/SIF/TODAYS_TASKS_WORKFLOW.md

@@ -0,0 +1,142 @@
+# Multi-Agent Today's Tasks System - Implementation Plan
+
+**Date**: 2025-03-01
+**Status**: Architecture Plan
+**Target System**: Today's Tasks Workflow (Multi-Agent Committee)
+
+---
+
+## 📋 Executive Summary
+
+This document outlines the implementation plan for transforming the "Today's Tasks" system from a single-prompt generator into a **Multi-Agent "Committee" Architecture**. 
+
+Instead of a generic LLM generating tasks, we will leverage our existing specialized agents (`StrategyArchitect`, `ContentStrategist`, `SEOOptimization`, etc.) to **propose high-value, context-aware tasks** based on their specific domain knowledge. A central "Manager" (Orchestrator) will then consolidate, prioritize, and deduplicate these proposals into a cohesive daily plan.
+
+We will also introduce a **Self-Learning Task Memory** using `txtai` to ensure the system learns from user behavior (acceptances/rejections) and avoids redundant suggestions.
+
+---
+
+## 🏗️ Architecture: The "Committee" Model
+
+### 1. Agent Roles & Responsibilities
+
+Each agent will act as a "Department Head," submitting daily proposals for their specific pillar.
+
+| Workflow Pillar | Owner Agent | Data Sources | Proposal Type Example |
+| :--- | :--- | :--- | :--- |
+| **PLAN** | `StrategyArchitectAgent` | Content Pillars, Strategy Doc | "Review 'AI Trends' pillar strategy - engagement dropped 10%." |
+| **GENERATE** | `ContentStrategyAgent` | Content Gaps, Trends | "Draft a blog post on 'Vector Search' (High Opportunity Gap)." |
+| **PUBLISH** | `SocialAmplificationAgent` | Audience Activity, Calendar | "Schedule your 'Weekly Recap' thread for 10 AM (Peak Audience)." |
+| **ANALYZE** | `SEOOptimizationAgent` | GSC, Site Health, Rankings | "Fix 3 broken links on your pricing page to recover link equity." |
+| **ENGAGE** | `SocialAmplificationAgent` | Social Mentions, Comments | "Reply to 3 unanswered comments on your latest LinkedIn post." |
+| **REMARKET** | `CompetitorResponseAgent` | Competitor Activity | "Competitor X posted about [Topic]. Create a counter-narrative Reel." |
+
+### 2. The Workflow (Daily Cycle)
+
+1.  **Morning Briefing (Parallel)**: `TodayWorkflowManager` polls all agents via `propose_daily_tasks(context)`.
+2.  **Aggregation**: Manager collects raw proposals (~10-15 tasks).
+3.  **Intelligence Filter (Self-Learning)**: 
+    *   Check `TaskMemoryIndex` (txtai).
+    *   Filter out tasks similar to previously **Rejected** tasks.
+    *   Deprioritize tasks similar to recently **Completed** tasks.
+4.  **Consolidation**: Deduplicate overlapping ideas (e.g., SEO & Content agents both suggesting the same topic).
+5.  **Final Selection**: Select top 1-3 tasks per pillar based on user goals (e.g., "Growth" mode = more Publish/Remarket tasks).
+
+---
+
+## 🚀 Implementation Phases
+
+### Phase 1: Agent Interface Standardization (The "Voice")
+**Objective**: Give every agent the ability to speak the "Task Proposal" language.
+**Status**: ✅ Completed
+
+*   **Task 1.1**: Define `TaskProposal` schema (Pydantic model). ✅
+    *   Fields: `title`, `description`, `pillar`, `priority`, `reasoning`, `estimated_time`, `action_type`.
+*   **Task 1.2**: Update `BaseALwrityAgent` with abstract `propose_daily_tasks(context: Dict) -> List[TaskProposal]`. ✅
+*   **Task 1.3**: Implement `propose_daily_tasks` in all specialized agents. ✅
+    *   *StrategyArchitect*: Logic to check pillar health.
+    *   *ContentStrategist*: Logic to check content gaps.
+    *   *SEOAgent*: Logic to check GSC alerts/errors.
+    *   *SocialAmplification*: Logic for publish/engage.
+    *   *CompetitorResponse*: Logic for monitoring.
+
+### Phase 2: The Manager (The "Orchestrator")
+**Objective**: Build the backend service that coordinates the committee.
+**Status**: ✅ Completed
+
+*   **Task 2.1**: Refactor `TodayWorkflowGenerator` in `today_workflow_service.py`. ✅
+    *   Replace single-prompt generation with `gather_agent_proposals()`.
+    *   Implement `asyncio.gather` for parallel agent execution (performance critical).
+*   **Task 2.2**: Implement `consolidate_proposals()` logic. ✅
+    *   Use a lightweight LLM call to merge/rank the raw list if needed, or deterministic logic for speed.
+*   **Task 2.3**: Connect to Frontend. ✅
+    *   Ensure the API response matches the existing `TodayTask` frontend interface.
+
+### Phase 3: Self-Learning Memory (The "Brain")
+**Objective**: Stop the system from nagging users about things they hate or just did.
+**Status**: ✅ Completed
+
+*   **Task 3.1**: Create `TaskHistory` model in DB. ✅
+    *   Store: `task_vector_id`, `original_text`, `status` (completed/rejected/skipped), `user_feedback`.
+*   **Task 3.2**: Implement `TaskMemoryService` using `txtai`. ✅
+    *   Index tasks with metadata.
+    *   Implement `is_redundant_or_rejected(proposal_text)` check.
+*   **Task 3.3**: Wire feedback loop. ✅
+    *   When user clicks "Dismiss" or "Complete" in frontend, update the `txtai` index.
+
+### Phase 4: UI Feedback & Transparency
+**Objective**: Show the user *why* a task was suggested.
+
+*   **Task 4.1**: Update Frontend `TodayTask` card.
+    *   Add "Suggested by [Agent Name]" badge.
+    *   Add "Why?" tooltip (e.g., "Because Competitor X did Y").
+*   **Task 4.2**: Add "Train my Agents" feedback.
+    *   "Don't show this again" vs "Not today".
+
+---
+
+## 📊 Data Models
+
+### 1. TaskProposal (Backend)
+```python
+class TaskProposal(BaseModel):
+    title: str
+    description: str
+    pillar_id: str  # plan, generate, publish, analyze, engage, remarket
+    priority: str   # high, medium, low
+    estimated_time: int # minutes
+    source_agent: str # e.g., "SEOOptimizationAgent"
+    reasoning: str # "Detected 404 error spike"
+    context_data: Optional[Dict] # e.g., {"url": "..."}
+```
+
+### 2. TaskMemoryDocument (txtai)
+```json
+{
+  "id": "uuid",
+  "text": "Write a blog post about AI Trends",
+  "embedding": [vector],
+  "tags": ["generate", "content_strategy"],
+  "user_id": "123",
+  "status": "rejected",
+  "last_updated": "2024-03-01T10:00:00Z"
+}
+```
+
+---
+
+## 🛠️ Technical Considerations
+
+*   **Performance**: Calling 6 agents + LLMs in parallel can be slow.
+    *   *Mitigation*: Set strict timeouts (e.g., 5s) per agent. Use "Lite" logic for proposals (e.g., check DB/Cache instead of live crawling) where possible.
+*   **Fallback**: If agents time out or fail, fall back to the `_fallback_tasks` template currently in place.
+*   **Token Usage**: Summarize context before sending to agents to minimize input tokens.
+
+---
+
+## 📅 Execution Timeline
+
+1.  **Day 1**: Phase 1 (Interfaces & 2 core agents).
+2.  **Day 2**: Phase 2 (Orchestrator wiring).
+3.  **Day 3**: Phase 3 (txtai Memory integration).
+4.  **Day 4**: Phase 1 completion (remaining agents) & Phase 4 (UI polish).

docs/SIF/TODAYS_TASKS_WORKFLOW_DOCS.md

@@ -0,0 +1,109 @@
+# Multi-Agent Today's Tasks Workflow
+
+**Last Updated**: 2025-03-01
+**Component**: Today's Workflow Service
+
+---
+
+## 📅 Overview
+
+The **Today's Tasks Workflow** is an automated, intelligent system that generates a personalized daily to-do list for the user. Unlike static templates or generic AI prompts, this system uses a **Multi-Agent Committee** to analyze real-time data and propose high-value actions.
+
+## 🏗️ Architecture: The "Committee" Model
+
+The workflow follows a **Manager-Worker** pattern where the `TodayWorkflowGenerator` acts as the Orchestrator.
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Orchestrator
+    participant Agents (Committee)
+    participant Memory (SIF)
+    
+    User->>Orchestrator: Loads Dashboard
+    Orchestrator->>Orchestrator: Checks for existing plan
+    alt No Plan for Today
+        Orchestrator->>Agents: "Propose tasks for [User Context]"
+        par Parallel Execution
+            Agents->>Agents: Analyze GSC, Trends, Gaps
+        end
+        Agents-->>Orchestrator: [Task Proposals]
+        Orchestrator->>Memory: Filter Redundant/Rejected?
+        Memory-->>Orchestrator: Filtered List
+        Orchestrator->>Orchestrator: Consolidate & Prioritize
+        Orchestrator->>User: Daily Plan
+    else Plan Exists
+        Orchestrator->>User: Existing Plan
+    end
+```
+
+---
+
+## 🧠 The Intelligence Layer
+
+### 1. Proposal Phase (The "Workers")
+Each agent submits proposals based on its domain:
+
+| Agent | Data Source | Sample Proposal |
+| :--- | :--- | :--- |
+| **Strategy Architect** | Content Pillars | "Review 'AI Trends' pillar - performance dropped 10%." |
+| **Content Strategist** | Competitor Content | "Draft post on 'Vector Search' (Competitor Gap)." |
+| **SEO Specialist** | Search Console | "Fix 404 error on /pricing page." |
+| **Social Manager** | Engagement Metrics | "Reply to 3 comments on LinkedIn post." |
+| **Competitor Analyst** | Market Signals | "Competitor X launched feature Y. Monitor impact." |
+
+### 2. Orchestration Phase (The "Manager")
+The `TodayWorkflowGenerator`:
+1.  **Gathers**: Collects all proposals via `asyncio.gather`.
+2.  **Deduplicates**: Merges similar tasks (e.g., if SEO and Content agents both suggest the same blog update).
+3.  **Formats**: Converts raw proposals into the frontend-ready `TodayTask` schema.
+
+### 3. Self-Learning Phase (The "Brain")
+The system uses `TaskMemoryService` and `txtai` to improve over time.
+-   **Rejected Tasks**: If a user dismisses a task, it is indexed as "negative feedback." The system semantically checks future proposals against this index to avoid nagging.
+-   **Completed Tasks**: Completed tasks are recorded to prevent suggesting the same non-recurring task too soon.
+
+---
+
+## 🛠️ Data Models
+
+### TaskProposal (Internal)
+```python
+@dataclass
+class TaskProposal:
+    title: str
+    description: str
+    pillar_id: str          # plan, generate, publish, analyze, engage, remarket
+    priority: str           # high, medium, low
+    estimated_time: int     # minutes
+    source_agent: str       # e.g., "SEOOptimizationAgent"
+    reasoning: str          # "Detected 404 error spike"
+    context_data: Dict      # Payload for the action button
+```
+
+### TaskHistory (Database)
+Tracks the lifecycle for learning:
+-   `task_hash`: SHA-256 of title+desc for fast deduplication.
+-   `status`: completed / dismissed.
+-   `feedback`: User provided notes.
+-   `vector_id`: Link to the semantic index entry.
+
+---
+
+## 🎨 UI Experience
+
+1.  **The Card**: Each task appears as a card in the "Today's Workflow" modal.
+2.  **Transparency**: 
+    -   **Badge**: "Suggested by [Agent Name]"
+    -   **Tooltip**: "Why? [Reasoning]" (e.g., "Because traffic dropped 15%").
+3.  **Feedback**:
+    -   **Complete**: Triggers positive reinforcement learning.
+    -   **Dismiss**: Triggers negative reinforcement learning.
+
+---
+
+## 🔄 Lifecycle & Triggers
+
+-   **Daily Reset**: The plan is generated once per day (UTC).
+-   **Persistence**: Tasks remain "in progress" until marked done or the day ends.
+-   **On-Demand**: Users can manually trigger a regeneration if the day's plan is empty or irrelevant.

frontend/src/components/MainDashboard/MainDashboard.tsx

@@ -21,6 +21,7 @@ import AnalyticsInsights from './components/AnalyticsInsights';
 import ToolsModal from './components/ToolsModal';
 import EnhancedBillingDashboard from '../billing/EnhancedBillingDashboard';
 import CompactSidebar from './components/CompactSidebar';
+import TeamHuddleWidget from './components/TeamHuddleWidget';
 
 // Shared types and utilities
 import { Tool } from '../shared/types';
@@ -346,7 +347,10 @@ const MainDashboard: React.FC = () => {
               </Box>
 
               {/* Area 3: Analytics and Billing */}
-              <Box sx={{ flex: 1, minWidth: 0 }}>
+              <Box sx={{ flex: 1, minWidth: 0, display: 'flex', flexDirection: 'column', gap: 3 }}>
+                {/* Team Huddle Widget - New Addition */}
+                <TeamHuddleWidget />
+
                 {/* Analytics Insights - Good/Bad/Ugly */}
                 <AnalyticsInsights />
 

frontend/src/components/MainDashboard/components/EnhancedTodayModal.tsx

@@ -22,7 +22,9 @@ import {
   CheckCircle as CheckIcon,
   PlayArrow as PlayIcon,
   SkipNext as SkipIcon,
-  NavigateNext
+  NavigateNext,
+  Psychology as AgentIcon,
+  Lightbulb as ReasonIcon
 } from '@mui/icons-material';
 import { useNavigate } from 'react-router-dom';
 import { useWorkflowStore } from '../../../stores/workflowStore';
@@ -351,6 +353,35 @@ const EnhancedTodayModal: React.FC<EnhancedTodayModalProps> = ({
                           </Typography>
                         </Box>
                       </Box>
+                      
+                      {/* Agent Reasoning Section */}
+                      {task.metadata?.source_agent && (
+                        <Box sx={{ 
+                          mt: 1.5, 
+                          mb: 1.5,
+                          p: 1.5, 
+                          bgcolor: '#f8f9fa', 
+                          borderRadius: 2,
+                          border: '1px solid #e0e0e0',
+                          display: 'flex',
+                          alignItems: 'flex-start',
+                          gap: 1.5
+                        }}>
+                          <AgentIcon sx={{ fontSize: 16, color: pillarColor, mt: 0.3 }} />
+                          <Box>
+                            <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+                              <Typography variant="caption" sx={{ fontWeight: 700, color: '#444' }}>
+                                Suggested by {task.metadata.source_agent.replace('Agent', '')}
+                              </Typography>
+                            </Box>
+                            {task.metadata.reasoning && (
+                              <Typography variant="caption" sx={{ color: '#666', display: 'block', lineHeight: 1.4 }}>
+                                "{task.metadata.reasoning}"
+                              </Typography>
+                            )}
+                          </Box>
+                        </Box>
+                      )}
 
                       {/* Task Actions */}
                       <Box sx={{ display: 'flex', gap: 1.25, mt: 2 }}>

frontend/src/components/MainDashboard/components/TeamHuddleWidget.tsx

@@ -0,0 +1,206 @@
+import React from 'react';
+import {
+  Box,
+  Paper,
+  Typography,
+  Avatar,
+  AvatarGroup,
+  Chip,
+  List,
+  ListItem,
+  ListItemAvatar,
+  ListItemText,
+  Divider,
+  IconButton,
+  Tooltip
+} from '@mui/material';
+import {
+  Psychology as StrategyIcon,
+  Article as ContentIcon,
+  Search as SeoIcon,
+  Campaign as SocialIcon,
+  CompareArrows as CompetitorIcon,
+  Refresh as RefreshIcon,
+  MoreVert as MoreVertIcon
+} from '@mui/icons-material';
+
+interface AgentStatus {
+  id: string;
+  name: string;
+  role: string;
+  status: 'active' | 'thinking' | 'idle' | 'offline';
+  current_activity: string;
+  icon: React.ElementType;
+  color: string;
+}
+
+// Mock data - In real implementation, this would come from a backend endpoint
+// /api/agents/status or similar
+const AGENT_TEAM: AgentStatus[] = [
+  {
+    id: 'strategy_architect',
+    name: 'Strategy Architect',
+    role: 'Team Lead',
+    status: 'active',
+    current_activity: 'Analyzing content pillar performance',
+    icon: StrategyIcon,
+    color: '#6366f1' // Indigo
+  },
+  {
+    id: 'content_strategist',
+    name: 'Content Strategist',
+    role: 'Creative',
+    status: 'thinking',
+    current_activity: 'Identifying semantic gaps in "AI Tools"',
+    icon: ContentIcon,
+    color: '#10b981' // Emerald
+  },
+  {
+    id: 'seo_specialist',
+    name: 'SEO Specialist',
+    role: 'Technical',
+    status: 'idle',
+    current_activity: 'Monitoring SERP rankings',
+    icon: SeoIcon,
+    color: '#f59e0b' // Amber
+  },
+  {
+    id: 'social_manager',
+    name: 'Social Manager',
+    role: 'Engagement',
+    status: 'idle',
+    current_activity: 'Waiting for new content to schedule',
+    icon: SocialIcon,
+    color: '#ec4899' // Pink
+  },
+   {
+    id: 'competitor_analyst',
+    name: 'Competitor Analyst',
+    role: 'Intelligence',
+    status: 'active',
+    current_activity: 'Scanning competitor X for new posts',
+    icon: CompetitorIcon,
+    color: '#ef4444' // Red
+  }
+];
+
+const TeamHuddleWidget: React.FC = () => {
+  return (
+    <Paper
+      elevation={0}
+      sx={{
+        p: 2,
+        borderRadius: 3,
+        border: '1px solid',
+        borderColor: 'divider',
+        height: '100%',
+        background: 'linear-gradient(180deg, #ffffff 0%, #f8fafc 100%)'
+      }}
+    >
+      <Box display="flex" justifyContent="space-between" alignItems="center" mb={2}>
+        <Box display="flex" alignItems="center" gap={1}>
+          <Typography variant="h6" fontWeight={700} color="text.primary">
+            Team Huddle
+          </Typography>
+          <Chip 
+            label="Live" 
+            size="small" 
+            color="success" 
+            sx={{ height: 20, fontSize: '0.65rem', fontWeight: 700 }} 
+          />
+        </Box>
+        <Box>
+           <Tooltip title="Refresh Team Status">
+            <IconButton size="small">
+              <RefreshIcon fontSize="small" />
+            </IconButton>
+          </Tooltip>
+        </Box>
+      </Box>
+
+      <List disablePadding>
+        {AGENT_TEAM.map((agent, index) => (
+          <React.Fragment key={agent.id}>
+            {index > 0 && <Divider variant="inset" component="li" sx={{ my: 1, ml: 7 }} />}
+            <ListItem 
+              alignItems="flex-start" 
+              disableGutters 
+              sx={{ py: 0.5 }}
+              secondaryAction={
+                 <Tooltip title={agent.status}>
+                    <Box
+                      sx={{
+                        width: 8,
+                        height: 8,
+                        borderRadius: '50%',
+                        bgcolor: 
+                          agent.status === 'active' ? '#22c55e' : 
+                          agent.status === 'thinking' ? '#3b82f6' : 
+                          '#94a3b8',
+                        boxShadow: agent.status === 'active' ? '0 0 0 2px rgba(34, 197, 94, 0.2)' : 'none',
+                        animation: agent.status === 'thinking' ? 'pulse 1.5s infinite' : 'none',
+                        '@keyframes pulse': {
+                          '0%': { opacity: 1, transform: 'scale(1)' },
+                          '50%': { opacity: 0.6, transform: 'scale(1.2)' },
+                          '100%': { opacity: 1, transform: 'scale(1)' }
+                        }
+                      }}
+                    />
+                 </Tooltip>
+              }
+            >
+              <ListItemAvatar>
+                <Avatar 
+                  sx={{ 
+                    bgcolor: `${agent.color}15`, 
+                    color: agent.color,
+                    width: 40,
+                    height: 40
+                  }}
+                >
+                  <agent.icon fontSize="small" />
+                </Avatar>
+              </ListItemAvatar>
+              <ListItemText
+                primary={
+                  <Box display="flex" alignItems="center" gap={1}>
+                    <Typography variant="subtitle2" fontWeight={600}>
+                      {agent.name}
+                    </Typography>
+                    <Typography variant="caption" color="text.secondary" sx={{ fontSize: '0.65rem', border: '1px solid #e2e8f0', px: 0.5, borderRadius: 1 }}>
+                      {agent.role}
+                    </Typography>
+                  </Box>
+                }
+                secondary={
+                  <Typography
+                    variant="body2"
+                    color="text.secondary"
+                    sx={{
+                      display: '-webkit-box',
+                      WebkitLineClamp: 1,
+                      WebkitBoxOrient: 'vertical',
+                      overflow: 'hidden',
+                      fontSize: '0.75rem',
+                      mt: 0.25
+                    }}
+                  >
+                    {agent.current_activity}
+                  </Typography>
+                }
+              />
+            </ListItem>
+          </React.Fragment>
+        ))}
+      </List>
+      
+      <Box mt={2} pt={2} borderTop="1px solid #eee" display="flex" justifyContent="center">
+        <Typography variant="caption" color="primary" sx={{ fontWeight: 600, cursor: 'pointer', '&:hover': { textDecoration: 'underline' } }}>
+          View Full Team Activity
+        </Typography>
+      </Box>
+    </Paper>
+  );
+};
+
+export default TeamHuddleWidget;

frontend/src/components/SEODashboard/components/SemanticInsights.tsx

@@ -33,7 +33,8 @@ import {
   Info as InfoIcon,
   CheckCircle as CheckCircleIcon,
   PriorityHigh as PriorityHighIcon,
-  Stars as StarsIcon
+  Stars as StarsIcon,
+  Face as AgentIcon
 } from '@mui/icons-material';
 
 // TypeScript interfaces for semantic insights
@@ -45,6 +46,7 @@ export interface ContentPillar {
   key_topics: string[];
   competitor_coverage: number;
   user_coverage: number;
+  source_agent?: string; // Added for agent attribution
 }
 
 export interface SemanticGap {
@@ -53,6 +55,7 @@ export interface SemanticGap {
   competitor_count: number;
   opportunity_score: number;
   suggested_content_ideas: string[];
+  source_agent?: string; // Added for agent attribution
 }
 
 export interface ThemeAnalysis {
@@ -271,6 +274,15 @@ const ContentPillarsSection: React.FC<{ pillars: ContentPillar[] }> = ({ pillars
                     Competitor Coverage: {Math.round(pillar.competitor_coverage * 100)}%
                   </Typography>
                 </Box>
+                
+                {pillar.source_agent && (
+                  <Box mt={2} pt={1} borderTop="1px solid #eee" display="flex" alignItems="center" gap={1}>
+                    <AgentIcon fontSize="small" color="action" sx={{ width: 16, height: 16 }} />
+                    <Typography variant="caption" color="text.secondary" sx={{ fontStyle: 'italic' }}>
+                      Identified by {pillar.source_agent}
+                    </Typography>
+                  </Box>
+                )}
               </CardContent>
             </Card>
           </Grid>
@@ -336,10 +348,19 @@ const SemanticGapsSection: React.FC<{ gaps: SemanticGap[] }> = ({ gaps }) => {
               </Box>
             )}
 
-            <Box mt={2}>
+            <Box mt={2} display="flex" justifyContent="space-between" alignItems="center">
               <Typography variant="caption" color="text.secondary">
                 Opportunity Score: {Math.round(gap.opportunity_score * 100)}%
               </Typography>
+              
+              {gap.source_agent && (
+                <Box display="flex" alignItems="center" gap={1}>
+                  <AgentIcon fontSize="small" color="action" sx={{ width: 16, height: 16 }} />
+                  <Typography variant="caption" color="text.secondary" sx={{ fontStyle: 'italic' }}>
+                    Spotted by {gap.source_agent}
+                  </Typography>
+                </Box>
+              )}
             </Box>
           </AccordionDetails>
         </Accordion>

frontend/src/components/shared/UsageDashboard.tsx

@@ -9,7 +9,11 @@ import {
   IconButton,
   Menu,
   MenuItem,
-  LinearProgress
+  LinearProgress,
+  Select,
+  FormControl,
+  InputLabel,
+  SelectChangeEvent
 } from '@mui/material';
 import {
   TrendingUp,
@@ -17,7 +21,8 @@ import {
   CheckCircle,
   Refresh,
   MoreVert,
-  Dashboard
+  Dashboard,
+  CalendarMonth
 } from '@mui/icons-material';
 import { useUser } from '@clerk/clerk-react';
 import { apiClient } from '../../api/client';
@@ -34,6 +39,7 @@ interface UsageStats {
     tokens: number;
     cost: number;
   }>;
+  billing_period?: string;
 }
 
 interface UsageLimits {
@@ -65,6 +71,7 @@ interface DashboardData {
     usage_status: string;
     unread_alerts: number;
   };
+  trends?: { periods: string[] };
 }
 
 interface UsageDashboardProps {
@@ -82,6 +89,8 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
   const [error, setError] = useState<string | null>(null);
   const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
   const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
+  const [selectedPeriod, setSelectedPeriod] = useState<string>('');
+  const [availablePeriods, setAvailablePeriods] = useState<string[]>([]);
 
   const { user } = useUser();
   const userId = localStorage.getItem('user_id') || user?.id;
@@ -93,42 +102,57 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
     checkInterval: 120000, // Check every 2 minutes
   });
 
-  const fetchUsageData = useCallback(async () => {
+  const fetchUsageData = useCallback(async (period?: string) => {
     if (!userId) return;
     
     setLoading(true);
     setError(null);
-    
     try {
-      const response = await apiClient.get(`/api/subscription/dashboard/${userId}`);
+      const url = period 
-      setDashboardData(response.data.data);
+        ? `/api/subscription/dashboard/${userId}?billing_period=${period}`
-      setLastUpdated(new Date());
+        : `/api/subscription/dashboard/${userId}`;
-    } catch (err) {
+        
+      const response = await apiClient.get<any>(url);
+      
+      if (response.data && response.data.success) {
+        setDashboardData(response.data.data);
+        setLastUpdated(new Date());
+        
+        // Extract available periods from trends if not set
+        if (!period && response.data.data.trends?.periods) {
+          setAvailablePeriods(response.data.data.trends.periods);
+          // Set current period if not selected
+          if (!selectedPeriod) {
+            const current = new Date().toISOString().slice(0, 7); // YYYY-MM
+            setSelectedPeriod(current);
+          }
+        }
+      } else {
+        throw new Error(response.data?.error || 'Failed to fetch usage data');
+      }
+    } catch (err: any) {
       console.error('Error fetching usage data:', err);
-      setError('Failed to load usage data');
+      setError(err.message || 'Failed to load usage statistics');
     } finally {
       setLoading(false);
     }
   }, [userId]);
 
+  const handlePeriodChange = (event: SelectChangeEvent) => {
+    const period = event.target.value;
+    setSelectedPeriod(period);
+    fetchUsageData(period);
+  };
+
   useEffect(() => {
-    fetchUsageData();
+    // Initial fetch
-
+    if (userId) {
-    // Listen for custom event to refresh usage data
-    const handleUsageRefresh = () => {
-      console.log('UsageDashboard: Refreshing usage data due to event');
       fetchUsageData();
-    };
+    }
-
+  }, [userId, fetchUsageData]); // Added fetchUsageData to deps since it's memoized
-    window.addEventListener('alwrity:refresh-usage', handleUsageRefresh);
-
-    return () => {
-      window.removeEventListener('alwrity:refresh-usage', handleUsageRefresh);
-    };
-  }, [fetchUsageData, userId]);
 
   const handleRefresh = () => {
-    fetchUsageData();
+    fetchUsageData(selectedPeriod);
   };
 
   const handleMenuOpen = (event: React.MouseEvent<HTMLElement>) => {
@@ -141,111 +165,125 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
 
   const handleViewFullDashboard = () => {
     handleMenuClose();
-    window.open('/billing', '_blank');
+    window.location.href = '/dashboard';
   };
 
-  const getUsageColor = (used: number, limit: number) => {
+  const getUsageColor = (current: number, max: number) => {
-    const percentage = (used / limit) * 100;
+    if (max === 0) return '#757575';
-    if (percentage >= 90) return '#f44336'; // Red
+    const percentage = (current / max) * 100;
-    if (percentage >= 75) return '#ff9800'; // Orange
+    if (percentage >= 100) return '#d32f2f'; // error
-    if (percentage >= 50) return '#ffeb3b'; // Yellow
+    if (percentage >= 80) return '#ed6c02'; // warning
-    return '#4caf50'; // Green
+    return '#2e7d32'; // success
-  };
-
-  const getUsageStatusIcon = (status: string) => {
-    switch (status) {
-      case 'active': return <CheckCircle sx={{ fontSize: 16, color: '#4caf50' }} />;
-      case 'warning': return <Warning sx={{ fontSize: 16, color: '#ff9800' }} />;
-      case 'limit_exceeded': return <Warning sx={{ fontSize: 16, color: '#f44336' }} />;
-      default: return <CheckCircle sx={{ fontSize: 16, color: '#4caf50' }} />;
-    }
   };
 
   const getProviderDisplayName = (provider: string) => {
-    const names: Record<string, string> = {
+    // Map internal provider names to display names
-      'gemini': 'Gemini',
+    const displayNames: Record<string, string> = {
-      'openai': 'OpenAI',
+      'gemini': 'Google Gemini',
-      'anthropic': 'Claude',
+      'openai': 'OpenAI GPT-4',
-      'mistral': 'Mistral',
+      'anthropic': 'Anthropic Claude',
-      'tavily': 'Tavily',
+      'mistral': 'HuggingFace (Mistral)',
-      'serper': 'Serper',
+      'tavily': 'Tavily Search',
-      'metaphor': 'Metaphor',
+      'serper': 'Serper Google',
+      'metaphor': 'Exa Search', // Metaphor is now Exa
+      'exa': 'Exa Search',
       'firecrawl': 'Firecrawl',
-      'stability': 'Stability',
+      'stability': 'Stability AI',
+      'video': 'Video Gen',
+      'audio': 'Audio Gen',
+      'image_edit': 'Image Edit',
       'wavespeed': 'WaveSpeed'
     };
-    return names[provider] || provider;
+    return displayNames[provider] || provider.charAt(0).toUpperCase() + provider.slice(1);
   };
 
-  if (!dashboardData) {
+  if (!dashboardData && loading) {
-    if (loading) {
+    return (
-      return (
+      <Box sx={{ display: 'flex', justifyContent: 'center', p: 2 }}>
-        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+        <CircularProgress size={24} />
-          <CircularProgress size={16} />
+      </Box>
-          <Typography variant="caption" color="text.secondary">
+    );
-            Loading usage...
-          </Typography>
-        </Box>
-      );
-    }
-    
-    if (error) {
-      return (
-        <Alert severity="error" sx={{ py: 0.5 }}>
-          <Typography variant="caption">{error}</Typography>
-        </Alert>
-      );
-    }
-    
-    // If no data and not loading/error, try to fetch again or show placeholder
-    if (userId && !dashboardData) {
-       // Optional: could auto-trigger another fetch here if needed, but useEffect handles it
-       return <Box />;
-    }
-    
-    return <Box />;
   }
 
+  if (error && !dashboardData) {
+    return (
+      <Alert severity="error" sx={{ mb: 2 }}>
+        {error}
+        <IconButton size="small" onClick={() => fetchUsageData(selectedPeriod)}>
+          <Refresh fontSize="small" />
+        </IconButton>
+      </Alert>
+    );
+  }
+
+  if (!dashboardData) return null;
+
+  const currentUsage = dashboardData.current_usage;
+  const limits = dashboardData.limits;
+
   if (compact) {
     // Compact view - show key metrics as chips
     // Use current_usage for accurate cost (properly coerced from provider breakdown)
     // Fallback to summary if current_usage is not available
-    const totalCalls = dashboardData.current_usage?.total_calls ?? dashboardData.summary.total_api_calls_this_month;
+    const usageData = dashboardData?.current_usage || {
-    const totalCost = dashboardData.current_usage?.total_cost ?? dashboardData.summary.total_cost_this_month ?? 0;
+        total_calls: dashboardData?.summary?.total_api_calls_this_month || 0,
-    const monthlyLimit = dashboardData.limits.limits.monthly_cost;
+        total_cost: dashboardData?.summary?.total_cost_this_month || 0,
+        usage_status: dashboardData?.summary?.usage_status || 'active',
+        provider_breakdown: {}
+    };
+    
+    const totalCalls = usageData.total_calls;
+    const totalCost = usageData.total_cost;
+    const monthlyLimit = dashboardData?.limits?.limits?.monthly_cost || 0;
     const usagePercentage = monthlyLimit > 0 ? (totalCost / monthlyLimit) * 100 : 0;
 
     return (
-      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+      <Box sx={{ width: '100%' }}>
-        {/* Priority 2 Alerts - Shows cost trends, OSS recommendations, spending velocity */}
+        {/* Priority 2 Alert Banner (Usage limits) */}
         {priority2Alerts.length > 0 && (
-          <Box sx={{ mb: 0.5 }}>
+          <Box sx={{ mb: 1 }}>
-            <Priority2AlertBanner
+            <Priority2AlertBanner 
-              alerts={priority2Alerts}
+              alerts={[priority2Alerts[0]]} 
-              onDismiss={dismissPriority2Alert}
+              onDismiss={() => dismissPriority2Alert(priority2Alerts[0].id)} 
-              maxAlerts={1} // Show only 1 alert in compact view
             />
           </Box>
         )}
         
-        {/* Usage Statistics */}
+        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, flexWrap: 'wrap' }}>
-        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+        
-          {/* Total API Calls */}
+        {/* Month Selector for Compact View */}
-        <Tooltip title={`${totalCalls.toLocaleString()} API calls this month`}>
+        {availablePeriods.length > 1 && (
+          <FormControl variant="standard" size="small" sx={{ minWidth: 100, mr: 1 }}>
+            <Select
+              value={selectedPeriod}
+              onChange={handlePeriodChange}
+              disableUnderline
+              sx={{ 
+                fontSize: '0.875rem', 
+                fontWeight: 500,
+                color: 'text.secondary',
+                '& .MuiSelect-select': { py: 0.5 }
+              }}
+              IconComponent={() => <CalendarMonth sx={{ fontSize: 16, color: 'action.active', ml: 0.5 }} />}
+            >
+              {availablePeriods.map((period) => (
+                <MenuItem key={period} value={period} dense>
+                  {period}
+                </MenuItem>
+              ))}
+            </Select>
+          </FormControl>
+        )}
+
+        {/* Status Chip */}
+        <Tooltip title={`Status: ${usageData.usage_status}`}>
           <Chip
-            icon={getUsageStatusIcon(dashboardData.summary.usage_status)}
+            icon={usageData.usage_status === 'active' ? <CheckCircle sx={{ fontSize: 14 }} /> : <Warning sx={{ fontSize: 14 }} />}
-            label={`${totalCalls.toLocaleString()}`}
+            label={usageData.usage_status === 'limit_reached' ? 'Limit Reached' : 'Active'}
             size="small"
+            color={usageData.usage_status === 'limit_reached' ? 'error' : usageData.usage_status === 'warning' ? 'warning' : 'success'}
             variant="outlined"
-            sx={{
+            sx={{ fontWeight: 600 }}
-              bgcolor: 'rgba(33, 150, 243, 0.1)',
-              borderColor: '#2196f3',
-              color: '#1976d2',
-              fontWeight: 600,
-              '& .MuiChip-icon': {
-                color: '#2196f3'
-              }
-            }}
           />
         </Tooltip>
 
@@ -347,11 +385,38 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
   }
 
   // Full dashboard view (for dedicated usage page)
+  const usageData = dashboardData?.current_usage || {
+    total_calls: dashboardData?.summary?.total_api_calls_this_month || 0,
+    total_cost: dashboardData?.summary?.total_cost_this_month || 0,
+    provider_breakdown: {}
+  };
+  
   return (
     <Box sx={{ p: 2 }}>
-      <Typography variant="h6" gutterBottom>
+      <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2 }}>
-        Usage Dashboard
+        <Typography variant="h6">
-      </Typography>
+          Usage Dashboard
+        </Typography>
+        
+        {/* Month Selector for Full View */}
+        {availablePeriods.length > 1 && (
+          <FormControl variant="outlined" size="small" sx={{ minWidth: 150 }}>
+            <InputLabel>Billing Period</InputLabel>
+            <Select
+              value={selectedPeriod}
+              onChange={handlePeriodChange}
+              label="Billing Period"
+              startAdornment={<CalendarMonth sx={{ fontSize: 18, mr: 1, color: 'action.active' }} />}
+            >
+              {availablePeriods.map((period) => (
+                <MenuItem key={period} value={period}>
+                  {period}
+                </MenuItem>
+              ))}
+            </Select>
+          </FormControl>
+        )}
+      </Box>
       
       <Box sx={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(250px, 1fr))', gap: 2 }}>
         {/* Total Calls */}
@@ -360,7 +425,7 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
             Total API Calls
           </Typography>
           <Typography variant="h4" color="primary">
-            {(dashboardData.current_usage?.total_calls ?? dashboardData.summary.total_api_calls_this_month).toLocaleString()}
+            {usageData.total_calls.toLocaleString()}
           </Typography>
         </Box>
 
@@ -370,10 +435,10 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
             Monthly Cost
           </Typography>
           <Typography variant="h4" color="secondary">
-            ${(dashboardData.current_usage?.total_cost ?? dashboardData.summary.total_cost_this_month ?? 0).toFixed(2)}
+            ${usageData.total_cost.toFixed(2)}
           </Typography>
           <Typography variant="caption" color="text.secondary">
-            of ${dashboardData.limits.limits.monthly_cost} limit
+            of ${dashboardData?.limits?.limits?.monthly_cost || 0} limit
           </Typography>
         </Box>
 
@@ -382,16 +447,21 @@ const UsageDashboard: React.FC<UsageDashboardProps> = ({
           <Typography variant="subtitle2" color="text.secondary" gutterBottom>
             Usage by Provider
           </Typography>
-          {Object.entries(dashboardData.current_usage.provider_breakdown).map(([provider, stats]) => (
+          {Object.entries(usageData.provider_breakdown || {}).map(([provider, stats]) => (
             <Box key={provider} sx={{ display: 'flex', justifyContent: 'space-between', mb: 1 }}>
               <Typography variant="body2">
                 {getProviderDisplayName(provider)}
               </Typography>
               <Typography variant="body2" fontWeight={600}>
-                {stats.calls.toLocaleString()}
+                {(stats as any).calls?.toLocaleString() || 0}
               </Typography>
             </Box>
           ))}
+          {Object.keys(usageData.provider_breakdown || {}).length === 0 && (
+            <Typography variant="body2" color="text.secondary" fontStyle="italic">
+              No usage this period
+            </Typography>
+          )}
         </Box>
       </Box>
     </Box>

frontend/src/types/workflow.ts

@@ -19,7 +19,12 @@ export interface TodayTask {
   actionType: ActionType;
   completedAt?: Date;
   startedAt?: Date;
-  metadata?: Record<string, any>;
+  metadata?: {
+    source_agent?: string;
+    reasoning?: string;
+    context_data?: any;
+    [key: string]: any;
+  };
   icon?: string | React.ComponentType<any>; // icon name or component reference
   color?: string;
   enabled: boolean;