Update with production optimizations

backend/services/config.py

@@ -18,6 +18,8 @@ class Settings(BaseSettings):
     
     # App Config
     TASK_QUEUE_EMBEDDED_WORKER: bool = True
+    TASK_QUEUE_HEARTBEAT_ENABLED: bool = True
+    TASK_EXECUTION_MODE: str = "queue"  # direct | queue
     OUTPUT_LANGUAGE: str = "en"
     PORT: int = 8000
     SENTRY_DSN: Optional[str] = None

backend/services/orchestrator_service.py

@@ -5,7 +5,8 @@ import logging
 import re
 from services.config import settings
 from services.agent_runner_service import AgentRunnerService
-from services.output_quality import clean_report_text, dedupe_lines, filter_report_sections, report_text_from_output
+from services.audit_service import audit_service
+from services.output_quality import clean_report_text, dedupe_lines, filter_report_sections, validate_output
 
 logger = logging.getLogger("uvicorn")
 
@@ -68,20 +69,46 @@ def _format_value_for_report(value, level: int = 0) -> list[str]:
 
 
 def _extract_json_payload(text: str):
+    if not text:
+        return None
+        
     stripped = text.strip()
+    
+    # 1. Try standard block extraction
     if stripped.startswith("```"):
-        stripped = stripped.strip("`")
-        if stripped.lower().startswith("json"):
-            stripped = stripped[4:].strip()
+        cleaned = stripped.strip("`")
+        if cleaned.lower().startswith("json"):
+            cleaned = cleaned[4:].strip()
+        try:
+            return json.loads(cleaned)
+        except Exception:
+            pass # Fallback to regex
+
+    # 2. Try direct parsing
     try:
         return json.loads(stripped)
     except Exception:
-        match = re.search(r"```json\s*(.*?)\s*```", text, re.IGNORECASE | re.DOTALL)
+        pass
+
+    # 3. Robust Regex Search (find content between first { and last })
+    # This is the "Repair Layer" for noisy LLM outputs
+    try:
+        # Search for anything starting with { and ending with }
+        # across multiple lines
+        match = re.search(r'(\{.*\})', stripped, re.DOTALL)
         if match:
-            try:
-                return json.loads(match.group(1))
-            except Exception:
-                return None
+            return json.loads(match.group(1))
+    except Exception:
+        pass
+
+    # 4. Specific Markdown Block Search
+    match = re.search(r"```json\s*(.*?)\s*```", text, re.IGNORECASE | re.DOTALL)
+    if match:
+        try:
+            return json.loads(match.group(1))
+        except Exception:
+            pass
+            
     return None
 
 def _format_output_for_report(output_data) -> str:
@@ -125,12 +152,17 @@ def _format_conclusion_payload(data: dict) -> str:
     if isinstance(conclusion, str) and conclusion.strip():
         lines.append(conclusion.strip())
 
-    if isinstance(next_steps, list) and next_steps:
+    usable_steps = [
+        step.strip()
+        for step in next_steps
+        if isinstance(step, str) and step.strip()
+    ] if isinstance(next_steps, list) else []
+
+    if usable_steps:
         lines.append("")
         lines.append("Next steps:")
-        for step in next_steps[:5]:
-            if isinstance(step, str) and step.strip():
-                lines.append(f"- {step.strip()}")
+        for step in usable_steps[:5]:
+            lines.append(f"- {step}")
 
     return "\n".join(lines).strip() or "\n".join(_format_value_for_report(data))
 
@@ -171,7 +203,7 @@ def _build_report_charts(tasks: list[dict]) -> dict:
     risk_mentions = 0
 
     for task in tasks:
-        text = f"{task.get('title', '')} {task.get('description', '')} {_output_text(task.get('output_data'))}"
+        text = f"{task.get('title', '')} {task.get('description', '')} {_output_text(task.get('output_data'))}".lower()
         risk_mentions += sum(text.count(term) for term in categories["Risk"])
         for category, terms in categories.items():
             if any(term in text for term in terms):
@@ -202,6 +234,27 @@ def _build_report_charts(tasks: list[dict]) -> dict:
         ]
     }
 
