Full ATOM backend sync from D:/Annator/ATOM/atom/backend + HF slim runtime (part 3)

DEPLOY_STAMP.txt

@@ -0,0 +1 @@
+2026-07-30T05:50:20Z backend sync prepared

backend/workers/activity_state_worker.py

@@ -0,0 +1,165 @@
+"""
+Activity State Worker
+
+Background worker that processes user activity state transitions.
+Runs every 60 seconds to check for inactive users and update their states.
+
+State Transitions:
+- online → away after 5 minutes of inactivity
+- away → offline after 15 minutes of inactivity
+- offline → online on activity resumption
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+
+from core.database import get_db
+from core.user_activity_service import UserActivityService
+
+logger = logging.getLogger(__name__)
+
+
+class ActivityStateWorker:
+    """
+    Background worker for processing user activity state transitions.
+
+    Runs every 60 seconds to:
+    1. Check user state transitions based on inactivity
+    2. Process manual override expiry
+    3. Clean up stale sessions
+    4. Emit state change events (optional, for WebSocket notifications)
+
+    Performance target: <1s per batch of 100 users
+    """
+
+    def __init__(self, interval_seconds: int = 60):
+        self.interval_seconds = interval_seconds
+        self.running = False
+
+    async def run(self):
+        """Main worker loop."""
+        self.running = True
+        logger.info("ActivityStateWorker started")
+
+        while self.running:
+            try:
+                start_time = datetime.now()
+
+                # Process state transitions
+                await self.process_state_transitions()
+
+                # Process manual override expiry
+                await self.process_manual_override_expiry()
+
+                # Cleanup stale sessions
+                await self.cleanup_stale_sessions()
+
+                elapsed = (datetime.now() - start_time).total_seconds()
+                logger.info(
+                    f"ActivityStateWorker cycle completed in {elapsed:.2f}s"
+                )
+
+            except Exception as e:
+                logger.error(f"ActivityStateWorker error: {e}", exc_info=True)
+
+            # Wait for next cycle
+            await asyncio.sleep(self.interval_seconds)
+
+    async def stop(self):
+        """Stop the worker."""
+        self.running = False
+        logger.info("ActivityStateWorker stopped")
+
+    async def process_state_transitions(self):
+        """Process state transitions for inactive users."""
+        db = next(get_db())
+
+        try:
+            service = UserActivityService(db)
+            transitions = await service.transition_state_batch(limit=100)
+
+            if transitions["total_processed"] > 0:
+                transition_summary = ", ".join([
+                    f"{k}: {v}"
+                    for k, v in transitions.items()
+                    if k != "total_processed" and v > 0
+                ])
+                logger.info(
+                    f"State transitions: {transitions['total_processed']} processed"
+                    + (f" ({transition_summary})" if transition_summary else "")
+                )
+
+        finally:
+            db.close()
+
+    async def process_manual_override_expiry(self):
+        """Process manual overrides that have expired."""
+        from core.models import UserActivity
+        from sqlalchemy.orm import Session
+
+        db: Session = next(get_db())
+
+        try:
+            # Find expired manual overrides
+            now = datetime.utcnow()
+            expired = db.query(UserActivity).filter(
+                UserActivity.manual_override == True,
+                UserActivity.manual_override_expires_at.isnot(None),
+                UserActivity.manual_override_expires_at < now
+            ).all()
+
+            count = 0
+            for activity in expired:
+                # Clear manual override
+                activity.manual_override = False
+                activity.manual_override_expires_at = None
+
+                # Recalculate state based on actual activity
+                service = UserActivityService(db)
+                await service._recalculate_activity_state(activity)
+
+                count += 1
+                logger.info(
+                    f"Cleared expired manual override for user {activity.user_id}"
+                )
+
+            if count > 0:
+                db.commit()
+                logger.info(f"Cleared {count} expired manual overrides")
+
+        finally:
+            db.close()
+
+    async def cleanup_stale_sessions(self):
+        """Clean up stale sessions (no heartbeat for >1 hour)."""
+        db = next(get_db())
+
+        try:
+            service = UserActivityService(db)
+            count = await service.cleanup_stale_sessions(limit=50)
+
+            if count > 0:
+                logger.info(f"Cleaned up {count} stale sessions")
+
+        finally:
+            db.close()
+
+
+# ============================================================================
+# Worker Entry Point
+# ============================================================================
+
+async def main():
+    """Entry point for running the worker."""
+    worker = ActivityStateWorker(interval_seconds=60)
+
+    try:
+        await worker.run()
+    except KeyboardInterrupt:
+        logger.info("Received keyboard interrupt")
+        await worker.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

backend/workers/queue_processing_worker.py

@@ -0,0 +1,113 @@
+"""
+Queue Processing Worker
+
+Background worker that processes supervised execution queue.
+Runs every 60 seconds to check for available users and process their queues.
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+
+from core.database import get_db
+from core.supervised_queue_service import SupervisedQueueService
+
+logger = logging.getLogger(__name__)
+
+
+class QueueProcessingWorker:
+    """
+    Background worker for processing supervised execution queue.
+
+    Runs every 60 seconds to:
+    1. Find users who recently became online/away
+    2. Fetch their pending queues (batch of 10)
+    3. Execute queued entries with supervision
+    4. Handle expired queues (>24 hours)
+
+    Performance target: <5s per batch of 10 entries
+    """
+
+    def __init__(self, interval_seconds: int = 60):
+        self.interval_seconds = interval_seconds
+        self.running = False
+
+    async def run(self):
+        """Main worker loop."""
+        self.running = True
+        logger.info("QueueProcessingWorker started")
+
+        while self.running:
+            try:
+                start_time = datetime.now()
+
+                # Process pending queues
+                await self.process_pending_queues()
+
+                # Mark expired queues
+                await self.mark_expired_queues()
+
+                elapsed = (datetime.now() - start_time).total_seconds()
+                logger.info(
+                    f"QueueProcessingWorker cycle completed in {elapsed:.2f}s"
+                )
+
+            except Exception as e:
+                logger.error(f"QueueProcessingWorker error: {e}", exc_info=True)
+
+            # Wait for next cycle
+            await asyncio.sleep(self.interval_seconds)
+
+    async def stop(self):
+        """Stop the worker."""
+        self.running = False
+        logger.info("QueueProcessingWorker stopped")
+
+    async def process_pending_queues(self):
+        """Process pending queue entries for available users."""
+        db = next(get_db())
+
+        try:
+            service = SupervisedQueueService(db)
+            processed = await service.process_pending_queues(limit=10)
+
+            if processed:
+                logger.info(
+                    f"Processed {len(processed)} supervised queue entries"
+                )
+
+        finally:
+            db.close()
+
+    async def mark_expired_queues(self):
+        """Mark expired queue entries as failed."""
+        db = next(get_db())
+
+        try:
+            service = SupervisedQueueService(db)
+            count = await service.mark_expired_queues()
+
+            if count > 0:
+                logger.info(f"Marked {count} expired queues as failed")
+
+        finally:
+            db.close()
+
+
+# ============================================================================
+# Worker Entry Point
+# ============================================================================
+
+async def main():
+    """Entry point for running the worker."""
+    worker = QueueProcessingWorker(interval_seconds=60)
+
+    try:
+        await worker.run()
+    except KeyboardInterrupt:
+        logger.info("Received keyboard interrupt")
+        await worker.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