+def _format_chart_rows(title: str, rows: list[dict]) -> list[str]:
+    if not rows:
+        return [f"### {title}", "No data available.", ""]
+
+    lines = [f"### {title}"]
+    lines.extend(f"- {row['label']}: {row['value']}" for row in rows)
+    lines.append("")
+    return lines
+
+def _format_execution_summary(charts: dict, total_tasks: int, kept_task_count: int, excluded_count: int) -> list[str]:
+    lines = [
+        f"- Total tasks: {total_tasks}",
+        f"- Included outputs: {kept_task_count}",
+        f"- Excluded outputs: {excluded_count}",
+        "",
+    ]
+    lines.extend(_format_chart_rows("Scores", charts.get("scores", [])))
+    lines.extend(_format_chart_rows("Task Categories", charts.get("categories", [])))
+    lines.extend(_format_chart_rows("Priorities", charts.get("priorities", [])))
+    return lines
+
 REPORT_VARIANTS = {
     "full": {
         "title": "Final Report",
@@ -251,6 +304,13 @@ class OrchestratorService:
 
             # Update status to in_progress
             supabase.table("tasks").update({"status": "in_progress"}).eq("id", task_id).execute()
+            await audit_service.log_action(
+                user_id=None,
+                action="debate_started",
+                agent_id=agent_a_id,
+                task_id=task_id,
+                metadata={"agent_b_id": agent_b_id, "project_id": task.get("project_id")},
+            )
             
             # 2. Agent A generates initial response
             initial_res, _ = await AgentRunnerService.run_agent_task(
@@ -307,6 +367,13 @@ class OrchestratorService:
                 "status": "awaiting_approval",
                 "output_data": consolidated_output
             }).eq("id", task_id).execute()
+            await audit_service.log_action(
+                user_id=None,
+                action="debate_completed",
+                agent_id=agent_a_id,
+                task_id=task_id,
+                metadata={"agent_b_id": agent_b_id, "project_id": task.get("project_id")},
+            )
             
             logger.info(f"Debate completed for task {task_id}")
             
@@ -316,6 +383,13 @@ class OrchestratorService:
                 "status": "failed",
                 "output_data": {"error": str(e)}
             }).eq("id", task_id).execute()
+            await audit_service.log_action(
+                user_id=None,
+                action="debate_failed",
+                agent_id=agent_a_id,
+                task_id=task_id,
+                metadata={"agent_b_id": agent_b_id, "error": str(e)},
+            )
             
             # LOG ERROR TO AGENT CONSOLE
             supabase.table("agent_logs").insert({
@@ -338,7 +412,7 @@ class OrchestratorService:
             supabase.table("tasks")
             .select("*")
             .eq("project_id", project_id)
-            .eq("status", "todo")
+            .in_("status", ["todo", "failed"])
             .order("priority", desc=True)
             .order("created_at", desc=False)
             .execute()
@@ -405,6 +479,109 @@ class OrchestratorService:
             "failed": failed,
         }
 
+    async def queue_project(self, project_id: str):
+        """
+        Assigns available agents and queues runnable project tasks for worker execution.
+        """
+        from services.task_queue import TaskQueueService
+
+        project = supabase.table("projects").select("*").eq("id", project_id).single().execute().data
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        if project.get("status") == "completed":
+            raise ValueError("Completed projects are locked and cannot be modified.")
+
+        owner_id = project.get("owner_id")
+        tasks = (
+            supabase.table("tasks")
+            .select("*")
+            .eq("project_id", project_id)
+            .in_("status", ["todo", "failed"])
+            .order("priority", desc=True)
+            .order("created_at", desc=False)
+            .execute()
+            .data
+            or []
+        )
+
+        all_tasks_res = supabase.table("tasks").select("id", count="exact").eq("project_id", project_id).limit(1).execute()
+        has_any_tasks = all_tasks_res.count > 0 if all_tasks_res.count is not None else len(all_tasks_res.data) > 0
+
+        if not has_any_tasks:
+            logger.info(f"No tasks found for project {project_id}. Triggering auto-decomposition before queueing.")
+            await self.decompose_project(project_id)
+            tasks = (
+                supabase.table("tasks")
+                .select("*")
+                .eq("project_id", project_id)
+                .in_("status", ["todo", "failed"])
+                .order("priority", desc=True)
+                .order("created_at", desc=False)
+                .execute()
+                .data
+                or []
+            )
+
+        agents = supabase.table("agents").select("*").execute().data or []
+        available_agents = [
+            agent for agent in agents
+            if agent.get("user_id") in (None, owner_id)
+        ]
+
+        queued = 0
+        failed = 0
+        skipped = 0
+
+        for task in tasks:
+            try:
+                agent_data = self._resolve_agent(task, available_agents)
+                if not agent_data:
+                    raise ValueError("No available agent for task")
+
+                if not task.get("assigned_agent_id"):
+                    supabase.table("tasks").update({
+                        "assigned_agent_id": agent_data["id"]
+                    }).eq("id", task["id"]).execute()
+
+                result = await TaskQueueService.queue_task(task["id"])
+                if result and result.data:
+                    queued += 1
+                else:
+                    skipped += 1
+            except Exception as exc:
+                failed += 1
+                logger.error(f"Project queueing task failed: {str(exc)}")
+                supabase.table("tasks").update({
+                    "status": "failed",
+                    "last_error": str(exc),
+                    "output_data": {"error": str(exc)}
+                }).eq("id", task["id"]).execute()
+                await audit_service.log_action(
+                    user_id=owner_id,
+                    action="task_queue_failed",
+                    task_id=task.get("id"),
+                    metadata={"project_id": project_id, "error": str(exc)},
+                )
+
+        await audit_service.log_action(
+            user_id=owner_id,
+            action="project_queued",
+            metadata={
+                "project_id": project_id,
+                "queued_tasks": queued,
+                "failed": failed,
+                "skipped": skipped,
+            },
+        )
+
+        return {
+            "project_id": project_id,
+            "queued_tasks": queued,
+            "failed": failed,
+            "skipped": skipped,
+            "mode": "queue",
+        }
+
     def _select_report_agent(self, project: dict, variant: str):
         config = REPORT_VARIANTS.get(variant, REPORT_VARIANTS["full"])
         terms = config["agent_terms"]
@@ -495,7 +672,7 @@ class OrchestratorService:
 
         return None
 
-    def _quality_approved_tasks(self, tasks: list[dict]) -> tuple[list[dict], list[dict]]:
+    def _quality_approved_tasks(self, tasks: list[dict], project: dict) -> tuple[list[dict], list[dict]]:
         approved: list[dict] = []
         excluded: list[dict] = []
         for task in tasks:
@@ -506,7 +683,10 @@ class OrchestratorService:
                     "reasons": ["Task has no usable approved output."]
                 })
                 continue
+            task_with_project = {**task, "project": project}
             quality_review = output_data.get("quality_review") if isinstance(output_data, dict) else None
+            if not quality_review and isinstance(output_data, dict):
+                quality_review = validate_output(task_with_project, output_data)
             if quality_review and not quality_review.get("approved", False):
                 excluded.append({
                     "title": task.get("title", "Untitled task"),
@@ -517,7 +697,7 @@ class OrchestratorService:
         return approved, excluded
 
     def _curate_task_output(self, output_data) -> tuple[str, list[str]]:
-        text = report_text_from_output(output_data)
+        text = _format_output_for_report(output_data)
         text = clean_report_text(dedupe_lines(text))
         text, excluded_lines = filter_report_sections(text)
         return text or "No approved output was saved for this task.", excluded_lines
@@ -546,7 +726,7 @@ class OrchestratorService:
         if incomplete:
             raise ValueError(f"Final report is available after all tasks are approved. Pending tasks: {len(incomplete)}")
 
-        curated_tasks, excluded_tasks = self._quality_approved_tasks(tasks)
+        curated_tasks, excluded_tasks = self._quality_approved_tasks(tasks, project)
         if not curated_tasks:
             raise ValueError("No approved task outputs passed quality validation for final reporting.")
 
@@ -564,13 +744,10 @@ class OrchestratorService:
         if project.get("context"):
             lines.extend(["## Context", project["context"], ""])
 
-        lines.extend(["## Execution Summary", ""])
-        
-        # We will add the tabular summary later in the UI or via charts, 
-        # but for the text report, we include the approved work summary.
-        lines.extend(["## Approved Work Summary", ""])
+        approved_work_lines = ["## Approved Work Summary", ""]
 
         report_exclusions: list[str] = []
+        included_tasks: list[dict] = []
         kept_task_count = 0
         for task in curated_tasks:
             curated_text, excluded_lines = self._curate_task_output(task.get("output_data"))
@@ -582,7 +759,8 @@ class OrchestratorService:
                 })
                 continue
             kept_task_count += 1