backend/workers/reindex_graph_worker.py

@@ -0,0 +1,229 @@
+"""
+GraphRAG Redis Worker (Upstash)
+Background process to run community detection (Leiden Algorithm) on PostgreSQL Graph.
+Consumes jobs from 'graph_reindex_jobs' Redis queue.
+"""
+
+import json
+import logging
+import os
+import sys
+import time
+from typing import Any, Dict, List, Optional
+import uuid
+from sqlalchemy import text
+
+# Add backend to path
+sys.path.append(os.getcwd())
+
+from core.database import SessionLocal, get_db_session
+from core.models import CommunityMembership, GraphCommunity, GraphEdge, GraphNode
+from core.service_factory import ServiceFactory
+import asyncio
+
+try:
+    import networkx as nx
+except ImportError:
+    class MockGraph:
+        def __init__(self):
+            self._nodes = {}
+            self._edges = {}
+        @property
+        def nodes(self): return self._nodes
+        def add_node(self, id, **attr): self._nodes[id] = attr
+        def add_edge(self, u, v, **attr): self._edges[(u, v)] = attr
+        def number_of_nodes(self): return len(self._nodes)
+
+    class nx:
+        Graph = MockGraph
+        @staticmethod
+        def connected_components(G):
+            return [list(G.nodes.keys())]
+
+# Configure Logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+class RedisWorker:
+    def __init__(self, redis_url: str = None):
+        self.max_ram_nodes = 50000 
+        self.queue_name = "graph_reindex_jobs"
+        self.redis_client = None
+        
+        # Init Redis
+        redis_url = redis_url or os.getenv("UPSTASH_REDIS_URL") or os.getenv("REDIS_URL")
+        if redis_url:
+            try:
+                import redis
+                self.redis_client = redis.from_url(redis_url)
+                logger.info(f"Connected to Redis: {redis_url.split('@')[-1]}") # Log host only
+            except ImportError:
+                logger.warning("redis-py not installed.")
+            except Exception as e:
+                logger.error(f"Failed to connect to Redis: {e}")
+        else:
+            logger.warning("No REDIS_URL provided. Worker will not listen to queue.")
+
+    def fetch_graph(self, workspace_id: str) -> nx.Graph:
+        """Load entire workspace graph into NetworkX"""
+        session = SessionLocal()
+        G = nx.Graph()
+        try:
+            logger.info(f"Fetching nodes for workspace {workspace_id}...")
+            nodes = session.query(GraphNode.id, GraphNode.name).filter_by(workspace_id=workspace_id).all()
+            for n in nodes:
+                G.add_node(n.id, name=n.name)
+            
+            logger.info(f"Fetching edges for workspace {workspace_id}...")
+            edges = session.query(GraphEdge.source_node_id, GraphEdge.target_node_id, GraphEdge.weight).filter_by(workspace_id=workspace_id).all()
+            for e in edges:
+                G.add_edge(e.source_node_id, e.target_node_id, weight=e.weight)
+                
+            return G
+        finally:
+            session.close()
+
+    def detect_communities(self, G: nx.Graph) -> List[List[str]]:
+        """Run Louvain/Leiden algorithm"""
+        if G.number_of_nodes() == 0:
+            return []
+            
+        try:
+            from networkx.algorithms.community import louvain_communities
+            logger.info(f"Running Louvain on {G.number_of_nodes()} nodes...")
+            communities = louvain_communities(G, seed=42)
+            return [list(c) for c in communities]
+        except ImportError:
+            logger.warning("Louvain not available, falling back to connected components")
+            return [list(c) for c in nx.connected_components(G)]
+
+    async def summarize_community(self, workspace_id: str, G: nx.Graph, community_nodes: List[str]) -> Dict[str, Any]:
+        """Generate LLM summary and keywords for a community using unified LLMService"""
+        llm = ServiceFactory.get_llm_service()
+        
+        # Prepare context
+        nodes_list = [f"- {G.nodes[n].get('name', 'Unknown')} ({G.nodes[n].get('type', 'entity')})" for n in community_nodes[:20]]
+        nodes_str = "\n".join(nodes_list)
+        
+        prompt = f"""Summarize this knowledge graph community of related entities.
+Entities:
+{nodes_str}
+
+Respond in valid JSON only with this structure:
+{{
+  "summary": "Short 1-2 sentence description emphasizing the common theme",
+  "keywords": ["keyword1", "keyword2", "keyword3"]
+}}"""
+
+        try:
+            # LLMService handles tenant isolation and usage tracking automatically
+            result = await llm.generate_response(
+                prompt=prompt,
+                tenant_id=workspace_id,
+                system_prompt="You are a GraphRAG Community Analyst. Categorize and summarize groups of entities.",
+                json_mode=True
+            )
+            
+            data = json.loads(result)
+            return {
+                "summary": data.get("summary", f"Community of {len(community_nodes)} entities."),
+                "keywords": data.get("keywords", [])
+            }
+        except Exception as e:
+            logger.error(f"Failed to summarize community via LLMService: {e}")
+            node_names = [G.nodes[n].get("name", "Unknown") for n in community_nodes[:3]]
+            return {
+                "summary": f"Group related to {', '.join(node_names)}.",
+                "keywords": node_names
+            }
+
+    def save_communities(self, workspace_id: str, communities: List[List[str]], G: nx.Graph):
+        """Persist results to Postgres"""
+        session = SessionLocal()
+        try:
+            session.execute(text("DELETE FROM graph_communities WHERE workspace_id = :ws_id"), {"ws_id": workspace_id})
+            session.commit()
+            
+            logger.info(f"Summarizing and saving {len(communities)} communities...")
+            for i, members in enumerate(communities):
+                if len(members) < 2: continue 
+                
+                # Perform async LLM summarization
+                res = asyncio.run(self.summarize_community(workspace_id, G, members))
+                
+                comm = GraphCommunity(
+                    workspace_id=workspace_id,
+                    level=0,
+                    summary=res["summary"],
+                    keywords=res["keywords"]
+                )
+                session.add(comm)
+                session.flush() # Get ID
+                
+                for node_id in members:
+                    membership = CommunityMembership(
+                        community_id=comm.id,
+                        node_id=node_id
+                    )
+                    session.add(membership)
+            
+            session.commit()
+            logger.info(f"Saved {len(communities)} communities for workspace {workspace_id}")
+            
+        except Exception as e:
+            session.rollback()
+            logger.error(f"Failed to save communities: {e}")
+        finally:
+            session.close()
+
+    def process_job(self, workspace_id: str):
+        logger.info(f"WORKER: Starting job for {workspace_id}")
+        G = self.fetch_graph(workspace_id)
+        if G.number_of_nodes() > self.max_ram_nodes:
+            logger.error(f"Graph too large ({G.number_of_nodes()} nodes).")
+            return
+            
+        communities = self.detect_communities(G)
+        self.save_communities(workspace_id, communities, G)
+        logger.info("WORKER: Job Finished.")
+
+    def run(self):
+        """Main listening loop"""
+        if not self.redis_client:
+            logger.error("Redis not connected. Exiting.")
+            return
+
+        logger.info(f"Listening on queue: {self.queue_name}...")
+        
+        while True:
+            # Scale-to-Zero logic: If fetch returns None after timeout, exit
+            # For now, block indefinitely or use timeout
+            try:
+                # brpop returns tuple (queue_name, value)
+                job = self.redis_client.brpop(self.queue_name, timeout=30)
+                
+                if job:
+                    _, workspace_id_bytes = job
+                    workspace_id = workspace_id_bytes.decode('utf-8')
+                    self.process_job(workspace_id)
+                else:
+                    logger.info("Queue empty (timeout). Idle...")
+                    # In production with 'machines on demand', we would exit here
+                    # sys.exit(0) 
+            except Exception as e:
+                logger.error(f"Worker Error: {e}")
+                time.sleep(5)
+
+if __name__ == "__main__":
+    # If run with argument, process single job (Manual/Test mode)
+    if len(sys.argv) > 1:
+        workspace_id = sys.argv[1]
+        worker = RedisWorker(redis_url="mock://") # Skip redis conn
+        worker.process_job(workspace_id)
+    else:
+        # Run in Daemon mode
+        worker = RedisWorker()
+        worker.run()