-            lines.extend([
+            included_tasks.append(task)
+            approved_work_lines.extend([
                 f"### {kept_task_count}. {task['title']}",
                 task.get("description") or "No task description provided.",
                 "",
@@ -590,6 +768,11 @@ class OrchestratorService:
                 ""
             ])
 
+        charts = _build_report_charts(included_tasks)
+        lines.extend(["## Execution Summary", ""])
+        lines.extend(_format_execution_summary(charts, len(tasks), kept_task_count, len(excluded_tasks)))
+        lines.extend(approved_work_lines)
+
         if excluded_tasks or report_exclusions:
             lines.extend(["## Excluded Content", ""])
             for excluded in excluded_tasks:
@@ -648,13 +831,24 @@ class OrchestratorService:
                 logger.warning(f"Report variant generation failed: {exc}")
                 report = self._build_fallback_variant(project, tasks, variant) or report
 
+        await audit_service.log_action(
+            user_id=project.get("owner_id"),
+            action="final_report_generated",
+            metadata={
+                "project_id": project_id,
+                "variant": variant,
+                "task_count": kept_task_count,
+                "excluded_task_count": len(excluded_tasks),
+            },
+        )
+
         return {
             "project_id": project_id,
             "project_name": project["name"],
             "task_count": kept_task_count,
             "variant": variant,
             "report": clean_report_text(dedupe_lines(report)),
-            "charts": _build_report_charts(curated_tasks)
+            "charts": charts
         }
 
     async def decompose_project(self, project_id: str):
@@ -747,6 +941,11 @@ Do not use placeholder names or generic filler tasks. Every task title must be c
             # Insert tasks
             from .project_service import project_service
             await project_service.add_tasks_to_project(project_id, valid_tasks)
+            await audit_service.log_action(
+                user_id=owner_id,
+                action="project_decomposed",
+                metadata={"project_id": project_id, "task_count": len(valid_tasks)},
+            )
             logger.info(f"Auto-decomposed project {project_id} into {len(valid_tasks)} tasks.")
         except Exception as e:
             logger.error(f"Project decomposition failed: {e}")

backend/worker.py

@@ -1,9 +1,13 @@
 import asyncio
 import logging
+import os
 import signal
+import socket
+import uuid
 from services.task_queue import TaskQueueService
 from services.supabase_service import supabase
 from services.agent_runner_service import AgentRunnerService
+from services.config import settings
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("worker")
@@ -11,29 +15,95 @@ logger = logging.getLogger("worker")
 class AubmWorker:
     def __init__(self):
         self.running = True
+        suffix = uuid.uuid4().hex[:8]
+        self.worker_id = os.getenv("AUBM_WORKER_ID") or f"{socket.gethostname()}-{suffix}"
+        self.lease_seconds = int(os.getenv("AUBM_WORKER_LEASE_SECONDS", "300"))
+        self.max_attempts = int(os.getenv("AUBM_WORKER_MAX_ATTEMPTS", "3"))
+        self.retry_delay_seconds = int(os.getenv("AUBM_WORKER_RETRY_DELAY_SECONDS", "30"))
+        self.processed_count = 0
+        self.failed_count = 0
 
-    async def start(self):
-        logger.info("Aubm Background Worker started.")
-        while self.running:
-            task = await TaskQueueService.get_next_queued_task()
+    async def heartbeat(self, status: str, current_task_id: str | None = None):
+        if not settings.TASK_QUEUE_HEARTBEAT_ENABLED:
+            return
             
-            if task:
-                task_id = task['id']
-                logger.info(f"Processing task: {task_id}")
+        await TaskQueueService.heartbeat(
+            self.worker_id,
+            status=status,
+            current_task_id=current_task_id,
+            processed_count=self.processed_count,
+            failed_count=self.failed_count,
+            metadata={
+                "lease_seconds": self.lease_seconds,
+                "max_attempts": self.max_attempts,
+                "retry_delay_seconds": self.retry_delay_seconds,
+            },
+        )
+
+    async def _heartbeat_loop(self):
+        """Separate loop to send heartbeat at a fixed interval."""
+        while self.running:
+            try:
+                # We use a longer interval for regular heartbeats
+                await self.heartbeat("idle")
+            except Exception as e:
+                logger.warning("Background heartbeat failed: %s", e)
+            await asyncio.sleep(30) # Regular heartbeat every 30 seconds
+
+    async def start(self):
+        mode_suffix = "" if settings.TASK_QUEUE_HEARTBEAT_ENABLED else " (HEARTBEAT DISABLED)"
+        logger.info(f"Aubm Background Worker started{mode_suffix}: {self.worker_id}")
+        
+        # Start the background heartbeat task if enabled
+        heartbeat_task = None
+        if settings.TASK_QUEUE_HEARTBEAT_ENABLED:
+            heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+        
+        try:
+            while self.running:
+                task = await TaskQueueService.claim_next_queued_task(
+                    self.worker_id,
+                    lease_seconds=self.lease_seconds,
+                    max_attempts=self.max_attempts,
+                )
                 
-                try:
-                    # Fetch agent data for this task
-                    agent_res = supabase.table("agents").select("*").eq("id", task["assigned_agent_id"]).single().execute()
-                    if agent_res.data:
-                        await AgentRunnerService.execute_agent_logic(task, agent_res.data)
-                        logger.info(f"Task {task_id} completed successfully.")
-                    else:
-                        logger.error(f"No agent found for task {task_id}")
-                except Exception as e:
-                    logger.error(f"Failed to process task {task_id}: {e}")
-            else:
-                # No tasks, sleep for a bit
-                await asyncio.sleep(5)
+                if task:
+                    task_id = task['id']
+                    logger.info("Processing task: %s", task_id)
+                    await self.heartbeat("processing", task_id)
+                    
+                    try:
+                        # Fetch agent data for this task
+                        agent_id = task.get("assigned_agent_id")
+                        if not agent_id:
+                            raise RuntimeError("No agent assigned to queued task")
+
+                        agent_res = supabase.table("agents").select("*").eq("id", agent_id).single().execute()
+                        if agent_res.data:
+                            await AgentRunnerService.execute_agent_logic(task, agent_res.data)
+                            await TaskQueueService.clear_lease(task_id)
+                            self.processed_count += 1
+                            await self.heartbeat("idle")
+                            logger.info("Task %s completed successfully.", task_id)
+                        else:
+                            raise RuntimeError(f"Assigned agent not found: {agent_id}")
+                    except Exception as e:
+                        logger.error("Failed to process task %s: %s", task_id, e)
+                        self.failed_count += 1
+                        await TaskQueueService.mark_attempt_failed(
+                            task,
+                            str(e),
+                            self.max_attempts,
+                            self.retry_delay_seconds,
+                        )
+                        await self.heartbeat("error")
+                else:
+                    # No tasks, sleep for a bit (10s)
+                    await asyncio.sleep(10)
+        finally:
+            if heartbeat_task:
+                heartbeat_task.cancel()
+            await self.heartbeat("stopping")
 
     def stop(self):
         logger.info("Stopping worker...")
@@ -45,9 +115,13 @@ async def main():
     # Handle shutdown signals
     loop = asyncio.get_running_loop()
     for sig in (signal.SIGINT, signal.SIGTERM):
-        loop.add_signal_handler(sig, worker.stop)
+        try:
+            loop.add_signal_handler(sig, worker.stop)
+        except NotImplementedError:
+            signal.signal(sig, lambda *_: worker.stop())
 
     await worker.start()
+    await worker.heartbeat("stopping")
 
 if __name__ == "__main__":
     asyncio.run(main())

frontend/src/components/Dashboard.tsx

@@ -1,8 +1,9 @@
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { FolderOpen, Play, RefreshCw, Trash2 } from 'lucide-react';
+import { FolderOpen, Play, RefreshCw, Search, SlidersHorizontal, Trash2, X } from 'lucide-react';
 import { motion } from 'framer-motion';
 import { supabase } from '../services/supabase';
 import { useAuth } from '../context/useAuth';
+import StatusBadge from './common/StatusBadge';
 
 interface Project {
   id: string;
@@ -29,6 +30,10 @@ const Dashboard: React.FC<DashboardProps> = ({ onNewProject, onOpenProject }) =>
   const [tasks, setTasks] = useState<Task[]>([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [searchTerm, setSearchTerm] = useState('');
+  const [statusFilter, setStatusFilter] = useState('all');
+  const [progressFilter, setProgressFilter] = useState('all');
+  const [sortBy, setSortBy] = useState('newest');
 
   const loadDashboard = useCallback(async () => {
     if (!user) return;
@@ -92,6 +97,52 @@ const Dashboard: React.FC<DashboardProps> = ({ onNewProject, onOpenProject }) =>
     }, {});
   }, [tasks]);
 
+  const filteredProjects = useMemo(() => {
+    const normalizedSearch = searchTerm.trim().toLowerCase();
+
+    return projects
+      .filter((project) => {
+        if (statusFilter !== 'all' && project.status !== statusFilter) return false;
+
+        if (normalizedSearch) {
+          const searchableText = `${project.name} ${project.description ?? ''}`.toLowerCase();
+          if (!searchableText.includes(normalizedSearch)) return false;
+        }
+
+        const counts = taskCounts[project.id] ?? { done: 0, total: 0 };
+        const progress = counts.total > 0 ? counts.done / counts.total : 0;
+
+        if (progressFilter === 'not_started') return counts.done === 0;
+        if (progressFilter === 'in_progress') return progress > 0 && progress < 1;
+        if (progressFilter === 'completed') return counts.total > 0 && progress === 1;
+        if (progressFilter === 'no_tasks') return counts.total === 0;
+
+        return true;
+      })
+      .sort((a, b) => {
+        if (sortBy === 'name') return a.name.localeCompare(b.name);
+        if (sortBy === 'oldest') return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+        if (sortBy === 'progress') {
+          const aCounts = taskCounts[a.id] ?? { done: 0, total: 0 };
+          const bCounts = taskCounts[b.id] ?? { done: 0, total: 0 };
+          const aProgress = aCounts.total > 0 ? aCounts.done / aCounts.total : 0;
+          const bProgress = bCounts.total > 0 ? bCounts.done / bCounts.total : 0;
+          return bProgress - aProgress;
+        }
+
+        return new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
+      });
+  }, [progressFilter, projects, searchTerm, sortBy, statusFilter, taskCounts]);
+
+  const hasActiveFilters = Boolean(searchTerm.trim()) || statusFilter !== 'all' || progressFilter !== 'all' || sortBy !== 'newest';
+
+  const clearFilters = () => {
+    setSearchTerm('');
+    setStatusFilter('all');
+    setProgressFilter('all');
+    setSortBy('newest');
+  };
+
   return (
     <>
       <div className="page-heading dashboard-heading">
@@ -113,6 +164,53 @@ const Dashboard: React.FC<DashboardProps> = ({ onNewProject, onOpenProject }) =>
 
       {error && <div className="inline-status">{error}</div>}
 
+      {projects.length > 0 && (
+        <div className="dashboard-controls glass-panel">
+          <div className="dashboard-search">
+            <Search size={17} />
+            <input
+              value={searchTerm}
+              onChange={(event) => setSearchTerm(event.target.value)}
+              placeholder="Search projects..."
+              aria-label="Search projects"
+            />
+          </div>
+
+          <div className="dashboard-filter-group">
+            <SlidersHorizontal size={17} />
+            <select value={statusFilter} onChange={(event) => setStatusFilter(event.target.value)} aria-label="Filter by status">
+              <option value="all">All statuses</option>
+              <option value="active">Active</option>
+              <option value="completed">Completed</option>
+              <option value="archived">Archived</option>
+            </select>
+            <select value={progressFilter} onChange={(event) => setProgressFilter(event.target.value)} aria-label="Filter by progress">
+              <option value="all">All progress</option>
+              <option value="not_started">Not started</option>
+              <option value="in_progress">In progress</option>
+              <option value="completed">Completed tasks</option>
+              <option value="no_tasks">No tasks</option>
+            </select>
+            <select value={sortBy} onChange={(event) => setSortBy(event.target.value)} aria-label="Sort projects">
+              <option value="newest">Newest first</option>
+              <option value="oldest">Oldest first</option>
+              <option value="name">Name A-Z</option>
+              <option value="progress">Most progress</option>
+            </select>
+          </div>
+
+          <div className="dashboard-results">
+            <span>{filteredProjects.length}/{projects.length} shown</span>
+            {hasActiveFilters && (
+              <button className="btn btn-glass btn-sm" type="button" onClick={clearFilters}>
+                <X size={14} />
+                Clear
+              </button>
+            )}
+          </div>
+        </div>
+      )}
+
       {!loading && projects.length === 0 && (
         <div className="glass-panel empty-state">
           <FolderOpen size={32} color="var(--accent)" />
@@ -124,8 +222,19 @@ const Dashboard: React.FC<DashboardProps> = ({ onNewProject, onOpenProject }) =>
         </div>
       )}
 
+      {!loading && projects.length > 0 && filteredProjects.length === 0 && (
+        <div className="glass-panel empty-state">
+          <Search size={32} color="var(--accent)" />
+          <h3>No matching projects</h3>
+          <p>Adjust the search or filters to show more projects.</p>
+          <button className="btn btn-glass" onClick={clearFilters}>
+            Clear Filters
+          </button>
+        </div>
+      )}
+
       <div className="dashboard-grid">
-        {projects.map((project) => {
+        {filteredProjects.map((project) => {
           const counts = taskCounts[project.id] ?? { done: 0, total: 0 };
           return (
             <ProjectCard
@@ -155,15 +264,15 @@ const ProjectCard: React.FC<{ name: string; status: string; tasksDone: number; t
   const progress = tasksTotal > 0 ? (tasksDone / tasksTotal) * 100 : 0;
 
   return (
-    <motion.div whileHover={{ y: -5 }} className="glass-panel project-card" style={{ padding: 'var(--space-lg)', position: 'relative', overflow: 'hidden' }}>
-      <div className="project-card-header" style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'flex-start', gap: 'var(--space-md)' }}>
-        <h3 style={{ fontSize: '1.25rem', margin: 0, flex: 1, lineHeight: 1.2 }}>{name}</h3>
-        <div style={{ display: 'flex', gap: '8px', alignItems: 'center', flexShrink: 0 }}>
+    <motion.div whileHover={{ y: -5 }} className="glass-panel project-card">
+      <div className="project-card-header">
+        <h3>{name}</h3>
+        <div className="project-card-actions">
           <StatusBadge status={status} />
           <button 
             className="btn btn-icon" 
             onClick={(e) => { e.stopPropagation(); onDelete(); }}
-            style={{ color: 'var(--danger)', opacity: 0.6, padding: '4px' }}
+            style={{ color: 'var(--danger)', opacity: 0.6 }}
             title="Delete Project"
           >
             <Trash2 size={16} />
@@ -173,17 +282,17 @@ const ProjectCard: React.FC<{ name: string; status: string; tasksDone: number; t
 
       {/* Description removed as requested for a cleaner layout */}
 
-      <div style={{ marginBottom: 'var(--space-lg)' }}>
-        <div style={{ display: 'flex', justifyContent: 'space-between', fontSize: '0.85rem', marginBottom: 'var(--space-xs)' }}>
-          <span style={{ color: 'var(--text-dim)' }}>Tasks Progress</span>
+      <div className="project-card-progress">
+        <div className="project-card-progress-label">
+          <span>Tasks Progress</span>
           <span>{tasksDone}/{tasksTotal}</span>
         </div>
-        <div style={{ height: '6px', width: '100%', background: 'rgba(255,255,255,0.1)', borderRadius: '3px' }}>
-          <div style={{ height: '100%', width: `${progress}%`, background: 'var(--accent)', borderRadius: '3px', boxShadow: '0 0 10px var(--accent)' }} />
+        <div className="project-card-progress-track">
+          <div className="project-card-progress-fill" style={{ width: `${progress}%` }} />
         </div>
       </div>
 
-      <button className="btn btn-primary" style={{ width: '100%' }} onClick={onOpen}>
+      <button className="btn btn-primary project-card-open" onClick={onOpen}>
         <Play size={16} fill="white" />
         Open Project
       </button>
@@ -191,25 +300,5 @@ const ProjectCard: React.FC<{ name: string; status: string; tasksDone: number; t
   );
 };
 
-const StatusBadge: React.FC<{ status: string }> = ({ status }) => {
-  const normalized = status.replace('_', ' ');
-  const color = status === 'active' ? 'var(--success)' : status === 'completed' ? 'var(--info)' : 'var(--text-muted)';
-
-  return (
-    <span style={{
-      fontSize: '0.7rem',
-      padding: '0.2rem 0.6rem',
-      borderRadius: 'var(--radius-full)',
-      background: 'rgba(255,255,255,0.05)',
-      border: `1px solid ${color}`,
-      color,
-      textTransform: 'uppercase',
-      fontWeight: 700,
-      letterSpacing: '0.05em'
-    }}>
-      {normalized}
-    </span>
-  );
-};
 
 export default Dashboard;

frontend/src/components/Login.tsx

@@ -19,11 +19,6 @@ const Login: React.FC = () => {
     setLoading(false);
   };
 
-  const handleSSOLogin = async (provider: 'google' | 'github') => {
-    const { error } = await supabase.auth.signInWithOAuth({ provider });
-    if (error) setError(error.message);
-  };
-
   return (
     <div className="login-screen">
       <motion.div 
@@ -95,6 +90,7 @@ const Login: React.FC = () => {
           </button>
         </form>
 
+        {/* Social Login - Hidden for now but code preserved 
         <div style={{ margin: 'var(--space-lg) 0', display: 'flex', alignItems: 'center', gap: 'var(--space-md)' }}>
           <div style={{ flex: 1, height: '1px', background: 'var(--glass-border)' }}></div>
           <span style={{ fontSize: '0.8rem', color: 'var(--text-dim)' }}>OR CONTINUE WITH</span>
@@ -102,15 +98,16 @@ const Login: React.FC = () => {
         </div>
 
         <div className="auth-provider-grid">
-          <button className="btn btn-glass" onClick={() => handleSSOLogin('google')}>
+          <button className="btn btn-glass" onClick={() => (window as any).handleSSOLogin?.('google')}>
             <Globe size={18} />
             Google
           </button>
-          <button className="btn btn-glass" onClick={() => handleSSOLogin('github')}>
+          <button className="btn btn-glass" onClick={() => (window as any).handleSSOLogin?.('github')}>
             <GitBranch size={18} />
             GitHub
           </button>
         </div>
+        */}
 
         <div style={{ marginTop: 'var(--space-lg)', fontSize: '0.85rem', color: 'var(--text-dim)' }}>
           Enterprise authentication enabled.

frontend/src/components/common/StatusBadge.tsx

@@ -0,0 +1,61 @@
+import React from 'react';
+
+interface StatusBadgeProps {
+  status: string;
+  style?: React.CSSProperties;
+}
+
+const StatusBadge: React.FC<StatusBadgeProps> = ({ status, style }) => {
+  const getStatusColor = (s: string) => {
+    switch (s?.toLowerCase()) {
+      case 'done':
+      case 'completed':
+      case 'approved':
+        return 'var(--success)';
+      case 'in_progress':
+      case 'running':
+        return 'var(--accent)';
+      case 'todo':
+      case 'queued':
+        return 'var(--text-dim)';
+      case 'failed':
+      case 'error':
+        return 'var(--danger)';
+      case 'awaiting_approval':
+        return 'var(--warning)';
+      default:
+        return 'var(--text-dim)';
+    }
+  };
+
+  const formatStatus = (s: string) => {
+    return (s || 'Unknown').replace(/_/g, ' ').toUpperCase();
+  };
+
+  return (
+    <span style={{ 
+      padding: '4px 8px', 
+      borderRadius: '4px', 
+      fontSize: '0.7rem', 
+      fontWeight: 600,
+      background: 'rgba(255,255,255,0.05)',
+      border: `1px solid ${getStatusColor(status)}33`,
+      color: getStatusColor(status),
+      display: 'inline-flex',
+      alignItems: 'center',
+      gap: '4px',
+      ...style
+    }}>
+      <span style={{ 
+        width: '6px', 
+        height: '6px', 
+        borderRadius: '50%', 
+        background: getStatusColor(status),
+        boxShadow: `0 0 8px ${getStatusColor(status)}`
+      }} />
+      {formatStatus(status)}
+    </span>
+  );
+};
+
+export default StatusBadge;