backend/workers/social_media_worker.py

@@ -0,0 +1,199 @@
+"""
+Social Media Worker for Background Post Processing
+
+Handles scheduled social media posts in the background using RQ.
+Processes posts at their scheduled time and logs results to the database.
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+async def process_scheduled_post(
+    post_id: str,
+    platforms: List[str],
+    text: str,
+    scheduled_for: datetime,
+    media_urls: Optional[List[str]] = None,
+    link_url: Optional[str] = None,
+    user_id: Optional[str] = None
+) -> Dict[str, any]:
+    """
+    Process a scheduled social media post.
+
+    This function is called by the RQ worker when a scheduled post is due.
+    It posts to each platform and logs the results.
+
+    Args:
+        post_id: Unique identifier for the post
+        platforms: List of platform names (twitter, linkedin, facebook)
+        text: Post content
+        scheduled_for: When the post was scheduled (for logging)
+        media_urls: Optional list of image/video URLs
+        link_url: Optional link to include in the post
+        user_id: User ID for tracking
+
+    Returns:
+        Dictionary with platform results
+    """
+    from core.database import SessionLocal
+    from core.models import SocialPostHistory, OAuthToken
+
+    db = SessionLocal()
+
+    try:
+        logger.info(f"Processing scheduled post {post_id} for {len(platforms)} platforms")
+
+        # Update status to processing
+        history = db.query(SocialPostHistory).filter(
+            SocialPostHistory.post_id == post_id
+        ).first()
+
+        if not history:
+            logger.error(f"SocialPostHistory record not found for post_id={post_id}")
+            return {"error": "Post not found in database"}
+
+        history.status = "posting"
+        history.posted_at = datetime.utcnow()
+        db.commit()
+
+        # Get platform poster functions
+        from api.social_media_routes import post_to_twitter, post_to_linkedin, post_to_facebook
+
+        platform_posters = {
+            "twitter": post_to_twitter,
+            "linkedin": post_to_linkedin,
+            "facebook": post_to_facebook,
+        }
+
+        platform_results = {}
+        successful_posts = 0
+
+        # Post to each platform
+        for platform in platforms:
+            platform = platform.lower()
+
+            logger.info(f"Posting to {platform} for post {post_id}")
+
+            try:
+                # Get OAuth token for this platform and user
+                oauth_token = db.query(OAuthToken).filter(
+                    OAuthToken.user_id == user_id,
+                    OAuthToken.provider == platform,
+                    OAuthToken.status == "active"
+                ).first()
+
+                if not oauth_token:
+                    platform_results[platform] = {
+                        "success": False,
+                        "error": f"No active {platform} account connected. Please connect your account first."
+                    }
+                    logger.warning(f"No OAuth token found for {platform}")
+                    continue
+
+                # Get the poster function
+                poster_func = platform_posters.get(platform)
+
+                if not poster_func:
+                    platform_results[platform] = {
+                        "success": False,
+                        "error": f"Platform {platform} not yet implemented"
+                    }
+                    logger.warning(f"No poster function for {platform}")
+                    continue
+
+                # Post to platform
+                result = await poster_func(
+                    text=text,
+                    access_token=oauth_token.access_token,
+                    media_urls=media_urls,
+                    link_url=link_url
+                )
+
+                platform_results[platform] = result
+
+                if result.get("success"):
+                    successful_posts += 1
+                    logger.info(f"Successfully posted to {platform}")
+                else:
+                    logger.error(f"Failed to post to {platform}: {result.get('error')}")
+
+                # Update last_used timestamp
+                oauth_token.last_used = datetime.utcnow()
+
+            except Exception as e:
+                logger.error(f"Error posting to {platform}: {e}", exc_info=True)
+                platform_results[platform] = {
+                    "success": False,
+                    "error": str(e)
+                }
+
+        # Update history with results
+        if successful_posts == len(platforms):
+            history.status = "posted"
+            logger.info(f"Post {post_id} successfully posted to all platforms")
+        elif successful_posts > 0:
+            history.status = "partial"
+            logger.warning(f"Post {post_id} partially posted ({successful_posts}/{len(platforms)})")
+        else:
+            history.status = "failed"
+            history.error_message = "Failed to post to any platform"
+            logger.error(f"Post {post_id} failed completely")
+
+        history.platform_results = platform_results
+        history.posted_at = datetime.utcnow()
+        db.commit()
+
+        return {
+            "success": successful_posts > 0,
+            "post_id": post_id,
+            "platforms": platforms,
+            "platform_results": platform_results,
+            "successful_posts": successful_posts,
+            "total_platforms": len(platforms),
+            "status": history.status
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to process scheduled post {post_id}: {e}", exc_info=True)
+
+        # Update history to failed
+        try:
+            history = db.query(SocialPostHistory).filter(
+                SocialPostHistory.post_id == post_id
+            ).first()
+
+            if history:
+                history.status = "failed"
+                history.error_message = str(e)
+                db.commit()
+        except Exception as db_error:
+            logger.error(f"Failed to update history: {db_error}")
+
+        raise
+
+    finally:
+        db.close()
+
+
+def process_scheduled_post_sync(*args, **kwargs):
+    """
+    Synchronous wrapper for process_scheduled_post.
+
+    RQ workers require synchronous functions, so this wrapper
+    handles the async execution properly.
+    """
+    import asyncio
+
+    try:
+        # Get or create event loop
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        # No event loop in this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    return loop.run_until_complete(process_scheduled_post(*args, **kwargs))

backend/zero_coverage_categorized.json

@@ -0,0 +1,276 @@
+{
+  "categories": {
+    "CRITICAL": [
+      {
+        "file": "core/workflow_versioning_system.py",
+        "lines": 442,
+        "missing": 442
+      },
+      {
+        "file": "core/workflow_marketplace.py",
+        "lines": 332,
+        "missing": 332
+      },
+      {
+        "file": "core/advanced_workflow_endpoints.py",
+        "lines": 265,
+        "missing": 265
+      },
+      {
+        "file": "core/workflow_template_endpoints.py",
+        "lines": 243,
+        "missing": 243
+      },
+      {
+        "file": "api/workflow_versioning_endpoints.py",
+        "lines": 228,
+        "missing": 228
+      },
+      {
+        "file": "core/graduation_exam.py",
+        "lines": 227,
+        "missing": 227
+      },
+      {
+        "file": "core/enterprise_user_management.py",
+        "lines": 208,
+        "missing": 208
+      },
+      {
+        "file": "core/reconciliation_engine.py",
+        "lines": 164,
+        "missing": 164
+      },
+      {
+        "file": "core/constitutional_validator.py",
+        "lines": 157,
+        "missing": 157
+      }
+    ],
+    "HIGH": [
+      {
+        "file": "api/smarthome_routes.py",
+        "lines": 188,
+        "missing": 188
+      },
+      {
+        "file": "api/creative_routes.py",
+        "lines": 157,
+        "missing": 157
+      },
+      {
+        "file": "api/productivity_routes.py",
+        "lines": 156,
+        "missing": 156
+      }
+    ],
+    "MEDIUM": [
+      {
+        "file": "core/apar_engine.py",
+        "lines": 177,
+        "missing": 177
+      },
+      {
+        "file": "core/byok_cost_optimizer.py",
+        "lines": 168,
+        "missing": 168
+      },
+      {
+        "file": "core/local_ocr_service.py",
+        "lines": 164,
+        "missing": 164
+      },
+      {
+        "file": "core/debug_alerting.py",
+        "lines": 155,
+        "missing": 155
+      },
+      {
+        "file": "core/budget_enforcement_service.py",
+        "lines": 151,
+        "missing": 151
+      },
+      {
+        "file": "core/logging_config.py",
+        "lines": 148,
+        "missing": 148
+      },
+      {
+        "file": "core/formula_memory.py",
+        "lines": 147,
+        "missing": 147
+      },
+      {
+        "file": "core/communication_service.py",
+        "lines": 145,
+        "missing": 145
+      },
+      {
+        "file": "core/scheduler.py",
+        "lines": 144,
+        "missing": 144
+      }
+    ],
+    "LOW": [
+      {
+        "file": "api/debug_routes.py",
+        "lines": 296,
+        "missing": 296
+      },
+      {
+        "file": "core/industry_workflow_endpoints.py",
+        "lines": 181,
+        "missing": 181
+      },
+      {
+        "file": "core/oauth_user_context.py",
+        "lines": 142,
+        "missing": 142
+      },
+      {
+        "file": "core/ai_workflow_optimization_endpoints.py",
+        "lines": 137,
+        "missing": 137
+      },
+      {
+        "file": "core/byok_competitive_endpoints.py",
+        "lines": 137,
+        "missing": 137
+      },
+      {
+        "file": "core/error_middleware.py",
+        "lines": 137,
+        "missing": 137
+      },
+      {
+        "file": "core/local_llm_secrets_detector.py",
+        "lines": 137,
+        "missing": 137
+      },
+      {
+        "file": "core/agent_execution_service.py",
+        "lines": 134,
+        "missing": 134
+      },
+      {
+        "file": "core/analytics_engine.py",
+        "lines": 130,
+        "missing": 130
+      },
+      {
+        "file": "core/governance_helper.py",
+        "lines": 130,
+        "missing": 130
+      },
+      {
+        "file": "core/competitive_advantage_dashboard.py",
+        "lines": 123,
+        "missing": 123
+      },
+      {
+        "file": "core/debug_streaming.py",
+        "lines": 123,
+        "missing": 123
+      },
+      {
+        "file": "tools/calendar_tool.py",
+        "lines": 123,
+        "missing": 123
+      },
+      {
+        "file": "core/mcp_service.py",
+        "lines": 122,
+        "missing": 122
+      },
+      {
+        "file": "core/background_agent_runner.py",
+        "lines": 121,
+        "missing": 121
+      },
+      {
+        "file": "core/chronological_integrity.py",
+        "lines": 120,
+        "missing": 120
+      },
+      {
+        "file": "core/analytics_endpoints.py",
+        "lines": 119,
+        "missing": 119
+      },
+      {
+        "file": "core/package_governance_service.py",
+        "lines": 119,
+        "missing": 119
+      },
+      {
+        "file": "core/health_monitor.py",
+        "lines": 113,
+        "missing": 113
+      },
+      {
+        "file": "core/active_intervention_service.py",
+        "lines": 112,
+        "missing": 112
+      },
+      {
+        "file": "core/financial_audit_orchestrator.py",
+        "lines": 112,
+        "missing": 112
+      },
+      {
+        "file": "core/governance_wrapper.py",
+        "lines": 111,
+        "missing": 111
+      },
+      {
+        "file": "core/token_refresher.py",
+        "lines": 107,
+        "missing": 107
+      },
+      {
+        "file": "core/uptime_tracker.py",
+        "lines": 103,
+        "missing": 103
+      },
+      {
+        "file": "core/database_helper.py",
+        "lines": 102,
+        "missing": 102
+      },
+      {
+        "file": "core/user_context_manager.py",
+        "lines": 102,
+        "missing": 102
+      }
+    ]
+  },
+  "modules": {
+    "core": 41,
+    "api": 5,
+    "tools": 1,
+    "cli": 0,
+    "other": 0
+  },
+  "coverage_potential": {
+    "wave3_critical": {
+      "files": 9,
+      "lines": 2266,
+      "pct": 3.061417493042233
+    },
+    "wave4_high": {
+      "files": 3,
+      "lines": 501,
+      "pct": 0.6768623848253128
+    },
+    "wave5_medium": {
+      "files": 9,
+      "lines": 1399,
+      "pct": 1.8900807911589075
+    },
+    "wave6_low": {
+      "files": 26,
+      "lines": 3393,
+      "pct": 4.584020103218136
+    }
+  }
+}

backend/zero_coverage_files_analysis.json

@@ -0,0 +1,237 @@
+[
+  {
+    "file": "core/workflow_versioning_system.py",
+    "lines": 442,
+    "missing": 442
+  },
+  {
+    "file": "core/workflow_marketplace.py",
+    "lines": 332,
+    "missing": 332
+  },
+  {
+    "file": "api/debug_routes.py",
+    "lines": 296,
+    "missing": 296
+  },
+  {
+    "file": "core/advanced_workflow_endpoints.py",
+    "lines": 265,
+    "missing": 265
+  },
+  {
+    "file": "core/workflow_template_endpoints.py",
+    "lines": 243,
+    "missing": 243
+  },
+  {
+    "file": "api/workflow_versioning_endpoints.py",
+    "lines": 228,
+    "missing": 228
+  },
+  {
+    "file": "core/graduation_exam.py",
+    "lines": 227,
+    "missing": 227
+  },
+  {
+    "file": "core/enterprise_user_management.py",
+    "lines": 208,
+    "missing": 208
+  },
+  {
+    "file": "api/smarthome_routes.py",
+    "lines": 188,
+    "missing": 188
+  },
+  {
+    "file": "core/industry_workflow_endpoints.py",
+    "lines": 181,
+    "missing": 181
+  },
+  {
+    "file": "core/apar_engine.py",
+    "lines": 177,
+    "missing": 177
+  },
+  {
+    "file": "core/byok_cost_optimizer.py",
+    "lines": 168,
+    "missing": 168
+  },
+  {
+    "file": "core/local_ocr_service.py",
+    "lines": 164,
+    "missing": 164
+  },
+  {
+    "file": "core/reconciliation_engine.py",
+    "lines": 164,
+    "missing": 164
+  },
+  {
+    "file": "api/creative_routes.py",
+    "lines": 157,
+    "missing": 157
+  },
+  {
+    "file": "core/constitutional_validator.py",
+    "lines": 157,
+    "missing": 157
+  },
+  {
+    "file": "api/productivity_routes.py",
+    "lines": 156,
+    "missing": 156
+  },
+  {
+    "file": "core/debug_alerting.py",
+    "lines": 155,
+    "missing": 155
+  },
+  {
+    "file": "core/budget_enforcement_service.py",
+    "lines": 151,
+    "missing": 151
+  },
+  {
+    "file": "core/logging_config.py",
+    "lines": 148,
+    "missing": 148
+  },
+  {
+    "file": "core/formula_memory.py",
+    "lines": 147,
+    "missing": 147
+  },
+  {
+    "file": "core/communication_service.py",
+    "lines": 145,
+    "missing": 145
+  },
+  {
+    "file": "core/scheduler.py",
+    "lines": 144,
+    "missing": 144
+  },
+  {
+    "file": "core/oauth_user_context.py",
+    "lines": 142,
+    "missing": 142
+  },
+  {
+    "file": "core/ai_workflow_optimization_endpoints.py",
+    "lines": 137,
+    "missing": 137
+  },
+  {
+    "file": "core/byok_competitive_endpoints.py",
+    "lines": 137,
+    "missing": 137
+  },
+  {
+    "file": "core/error_middleware.py",
+    "lines": 137,
+    "missing": 137
+  },
+  {
+    "file": "core/local_llm_secrets_detector.py",
+    "lines": 137,
+    "missing": 137
+  },
+  {
+    "file": "core/agent_execution_service.py",
+    "lines": 134,
+    "missing": 134
+  },
+  {
+    "file": "core/analytics_engine.py",
+    "lines": 130,
+    "missing": 130
+  },
+  {
+    "file": "core/governance_helper.py",
+    "lines": 130,
+    "missing": 130
+  },
+  {
+    "file": "core/competitive_advantage_dashboard.py",
+    "lines": 123,
+    "missing": 123
+  },
+  {
+    "file": "core/debug_streaming.py",
+    "lines": 123,
+    "missing": 123
+  },
+  {
+    "file": "tools/calendar_tool.py",
+    "lines": 123,
+    "missing": 123
+  },
+  {
+    "file": "core/mcp_service.py",
+    "lines": 122,
+    "missing": 122
+  },
+  {
+    "file": "core/background_agent_runner.py",
+    "lines": 121,
+    "missing": 121
+  },
+  {
+    "file": "core/chronological_integrity.py",
+    "lines": 120,
+    "missing": 120
+  },
+  {
+    "file": "core/analytics_endpoints.py",
+    "lines": 119,
+    "missing": 119
+  },
+  {
+    "file": "core/package_governance_service.py",
+    "lines": 119,
+    "missing": 119
+  },
+  {
+    "file": "core/health_monitor.py",
+    "lines": 113,
+    "missing": 113
+  },
+  {
+    "file": "core/active_intervention_service.py",
+    "lines": 112,
+    "missing": 112
+  },
+  {
+    "file": "core/financial_audit_orchestrator.py",
+    "lines": 112,
+    "missing": 112
+  },
+  {
+    "file": "core/governance_wrapper.py",
+    "lines": 111,
+    "missing": 111
+  },
+  {
+    "file": "core/token_refresher.py",
+    "lines": 107,
+    "missing": 107
+  },
+  {
+    "file": "core/uptime_tracker.py",
+    "lines": 103,
+    "missing": 103
+  },
+  {
+    "file": "core/database_helper.py",
+    "lines": 102,
+    "missing": 102
+  },
+  {
+    "file": "core/user_context_manager.py",
+    "lines": 102,
+    "missing": 102
+  }
+]