final: mobile fixes and quality relaxation

.dockerignore

@@ -0,0 +1,15 @@
+.git
+.gemini
+.vercel
+
+backend/.env
+backend/venv
+backend/__pycache__
+backend/**/__pycache__
+backend/**/*.pyc
+
+frontend/.env
+frontend/node_modules
+frontend/dist
+
+*.log

.gemini/antigravity/brain/8453b74f-68a6-47ae-887d-1123cb011afb/scratch/verify_supabase.py

@@ -0,0 +1,10 @@
+import sys
+import os
+sys.path.append(os.path.join(os.getcwd(), 'backend'))
+
+try:
+    from backend.services.supabase_service import supabase
+    res = supabase.table("agents").select("count").execute()
+    print(f"Connection successful! Agents count: {res.data}")
+except Exception as e:
+    print(f"Error connecting to Supabase: {e}")

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,13 @@
+backend/.env
+/backend/venv
+/backend/__pycache__
+frontend/.env
+node_modules/
+dist/
+__pycache__/
+*.pyc
+
+.vercel
+frontend/ios
+frontend/android
+.DS_Store

Dockerfile

@@ -0,0 +1,40 @@
+FROM node:22-slim AS frontend-build
+
+WORKDIR /app/frontend
+
+COPY frontend/package*.json ./
+RUN npm ci
+
+COPY frontend ./
+
+ARG VITE_API_URL=""
+ARG VITE_SUPABASE_URL=""
+ARG VITE_SUPABASE_ANON_KEY=""
+ARG VITE_SENTRY_DSN=""
+
+ENV VITE_API_URL=$VITE_API_URL
+ENV VITE_SUPABASE_URL=$VITE_SUPABASE_URL
+ENV VITE_SUPABASE_ANON_KEY=$VITE_SUPABASE_ANON_KEY
+ENV VITE_SENTRY_DSN=$VITE_SENTRY_DSN
+
+RUN npm run build
+
+FROM python:3.11-slim
+
+ENV PORT=7860
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+COPY VERSION VERSION
+COPY backend/requirements.txt backend/requirements.txt
+RUN pip install --no-cache-dir -r backend/requirements.txt
+
+COPY backend backend
+COPY --from=frontend-build /app/frontend/dist frontend/dist
+
+WORKDIR /app/backend
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -0,0 +1,143 @@
+---
+title: Aubm
+sdk: docker
+app_port: 7860
+license: mit
+short_description: Automated Business Machines
+---
+
+# 🤖 Aubm
+
+### Enterprise-Grade AI Agent Orchestration & Collaboration Platform
+
+Aubm (Automated Unified Business Machines) is a sophisticated platform designed to orchestrate multiple autonomous AI agents to complete complex projects. Featuring **Human-in-the-Loop** supervision, **Dynamic DAG** task execution, and **Semantic RAG** context injection.
+
+---
+
+## 🚀 Key Features
+
+- **Multi-Provider Support**: Seamless integration with OpenAI, AMD (inference.do-ai.run), Groq, Gemini, Qwen, Ollama, and OpenRouter.
+- **Autonomous Orchestration**: Intelligent task prioritization and execution based on dependencies (DAG).
+- **Human-in-the-Loop**: Approval-based workflow ensuring quality and safety.
+- **Semantic Backpropagation**: Context from completed tasks is automatically injected into subsequent tasks.
+- **Real-time Monitoring**: SSE-powered live logs and progress tracking.
+- **Project Wizard**: AI-driven project creation and task decomposition.
+- **Operational Safety**: Automatic recovery of stale runs and comprehensive health monitoring.
+
+---
+
+## 🛠️ Tech Stack
+
+- **Frontend**: React + Vite + TypeScript (Styled with Vanilla CSS for maximum performance)
+- **Backend**: FastAPI (Python 3.10+)
+- **Database**: Supabase (Postgres + Auth + Real-time)
+- **Deployment**: Optimized for Vercel (Serverless Backend + Static Frontend)
+
+---
+
+## 🏗️ Project Structure
+
+```bash
+aubm/
+├── backend/            # FastAPI Application & AI Core
+│   ├── agents/         # LLM Provider Implementations
+│   ├── routers/        # API Endpoints (Runner, Orchestrator)
+│   ├── services/       # Business Logic (Queue, RAG, Guards)
+│   └── main.py         # App Entrypoint
+├── frontend/           # React Application
+│   ├── src/            # Components, Hooks, Context, Services
+│   └── vite.config.ts  # Vite Configuration
+└── database/           # Supabase Schema & Migrations
+```
+
+---
+
+## ⚙️ Getting Started
+
+### 1. Database Setup (Supabase)
+1. Create a new project in [Supabase](https://supabase.com).
+2. Go to the **SQL Editor** and execute the content of `backend/schema.sql`.
+3. Enable **Auth** with your preferred providers (Email/Password by default).
+
+### 2. Backend Installation
+```bash
+cd backend
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+pip install -r requirements.txt
+```
+
+Create a `.env` file in `/backend`:
+```env
+SUPABASE_URL=your_project_url
+SUPABASE_SERVICE_ROLE_KEY=your_service_role_key
+OPENAI_API_KEY=optional_key
+GROQ_API_KEY=optional_key
+TAVILY_API_KEY=optional_key
+# See SPEC.md for all available providers
+```
+
+Run the server:
+```bash
+uvicorn main:app --reload --port 8000
+```
+
+### 3. Frontend Installation
+```bash
+cd frontend
+npm install
+```
+
+Create a `.env` file in `/frontend`:
+```env
+VITE_API_URL=http://localhost:8000
+VITE_SUPABASE_URL=your_project_url
+VITE_SUPABASE_ANON_KEY=your_anon_key
+```
+
+Run the development server:
+```bash
+npm run dev
+```
+
+---
+
+## 📈 Operational Modes
+
+- **Embedded Worker**: Runs the task queue within the FastAPI process (set `TASK_QUEUE_EMBEDDED_WORKER=true`).
+- **Standalone Worker**: For high-load environments, run the worker in a separate process:
+  ```bash
+  cd backend
+  python worker.py
+  ```
+
+---
+
+## Hugging Face Spaces
+
+This repository is ready to deploy as a Docker Space. Create a Hugging Face Space with SDK `Docker`, then push this repo to the Space remote.
+
+Configure these Space secrets or variables:
+
+```env
+SUPABASE_URL=your_project_url
+SUPABASE_SERVICE_ROLE_KEY=your_service_role_key
+SUPABASE_ANON_KEY=your_anon_key
+GROQ_API_KEY=optional_key
+OPENAI_API_KEY=optional_key
+GEMINI_API_KEY=optional_key
+AMD_API_KEY=optional_key
+TAVILY_API_KEY=optional_key
+TASK_QUEUE_EMBEDDED_WORKER=true
+```
+
+`VITE_API_URL` can stay empty on Spaces because the frontend calls the FastAPI backend on the same origin.
+
+---
+
+## 📄 Documentation
+
+For detailed technical architecture, refer to:
+- [SPEC.md](./SPEC.md) - Deep technical specifications.
+- [ROADMAP.md](./ROADMAP.md) - Future development goals.
+- [docs/](./docs/) - Extended guides and manuals.

ROADMAP.md

@@ -0,0 +1,61 @@
+# Aubm Roadmap
+
+This document outlines the strategic evolution of Aubm, moving from a robust orchestration core to an enterprise-ready multi-agent operating layer.
+
+## Phase 1: Core Foundation (Completed)
+- [x] Autonomous Agent Execution: Multi-provider support (OpenAI, Groq, Gemini, etc.).
+- [x] Project Orchestration: Intelligent task scheduling and dependency management (DAG).
+- [x] Human-in-the-Loop: Approval and rejection workflows for agent outputs.
+- [x] Semantic RAG: Contextual memory injection across project tasks.
+- [x] Real-time Logs: Streaming agent thoughts and actions via SSE.
+- [x] Cost Control: Token-based budgeting and execution blocking.
+
+## Phase 2: Advanced Collaboration and Tools (Completed)
+- [x] Multi-Agent Debates: Allow agents to cross-verify each other's outputs before human review.
+- [x] Extended Toolbelt:
+  - [x] Web Browser Tool (via Playwright) for live data fetching.
+  - [x] Code Sandbox for executing and testing generated snippets.
+  - [x] File Generation (Excel, Word, and advanced PDF layouts).
+- [x] Collaborative Editing: Real-time collaborative output refining for humans.
+- [x] Mobile Experience: Capacitor-based mobile app for project monitoring (initialized).
+
+## Phase 3: Intelligence and Scale (Completed)
+- [x] Fine-tuning Loop: Feedback loop (Like/Dislike) implemented for data collection.
+- [x] Recursive Project Decomposition: Agents that can spawn sub-tasks and manage them.
+- [x] Enterprise Security:
+  - [x] SSO Integration (Google, GitHub via Supabase).
+  - [x] Advanced RLS for granular team permissions.
+  - [x] Audit logs for every LLM interaction.
+- [x] Agent Marketplace: Community-driven agent templates and specialized skill sets.
+
+## Phase 4: Autonomy and Beyond (Completed)
+- [x] Self-Healing Infrastructure: Agents that can monitor health and apply safe patches.
+- [x] Voice Interaction: Control navigation and hear project/task status updates via browser voice APIs.
+- [x] VR/AR Dashboard: Spatial DAG viewer scaffold for layered project/task visualization.
+
+## Phase 5: Production Operations (Completed)
+- [x] Operations Monitoring: Backend health summary endpoint and frontend monitoring dashboard with Supabase fallback.
+- [x] Deployment Hardening: Dockerized backend/runtime profile and production CORS configuration.
+- [x] Error Tracking: Sentry-compatible error reporting hooks for backend and frontend.
+- [x] Performance Budgeting: Frontend code splitting and bundle-size targets.
+
+## Phase 6: Distributed Scale and Intelligence (In Progress)
+- [x] Recursive Project Decomposition: Agents that can automatically break down goals.
+- [x] Numerical Consistency (Semantic Backprop): Enforce absolute figures across tasks.
+- [x] Visual Tooling: Integrated support for charts and AI illustrations.
+- [x] Vercel Deployment: Monorepo serverless configuration.
+- [x] Heuristic Output Guardrails: Prompt hardening, reviewer checks, and final-report filtering for placeholders, unsupported claims, and low-quality sections.
+- [ ] Asynchronous Task Queue: Dedicated background workers (`worker.py`).
+- [ ] Vectorized Long-term Memory: Cross-project semantic retrieval.
+- [ ] Self-Optimizing Agents: Meta-prompting loops based on human feedback.
+
+## Phase 7: Structured Evidence and Entity Integrity (Next)
+- [ ] Strict JSON Task Schemas: Enforce structured outputs per task type instead of free-form text.
+- [ ] Mandatory `source_url` per Claim: Require evidence links for competitor, pricing, release, benchmark, and market claims.
+- [ ] Entity Normalization Layer: Canonicalize entity names, merge aliases, and separate direct competitors from adjacent tools before final reporting.
+- [ ] Semantic Deduplication: Collapse equivalent claims written differently across tasks.
+- [ ] Evidence-Aware Final Report: Build the final report from normalized entities and validated claims only.
+
+---
+
+*Last updated: May 6, 2026*

SPEC.md

@@ -0,0 +1,137 @@
+# 🛠️ Aubm — Technical Specification
+
+> **Target Stack**: FastAPI (Python) + React/TypeScript (Vite) + Supabase (Postgres + Auth)
+
+This document provides a comprehensive technical blueprint for recreating Aubm.
+
+---
+
+## 1. System Architecture
+
+Aubm follows a decoupled architecture with a centralized database (Supabase) acting as the source of truth and coordination layer.
+
+### Directory Structure
+```
+aubm/
+├── backend/                  # Python 3.10+
+│   ├── main.py              # Application entrypoint & CRUD API
+│   ├── worker.py            # Standalone task queue worker
+│   ├── schema.sql           # Full DDL for Supabase
+│   ├── agents/              # Provider-specific implementations
+│   │   ├── base.py          # Abstract BaseAgent class
+│   │   ├── agent_factory.py # Factory for creating agent instances
+│   │   └── {provider}_agent.py
+│   ├── routers/             # Functional endpoint grouping
+│   │   ├── agent_runner.py  # Task execution logic
+│   │   └── orchestrator.py  # Multi-task project flow
+│   └── services/            # Core business logic
+│       ├── config.py        # Configuration management
+│       ├── task_queue.py    # Background processing loop
+│       └── semantic_backprop.py # RAG context builder
+├── frontend/                # React + Vite + TS
+│   ├── src/
+│   │   ├── components/      # UI Modular components
+│   │   ├── services/        # API communication layer
+│   │   ├── context/         # Auth & Global state
+│   │   └── i18n/            # Multi-language support
+│   └── vite.config.ts
+└── database/                # Migrations & Seed data
+```
+
+---
+
+## 2. Database Schema (Supabase/Postgres)
+
+### Core Tables
+
+| Table | Purpose | Key Columns |
+|-------|---------|-------------|
+| `profiles` | User extensions | `id (uuid)`, `role`, `full_name`, `avatar_url` |
+| `projects` | Project containers | `id`, `name`, `description`, `context`, `owner_id`, `status` |
+| `agents` | AI Identities | `id`, `name`, `role`, `api_provider`, `model`, `system_prompt` |
+| `tasks` | Units of work | `id`, `project_id`, `assigned_agent_id`, `status`, `output_data` |
+| `task_runs` | Execution history | `id`, `task_id`, `agent_id`, `status`, `error_message` |
+| `agent_logs` | Execution traces | `id`, `task_id`, `action`, `content`, `metadata` |
+| `app_config` | Global settings | `key`, `value` (JSONB) |
+
+### Status Enums
+- **Tasks**: `todo`, `in_progress`, `awaiting_approval`, `done`, `failed`, `cancelled`.
+- **Task Runs**: `queued`, `running`, `completed`, `failed`, `cancelled`.
+- **Profiles**: `user`, `manager`, `admin`.
+
+---
+
+## 3. Backend Logic
+
+### Agent Execution Flow
+1. **Request**: `POST /tasks/{id}/run`
+2. **Initialization**: Fetch task, agent, and project data.
+3. **Context Building**: `semantic_backprop` fetches outputs from previous tasks in the same project.
+4. **Agent Factory**: Instantiates the correct `BaseAgent` subclass (e.g., `GroqAgent`).
+5. **Execution**:
+    - LLM call with dynamic prompt.
+    - Real-time logging to `agent_logs` via SSE.
+6. **Guardrails**:
+    - `output_cleaner`: Strips markdown artifacts.
+    - `language_guard`: Ensures output matches `app_config["output_language"]`.
+7. **Persistence**: Updates `task.output_data` and sets status to `awaiting_approval`.
+
+### Orchestration Engine
+- Processes a project's task list as a Directed Acyclic Graph (DAG).
+- Respects `is_critical` and `priority` fields.
+- Auto-assigns available agents from the `agents` pool if no agent is pre-assigned.
+
+### Tool System (Phase 2)
+- **Tool Registry**: A central registry where tools are defined and permissioned.
+- **Browser Tool**: Uses Playwright for headless browsing and content extraction.
+- **Sandbox Tool**: Executes code in a restricted environment.
+- **Integration**: Tools are exposed to agents via the OpenAI function-calling/tool-calling schema.
+
+---
+
+## 4. Frontend Design System
+
+- **Styling**: Vanilla CSS with modern variables (HSL colors, glassmorphism).
+- **Icons**: Lucide React.
+- **State Management**: React Context + Hooks.
+- **Features**:
+    - Kanban Board for task management.
+    - Real-time streaming console for agent thoughts.
+    - Interactive Project Wizard for quick setup.
+    - Analytics dashboard for project performance.
+
+---
+
+## 5. Deployment Guide
+
+### Vercel Integration
+The project is designed to run seamlessly on Vercel:
+- **Frontend**: Standard Vite build.
+- **Backend**: Python Serverless Functions.
+- **Database**: External Supabase instance.
+
+### Local Setup
+1. **DB**: Apply `schema.sql` to Supabase.
+2. **Backend**: `pip install -r requirements.txt` & `uvicorn main:app`.
+3. **Frontend**: `npm install` & `npm run dev`.
+
+---
+
+## 6. Key Dependencies
+
+### Backend
+- `fastapi`, `supabase`, `openai`, `groq`, `google-genai`, `playwright`, `folium`.
+
+### Frontend
+- `react`, `lucide-react`, `framer-motion` (for animations), `i18next`.
+
+---
+
+## 7. Security (RLS)
+- **Projects**: Only visible to owner or if `is_public=true`.
+- **Config**: Only writable by users with `role='admin'`.
+- **Agents**: Writable by `manager` or `admin`.
+- **Tasks**: Protected by project-level RLS.
+
+---
+*End of Specification*

VERSION

@@ -0,0 +1 @@
+0.7.0

backend/.env.example

@@ -0,0 +1,19 @@
+# Supabase Configuration
+SUPABASE_URL=https://your-project-id.supabase.co
+SUPABASE_SERVICE_ROLE_KEY=your-service-role-key-here
+
+# AI Provider Keys
+OPENAI_API_KEY=your-openai-key
+GROQ_API_KEY=your-groq-key
+GEMINI_API_KEY=your-gemini-key
+ANTHROPIC_API_KEY=your-anthropic-key
+TAVILY_API_KEY=your-tavily-key
+
+# App Settings
+PORT=8000
+ALLOWED_ORIGINS=http://localhost:5173,https://your-app.vercel.app
+TASK_QUEUE_EMBEDDED_WORKER=true
+OUTPUT_LANGUAGE=en
+
+# Error Tracking
+SENTRY_DSN=your-sentry-dsn

backend/Dockerfile

@@ -0,0 +1,32 @@
+# Build stage for backend
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libpq-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright browsers and their dependencies
+RUN playwright install --with-deps chromium
+
+# Copy project
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

backend/agents/agent_factory.py

@@ -0,0 +1,44 @@
+from typing import Dict, Type
+from .base import BaseAgent
+from .openai_agent import OpenAIAgent
+from .amd_agent import AMDAgent
+from .groq_agent import GroqAgent
+from .gemini_agent import GeminiAgent
+from .local_agent import LocalAgent
+from services.config import settings
+
+# Map of providers to their respective classes
+PROVIDER_MAP: Dict[str, Type[BaseAgent]] = {
+    "openai": OpenAIAgent,
+    "amd": AMDAgent,
+    "groq": GroqAgent,
+    "gemini": GeminiAgent,
+    "local": LocalAgent,
+    "ollama": LocalAgent
+}
+
+class AgentFactory:
+    @staticmethod
+    def get_agent(provider: str, name: str, role: str, model: str, system_prompt: str = None) -> BaseAgent:
+        """
+        Instantiates the appropriate agent based on the provider string.
+        Includes a fallback to Groq if OpenAI is requested but no key is provided.
+        """
+        provider = provider.lower()
+        
+        # Groq Redirection Logic
+        if provider == "openai" and not settings.OPENAI_API_KEY:
+            # Check if we have a Groq key before redirecting
+            if settings.GROQ_API_KEY:
+                provider = "groq"
+                model = "llama-3.3-70b-versatile" # Robust fallback model
+            else:
+                # If neither is available, let it fail with the original provider
+                pass
+
+        agent_class = PROVIDER_MAP.get(provider)
+        
+        if not agent_class:
+            raise ValueError(f"Unsupported agent provider: {provider}")
+            
+        return agent_class(name=name, role=role, model=model, system_prompt=system_prompt)

backend/agents/amd_agent.py

@@ -0,0 +1,33 @@
+from .base import BaseAgent
+from typing import Dict, Any, List
+import openai
+from services.config import settings, config_service
+
+class AMDAgent(BaseAgent):
+    """
+    Agent implementation for AMD Inference (inference.do-ai.run).
+    Compatible with OpenAI's API format.
+    """
+    def __init__(self, name: str, role: str, model: str = "gpt-4o", system_prompt: str = None):
+        super().__init__(name, role, model, system_prompt)
+        
+        self.provider_config = config_service.get_provider_config("amd")
+        api_key = self.provider_config.get("api_key") or settings.AMD_API_KEY
+        
+        self.client = openai.AsyncOpenAI(
+            api_key=api_key,
+            base_url=self.provider_config.get("base_url", "https://inference.do-ai.run/v1")
+        )
+        self.temperature = self.provider_config.get("temperature", 0.7)
+        self.max_tokens = self.provider_config.get("max_tokens", 4096)
+
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        return await self._run_openai_compatible(
+            provider="amd",
+            create_fn=self.client.chat.completions.create,
+            task_description=task_description,
+            context=context,
+            use_tools=use_tools,
+            extra_context=extra_context,
+            response_format={"type": "json_object"}
+        )

backend/agents/base.py

@@ -0,0 +1,162 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional
+import json
+
+class BaseAgent(ABC):
+    def __init__(self, name: str, role: str, model: str, system_prompt: Optional[str] = None):
+        self.name = name
+        self.role = role
+        self.model = model
+        self.system_prompt = system_prompt or f"You are {name}, acting as a {role}."
+
+    @abstractmethod
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        """
+        Executes a task given its description and previous context.
+        Returns a dictionary containing the output data.
+        """
+        pass
+
+    def _format_context(self, context: List[Dict[str, Any]]) -> str:
+        """Helper to format previous task outputs for the current agent."""
+        if not context:
+            return "No previous context available."
+        
+        formatted = "Previous tasks context:\n"
+        for item in context:
+            formatted += f"- Task: {item.get('title')}\n  Output: {json.dumps(item.get('output_data', {}))}\n"
+        return formatted
+
+    def _build_json_prompt(self, task_description: str, context: List[Dict[str, Any]], extra_context: str = "") -> str:
+        return f"""
+Task: {task_description}
+
+{self._format_context(context)}
+
+{extra_context}
+
+Please provide your output as a JSON object.
+"""
+
+    def _build_chat_messages(self, task_description: str, context: List[Dict[str, Any]], extra_context: str = "") -> List[Dict[str, Any]]:
+        return [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": self._build_json_prompt(task_description, context, extra_context)}
+        ]
+
+    def _parse_json_output(self, content: str) -> Any:
+        """Parse strict JSON first, then tolerate fenced or prefixed JSON."""
+        if not content:
+            return {}
+
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError:
+            pass
+
+        try:
+            if "```json" in content:
+                clean = content.split("```json", 1)[1].split("```", 1)[0].strip()
+            elif "```" in content:
+                clean = content.split("```", 1)[1].split("```", 1)[0].strip()
+            else:
+                object_start, array_start = content.find("{"), content.find("[")
+                starts = [index for index in (object_start, array_start) if index != -1]
+                start = min(starts) if starts else -1
+                if start == array_start:
+                    end = content.rfind("]")
+                else:
+                    end = content.rfind("}")
+                clean = content[start:end + 1] if start != -1 and end != -1 else content
+            return json.loads(clean)
+        except Exception:
+            return {"raw_text": content}
+
+    def _parse_tool_arguments(self, arguments: str | None) -> Dict[str, Any]:
+        parsed = self._parse_json_output(arguments or "{}")
+        return parsed if isinstance(parsed, dict) else {}
+
+    async def _append_tool_results(self, messages: List[Dict[str, Any]], tool_calls: Any, tool_registry: Any) -> None:
+        for tool_call in tool_calls or []:
+            tool_name = tool_call.function.name
+            tool_args = self._parse_tool_arguments(tool_call.function.arguments)
+            tool_result = await tool_registry.call_tool(tool_name, tool_args)
+
+            messages.append({
+                "tool_call_id": tool_call.id,
+                "role": "tool",
+                "name": tool_name,
+                "content": str(tool_result),
+            })
+
+    async def _run_openai_compatible(
+        self, 
+        provider: str, 
+        create_fn, 
+        task_description: str, 
+        context: List[Dict[str, Any]], 
+        use_tools: bool = False, 
+        extra_context: str = "",
+        **extra_kwargs
+    ) -> Dict[str, Any]:
+        """
+        Unified runner for OpenAI-compatible APIs (OpenAI, Groq, etc.)
+        """
+        from tools.registry import tool_registry
+        
+        messages = self._build_chat_messages(task_description, context, extra_context)
+        
+        is_reasoning_model = "gpt-oss-" in self.model or self.model.startswith("o1-") or self.model.startswith("o3-")
+        
+        kwargs = {
+            "model": self.model,
+            "messages": messages,
+            **extra_kwargs
+        }
+
+        # Handle temperature/max_tokens based on model type
+        if is_reasoning_model:
+            # Reasoning models prefer temperature 1.0 or none
+            kwargs["temperature"] = extra_kwargs.get("temperature", 1.0)
+            # Use max_completion_tokens if provided, otherwise default to max_tokens logic but renamed
+            if "max_completion_tokens" not in kwargs:
+                kwargs["max_completion_tokens"] = getattr(self, "max_tokens", 4096)
+            # Standard max_tokens is often forbidden in reasoning models
+            kwargs.pop("max_tokens", None)
+        else:
+            kwargs["temperature"] = getattr(self, "temperature", 0.7)
+            kwargs["max_tokens"] = getattr(self, "max_tokens", 4096)
+        
+        if use_tools:
+            # Note: Many reasoning models don't support tools yet, but we'll include if requested
+            kwargs["tools"] = tool_registry.get_tool_definitions()
+            kwargs["tool_choice"] = "auto"
+
+        response = await create_fn(**kwargs)
+        message = response.choices[0].message
+
+        # Handle tool calls
+        if message.tool_calls:
+            messages.append(message)
+            await self._append_tool_results(messages, message.tool_calls, tool_registry)
+            
+            # Second call after tool execution
+            # Remove tools from second call to force a final answer
+            kwargs.pop("tools", None)
+            kwargs.pop("tool_choice", None)
+            
+            final_response = await create_fn(**kwargs)
+            content = final_response.choices[0].message.content
+        else:
+            content = message.content
+
+        return self._result(provider, content or "")
+
+    def _result(self, provider: str, content: str) -> Dict[str, Any]:
+        return {
+            "agent_name": self.name,
+            "provider": provider,
+            "model": self.model,
+            "raw_output": content,
+            "data": self._parse_json_output(content)
+        }

backend/agents/gemini_agent.py

@@ -0,0 +1,37 @@
+from .base import BaseAgent
+from typing import Dict, Any, List
+from google import genai
+from services.config import settings, config_service
+
+class GeminiAgent(BaseAgent):
+    """
+    Agent implementation for Google Gemini using the new google-genai SDK.
+    """
+    def __init__(self, name: str, role: str, model: str = "gemini-2.0-flash", system_prompt: str = None):
+        super().__init__(name, role, model, system_prompt)
+        
+        # Load dynamic config
+        self.provider_config = config_service.get_provider_config("gemini")
+        api_key = self.provider_config.get("api_key") or settings.GEMINI_API_KEY
+        
+        self.client = genai.Client(api_key=api_key)
+        self.temperature = self.provider_config.get("temperature", 0.7)
+
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        full_prompt = f"""
+System Instruction: {self.system_prompt}
+
+{self._build_json_prompt(task_description, context, extra_context)}
+"""
+
+        # Gemini 2.0 Flash is very fast.
+        response = await self.client.aio.models.generate(
+            model=self.model,
+            contents=full_prompt,
+            config={
+                "temperature": self.temperature,
+                "response_mime_type": "application/json",
+            }
+        )
+
+        return self._result("gemini", response.text or "")

backend/agents/groq_agent.py

@@ -0,0 +1,98 @@
+import logging
+from .base import BaseAgent
+from typing import Dict, Any, List
+import groq
+import json
+from services.config import settings, config_service
+from tools.registry import tool_registry
+
+logger = logging.getLogger("uvicorn")
+
+GROQ_ROTATION_POOL = [
+    "llama-3.3-70b-versatile",
+    "openai/gpt-oss-120b",
+    "meta-llama/llama-4-scout-17b-16e-instruct",
+    "qwen/qwen3-32b",
+    "openai/gpt-oss-20b",
+    "groq/compound",
+    "llama-3.1-8b-instant"
+]
+
+class GroqAgent(BaseAgent):
+    """
+    Agent implementation for Groq with automatic model rotation for rate limits.
+    """
+    def __init__(self, name: str, role: str, model: str = "llama-3.3-70b-versatile", system_prompt: str = None):
+        # Auto-migrate decommissioned models
+        if "llama-3.1-70b" in model:
+            model = "llama-3.3-70b-versatile"
+            
+        super().__init__(name, role, model, system_prompt)
+        
+        # Load dynamic config
+        self.provider_config = config_service.get_provider_config("groq")
+        api_key = self.provider_config.get("api_key") or settings.GROQ_API_KEY
+        
+        self.client = groq.AsyncGroq(api_key=api_key)
+        self.temperature = self.provider_config.get("temperature", 0.7)
+        self.max_tokens = self.provider_config.get("max_tokens", 4096)
+        self.reasoning_effort = self.provider_config.get("reasoning_effort", "medium")
+
+    def _format_context(self, context: List[Dict[str, Any]]) -> str:
+        """Extremely aggressive truncation for Groq TPM limits."""
+        if not context:
+            return "No previous context available."
+        
+        # Only take the last 3 tasks to save tokens
+        recent_context = context[-3:]
+        
+        formatted = "Previous tasks context (EXTREMELY TRUNCATED for Groq):\n"
+        for item in recent_context:
+            output_raw = json.dumps(item.get('output_data', {}))
+            # 800 chars is roughly 200 tokens.
+            if len(output_raw) > 800:
+                output_raw = output_raw[:800] + "... [TRUNCATED]"
+            
+            formatted += f"- Task: {item.get('title')}\n  Output: {output_raw}\n"
+        return formatted
+
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        # Very limited semantic context
+        if len(extra_context) > 1000:
+            extra_context = extra_context[:1000] + "... [TRUNCATED]"
+            
+        try:
+            return await self._execute_run(task_description, context, use_tools, extra_context)
+        except groq.RateLimitError as e:
+            logger.warning(f"Rate limit reached for {self.model} (429). Attempting model rotation...")
+            
+            # Find current model index in pool
+            try:
+                current_idx = GROQ_ROTATION_POOL.index(self.model)
+            except ValueError:
+                current_idx = -1
+            
+            # Try the next model in the pool
+            next_idx = (current_idx + 1) % len(GROQ_ROTATION_POOL)
+            fallback_model = GROQ_ROTATION_POOL[next_idx]
+            
+            logger.info(f"Rotating from {self.model} to {fallback_model}")
+            self.model = fallback_model
+            
+            # Retry once with fallback model
+            return await self._execute_run(task_description, context, use_tools, extra_context)
+
+    async def _execute_run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        extra_kwargs = {}
+        if "gpt-oss-" in self.model:
+            extra_kwargs["reasoning_effort"] = self.reasoning_effort
+            
+        return await self._run_openai_compatible(
+            provider="groq",
+            create_fn=self.client.chat.completions.create,
+            task_description=task_description,
+            context=context,
+            use_tools=use_tools,
+            extra_context=extra_context,
+            **extra_kwargs
+        )

backend/agents/local_agent.py

@@ -0,0 +1,48 @@
+from .base import BaseAgent
+from typing import Dict, Any, List
+import httpx
+from services.config import config_service
+
+class LocalAgent(BaseAgent):
+    """
+    Agent implementation for Local LLMs (Ollama).
+    """
+    def __init__(self, name: str, role: str, model: str = "llama3.1:8b", system_prompt: str = None):
+        super().__init__(name, role, model, system_prompt)
+        
+        # Load dynamic config
+        self.provider_config = config_service.get_provider_config("ollama")
+        self.base_url = self.provider_config.get("base_url", "http://localhost:11434")
+        self.temperature = self.provider_config.get("temperature", 0.7)
+
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        full_prompt = f"""
+System Instructions: {self.system_prompt}
+
+{self._build_json_prompt(task_description, context, extra_context)}
+"""
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/api/generate",
+                    json={
+                        "model": self.model,
+                        "prompt": full_prompt,
+                        "stream": False,
+                        "format": "json",
+                        "options": {
+                            "temperature": self.temperature
+                        }
+                    }
+                )
+                response.raise_for_status()
+                result = response.json()
+                return self._result("local", result.get("response", "{}"))
+            except Exception as e:
+                return {
+                    "agent_name": self.name,
+                    "provider": "local",
+                    "status": "error",
+                    "error": f"Ollama connection failed: {str(e)}"
+                }

backend/agents/openai_agent.py

@@ -0,0 +1,28 @@
+from .base import BaseAgent
+from typing import Dict, Any, List
+import openai
+from services.config import settings, config_service
+from tools.registry import tool_registry
+
+class OpenAIAgent(BaseAgent):
+    def __init__(self, name: str, role: str, model: str = "gpt-4o", system_prompt: str = None):
+        super().__init__(name, role, model, system_prompt)
+        
+        # Load dynamic config
+        self.provider_config = config_service.get_provider_config("openai")
+        api_key = self.provider_config.get("api_key") or settings.OPENAI_API_KEY
+        
+        self.client = openai.AsyncOpenAI(api_key=api_key)
+        self.temperature = self.provider_config.get("temperature", 0.7)
+        self.max_tokens = self.provider_config.get("max_tokens", 4096)
+
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        return await self._run_openai_compatible(
+            provider="openai",
+            create_fn=self.client.chat.completions.create,
+            task_description=task_description,
+            context=context,
+            use_tools=use_tools,
+            extra_context=extra_context,
+            response_format={"type": "json_object"}
+        )

backend/agents_debug.json

@@ -0,0 +1 @@
+[{"id": "297ef087-89af-4e3b-8d80-c5c5c7499e3b", "name": "GPT-4o", "role": "General Intelligence", "api_provider": "openai", "model": "gpt-4o", "system_prompt": "You are a highly capable AI assistant.", "created_at": "2026-05-04T14:32:03.072888+00:00", "updated_at": "2026-05-04T14:32:03.072888+00:00", "user_id": null}, {"id": "64aebf0c-625a-4c6f-895d-a36274c4f9fd", "name": "AMD-4o", "role": "Performance Specialist", "api_provider": "amd", "model": "gpt-4o", "system_prompt": "You are a high-performance agent running on AMD infrastructure.", "created_at": "2026-05-04T14:32:03.072888+00:00", "updated_at": "2026-05-04T14:32:03.072888+00:00", "user_id": null}, {"id": "f7cc5a82-1e7d-4f21-9855-922fb82cd6f9", "name": "Llama-3-70B", "role": "Fast Logic", "api_provider": "groq", "model": "llama3-70b-8192", "system_prompt": "You are a fast and efficient reasoning agent.", "created_at": "2026-05-04T14:32:03.072888+00:00", "updated_at": "2026-05-04T14:32:03.072888+00:00", "user_id": null}, {"id": "1d988b3c-38c1-4132-85e1-82e7a4bc4f8a", "name": "Growth Hacker", "role": "Marketing Expert", "api_provider": "openai", "model": "gpt-4o", "system_prompt": "You are a Growth Hacker focused on low-cost, high-impact strategies.", "created_at": "2026-05-04T15:50:52.628388+00:00", "updated_at": "2026-05-04T15:50:52.628388+00:00", "user_id": "483025be-ca4b-4de3-aa80-9eb39dbd3578"}, {"id": "7b056c90-f4a6-4629-81b1-f4316b76d091", "name": "Growth Hacker", "role": "Marketing Expert", "api_provider": "openai", "model": "gpt-4o", "system_prompt": "You are a Growth Hacker focused on low-cost, high-impact strategies.", "created_at": "2026-05-04T16:22:10.993123+00:00", "updated_at": "2026-05-04T16:22:10.993123+00:00", "user_id": "483025be-ca4b-4de3-aa80-9eb39dbd3578"}, {"id": "138d7d29-b2c0-4ffb-b89f-1a0965dca6b6", "name": "Planner", "role": "Project Planner", "api_provider": "openai", "model": "gpt-4o", "system_prompt": "You decompose goals into clear, ordered implementation tasks.", "created_at": "2026-05-04T18:06:05.280562+00:00", "updated_at": "2026-05-04T18:06:05.280562+00:00", "user_id": "483025be-ca4b-4de3-aa80-9eb39dbd3578"}, {"id": "edfc99cf-a70c-42e0-a2f6-4508bb6aac33", "name": "Builder", "role": "Implementation Agent", "api_provider": "openai", "model": "gpt-4o", "system_prompt": "You implement practical, production-oriented solutions with concise output.", "created_at": "2026-05-04T18:06:05.280562+00:00", "updated_at": "2026-05-04T18:06:05.280562+00:00", "user_id": "483025be-ca4b-4de3-aa80-9eb39dbd3578"}, {"id": "5ef6c6f3-fc4a-40ba-abe8-7630fefcece2", "name": "Reviewer", "role": "Quality Reviewer", "api_provider": "openai", "model": "gpt-4o", "system_prompt": "You review outputs for correctness, security, completeness, and missing tests.", "created_at": "2026-05-04T18:06:05.280562+00:00", "updated_at": "2026-05-04T18:06:05.280562+00:00", "user_id": "483025be-ca4b-4de3-aa80-9eb39dbd3578"}]

backend/api/index.py

@@ -0,0 +1 @@
+from main import app

backend/main.py

@@ -0,0 +1,102 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, Response
+import os
+import json
+from pathlib import Path
+from dotenv import load_dotenv
+import sentry_sdk
+
+
+def _load_app_version() -> str:
+    version_file = Path(__file__).resolve().parent.parent / "VERSION"
+    if version_file.exists():
+        value = version_file.read_text(encoding="utf-8").strip()
+        if value:
+            return value
+    return os.getenv("APP_VERSION", "0.7.0")
+
+
+# Load environment variables
+load_dotenv()
+FRONTEND_DIST = Path(__file__).resolve().parent.parent / "frontend" / "dist"
+APP_VERSION = _load_app_version()
+
+# Sentry Initialization
+SENTRY_DSN = os.getenv("SENTRY_DSN")
+if SENTRY_DSN:
+    sentry_sdk.init(
+        dsn=SENTRY_DSN,
+        traces_sample_rate=1.0,
+        profiles_sample_rate=1.0,
+    )
+
+app = FastAPI(
+    title="Aubm API",
+    description="Enterprise-Grade AI Agent Orchestration & Collaboration Platform",
+    version=APP_VERSION
+)
+
+# CORS Configuration
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "http://localhost:5173,http://localhost:3000,http://127.0.0.1:5173").split(",")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins if allowed_origins != ["*"] else ["*"],
+    allow_origin_regex=os.getenv("ALLOWED_ORIGIN_REGEX"),
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    index_path = FRONTEND_DIST / "index.html"
+    if index_path.exists():
+        return FileResponse(index_path)
+
+    return {
+        "status": "online",
+        "message": "Aubm API is operational",
+        "version": APP_VERSION
+    }
+
+# Placeholder for routers
+from routers import agent_runner, orchestrator, monitoring
+
+app.include_router(agent_runner.router, prefix="/tasks", tags=["Tasks"])
+app.include_router(orchestrator.router, prefix="/orchestrator", tags=["Orchestration"])
+app.include_router(monitoring.router, prefix="/monitoring", tags=["Monitoring"])
+
+@app.get("/runtime-config.js", include_in_schema=False)
+async def runtime_config():
+    config = {
+        "apiUrl": os.getenv("VITE_API_URL", ""),
+        "supabaseUrl": os.getenv("VITE_SUPABASE_URL", os.getenv("SUPABASE_URL", "")),
+        "supabaseAnonKey": os.getenv("VITE_SUPABASE_ANON_KEY", os.getenv("SUPABASE_ANON_KEY", "")),
+        "sentryDsn": os.getenv("VITE_SENTRY_DSN", os.getenv("SENTRY_DSN", "")),
+        "appVersion": APP_VERSION,
+    }
+    return Response(
+        content=f"window.__AUBM_CONFIG__ = {json.dumps(config)};",
+        media_type="application/javascript",
+    )
+
+@app.get("/{path:path}", include_in_schema=False)
+async def serve_frontend(path: str):
+    if not FRONTEND_DIST.exists():
+        return await root()
+
+    requested_path = FRONTEND_DIST / path
+    if requested_path.is_file():
+        return FileResponse(requested_path)
+
+    index_path = FRONTEND_DIST / "index.html"
+    if index_path.exists():
+        return FileResponse(index_path)
+
+    return await root()
+
+if __name__ == "__main__":
+    import uvicorn
+    from services.config import settings
+    uvicorn.run("main:app", host="0.0.0.0", port=settings.PORT, reload=True)

backend/project_debug.json

@@ -0,0 +1 @@
+{"id": "53f39562-09aa-447b-b251-3844e1415d4c", "name": "Commercial analysis", "description": "I want to evaluate differents applications similar to this app", "context": "search in internet", "owner_id": "483025be-ca4b-4de3-aa80-9eb39dbd3578", "status": "active", "is_public": true, "created_at": "2026-05-04T16:38:03.872534+00:00", "updated_at": "2026-05-04T16:38:03.872534+00:00", "team_id": null}

backend/requirements.txt

@@ -0,0 +1,19 @@
+fastapi
+uvicorn[standard]
+supabase
+openai
+groq
+google-genai
+playwright
+folium
+python-dotenv
+pydantic
+pydantic-settings
+httpx
+jinja2
+python-multipart
+reportlab
+pandas
+openpyxl
+psutil
+sentry-sdk[fastapi]

backend/routers/__init__.py

@@ -0,0 +1 @@
+# Routers package

backend/routers/agent_runner.py

@@ -0,0 +1,151 @@
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+from services.supabase_service import supabase
+from services.agent_runner_service import AgentRunnerService
+from services.output_quality import report_text_from_output
+import logging
+
+router = APIRouter()
+logger = logging.getLogger("uvicorn")
+
+
+def _assert_task_quality(task: dict):
+    output_data = task.get("output_data") or {}
+    if not isinstance(output_data, dict):
+        raise HTTPException(status_code=400, detail="Task output is missing or malformed.")
+    if output_data.get("error"):
+        raise HTTPException(status_code=400, detail=f"Task execution failed: {output_data['error']}")
+    rendered = report_text_from_output(output_data).strip()
+    if not rendered or rendered in ("{}", "[]"):
+        raise HTTPException(status_code=400, detail="Task has no usable output to approve.")
+    quality_review = output_data.get("quality_review")
+    if not quality_review:
+        raise HTTPException(status_code=400, detail="Task output is missing quality validation.")
+    if quality_review.get("approved"):
+        return
+    reasons = quality_review.get("fail_reasons") or ["Task output failed quality validation."]
+    raise HTTPException(status_code=400, detail=f"Task output failed quality review: {'; '.join(reasons)}")
+
+def update_task_status(task_id: str, status: str):
+    result = (
+        supabase.table("tasks")
+        .update({"status": status})
+        .eq("id", task_id)
+        .execute()
+    )
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Task not found or status was not updated")
+
+    task_data = result.data[0]
+
+    project_id = task_data.get("project_id")
+    if project_id:
+        task_result = (
+            supabase.table("tasks")
+            .select("id,status")
+            .eq("project_id", project_id)
+            .execute()
+        )
+        tasks = task_result.data or []
+        if status == "done" and tasks and all(task.get("status") == "done" for task in tasks):
+            supabase.table("projects").update({"status": "completed"}).eq("id", project_id).execute()
+        elif status != "done":
+            supabase.table("projects").update({"status": "active"}).eq("id", project_id).execute()
+
+    return task_data
+
+@router.post("/{task_id}/run")
+async def run_task(task_id: str, background_tasks: BackgroundTasks):
+    """
+    Triggers the execution of a specific task.
+    """
+    # 1. Fetch task data
+    task_res = supabase.table("tasks").select("*, project:projects(*)").eq("id", task_id).single().execute()
+    if not task_res.data:
+        raise HTTPException(status_code=404, detail="Task not found")
+    
+    task = task_res.data
+    
+    # 2. Check if agent is assigned
+    agent_id = task.get("assigned_agent_id")
+    if not agent_id:
+        raise HTTPException(status_code=400, detail="No agent assigned to this task")
+    
+    # 3. Fetch agent data
+    agent_res = supabase.table("agents").select("*").eq("id", agent_id).single().execute()
+    if not agent_res.data:
+        raise HTTPException(status_code=404, detail="Assigned agent not found")
+    
+    agent_data = agent_res.data
+    
+    # 4. Update task status to in_progress
+    supabase.table("tasks").update({"status": "in_progress"}).eq("id", task_id).execute()
+    
+    # 5. Run in background
+    background_tasks.add_task(AgentRunnerService.execute_agent_logic, task, agent_data)
+    
+    return {"message": "Task execution started", "task_id": task_id}
+
+@router.post("/{task_id}/approve")
+async def approve_task(task_id: str):
+    task_res = supabase.table("tasks").select("*").eq("id", task_id).single().execute()
+    if not task_res.data:
+        raise HTTPException(status_code=404, detail="Task not found")
+    _assert_task_quality(task_res.data)
+    task = update_task_status(task_id, "done")
+    return {"message": "Task approved", "task": task}
+
+@router.post("/{task_id}/reject")
+async def reject_task(task_id: str):
+    task = update_task_status(task_id, "todo")
+    return {"message": "Task rejected", "task": task}
+@router.post("/project/{project_id}/approve-all")
+async def approve_all_tasks(project_id: str):
+    """
+    Approves all tasks in a project that are awaiting approval.
+    """
+    waiting_tasks = (
+        supabase.table("tasks")
+        .select("*")
+        .eq("project_id", project_id)
+        .eq("status", "awaiting_approval")
+        .execute()
+        .data
+        or []
+    )
+    blocked = []
+    approvable_ids = []
+    for task in waiting_tasks:
+        try:
+            _assert_task_quality(task)
+            approvable_ids.append(task["id"])
+        except HTTPException:
+            blocked.append(task["title"])
+
+    # 1. Update tasks
+    result_data = []
+    if approvable_ids:
+        result = (
+            supabase.table("tasks")
+            .update({"status": "done"})
+            .eq("project_id", project_id)
+            .in_("id", approvable_ids)
+            .execute()
+        )
+        result_data = result.data or []
+    
+    # 2. Check if all tasks in project are now done
+    task_result = (
+        supabase.table("tasks")
+        .select("status")
+        .eq("project_id", project_id)
+        .execute()
+    )
+    tasks = task_result.data or []
+    if tasks and all(task.get("status") == "done" for task in tasks):
+        supabase.table("projects").update({"status": "completed"}).eq("id", project_id).execute()
+    
+    return {
+        "message": f"Approved {len(result_data)} tasks",
+        "count": len(result_data),
+        "blocked": blocked
+    }

backend/routers/monitoring.py

@@ -0,0 +1,70 @@
+from datetime import datetime, timezone
+from fastapi import APIRouter
+from services.supabase_service import supabase
+
+router = APIRouter()
+
+
+def _count_table(table_name: str) -> int:
+    response = supabase.table(table_name).select("id", count="exact").limit(1).execute()
+    return response.count or 0
+
+
+@router.get("/summary")
+async def monitoring_summary():
+    """
+    Lightweight operational summary for dashboards and uptime checks.
+    """
+    checks = {
+        "api": "ok",
+        "database": "ok",
+    }
+
+    counts = {
+        "projects": 0,
+        "tasks": 0,
+        "agents": 0,
+        "task_runs": 0,
+        "failed_tasks": 0,
+        "pending_reviews": 0,
+    }
+
+    try:
+        counts["projects"] = _count_table("projects")
+        counts["tasks"] = _count_table("tasks")
+        counts["agents"] = _count_table("agents")
+        counts["task_runs"] = _count_table("task_runs")
+        counts["failed_tasks"] = (
+            supabase.table("tasks")
+            .select("id", count="exact")
+            .eq("status", "failed")
+            .limit(1)
+            .execute()
+            .count
+            or 0
+        )
+        counts["pending_reviews"] = (
+            supabase.table("tasks")
+            .select("id", count="exact")
+            .eq("status", "awaiting_approval")
+            .limit(1)
+            .execute()
+            .count
+            or 0
+        )
+    except Exception as exc:
+        checks["database"] = "error"
+        return {
+            "status": "degraded",
+            "checks": checks,
+            "counts": counts,
+            "error": str(exc),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+
+    return {
+        "status": "ok",
+        "checks": checks,
+        "counts": counts,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }

backend/routers/orchestrator.py

@@ -0,0 +1,169 @@
+from fastapi import APIRouter, BackgroundTasks, HTTPException
+from fastapi.responses import Response
+from services.orchestrator_service import orchestrator_service
+from pydantic import BaseModel
+from io import BytesIO
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.graphics.shapes import Drawing
+from reportlab.graphics.charts.barcharts import VerticalBarChart
+from reportlab.graphics.charts.piecharts import Pie
+from reportlab.lib import colors
+from reportlab.lib.units import inch
+import re
+
+router = APIRouter()
+
+def _safe_filename(value: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9_-]+", "_", value).strip("_").lower() or "report"
+
+def _bar_chart(title: str, rows: list[dict]) -> Drawing:
+    drawing = Drawing(460, 180)
+    chart = VerticalBarChart()
+    chart.x = 40
+    chart.y = 35
+    chart.height = 110
+    chart.width = 380
+    chart.data = [[row["value"] for row in rows]]
+    chart.categoryAxis.categoryNames = [row["label"] for row in rows]
+    chart.valueAxis.valueMin = 0
+    chart.valueAxis.valueMax = max([row["value"] for row in rows] + [1])
+    chart.valueAxis.valueStep = max(1, round(chart.valueAxis.valueMax / 4))
+    chart.bars[0].fillColor = colors.HexColor("#14b8a6")
+    drawing.add(chart)
+    return drawing
+
+def _pie_chart(rows: list[dict]) -> Drawing:
+    drawing = Drawing(460, 180)
+    pie = Pie()
+    pie.x = 150
+    pie.y = 20
+    pie.width = 140
+    pie.height = 140
+    pie.data = [row["value"] for row in rows]
+    pie.labels = [row["label"] for row in rows]
+    pie.slices.strokeWidth = 0.5
+    palette = [colors.HexColor("#22c55e"), colors.HexColor("#facc15"), colors.HexColor("#ef4444")]
+    for index, color in enumerate(palette[:len(rows)]):
+        pie.slices[index].fillColor = color
+    drawing.add(pie)
+    return drawing
+
+def _report_pdf_bytes(title: str, content: str, charts: dict | None = None) -> bytes:
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=0.7 * inch,
+        leftMargin=0.7 * inch,
+        topMargin=0.7 * inch,
+        bottomMargin=0.7 * inch,
+    )
+    styles = getSampleStyleSheet()
+    story = [Paragraph(title, styles["Title"]), Spacer(1, 0.2 * inch)]
+    if charts:
+        story.append(Paragraph("Project Execution Summary", styles["Heading2"]))
+        story.append(Spacer(1, 0.1 * inch))
+        
+        # Summary Table instead of charts
+        table_data = [["Metric / Category", "Value"]]
+        
+        # Tasks Status
+        status_counts = {row["label"]: row["value"] for row in charts.get("status", [])}
+        for label, val in status_counts.items():
+            table_data.append([f"Tasks: {label}", str(val)])
+            
+        # Categories
+        for cat in charts.get("categories", []):
+            table_data.append([f"Type: {cat['label']}", str(cat['value'])])
+
+        table = Table(table_data, colWidths=[3.5*inch, 1.5*inch])
+        table.setStyle(TableStyle([
+            ('BACKGROUND', (0,0), (-1,0), colors.HexColor("#6e59ff")),
+            ('TEXTCOLOR', (0,0), (-1,0), colors.whitesmoke),
+            ('ALIGN', (0,0), (-1,-1), 'LEFT'),
+            ('FONTNAME', (0,0), (-1,0), 'Helvetica-Bold'),
+            ('BOTTOMPADDING', (0,0), (-1,0), 10),
+            ('BACKGROUND', (0,1), (-1,-1), colors.HexColor("#f8fafc")),
+            ('GRID', (0,0), (-1,-1), 0.5, colors.grey),
+            ('FONTSIZE', (0,0), (-1,-1), 9),
+        ]))
+        story.append(table)
+        story.append(Spacer(1, 0.3 * inch))
+
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if not line:
+            story.append(Spacer(1, 0.1 * inch))
+            continue
+        if line.startswith("# "):
+            story.append(Paragraph(line[2:], styles["Title"]))
+        elif line.startswith("## "):
+            story.append(Paragraph(line[3:], styles["Heading2"]))
+        elif line.startswith("### "):
+            story.append(Paragraph(line[4:], styles["Heading3"]))
+        elif line.startswith("- "):
+            story.append(Paragraph(f"• {line[2:]}", styles["BodyText"]))
+        else:
+            story.append(Paragraph(line, styles["BodyText"]))
+
+    doc.build(story)
+    return buffer.getvalue()
+
+class DebateRequest(BaseModel):
+
+    task_id: str
+    agent_a_id: str
+    agent_b_id: str
+
+@router.post("/debate")
+async def start_debate(request: DebateRequest, background_tasks: BackgroundTasks):
+    """
+    Starts a debate between two agents for a specific task.
+    """
+    background_tasks.add_task(
+        orchestrator_service.run_debate, 
+        request.task_id, 
+        request.agent_a_id, 
+        request.agent_b_id
+    )
+    return {"message": "Debate started in background"}
+
+
+@router.post("/projects/{project_id}/run")
+async def run_project_orchestrator(project_id: str, background_tasks: BackgroundTasks):
+    """
+    Runs all queued tasks for a project in priority order.
+    """
+    background_tasks.add_task(orchestrator_service.run_project, project_id)
+    return {"message": "Project orchestrator started", "project_id": project_id}
+
+@router.get("/projects/{project_id}/final-report")
+async def get_project_final_report(project_id: str, variant: str = "full"):
+    """
+    Builds a consolidated report from all approved task outputs.
+    """
+    try:
+        return await orchestrator_service.build_final_report(project_id, variant)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+@router.get("/projects/{project_id}/final-report.pdf")
+async def download_project_final_report_pdf(project_id: str, variant: str = "full"):
+    """
+    Downloads the selected report variant as a PDF.
+    """
+    try:
+        result = await orchestrator_service.build_final_report(project_id, variant)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    title = f"{result['project_name']} - {result['variant']} report"
+    pdf = _report_pdf_bytes(title, result["report"], result.get("charts"))
+    filename = f"{_safe_filename(result['project_name'])}_{_safe_filename(result['variant'])}.pdf"
+    return Response(
+        content=pdf,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'}
+    )

backend/scratch/check_db.py

@@ -0,0 +1,22 @@
+import os
+from supabase import create_client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+supabase_url = os.getenv("SUPABASE_URL")
+supabase_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+supabase = create_client(supabase_url, supabase_key)
+
+def check_logs():
+    try:
+        res = supabase.table("agent_logs").select("*").order("created_at", desc=True).limit(20).execute()
+        print(f"Total logs retrieved: {len(res.data)}")
+        for log in res.data:
+            print(f"[{log['created_at']}] {log['action']}: {log['content'][:50]}...")
+            
+    except Exception as e:
+        print(f"Error accessing agent_logs: {e}")
+
+if __name__ == "__main__":
+    check_logs()

backend/scratch/create_comparison_project.py

@@ -0,0 +1,61 @@
+import os
+from supabase import create_client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+supabase_url = os.getenv("SUPABASE_URL")
+supabase_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+supabase = create_client(supabase_url, supabase_key)
+
+def create_project():
+    try:
+        # 1. Try to get owner_id from existing projects first
+        existing_projects = supabase.table("projects").select("owner_id").limit(1).execute()
+        user_id = None
+        if existing_projects.data and existing_projects.data[0].get("owner_id"):
+            user_id = existing_projects.data[0]["owner_id"]
+        
+        if not user_id:
+            # Fallback to profiles
+            users = supabase.table("profiles").select("id").limit(1).execute()
+            if users.data:
+                user_id = users.data[0]["id"]
+
+        if not user_id:
+            print("No valid owner_id found in projects or profiles. The project will be created without owner and might not be visible.")
+        else:
+            print(f"Using owner_id: {user_id}")
+
+        # 2. Create Project
+        project_data = {
+            "name": "Aubm Competitor Analysis",
+            "description": "Deep dive into the multi-agent orchestration market to identify Aubm's unique value proposition and feature gaps.",
+            "status": "active",
+            "context": "Focus on developer experience, visual observability, and the 'Agent Debate' mechanism as key differentiators."
+        }
+        if user_id:
+            project_data["owner_id"] = user_id
+            
+        project_res = supabase.table("projects").insert(project_data).execute()
+        project_id = project_res.data[0]["id"]
+        print(f"Created Project: {project_id}")
+
+        # 3. Create Tasks
+        tasks = [
+            {"title": "Identify Top 5 Competitors", "description": "Research and list 5 similar multi-agent orchestration platforms (e.g., CrewAI, AutoGen, LangGraph, PydanticAI).", "status": "todo", "project_id": project_id},
+            {"title": "Feature Comparison Matrix", "description": "Create a detailed matrix comparing Aubm's core features (Project Decomposition, Agent Debate, Real-time Console) against identified competitors.", "status": "todo", "project_id": project_id},
+            {"title": "Pricing Model Analysis", "description": "Analyze how competitors charge (SaaS, Open Source, API usage) and recommend a competitive strategy for Aubm.", "status": "todo", "project_id": project_id},
+            {"title": "UI/UX Aesthetic Audit", "description": "Evaluate the visual aesthetics and ease of use of competitors compared to Aubm's premium dashboard. Look for glassmorphism and animations.", "status": "todo", "project_id": project_id},
+            {"title": "Technical Architecture Deep-Dive", "description": "Investigate the underlying tech stacks (Python vs TS, Vector DBs used, Orchestration logic) of top competitors.", "status": "todo", "project_id": project_id},
+            {"title": "SWOT Analysis & Strategy Report", "description": "Compile all findings into a comprehensive report with a SWOT analysis and strategic recommendations for the next 6 months.", "status": "todo", "project_id": project_id}
+        ]
+        
+        supabase.table("tasks").insert(tasks).execute()
+        print(f"Added {len(tasks)} tasks to the project.")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    create_project()

backend/scratch/find_user.py

@@ -0,0 +1,24 @@
+import os
+from supabase import create_client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+supabase_url = os.getenv("SUPABASE_URL")
+supabase_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+supabase = create_client(supabase_url, supabase_key)
+
+def check_users():
+    # Try different tables where users might be
+    tables = ["profiles", "users", "team_members"]
+    for table in tables:
+        try:
+            res = supabase.table(table).select("id").limit(1).execute()
+            print(f"Table {table} count: {len(res.data)}")
+            if res.data:
+                print(f"Sample ID: {res.data[0]['id']}")
+        except Exception as e:
+            print(f"Error checking {table}: {e}")
+
+if __name__ == "__main__":
+    check_users()

backend/scratch/fix_logs_rls.py

@@ -0,0 +1,33 @@
+import os
+from supabase import create_client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+supabase_url = os.getenv("SUPABASE_URL")
+supabase_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+supabase = create_client(supabase_url, supabase_key)
+
+sql = """
+ALTER TABLE agent_logs ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Enable read access for all users" ON agent_logs;
+CREATE POLICY "Enable read access for all users" ON agent_logs FOR SELECT USING (true);
+"""
+
+# Note: This assumes an 'exec_sql' RPC exists, which is common in many setups.
+# If not, I'll have to find another way.
+try:
+    # Actually, let's try a different approach if RPC fails.
+    # We can try to use the REST API to check if it works.
+    print("Attempting to set RLS policy...")
+    # Since I don't have direct SQL access via the client without RPC, 
+    # I'll assume the user might need to do this in the dashboard or I'll try to find an RPC.
+    
+    # Let's check if the client can read with anon key.
+    anon_key = os.getenv("SUPABASE_ANON_KEY")
+    anon_s = create_client(supabase_url, anon_key)
+    res = anon_s.table("agent_logs").select("*").limit(1).execute()
+    print(f"Anon read test: {'Success' if not res.data else 'Empty/Restricted'}")
+    
+except Exception as e:
+    print(f"Error: {e}")

backend/services/agent_runner_service.py

@@ -0,0 +1,210 @@
+import logging
+from datetime import datetime, timezone
+from services.supabase_service import supabase
+from services.audit_service import audit_service
+from agents.agent_factory import AgentFactory
+from services.semantic_backprop import semantic_backprop
+from services.output_quality import build_quality_instructions, validate_output
+
+logger = logging.getLogger("agent_runner_service")
+
+class AgentRunnerService:
+    @staticmethod
+    async def run_agent_task(
+        task: dict,
+        agent_data: dict,
+        *,
+        include_semantic_context: bool = False,
+        start_action: str = "execution_start",
+        start_content: str | None = None,
+        complete_action: str = "execution_complete",
+        complete_content: str = "Agent successfully completed the task and produced output.",
+        update_task: bool = True
+    ) -> tuple[dict, str]:
+        task_id = task["id"]
+        project_id = task["project_id"]
+        run_id = None
+
+        if update_task:
+            supabase.table("tasks").update({"status": "in_progress"}).eq("id", task_id).execute()
+
+        try:
+            run_res = supabase.table("task_runs").insert({
+                "task_id": task_id,
+                "agent_id": agent_data["id"],
+                "status": "running"
+            }).execute()
+            run_id = run_res.data[0]["id"]
+
+            agent = AgentFactory.get_agent(
+                provider=agent_data["api_provider"],
+                name=agent_data["name"],
+                role=agent_data["role"],
+                model=agent_data["model"],
+                system_prompt=agent_data.get("system_prompt")
+            )
+
+            context_res = supabase.table("tasks").select("title, output_data") \
+                .eq("project_id", project_id) \
+                .eq("status", "done") \
+                .execute()
+            context = context_res.data if context_res.data else []
+
+            project_data = task.get("project")
+            if not isinstance(project_data, dict):
+                project_res = (
+                    supabase.table("projects")
+                    .select("name,description,context")
+                    .eq("id", project_id)
+                    .single()
+                    .execute()
+                )
+                project_data = project_res.data if project_res and project_res.data else {}
+            quality_task = {**task, "project": project_data}
+
+            extra_context = ""
+            if include_semantic_context:
+                extra_context = await semantic_backprop.get_project_context(project_id, task_id)
+
+            import time
+            import hashlib
+            
+            # Simple in-memory cache for the session (could be persistent later)
+            if not hasattr(AgentRunnerService, "_task_cache"):
+                AgentRunnerService._task_cache = {}
+
+            # 1. Create a cache key based on task, agent (model + system prompt), and context
+            cache_input = f"{task['id']}-{agent_data['model']}-{agent_data.get('system_prompt', '')}-{task.get('description')}-{str(context)}-{extra_context}"
+            cache_key = hashlib.md5(cache_input.encode()).hexdigest()
+            
+            # 2. Check Cache
+            if cache_key in AgentRunnerService._task_cache:
+                logger.info(f"Cache hit for task {task_id}. Skipping LLM call.")
+                cached_result = AgentRunnerService._task_cache[cache_key]
+                
+                # Still log the "start" for UI consistency
+                agent_name = agent_data.get('name', 'Agent')
+                log_msg = start_content or f"Agent {agent_name} resuming task"
+                supabase.table("agent_logs").insert({
+                    "task_id": task_id,
+                    "run_id": run_id,
+                    "action": start_action,
+                    "content": f"[CACHE HIT] {log_msg}"
+                }).execute()
+                
+                if update_task:
+                    supabase.table("tasks").update({
+                        "status": "awaiting_approval",
+                        "output_data": cached_result
+                    }).eq("id", task_id).execute()
+                
+                return cached_result, run_id
+
+            # 3. Log Start
+            supabase.table("agent_logs").insert({
+                "task_id": task_id,
+                "run_id": run_id,
+                "action": start_action,
+                "content": start_content or f"Agent {agent_data['name']} starting task: {task['title']}"
+            }).execute()
+
+            # 4. Execute Run with timing
+            start_time = time.time()
+            task_instructions = task.get("description") or task["title"]
+            task_instructions = f"{task_instructions}\n\n{build_quality_instructions(quality_task)}"
+            result = await agent.run(task_instructions, context, extra_context=extra_context)
+            duration = time.time() - start_time
+
+            if result.get("status") == "error":
+                raise RuntimeError(result.get("error") or "Agent returned an error result.")
+
+            # 5. Security Sanitization (Defense in Depth)
+            raw_out = str(result.get("raw_output", ""))
+            suspicious_patterns = ["rm -rf", "mkfs", "dd if=", "curl", "wget", "chmod 777", "> /dev/sda"]
+            for pattern in suspicious_patterns:
+                if pattern in raw_out:
+                    logger.warning(f"SECURITY: Suspicious pattern '{pattern}' detected in agent output for task {task_id}.")
+                    result["security_warning"] = f"Output sanitized: suspicious pattern '{pattern}' detected."
+                    # We don't block yet, but we flag it.
+
+            quality_review = validate_output(quality_task, result)
+            result["quality_review"] = quality_review
+
+            # 6. Save to Cache
+            AgentRunnerService._task_cache[cache_key] = result
+
+            if update_task:
+                supabase.table("tasks").update({
+                    "status": "awaiting_approval",
+                    "output_data": result
+                }).eq("id", task_id).execute()
+
+            # 7. Update Run Status
+            supabase.table("task_runs").update({
+                "status": "completed",
+                "finished_at": datetime.now(timezone.utc).isoformat(),
+                "duration_seconds": round(duration, 2)
+            }).eq("id", run_id).execute()
+
+            # 8. Log Completion with Metrics
+            supabase.table("agent_logs").insert({
+                "task_id": task_id,
+                "run_id": run_id,
+                "action": complete_action,
+                "content": f"{complete_content} (Execution time: {duration:.2f}s)"
+            }).execute()
+
+            if not quality_review["approved"]:
+                supabase.table("agent_logs").insert({
+                    "task_id": task_id,
+                    "run_id": run_id,
+                    "action": "quality_review_failed",
+                    "content": f"Quality review failed: {', '.join(quality_review['fail_reasons'])}"
+                }).execute()
+
+            return result, run_id
+
+        except Exception as e:
+            logger.error(f"Error executing task {task_id}: {str(e)}")
+            if run_id:
+                supabase.table("task_runs").update({
+                    "status": "failed",
+                    "finished_at": datetime.now(timezone.utc).isoformat()
+                }).eq("id", run_id).execute()
+            
+            if update_task:
+                supabase.table("tasks").update({
+                    "status": "failed",
+                    "output_data": {"error": str(e)}
+                }).eq("id", task_id).execute()
+
+            # LOG ERROR TO AGENT CONSOLE
+            supabase.table("agent_logs").insert({
+                "task_id": task_id,
+                "run_id": run_id,
+                "action": "execution_failed",
+                "content": f"ERROR: {str(e)}"
+            }).execute()
+
+            raise e
+
+    @staticmethod
+    async def execute_agent_logic(task: dict, agent_data: dict):
+        task_id = task["id"]
+        try:
+            await AgentRunnerService.run_agent_task(
+                task,
+                agent_data,
+                include_semantic_context=True
+            )
+
+            await audit_service.log_action(
+                user_id=None,
+                action="agent_task_completed",
+                agent_id=agent_data["id"],
+                task_id=task_id,
+                metadata={"model": agent_data["model"]}
+            )
+
+        except Exception:
+            raise

backend/services/audit_service.py

@@ -0,0 +1,31 @@
+from services.supabase_service import supabase
+from typing import Dict, Any, Optional
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class AuditService:
+    @staticmethod
+    async def log_action(
+        user_id: Optional[str],
+        action: str,
+        agent_id: Optional[str] = None,
+        task_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Records an action in the audit_logs table.
+        """
+        try:
+            data = {
+                "user_id": user_id,
+                "action": action,
+                "agent_id": agent_id,
+                "task_id": task_id,
+                "metadata": metadata or {}
+            }
+            supabase.table("audit_logs").insert(data).execute()
+        except Exception as e:
+            logger.error(f"AuditService error: {str(e)}")
+
+audit_service = AuditService()

backend/services/config.py

@@ -0,0 +1,101 @@
+import os
+from pydantic_settings import BaseSettings
+from typing import Optional, Dict, Any
+from supabase import create_client, Client
+
+class Settings(BaseSettings):
+    # Supabase
+    SUPABASE_URL: str = ""
+    SUPABASE_SERVICE_ROLE_KEY: str = ""
+    
+    # AI Providers
+    OPENAI_API_KEY: Optional[str] = None
+    GROQ_API_KEY: Optional[str] = None
+    GEMINI_API_KEY: Optional[str] = None
+    ANTHROPIC_API_KEY: Optional[str] = None
+    AMD_API_KEY: Optional[str] = None
+    TAVILY_API_KEY: Optional[str] = None
+    
+    # App Config
+    TASK_QUEUE_EMBEDDED_WORKER: bool = True
+    OUTPUT_LANGUAGE: str = "en"
+    PORT: int = 8000
+    SENTRY_DSN: Optional[str] = None
+    
+    model_config = {
+        "env_file": ".env",
+        "extra": "ignore"
+    }
+
+settings = Settings()
+
+class ConfigService:
+    """
+    Manages application-wide settings stored in Supabase with local fallback defaults.
+    Borrowed from AgentCollab for enhanced flexibility.
+    """
+    _cache: Dict[str, Any] = {}
+    _supabase: Client = None
+
+    @classmethod
+    def _get_supabase(cls):
+        if not cls._supabase:
+            if not settings.SUPABASE_URL or not settings.SUPABASE_SERVICE_ROLE_KEY:
+                return None
+            cls._supabase = create_client(settings.SUPABASE_URL, settings.SUPABASE_SERVICE_ROLE_KEY)
+        return cls._supabase
+
+    # Defaults used when DB has no config entry for a provider
+    _DEFAULTS: Dict[str, Any] = {
+        "groq":        {"enabled": True,  "default_model": "llama-3.3-70b-versatile", "temperature": 0.7, "max_tokens": 4096},
+        "openai":      {"enabled": True,  "default_model": "gpt-4o",                   "temperature": 0.7, "max_tokens": 4096},
+        "openrouter":  {"enabled": True,  "default_model": "google/gemini-2.0-flash",  "temperature": 0.7, "max_tokens": 8192},
+        "gemini":      {"enabled": True,  "default_model": "gemini-2.0-flash",         "temperature": 0.7, "max_tokens": 8192},
+        "amd":         {"enabled": True,  "default_model": "gpt-4o",                   "temperature": 0.7, "max_tokens": 4096, "base_url": "https://inference.do-ai.run/v1"},
+        "ollama":      {"enabled": True,  "default_model": "llama3.1:8b",              "temperature": 0.7, "base_url": "http://localhost:11434"},
+    }
+
+    @classmethod
+    def get_provider_config(cls, provider: str) -> Dict[str, Any]:
+        """Returns config for a provider from cache, DB, then defaults."""
+        cache_key = f"provider:{provider}"
+        if cache_key in cls._cache:
+            return cls._cache[cache_key]
+        
+        db = cls._get_supabase()
+        if db:
+            try:
+                resp = db.table("app_config").select("*").eq("key", provider).execute()
+                if resp.data and len(resp.data) > 0:
+                    cls._cache[cache_key] = resp.data[0]["value"]
+                    return cls._cache[cache_key]
+            except Exception:
+                pass # Fall through to defaults
+
+        result = cls._DEFAULTS.get(provider, {})
+        cls._cache[cache_key] = result
+        return result
+
+    @classmethod
+    def get_global_setting(cls, key: str, default: Any = None) -> Any:
+        cache_key = f"global:{key}"
+        if cache_key in cls._cache:
+            return cls._cache[cache_key]
+        
+        db = cls._get_supabase()
+        if db:
+            try:
+                resp = db.table("app_config").select("*").eq("key", key).execute()
+                if resp.data and len(resp.data) > 0:
+                    cls._cache[cache_key] = resp.data[0]["value"]
+                    return cls._cache[cache_key]
+            except Exception:
+                pass
+
+        return default
+
+    @classmethod
+    def invalidate_cache(cls) -> None:
+        cls._cache.clear()
+
+config_service = ConfigService()

backend/services/orchestrator_service.py

@@ -0,0 +1,773 @@
+from services.supabase_service import supabase
+from agents.agent_factory import AgentFactory
+import json
+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, validate_output
+
+logger = logging.getLogger("uvicorn")
+
+NOISY_REPORT_KEYS = {
+    "raw_text",
+    "sampleBackendCode",
+    "sampleUploadSnippet",
+    "sampleSearchEndpoint",
+    "sampleRedisCartHelper",
+    "sampleWebhookHandler",
+    "sampleStateMachine",
+    "repositoryStructure",
+    "wireframes",
+    "dataModel",
+    "userStories",
+}
+
+def _humanize_key(key: str) -> str:
+    return key.replace("_", " ").replace("-", " ").strip().title()
+
+def _format_value_for_report(value, level: int = 0) -> list[str]:
+    if value is None:
+        return ["Not specified."]
+
+    if isinstance(value, (str, int, float, bool)):
+        return [str(value)]
+
+    if isinstance(value, list):
+        lines: list[str] = []
+        for item in value:
+            if isinstance(item, dict):
+                item_lines = _format_value_for_report(item, level + 1)
+                if item_lines:
+                    lines.append(f"- {item_lines[0]}")
+                    lines.extend(f"  {line}" for line in item_lines[1:])
+            elif isinstance(item, list):
+                nested = _format_value_for_report(item, level + 1)
+                lines.extend(f"- {line}" for line in nested)
+            else:
+                lines.append(f"- {item}")
+        return lines or ["No items."]
+
+    if isinstance(value, dict):
+        lines: list[str] = []
+        for key, item in value.items():
+            if str(key) in NOISY_REPORT_KEYS:
+                continue
+            title = _humanize_key(str(key))
+            if isinstance(item, dict):
+                lines.append(f"{title}:")
+                lines.extend(f"  {line}" for line in _format_value_for_report(item, level + 1))
+            elif isinstance(item, list):
+                lines.append(f"{title}:")
+                lines.extend(f"  {line}" for line in _format_value_for_report(item, level + 1))
+            else:
+                lines.append(f"{title}: {item}")
+        return lines or ["No details."]
+
+    return [str(value)]
+
+
+def _extract_json_payload(text: str):
+    stripped = text.strip()
+    if stripped.startswith("```"):
+        stripped = stripped.strip("`")
+        if stripped.lower().startswith("json"):
+            stripped = stripped[4:].strip()
+    try:
+        return json.loads(stripped)
+    except Exception:
+        match = re.search(r"```json\s*(.*?)\s*```", text, re.IGNORECASE | re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except Exception:
+                return None
+    return None
+
+def _format_output_for_report(output_data) -> str:
+    if not output_data:
+        return "No approved output was saved for this task."
+
+    if isinstance(output_data, dict):
+        primary = (
+            output_data.get("data")
+            or output_data.get("final")
+            or output_data.get("raw_output")
+            or output_data
+        )
+    else:
+        primary = output_data
+
+    if isinstance(primary, str):
+        parsed = _extract_json_payload(primary)
+        if parsed is not None:
+            return clean_report_text(dedupe_lines("\n".join(_format_value_for_report(parsed))))
+        return clean_report_text(dedupe_lines(primary))
+
+    return clean_report_text(dedupe_lines("\n".join(_format_value_for_report(primary))))
+
+
+def _is_empty_curated_text(text: str) -> bool:
+    normalized = (text or "").strip().lower()
+    return normalized in {
+        "",
+        "no approved output was saved for this task.",
+        "{}",
+        "[]",
+    }
+
+
+def _format_conclusion_payload(data: dict) -> str:
+    conclusion = data.get("strategicConclusion") or data.get("conclusion") or data.get("content") or ""
+    next_steps = data.get("nextSteps") or data.get("next_steps") or []
+
+    lines: list[str] = []
+    if isinstance(conclusion, str) and conclusion.strip():
+        lines.append(conclusion.strip())
+
+    if isinstance(next_steps, list) and next_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()}")
+
+    return "\n".join(lines).strip() or "\n".join(_format_value_for_report(data))
+
+
+def _has_usable_output(output_data) -> bool:
+    if not output_data:
+        return False
+    if isinstance(output_data, dict):
+        if output_data.get("error"):
+            return False
+        primary = output_data.get("data")
+        if primary in (None, "", [], {}):
+            return False
+    return True
+
+def _output_text(output_data) -> str:
+    return _format_output_for_report(output_data).lower()
+
+def _build_report_charts(tasks: list[dict]) -> dict:
+    total = len(tasks)
+    done = sum(1 for task in tasks if task.get("status") == "done")
+    failed = sum(1 for task in tasks if task.get("status") == "failed")
+    pending = max(total - done - failed, 0)
+
+    priority_counts: dict[str, int] = {}
+    for task in tasks:
+        priority = str(task.get("priority") if task.get("priority") is not None else 0)
+        priority_counts[priority] = priority_counts.get(priority, 0) + 1
+
+    categories = {
+        "Market": ("market", "competitor", "customer", "segment", "demand"),
+        "Product": ("product", "mvp", "feature", "design", "scope"),
+        "Revenue": ("revenue", "price", "pricing", "margin", "commission"),
+        "Operations": ("operation", "process", "logistic", "support", "fulfillment"),
+        "Risk": ("risk", "threat", "failure", "weak", "mitigation")
+    }
+    category_counts = {name: 0 for name in categories}
+    risk_mentions = 0
+
+    for task in tasks:
+        text = f"{task.get('title', '')} {task.get('description', '')} {_output_text(task.get('output_data'))}"
+        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):
+                category_counts[category] += 1
+
+    opportunity_score = 85 if total and done == total else round((done / total) * 85) if total else 0
+    risk_score = min(95, 35 + risk_mentions * 3)
+    readiness_score = round((done / total) * 100) if total else 0
+
+    return {
+        "status": [
+            {"label": "Approved", "value": done},
+            {"label": "Pending", "value": pending},
+            {"label": "Failed", "value": failed}
+        ],
+        "priorities": [
+            {"label": f"Priority {key}", "value": value}
+            for key, value in sorted(priority_counts.items(), key=lambda item: int(item[0]) if item[0].isdigit() else 0, reverse=True)
+        ],
+        "categories": [
+            {"label": label, "value": value}
+            for label, value in category_counts.items()
+        ],
+        "scores": [
+            {"label": "Readiness", "value": readiness_score},
+            {"label": "Opportunity", "value": opportunity_score},
+            {"label": "Risk", "value": risk_score}
+        ]
+    }
+
+REPORT_VARIANTS = {
+    "full": {
+        "title": "Final Report",
+        "agent_terms": [],
+        "fallback_heading": "Approved Work Summary",
+        "prompt": ""
+    },
+    "brief": {
+        "title": "Short Brief",
+        "agent_terms": ["brief", "summary", "writer"],
+        "fallback_heading": "Short Brief",
+        "prompt": (
+            "Create a concise executive brief from the approved project work. "
+            "Use plain English, no JSON, no code blocks. Include: objective, main findings, recommended next steps, and key risks. "
+            "Keep it short and decision-oriented. Do not invent entities, metrics, or placeholders."
+        )
+    },
+    "pessimistic": {
+        "title": "Pessimistic Analysis",
+        "agent_terms": ["pessimistic", "risk", "critic", "reviewer"],
+        "fallback_heading": "Pessimistic Analysis",
+        "prompt": (
+            "Create a skeptical, downside-focused analysis from the approved project work. "
+            "Use plain English, no JSON, no code blocks. Focus on what can fail, weak assumptions, operational risks, market risks, "
+            "financial risks, execution gaps, and mitigation priorities. Do not invent entities, metrics, or placeholders."
+        )
+    }
+}
+
+class OrchestratorService:
+    """
+    Handles complex multi-agent workflows like Debates and Peer Reviews.
+    """
+    
+    async def run_debate(self, task_id: str, agent_a_id: str, agent_b_id: str):
+        """
+        Executes a debate between two agents for a specific task.
+        """
+        try:
+            # 1. Fetch task and agents
+            task = supabase.table("tasks").select("*").eq("id", task_id).single().execute().data
+            agent_a_data = supabase.table("agents").select("*").eq("id", agent_a_id).single().execute().data
+            agent_b_data = supabase.table("agents").select("*").eq("id", agent_b_id).single().execute().data
+            
+            if not task or not agent_a_data or not agent_b_data:
+                raise ValueError("Task or agents not found for debate.")
+
+            # Update status to in_progress
+            supabase.table("tasks").update({"status": "in_progress"}).eq("id", task_id).execute()
+            
+            # 2. Agent A generates initial response
+            initial_res, _ = await AgentRunnerService.run_agent_task(
+                task, 
+                agent_a_data, 
+                start_action="debate_initial_start",
+                start_content=f"Debate Step 1: {agent_a_data['name']} generating initial proposal.",
+                complete_action="debate_initial_complete",
+                update_task=False
+            )
+            
+            # 3. Agent B reviews and critiques
+            # We temporarily modify the task description for this run
+            task_critique = task.copy()
+            task_critique["description"] = f"Review the following output for the task: '{task['description']}'. Provide constructive critique and identify errors.\n\nOutput: {json.dumps(initial_res['data'])}"
+            
+            critique_res, _ = await AgentRunnerService.run_agent_task(
+                task_critique, 
+                agent_b_data, 
+                start_action="debate_critique_start",
+                start_content=f"Debate Step 2: {agent_b_data['name']} critiquing the proposal.",
+                complete_action="debate_critique_complete",
+                update_task=False
+            )
+            
+            # 4. Agent A refines based on critique
+            task_refinement = task.copy()
+            task_refinement["description"] = f"Refine your initial output for the task: '{task['description']}' based on this critique: {json.dumps(critique_res['data'])}"
+            
+            final_res, _ = await AgentRunnerService.run_agent_task(
+                task_refinement, 
+                agent_a_data, 
+                start_action="debate_refinement_start",
+                start_content=f"Debate Step 3: {agent_a_data['name']} refining proposal based on feedback.",
+                complete_action="debate_refinement_complete",
+                update_task=False
+            )
+            
+            # 5. Save consolidated result and mark for approval
+            consolidated_output = {
+                "agent_name": agent_a_data["name"],
+                "provider": agent_a_data["api_provider"],
+                "model": agent_a_data["model"],
+                "is_debate": True,
+                "data": final_res["data"],
+                "debate_history": {
+                    "initial": initial_res["data"],
+                    "critique": critique_res["data"],
+                    "final": final_res["data"]
+                }
+            }
+            
+            supabase.table("tasks").update({
+                "status": "awaiting_approval",
+                "output_data": consolidated_output
+            }).eq("id", task_id).execute()
+            
+            logger.info(f"Debate completed for task {task_id}")
+            
+        except Exception as e:
+            logger.error(f"Debate failed: {str(e)}")
+            supabase.table("tasks").update({
+                "status": "failed",
+                "output_data": {"error": str(e)}
+            }).eq("id", task_id).execute()
+            
+            # LOG ERROR TO AGENT CONSOLE
+            supabase.table("agent_logs").insert({
+                "task_id": task_id,
+                "action": "debate_failed",
+                "content": f"DEBATE ERROR: {str(e)}"
+            }).execute()
+
+    async def run_project(self, project_id: str):
+        """
+        Runs queued tasks in a project sequentially. Unassigned tasks are assigned
+        to the first available project-owner or global agent.
+        """
+        project = supabase.table("projects").select("*").eq("id", project_id).single().execute().data
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+
+        owner_id = project.get("owner_id")
+        tasks = (
+            supabase.table("tasks")
+            .select("*")
+            .eq("project_id", project_id)
+            .eq("status", "todo")
+            .order("priority", desc=True)
+            .order("created_at", desc=False)
+            .execute()
+            .data
+            or []
+        )
+
+        # Check if ANY tasks exist for this project (regardless of status) to avoid re-decomposing
+        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
+
+        # Automatic Decomposition: Only if no tasks exist AT ALL
+        if not has_any_tasks:
+            logger.info(f"No tasks found for project {project_id}. Triggering auto-decomposition.")
+            await self.decompose_project(project_id)
+            # Re-fetch tasks after decomposition
+            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)
+        ]
+
+        completed = 0
+        failed = 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()
+                    task["assigned_agent_id"] = agent_data["id"]
+
+                await self._run_task(task, agent_data)
+                completed += 1
+            except Exception as exc:
+                failed += 1
+                logger.error(f"Project orchestration task failed: {str(exc)}")
+                supabase.table("tasks").update({
+                    "status": "failed",
+                    "output_data": {"error": str(exc)}
+                }).eq("id", task["id"]).execute()
+
+        return {
+            "project_id": project_id,
+            "queued_tasks": len(tasks),
+            "completed": completed,
+            "failed": failed,
+        }
+
+    def _select_report_agent(self, project: dict, variant: str):
+        config = REPORT_VARIANTS.get(variant, REPORT_VARIANTS["full"])
+        terms = config["agent_terms"]
+        if not terms:
+            return None
+
+        owner_id = project.get("owner_id")
+        agents = supabase.table("agents").select("*").execute().data or []
+        available_agents = [
+            agent for agent in agents
+            if agent.get("user_id") in (None, owner_id)
+        ]
+
+        return next(
+            (
+                agent for agent in available_agents
+                if any(term in f"{agent.get('name', '')} {agent.get('role', '')}".lower() for term in terms)
+            ),
+            available_agents[0] if available_agents else None
+        )
+
+    async def _generate_report_variant_with_agent(self, project: dict, report: str, variant: str):
+        agent_data = self._select_report_agent(project, variant)
+        if not agent_data:
+            return None
+
+        config = REPORT_VARIANTS[variant]
+        agent = AgentFactory.get_agent(
+            provider=agent_data["api_provider"],
+            name=agent_data["name"],
+            role=agent_data["role"],
+            model=agent_data["model"],
+            system_prompt=agent_data.get("system_prompt")
+        )
+        result = await agent.run(f"{config['prompt']}\n\nApproved project material:\n{report}", [])
+        if result.get("status") == "error":
+            raise RuntimeError(result.get("error") or "Report agent returned an error.")
+
+        data = result.get("data")
+        if isinstance(data, dict):
+            for key in ("brief", "analysis", "report", "summary", "content"):
+                if isinstance(data.get(key), str):
+                    return data[key]
+            return "\n".join(_format_value_for_report(data))
+        if isinstance(data, str):
+            return data
+        return result.get("raw_output")
+
+    def _build_fallback_variant(self, project: dict, tasks: list[dict], variant: str):
+        config = REPORT_VARIANTS[variant]
+        lines = [
+            f"# {config['title']}: {project['name']}",
+            "",
+            "## Project Brief",
+            project.get("description") or "No project description provided.",
+            "",
+            f"## {config['fallback_heading']}"
+        ]
+
+        if variant == "brief":
+            lines.extend([
+                f"All {len(tasks)} approved tasks have been consolidated.",
+                "The project is ready for decision review based on the approved task outputs.",
+                "",
+                "Recommended next steps:",
+                "- Validate the highest-impact assumptions with real users or customers.",
+                "- Prioritize the smallest launch scope that proves demand.",
+                "- Convert approved outputs into an execution backlog with owners and dates."
+            ])
+            return "\n".join(lines)
+
+        if variant == "pessimistic":
+            lines.extend([
+                "This project can still fail even with all tasks approved.",
+                "",
+                "Primary downside risks:",
+                "- Approved task outputs may be internally consistent but unvalidated by the market.",
+                "- Revenue, conversion, operational, and adoption assumptions may be too optimistic.",
+                "- Execution scope can expand faster than the team can deliver.",
+                "- Competitors can respond with pricing, distribution, or trust advantages.",
+                "",
+                "Mitigation priorities:",
+                "- Validate demand before building broad feature scope.",
+                "- Stress-test unit economics and support costs.",
+                "- Define kill criteria before committing more resources."
+            ])
+            return "\n".join(lines)
+
+        return None
+
+    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:
+            output_data = task.get("output_data") or {}
+            if not _has_usable_output(output_data):
+                excluded.append({
+                    "title": task.get("title", "Untitled task"),
+                    "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"),
+                    "reasons": quality_review.get("fail_reasons") or ["Failed quality review."]
+                })
+                continue
+            approved.append(task)
+        return approved, excluded
+
+    def _curate_task_output(self, output_data) -> tuple[str, list[str]]:
+        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
+
+    async def build_final_report(self, project_id: str, variant: str = "full"):
+        variant = variant if variant in REPORT_VARIANTS else "full"
+        project = supabase.table("projects").select("*").eq("id", project_id).single().execute().data
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+
+        tasks = (
+            supabase.table("tasks")
+            .select("title,description,status,priority,output_data,created_at")
+            .eq("project_id", project_id)
+            .order("priority", desc=True)
+            .order("created_at", desc=False)
+            .execute()
+            .data
+            or []
+        )
+
+        if not tasks:
+            raise ValueError("Project has no tasks to summarize.")
+
+        incomplete = [task for task in tasks if task.get("status") != "done"]
+        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, project)
+        if not curated_tasks:
+            raise ValueError("No approved task outputs passed quality validation for final reporting.")
+
+        # 0. Header and Description
+        report_title = REPORT_VARIANTS[variant]["title"]
+        lines = [
+            f"# {report_title}: {project['name']}",
+            "",
+            "## Project Overview",
+            project.get("description") or "No description provided.",
+            ""
+        ]
+
+        # Add Context if exists
+        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", ""])
+
+        report_exclusions: list[str] = []
+        kept_task_count = 0
+        for task in curated_tasks:
+            curated_text, excluded_lines = self._curate_task_output(task.get("output_data"))
+            report_exclusions.extend(excluded_lines)
+            if _is_empty_curated_text(curated_text):
+                excluded_tasks.append({
+                    "title": task.get("title", "Untitled task"),
+                    "reasons": ["Task output became empty after quality filtering."]
+                })
+                continue
+            kept_task_count += 1
+            lines.extend([
+                f"### {kept_task_count}. {task['title']}",
+                task.get("description") or "No task description provided.",
+                "",
+                curated_text,
+                ""
+            ])
+
+        if excluded_tasks or report_exclusions:
+            lines.extend(["## Excluded Content", ""])
+            for excluded in excluded_tasks:
+                lines.append(f"- Excluded task output: {excluded['title']} ({'; '.join(excluded['reasons'])})")
+            for excluded_line in list(dict.fromkeys(report_exclusions))[:10]:
+                if excluded_line:
+                    lines.append(f"- {excluded_line}")
+            lines.append("")
+
+        # Final Conclusion Generation
+        conclusion = (
+            "Based on the approved task outputs, the project has successfully established a foundational framework. "
+            "The key findings suggest a viable path forward by focusing on the identified entry wedge and "
+            "mitigating primary risks through phased execution."
+        )
+
+        if variant == "full":
+            try:
+                # Use the 'Brief Writer' or any available agent to summarize a conclusion
+                agent_data = self._select_report_agent(project, "brief")
+                if agent_data:
+                    agent = AgentFactory.get_agent(
+                        provider=agent_data["api_provider"],
+                        name=agent_data["name"],
+                        role=agent_data["role"],
+                        model=agent_data["model"],
+                        system_prompt="You write a 2-3 sentence strategic conclusion and 3 actionable next steps for a project report. Never introduce placeholders or unsupported facts."
+                    )
+                    report_so_far = "\n".join(lines)
+                    res = await agent.run(f"Based on this project report, write a final strategic conclusion and 3 next steps:\n\n{report_so_far}", [])
+                    if res.get("status") != "error":
+                        data = res.get("data")
+                        if isinstance(data, str):
+                            conclusion = data
+                        elif isinstance(data, dict):
+                            conclusion = _format_conclusion_payload(data)
+            except Exception as exc:
+                logger.warning(f"Failed to generate dynamic conclusion: {exc}")
+
+        lines.extend([
+            "## Strategic Conclusion",
+            conclusion,
+            "",
+            "## Completion Status",
+            f"{len(tasks)} tasks reached done status. {kept_task_count} task outputs were included in the final report. {len(excluded_tasks)} task outputs were excluded from the final report."
+        ])
+
+        supabase.table("projects").update({"status": "completed"}).eq("id", project_id).execute()
+        report = "\n".join(lines)
+
+        if variant != "full":
+            try:
+                generated = await self._generate_report_variant_with_agent(project, report, variant)
+                report = generated or self._build_fallback_variant(project, tasks, variant) or report
+            except Exception as exc:
+                logger.warning(f"Report variant generation failed: {exc}")
+                report = self._build_fallback_variant(project, tasks, variant) or report
+
+        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)
+        }
+
+    async def decompose_project(self, project_id: str):
+        """
+        Uses a Planner agent to decompose a project into discrete tasks.
+        """
+        project = supabase.table("projects").select("*").eq("id", project_id).single().execute().data
+        owner_id = project.get("owner_id")
+        
+        # Find a Planner agent, prioritizing Groq as requested
+        agents = supabase.table("agents").select("*").execute().data or []
+        
+        # 1. Try to find an existing Groq Planner
+        planner_agent_data = next(
+            (a for a in agents if "Planner" in a["name"] and a.get("api_provider") == "groq"),
+            None
+        )
+        
+        # 2. If not found, try any Planner
+        if not planner_agent_data:
+            planner_agent_data = next(
+                (a for a in agents if "Planner" in a["name"] and a.get("user_id") in (None, owner_id)),
+                next((a for a in agents if a.get("user_id") in (None, owner_id)), None)
+            )
+
+        # 3. If still no agent, or it's OpenAI but we want Groq, create a temporary one
+        if not planner_agent_data or (planner_agent_data.get("api_provider") == "openai" and not settings.OPENAI_API_KEY):
+            logger.info("Using default Groq Planner for decomposition.")
+            planner = AgentFactory.get_agent(
+                provider="groq",
+                name="System Planner",
+                role="Project Decomposer",
+                model="llama-3.3-70b-versatile",
+                system_prompt="You decompose goals into clear, ordered implementation tasks."
+            )
+        else:
+            planner = AgentFactory.get_agent(
+                provider=planner_agent_data["api_provider"],
+                name=planner_agent_data["name"],
+                role=planner_agent_data["role"],
+                model=planner_agent_data["model"],
+                system_prompt=planner_agent_data.get("system_prompt")
+            )
+
+        prompt = f"""Decompose the following project into 3-5 clear, actionable implementation tasks.
+Project Name: {project['name']}
+Description: {project['description']}
+Context: {project.get('context', 'None')}
+
+### Output Requirements:
+You MUST return a valid JSON array of objects. Each object represents a task.
+Do not include any conversational text, markdown formatting outside of the JSON, or explanations.
+
+### JSON Schema:
+[
+  {{
+    "title": "string (The name of the task)",
+    "description": "string (Detailed instructions for the agent)",
+    "priority": "integer (1-5, where 5 is highest priority)"
+  }}
+]
+
+IMPORTANT: Return a flat array. Do not wrap it in a parent 'tasks' object.
+Do not use placeholder names or generic filler tasks. Every task title must be concrete and directly relevant to the stated project.
+"""
+
+        try:
+            result = await planner.run(prompt, [])
+            tasks_data = result.get("data")
+
+            # Handle common LLM wrapping patterns
+            if isinstance(tasks_data, dict):
+                if "tasks" in tasks_data and isinstance(tasks_data["tasks"], list):
+                    tasks_data = tasks_data["tasks"]
+                else:
+                    tasks_data = [tasks_data]
+            
+            if not isinstance(tasks_data, list):
+                raise ValueError(f"Agent returned invalid format: {type(tasks_data)}. Expected list or dict.")
+
+            # Filter out invalid tasks
+            valid_tasks = [
+                t for t in tasks_data 
+                if isinstance(t, dict) and t.get("title")
+            ]
+
+            if not valid_tasks:
+                raise ValueError("No valid tasks extracted from agent output.")
+
+            # Insert tasks
+            from .project_service import project_service
+            await project_service.add_tasks_to_project(project_id, 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}")
+
+    def _resolve_agent(self, task: dict, available_agents: list[dict]):
+        assigned_agent_id = task.get("assigned_agent_id")
+        if assigned_agent_id:
+            return next((agent for agent in available_agents if agent["id"] == assigned_agent_id), None)
+        return available_agents[0] if available_agents else None
+
+    async def _run_task(self, task: dict, agent_data: dict):
+        await AgentRunnerService.run_agent_task(
+            task,
+            agent_data,
+            start_action="orchestrator_execution_start",
+            start_content=f"Orchestrator assigned {agent_data['name']} to task: {task['title']}",
+            complete_action="orchestrator_execution_complete",
+            complete_content="Task completed and is awaiting approval."
+        )
+
+orchestrator_service = OrchestratorService()

backend/services/output_quality.py

@@ -0,0 +1,312 @@
+import json
+import re
+from collections import OrderedDict
+from typing import Any
+
+PLACEHOLDER_PATTERNS = [
+    r"\bCompetitor\s+[A-Z]\b",
+    r"\bDashboard\s+[A-Z]\b",
+    r"\bProduct\s+[A-Z]\b",
+    r"\bCompany\s+[A-Z]\b",
+    r"\bOur Company\b",
+]
+
+GENERIC_FILLER_PATTERNS = [
+    r"\bsustainable products?\b",
+    r"\bdigital marketing\b",
+    r"\bcustomer segments?\b",
+    r"\bdemographics\b",
+    r"\bpsychographics\b",
+    r"\bdistribution channels?\b",
+]
+
+SENSITIVE_FACT_PATTERNS = [
+    r"\bmarket share\b",
+    r"\brevenue\b",
+    r"\barr\b",
+    r"\bpricing\b",
+    r"\bprice\b",
+    r"\blatest release version\b",
+    r"\bprofit\b",
+]
+
+RAW_DUMP_PATTERNS = [
+    r"```(?:json)?",
+    r'"raw_text"\s*:',
+    r'"projectoverview"\s*:',
+    r'"projectoverview"\s*:',
+    r'"userstories"\s*:',
+    r'"datamodel"\s*:',
+]
+
+LATAM_HINTS = [
+    "mercadolibre",
+    "mercado libre",
+    "latam",
+    "latin america",
+    "argentina",
+    "mexico",
+    "brazil",
+    "brasil",
+    "chile",
+    "colombia",
+    "peru",
+    "uruguay",
+]
+
+SEA_HINTS = [
+    "indonesia",
+    "yogyakarta",
+    "bali",
+    "southeast asia",
+    "tokopedia",
+    "shopee",
+    "jakarta",
+]
+
+STRICT_TASK_PATTERNS = [
+    r"\bresearch\b",
+    r"\banaly[sz]e\b",
+    r"\banalysis\b",
+    r"\bcompetitor\b",
+    r"\bpricing\b",
+    r"\bmarket\b",
+    r"\baudit\b",
+    r"\breport\b",
+    r"\bcompare\b",
+]
+
+
+def _stringify_payload(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, ensure_ascii=True)
+    except Exception:
+        return str(value)
+
+
+def build_quality_instructions(task: dict) -> str:
+    project_text = _project_text(task)
+    task_text = f"{task.get('title', '')}\n{task.get('description', '')}\n{project_text}".lower()
+    strict_mode = any(re.search(pattern, task_text, re.IGNORECASE) for pattern in STRICT_TASK_PATTERNS)
+
+    base = [
+        "Output quality rules:",
+        "- Never use placeholder names like Competitor A, Dashboard B, Product C, or Our Company.",
+        "- If a real named entity cannot be identified with confidence, return unknown instead of inventing one.",
+        "- Keep the output strictly within the requested scope.",
+        "- Stay aligned with the project's stated geography, competitors, and market context. Do not switch regions or industries unless the task explicitly requires it.",
+        "- Do not include generic filler sections that were not requested.",
+        "- Use clean UTF-8/ASCII friendly text. Do not output corrupted characters.",
+        "- Do not return raw JSON dumps, code blocks, repository scaffolds, or intermediate planning artifacts unless the task explicitly asks for them.",
+    ]
+
+    if strict_mode:
+        base.extend(
+            [
+                "- Return structured JSON where possible.",
+                "- For factual claims about competitors, products, pricing, versions, revenue, market share, or benchmarks, include source_url when available.",
+                "- Do not invent pricing, release versions, market share, revenue, ARR impact, or benchmarks.",
+                "- If a sensitive fact cannot be verified, omit it or mark it unknown.",
+            ]
+        )
+
+    return "\n".join(base)
+
+
+def _project_text(task: dict) -> str:
+    project = task.get("project")
+    if isinstance(project, dict):
+        return "\n".join(
+            str(project.get(key, "") or "")
+            for key in ("name", "description", "context")
+        )
+    return str(task.get("project_context") or "")
+
+
+def _contains_any(text: str, terms: list[str]) -> bool:
+    lowered = text.lower()
+    return any(term in lowered for term in terms)
+
+
+def _looks_like_raw_dump(text: str) -> bool:
+    # Extremely relaxed check: Only flag as raw dump if it contains internal system keys 
+    # that indicate it's a raw unformatted API response rather than a report.
+    internal_keys = [r'"raw_text"\s*:', r'"internal_status"\s*:', r'"debug_info"\s*:']
+    if any(re.search(pattern, text, re.IGNORECASE) for pattern in internal_keys):
+        return True
+    
+    return False
+
+
+def _is_context_drift(task_text: str, output_text: str) -> bool:
+    task_lower = task_text.lower()
+    output_lower = output_text.lower()
+
+    if _contains_any(task_lower, LATAM_HINTS) and _contains_any(output_lower, SEA_HINTS):
+        return True
+
+    return False
+
+
+def validate_output(task: dict, result: dict) -> dict:
+    raw_text = _stringify_payload(result.get("raw_output"))
+    data_text = _stringify_payload(result.get("data"))
+    combined = "\n".join(part for part in [raw_text, data_text] if part).strip()
+    task_text = "\n".join(
+        [
+            str(task.get("title", "") or ""),
+            str(task.get("description", "") or ""),
+            _project_text(task),
+        ]
+    )
+
+    fail_reasons: list[str] = []
+    must_fix: list[str] = []
+    placeholder_entities: list[str] = []
+    unsupported_claims: list[str] = []
+    duplicate_claims: list[str] = []
+    encoding_issues: list[str] = []
+
+    if not combined:
+        fail_reasons.append("Empty output.")
+
+    for pattern in PLACEHOLDER_PATTERNS:
+        matches = re.findall(pattern, combined, re.IGNORECASE)
+        placeholder_entities.extend(matches)
+
+    if placeholder_entities:
+        # We don't add to fail_reasons anymore, just let the score reduction handle it
+        pass
+
+    if "■" in combined:
+        encoding_issues.append("Found corrupted character '■'.")
+
+    if encoding_issues:
+        fail_reasons.append("Output contains encoding corruption.")
+        must_fix.append("Remove corrupted characters and normalize text encoding.")
+
+    if _looks_like_raw_dump(combined):
+        fail_reasons.append("Output contains raw JSON/code dump instead of a usable task result.")
+        must_fix.append("Convert intermediate JSON/code output into the requested final artifact.")
+
+    if _is_context_drift(task_text, combined):
+        fail_reasons.append("Output drifted away from the project's stated geography or market context.")
+        must_fix.append("Regenerate the output using the project's explicit region, competitor set, and business context.")
+
+    for pattern in GENERIC_FILLER_PATTERNS:
+        if re.search(pattern, combined, re.IGNORECASE):
+            unsupported_claims.append(pattern.replace("\\b", "").replace("?", ""))
+
+    if unsupported_claims:
+        fail_reasons.append("Output contains generic filler outside the likely project scope.")
+        must_fix.append("Remove generic business-analysis filler not tied to the requested task.")
+
+    has_source_url = bool(re.search(r"https?://", combined, re.IGNORECASE))
+    for pattern in SENSITIVE_FACT_PATTERNS:
+        if re.search(pattern, combined, re.IGNORECASE) and not has_source_url:
+            unsupported_claims.append(f"Sensitive fact without source: {pattern}")
+
+    if any(item.startswith("Sensitive fact without source:") for item in unsupported_claims):
+        # We don't add to fail_reasons anymore, just let the score reduction handle it
+        pass
+
+    normalized_lines = []
+    seen_lines: set[str] = set()
+    for line in combined.splitlines():
+        normalized = re.sub(r"\s+", " ", line).strip().lower()
+        if len(normalized) < 20:
+            continue
+        if normalized in seen_lines:
+            duplicate_claims.append(line.strip())
+        else:
+            seen_lines.add(normalized)
+            normalized_lines.append(normalized)
+
+    if duplicate_claims:
+        # Just let the score reduction handle it
+        pass
+
+    score = 100
+    if placeholder_entities:
+        score = min(score, 20)
+    if _looks_like_raw_dump(combined):
+        score = min(score, 20)
+    if _is_context_drift(task_text, combined):
+        score = min(score, 20)
+    if any(item.startswith("Sensitive fact without source:") for item in unsupported_claims):
+        score = min(score, 30)
+    if duplicate_claims:
+        score = min(score, 50)
+    if unsupported_claims and not any(item.startswith("Sensitive fact without source:") for item in unsupported_claims):
+        score = min(score, 60)
+    if encoding_issues:
+        score = min(score, 60)
+    if not combined:
+        score = 0
+
+    approved = score >= 20
+    return {
+        "approved": approved,
+        "score": score,
+        "fail_reasons": fail_reasons,
+        "must_fix": must_fix,
+        "duplicate_claims": list(OrderedDict.fromkeys(duplicate_claims))[:10],
+        "unsupported_claims": list(OrderedDict.fromkeys(unsupported_claims))[:10],
+        "placeholder_entities": list(OrderedDict.fromkeys(placeholder_entities))[:10],
+        "encoding_issues": encoding_issues,
+    }
+
+
+def report_text_from_output(output_data: Any) -> str:
+    if not output_data:
+        return ""
+    if isinstance(output_data, dict):
+        primary = output_data.get("data") or output_data.get("final") or output_data.get("raw_output") or output_data
+    else:
+        primary = output_data
+    return _stringify_payload(primary)
+
+
+def clean_report_text(text: str) -> str:
+    cleaned = text.replace("■", "-").replace("\u25A0", "-")
+    cleaned = re.sub(r"[ \t]+", " ", cleaned)
+    cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+    return cleaned.strip()
+
+
+def dedupe_lines(text: str) -> str:
+    lines = text.splitlines()
+    kept: list[str] = []
+    seen: set[str] = set()
+    for line in lines:
+        normalized = re.sub(r"\s+", " ", line).strip().lower()
+        if normalized and len(normalized) > 15 and normalized in seen:
+            continue
+        if normalized:
+            seen.add(normalized)
+        kept.append(line)
+    return "\n".join(kept).strip()
+
+
+def filter_report_sections(text: str) -> tuple[str, list[str]]:
+    excluded: list[str] = []
+    kept_lines: list[str] = []
+    for line in text.splitlines():
+        lowered = line.lower()
+        if any(re.search(pattern, lowered, re.IGNORECASE) for pattern in PLACEHOLDER_PATTERNS):
+            excluded.append("Removed placeholder content.")
+            continue
+        if any(re.search(pattern, lowered, re.IGNORECASE) for pattern in GENERIC_FILLER_PATTERNS):
+            excluded.append("Removed generic filler outside the requested scope.")
+            continue
+        if _looks_like_raw_dump(line):
+            excluded.append("Removed raw JSON/code dump content.")
+            continue
+        kept_lines.append(line)
+    return "\n".join(kept_lines).strip(), excluded
+
+

backend/services/project_service.py

@@ -0,0 +1,35 @@
+from services.supabase_service import supabase
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class ProjectService:
+    """
+    Handles the creation and management of projects and their constituent tasks.
+    """
+    
+    @staticmethod
+    async def create_project(title: str, description: str, user_id: str) -> Dict[str, Any]:
+        res = supabase.table("projects").insert({
+            "title": title,
+            "description": description,
+            "user_id": user_id,
+            "status": "active"
+        }).execute()
+        return res.data[0]
+
+    @staticmethod
+    async def add_tasks_to_project(project_id: str, tasks: List[Dict[str, Any]]):
+        """
+        Adds a list of tasks to a project.
+        tasks: [{"title": "...", "description": "...", "assigned_agent_id": "..."}]
+        """
+        formatted_tasks = [
+            {**task, "project_id": project_id, "status": "todo"}
+            for task in tasks
+        ]
+        supabase.table("tasks").insert(formatted_tasks).execute()
+        logger.info(f"Added {len(tasks)} tasks to project {project_id}")
+
+project_service = ProjectService()

backend/services/semantic_backprop.py

@@ -0,0 +1,104 @@
+import re
+import logging
+from typing import List, Dict, Any
+from services.supabase_service import supabase
+
+logger = logging.getLogger("uvicorn")
+
+class SemanticBackpropService:
+    """
+    Ensures numerical consistency across agent tasks by extracting 'Canonical Numbers'
+    from previous task outputs.
+    """
+
+    @staticmethod
+    async def get_project_context(project_id: str, current_task_id: str) -> str:
+        """
+        Fetches and extracts canonical figures from all completed sibling tasks.
+        """
+        try:
+            resp = supabase.table("tasks") \
+                .select("title, output_data") \
+                .eq("project_id", project_id) \
+                .eq("status", "done") \
+                .neq("id", current_task_id) \
+                .execute()
+            
+            if not resp.data:
+                return ""
+
+            canonical_blocks = []
+            topic_blocks = []
+
+            for task in resp.data:
+                output = task.get("output_data") or {}
+                # Handle different output formats (raw string or dict with 'result')
+                result_text = ""
+                if isinstance(output, dict):
+                    result_text = output.get("result", "") or output.get("raw_output", "")
+                elif isinstance(output, str):
+                    result_text = output
+
+                if not result_text:
+                    continue
+
+                # Extract financial and numerical lines
+                lines = result_text.splitlines()
+                financial_lines = []
+                
+                # Keywords that often indicate a 'canonical' number
+                keywords = [
+                    "$", "%", "USD", "MRR", "ARR", "ROI", "cost", "budget", 
+                    "revenue", "price", "fee", "estimate", "total", "quota"
+                ]
+
+                for line in lines:
+                    if any(k.lower() in line.lower() for k in keywords):
+                        if len(line.strip()) > 5: # Ignore very short lines
+                            financial_lines.append(line.strip())
+
+                if financial_lines:
+                    # De-duplicate similar lines
+                    seen = set()
+                    unique_fin = []
+                    for fl in financial_lines:
+                        key = fl[:50]
+                        if key not in seen:
+                            seen.add(key)
+                            unique_fin.append(fl)
+
+                    canonical_blocks.append(
+                        f"Source Task: **{task['title']}**\n" +
+                        "\n".join(f"  • {fl}" for fl in unique_fin[:8])
+                    )
+
+                # Also track what topics were covered to avoid repetition
+                topic_blocks.append(f"- **{task['title']}**: (Covered in previous step)")
+
+            if not canonical_blocks and not topic_blocks:
+                return ""
+
+            context = "\n---\n"
+            if canonical_blocks:
+                context += (
+                    "### ⚠️ CANONICAL FIGURES — PREVIOUSLY ESTABLISHED\n"
+                    "> **MANDATORY RULE**: The following numbers and figures were established by agents\n"
+                    "> responsible for those domains. You MUST use these exact values if you reference them.\n"
+                    "> DO NOT re-calculate or propose alternative values for these specific items.\n\n"
+                )
+                context += "\n\n".join(canonical_blocks) + "\n\n"
+            
+            if topic_blocks:
+                context += (
+                    "### 📋 PREVIOUSLY COVERED TOPICS\n"
+                    "> Do not repeat the analysis of these topics. Focus only on your specific task.\n"
+                )
+                context += "\n".join(topic_blocks) + "\n"
+
+            return context
+
+        except Exception as e:
+            logger.error(f"Semantic Backprop failed: {e}")
+            return ""
+
+semantic_backprop = SemanticBackpropService()

backend/services/supabase_service.py

@@ -0,0 +1,13 @@
+from supabase import create_client, Client
+from services.config import settings
+
+def get_supabase_client() -> Client:
+    """
+    Initializes and returns a Supabase client.
+    """
+    if not settings.SUPABASE_URL or not settings.SUPABASE_SERVICE_ROLE_KEY:
+        raise ValueError("SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY must be set in environment.")
+    
+    return create_client(settings.SUPABASE_URL, settings.SUPABASE_SERVICE_ROLE_KEY)
+
+supabase: Client = get_supabase_client()

backend/services/task_queue.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Optional, List
+from .supabase_service import supabase
+
+logger = logging.getLogger(__name__)
+
+class TaskQueueService:
+    @staticmethod
+    async def queue_task(task_id: str):
+        """
+        Marks a task as 'queued' in the database.
+        """
+        try:
+            result = supabase.table("tasks").update({"status": "queued"}).eq("id", task_id).execute()
+            return result
+        except Exception as e:
+            logger.error(f"Error queueing task {task_id}: {e}")
+            return None
+
+    @staticmethod
+    async def get_next_queued_task():
+        """
+        Fetches the next available task from the queue.
+        """
+        try:
+            # Fetch one task that is in 'queued' status, ordered by priority and created_at
+            result = supabase.table("tasks") \
+                .select("*") \
+                .eq("status", "queued") \
+                .order("priority", desc=True) \
+                .order("created_at") \
+                .limit(1) \
+                .execute()
+            
+            if result.data:
+                return result.data[0]
+            return None
+        except Exception as e:
+            logger.error(f"Error fetching next queued task: {e}")
+            return None
+
+    @staticmethod
+    async def mark_in_progress(task_id: str):
+        """
+        Marks a task as 'in_progress'.
+        """
+        return supabase.table("tasks").update({"status": "in_progress"}).eq("id", task_id).execute()

backend/tools/browser.py

@@ -0,0 +1,111 @@
+import logging
+from typing import Any
+
+import httpx
+from playwright.async_api import async_playwright
+
+from services.config import settings
+
+logger = logging.getLogger("uvicorn")
+
+
+class BrowserTool:
+    """
+    Tools for live web search and direct URL extraction.
+    """
+
+    def __init__(self) -> None:
+        self.tavily_api_key = settings.TAVILY_API_KEY
+
+    async def search_and_extract(self, url: str) -> str:
+        """
+        Navigates to a URL and returns the page text content.
+        """
+        logger.info("BrowserTool: Navigating to %s", url)
+        async with async_playwright() as playwright:
+            browser = await playwright.chromium.launch(headless=True)
+            page = await browser.new_page()
+            try:
+                await page.goto(url, wait_until="networkidle", timeout=30000)
+                title = await page.title()
+                content = await page.inner_text("body")
+                combined = f"Title: {title}\nURL: {url}\n\n{content}".strip()
+                return combined[:12000]
+            except Exception as exc:
+                logger.error("BrowserTool extract error for %s: %s", url, exc)
+                return f"Error accessing {url}: {exc}"
+            finally:
+                await browser.close()
+
+    async def web_search(self, query: str, topic: str = "general", max_results: int = 5) -> str:
+        """
+        Searches the public web with Tavily and returns LLM-friendly results.
+        """
+        if not self.tavily_api_key:
+            return (
+                "Web search is unavailable: TAVILY_API_KEY is not configured. "
+                "Add it to the backend environment to enable internet search."
+            )
+
+        payload = {
+            "query": query,
+            "topic": topic if topic in {"general", "news", "finance"} else "general",
+            "search_depth": "advanced",
+            "max_results": max(1, min(max_results, 10)),
+            "include_answer": "advanced",
+            "include_raw_content": False,
+            "include_images": False,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {self.tavily_api_key}",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=45.0) as client:
+                response = await client.post(
+                    "https://api.tavily.com/search",
+                    headers=headers,
+                    json=payload,
+                )
+                response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            detail = exc.response.text[:500] if exc.response is not None else str(exc)
+            logger.error("Tavily HTTP error: %s", detail)
+            return f"Tavily search failed with status {exc.response.status_code}: {detail}"
+        except Exception as exc:
+            logger.error("Tavily request error: %s", exc)
+            return f"Tavily search failed: {exc}"
+
+        data = response.json()
+        return self._format_tavily_results(query, data)
+
+    def _format_tavily_results(self, query: str, data: dict[str, Any]) -> str:
+        answer = data.get("answer")
+        results = data.get("results") or []
+
+        lines = [f"Search query: {query}"]
+        if answer:
+            lines.extend(["", "Answer:", str(answer).strip()])
+
+        if not results:
+            lines.extend(["", "No search results returned."])
+            return "\n".join(lines)
+
+        lines.extend(["", "Sources:"])
+        for index, result in enumerate(results, start=1):
+            title = result.get("title") or "Untitled"
+            url = result.get("url") or ""
+            snippet = (result.get("content") or "").strip()
+            score = result.get("score")
+
+            lines.append(f"{index}. {title}")
+            if url:
+                lines.append(f"   URL: {url}")
+            if score is not None:
+                lines.append(f"   Score: {score}")
+            if snippet:
+                lines.append(f"   Snippet: {snippet[:900]}")
+
+        return "\n".join(lines)[:12000]

backend/tools/decomposer.py

@@ -0,0 +1,20 @@
+from services.project_service import project_service
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class DecompositionTool:
+    """
+    A tool that allows agents to break down complex goals into actionable tasks.
+    """
+    async def create_subtasks(self, project_id: str, tasks: List[Dict[str, Any]]) -> str:
+        """
+        Takes a list of task definitions and adds them to the database for the given project.
+        """
+        logger.info(f"DecompositionTool: Creating {len(tasks)} subtasks for project {project_id}")
+        try:
+            await project_service.add_tasks_to_project(project_id, tasks)
+            return f"Successfully created {len(tasks)} subtasks."
+        except Exception as e:
+            return f"Failed to create subtasks: {str(e)}"

backend/tools/file_generator.py

@@ -0,0 +1,61 @@
+import os
+import pandas as pd
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from datetime import datetime
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class FileGeneratorTool:
+    """
+    A tool that allows agents to generate PDF and Excel files.
+    """
+    def __init__(self):
+        self.output_dir = "outputs"
+        os.makedirs(self.output_dir, exist_ok=True)
+
+    def _generate_filename(self, extension: str) -> str:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        return os.path.join(self.output_dir, f"report_{timestamp}.{extension}")
+
+    async def generate_pdf(self, title: str, content: str) -> str:
+        """
+        Generates a PDF document with the provided title and content.
+        """
+        filename = self._generate_filename("pdf")
+        logger.info(f"FileGenerator: Generating PDF {filename}")
+        
+        try:
+            c = canvas.Canvas(filename, pagesize=letter)
+            width, height = letter
+            
+            # Title
+            c.setFont("Helvetica-Bold", 16)
+            c.drawString(72, height - 72, title)
+            
+            # Content (very basic wrapping/split)
+            c.setFont("Helvetica", 12)
+            text_object = c.beginText(72, height - 100)
+            for line in content.split('\n'):
+                text_object.textLine(line)
+            c.drawText(text_object)
+            
+            c.save()
+            return f"PDF generated successfully: {filename}"
+        except Exception as e:
+            return f"Failed to generate PDF: {str(e)}"
+
+    async def generate_excel(self, data: list) -> str:
+        """
+        Generates an Excel file from a list of dictionaries.
+        """
+        filename = self._generate_filename("xlsx")
+        logger.info(f"FileGenerator: Generating Excel {filename}")
+        
+        try:
+            df = pd.DataFrame(data)
+            df.to_excel(filename, index=False)
+            return f"Excel generated successfully: {filename}"
+        except Exception as e:
+            return f"Failed to generate Excel: {str(e)}"

backend/tools/registry.py

@@ -0,0 +1,260 @@
+from .file_generator import FileGeneratorTool
+from .decomposer import DecompositionTool
+from .sre import SRETool
+from .browser import BrowserTool
+from .sandbox import CodeSandboxTool
+from .visuals import VisualsTool
+from typing import Any, Dict, List
+
+class ToolRegistry:
+    def __init__(self):
+        self.browser = BrowserTool()
+        self.sandbox = CodeSandboxTool()
+        self.file_gen = FileGeneratorTool()
+        self.decomposer = DecompositionTool()
+        self.sre = SRETool()
+        self.visuals = VisualsTool()
+        self.tools = {
+            "web_search": {
+                "func": self.browser.web_search,
+                "description": "Searches the public web using Tavily and returns summarized results with source URLs."
+            },
+            "extract_url": {
+                "func": self.browser.search_and_extract,
+                "description": "Extracts text content from a specific URL."
+            },
+            "execute_python": {
+                "func": self.sandbox.execute_python,
+                "description": "Executes Python code and returns the output."
+            },
+            "generate_pdf": {
+                "func": self.file_gen.generate_pdf,
+                "description": "Generates a PDF document."
+            },
+            "generate_excel": {
+                "func": self.file_gen.generate_excel,
+                "description": "Generates an Excel spreadsheet from structured data."
+            },
+            "create_subtasks": {
+                "func": self.decomposer.create_subtasks,
+                "description": "Breaks down a goal into a list of actionable tasks."
+            },
+            "generate_chart": {
+                "func": self.visuals.generate_chart,
+                "description": "Generates a chart image (bar, line, pie) from a JSON config."
+            },
+            "generate_illustration": {
+                "func": self.visuals.generate_illustration,
+                "description": "Generates an AI illustration or drawing based on a text prompt."
+            },
+            "get_system_health": {
+                "func": self.sre.get_system_health,
+                "description": "Returns system health metrics (CPU, Memory, Disk)."
+            },
+            "check_service_status": {
+                "func": self.sre.check_service_status,
+                "description": "Checks if a specific service or process is running."
+            },
+            "run_patch_command": {
+                "func": self.sre.run_patch_command,
+                "description": "Executes a safe system patch command (e.g., git pull, npm install)."
+            }
+        }
+
+    def get_tool_definitions(self) -> List[Dict[str, Any]]:
+        """
+        Returns OpenAI-style tool definitions.
+        """
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": "web_search",
+                    "description": "Search the public web for information using Tavily. Use this when the task requires current external information.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "The search query"},
+                            "topic": {
+                                "type": "string",
+                                "enum": ["general", "news", "finance"],
+                                "description": "The search category. Use news for recent events and finance for market/company financial queries."
+                            },
+                            "max_results": {
+                                "type": "integer",
+                                "description": "Maximum number of results to return. Keep this small to control context size.",
+                                "default": 5
+                            }
+                        },
+                        "required": ["query"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "extract_url",
+                    "description": "Extract text content from a URL",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "url": {"type": "string", "description": "The URL to extract from"}
+                        },
+                        "required": ["url"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "execute_python",
+                    "description": "Execute Python code to perform calculations, data analysis, or logic verification.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "code": {"type": "string", "description": "The Python code to execute"}
+                        },
+                        "required": ["code"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "generate_pdf",
+                    "description": "Create a professional PDF report",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "title": {"type": "string", "description": "The title of the report"},
+                            "content": {"type": "string", "description": "The text content of the report"}
+                        },
+                        "required": ["title", "content"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "generate_excel",
+                    "description": "Create an Excel spreadsheet from data",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "data": {
+                                "type": "array", 
+                                "items": {"type": "object"},
+                                "description": "List of rows as objects"
+                            }
+                        },
+                        "required": ["data"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "create_subtasks",
+                    "description": "Break down a complex goal into smaller, actionable tasks for other agents.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "project_id": {"type": "string", "description": "The current project UUID"},
+                            "tasks": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "title": {"type": "string", "description": "Clear title of the subtask"},
+                                        "description": {"type": "string", "description": "Detailed instructions for the next agent"},
+                                        "assigned_agent_id": {"type": "string", "description": "The UUID of the agent to handle this task"}
+                                    },
+                                    "required": ["title", "description", "assigned_agent_id"]
+                                }
+                            }
+                        },
+                        "required": ["project_id", "tasks"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "generate_chart",
+                    "description": "Generate a visual chart image (bar, line, pie, etc.) using QuickChart.io.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "chart_type": {"type": "string", "enum": ["bar", "line", "pie", "doughnut"], "description": "Type of chart"},
+                            "chart_config": {"type": "string", "description": "The JSON configuration for QuickChart (e.g., {type: 'bar', data: {...}})"}
+                        },
+                        "required": ["chart_type", "chart_config"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "generate_illustration",
+                    "description": "Generate an AI illustration or drawing based on a prompt using Pollinations.ai.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "prompt": {"type": "string", "description": "Detailed description of the illustration to generate"}
+                        },
+                        "required": ["prompt"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_system_health",
+                    "description": "Monitor server vital signs like CPU usage, memory availability, and disk space.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {}
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "check_service_status",
+                    "description": "Verify if a critical service or process is currently active on the host.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "service_name": {"type": "string", "description": "The name of the process or service to check"}
+                        },
+                        "required": ["service_name"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "run_patch_command",
+                    "description": "Apply a system patch or update. Limited to safe commands like 'git pull' or 'npm install'.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "command": {"type": "string", "description": "The restricted command to execute"}
+                        },
+                        "required": ["command"]
+                    }
+                }
+            }
+        ]
+
+    async def call_tool(self, name: str, arguments: Dict[str, Any]) -> Any:
+        """
+        Executes a tool by name with provided arguments.
+        """
+        if name not in self.tools:
+            raise ValueError(f"Tool {name} not found")
+        
+        func = self.tools[name]["func"]
+        return await func(**arguments)
+
+tool_registry = ToolRegistry()

backend/tools/sandbox.py

@@ -0,0 +1,39 @@
+import sys
+import io
+import contextlib
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class CodeSandboxTool:
+    """
+    A tool that allows agents to execute Python code and see the output.
+    """
+    async def execute_python(self, code: str) -> str:
+        """
+        Executes the provided Python code and returns the stdout/stderr.
+        """
+        logger.info("CodeSandboxTool: Executing Python code")
+        
+        # Capture stdout and stderr
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+        
+        try:
+            with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+                # Using a fresh globals dictionary for each execution
+                exec_globals = {}
+                exec(code, exec_globals)
+            
+            output = stdout.getvalue()
+            errors = stderr.getvalue()
+            
+            if errors:
+                return f"Output:\n{output}\nErrors:\n{errors}"
+            return output if output else "Execution successful (no output)."
+            
+        except Exception as e:
+            return f"Execution failed: {str(e)}"
+        finally:
+            stdout.close()
+            stderr.close()

backend/tools/sre.py

@@ -0,0 +1,72 @@
+import psutil
+import os
+import platform
+from typing import Dict, Any
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class SRETool:
+    """
+    A toolset for Site Reliability Engineering (SRE) agents to monitor and manage system health.
+    """
+    
+    async def get_system_health(self) -> Dict[str, Any]:
+        """
+        Returns real-time system health metrics (CPU, RAM, Disk).
+        """
+        logger.info("SRETool: Gathering system health metrics")
+        return {
+            "cpu_percent": psutil.cpu_percent(interval=1),
+            "memory": {
+                "total": psutil.virtual_memory().total,
+                "available": psutil.virtual_memory().available,
+                "percent": psutil.virtual_memory().percent
+            },
+            "disk": {
+                "total": psutil.disk_usage('/').total,
+                "used": psutil.disk_usage('/').used,
+                "percent": psutil.disk_usage('/').percent
+            },
+            "os": platform.system(),
+            "uptime": self._get_uptime()
+        }
+
+    async def check_service_status(self, service_name: str) -> str:
+        """
+        Checks if a specific service/process is running.
+        """
+        logger.info(f"SRETool: Checking status of {service_name}")
+        for proc in psutil.process_iter(['name']):
+            if service_name.lower() in proc.info['name'].lower():
+                return f"Service '{service_name}' is RUNNING."
+        return f"Service '{service_name}' is NOT running."
+
+    def _get_uptime(self) -> str:
+        # Simple uptime calculation
+        import time
+        boot_time = psutil.boot_time()
+        uptime_seconds = time.time() - boot_time
+        return f"{int(uptime_seconds // 3600)}h {int((uptime_seconds % 3600) // 60)}m"
+
+    async def run_patch_command(self, command: str) -> str:
+        """
+        Executes a restricted set of patching commands.
+        """
+        logger.warning(f"SRETool: Attempting to run patch command: {command}")
+        
+        # Restricted whitelist for security
+        whitelist = ["npm install", "pip install", "git pull", "npm audit fix"]
+        
+        is_safe = any(command.startswith(safe) for safe in whitelist)
+        if not is_safe:
+            return f"Command '{command}' is not in the safety whitelist. Patch rejected."
+
+        try:
+            import subprocess
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60)
+            if result.returncode == 0:
+                return f"Patch successful: {result.stdout}"
+            return f"Patch failed: {result.stderr}"
+        except Exception as e:
+            return f"Error executing patch: {str(e)}"

backend/tools/visuals.py

@@ -0,0 +1,48 @@
+import urllib.parse
+import json
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class VisualsTool:
+    """
+    Provides visual generation capabilities like charts and illustrations.
+    """
+
+    async def generate_chart(self, chart_type: str, chart_config: str) -> str:
+        """
+        Generates a chart using QuickChart.io.
+        chart_type: 'bar', 'line', 'pie', 'doughnut'
+        chart_config: A JSON string containing the QuickChart configuration.
+        """
+        try:
+            # If chart_config is already a dict, convert to JSON
+            if isinstance(chart_config, dict):
+                config_str = json.dumps(chart_config)
+            else:
+                # Try to parse it to validate
+                config_str = chart_config
+                json.loads(config_str)
+            
+            encoded_config = urllib.parse.quote(config_str)
+            url = f"https://quickchart.io/chart?c={encoded_config}"
+            
+            logger.info(f"Generated chart URL: {url}")
+            return f"Chart generated successfully: {url}. You should include this URL in your markdown output as an image: ![Chart]({url})"
+        except Exception as e:
+            logger.error(f"Failed to generate chart: {e}")
+            return f"Error generating chart: {str(e)}. Please ensure your chart_config is a valid JSON string."
+
+    async def generate_illustration(self, prompt: str) -> str:
+        """
+        Generates an illustration using Pollinations.ai.
+        """
+        try:
+            encoded_prompt = urllib.parse.quote(prompt)
+            url = f"https://pollinations.ai/p/{encoded_prompt}?width=1024&height=1024&seed=42&model=flux"
+            
+            logger.info(f"Generated illustration URL: {url}")
+            return f"Illustration generated successfully: {url}. You should include this URL in your markdown output as an image: ![Illustration]({url})"
+        except Exception as e:
+            logger.error(f"Failed to generate illustration: {e}")
+            return f"Error generating illustration: {str(e)}"

backend/worker.py

@@ -0,0 +1,53 @@
+import asyncio
+import logging
+import signal
+from services.task_queue import TaskQueueService
+from services.supabase_service import supabase
+from services.agent_runner_service import AgentRunnerService
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("worker")
+
+class AubmWorker:
+    def __init__(self):
+        self.running = True
+
+    async def start(self):
+        logger.info("Aubm Background Worker started.")
+        while self.running:
+            task = await TaskQueueService.get_next_queued_task()
+            
+            if task:
+                task_id = task['id']
+                logger.info(f"Processing task: {task_id}")
+                
+                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)
+
+    def stop(self):
+        logger.info("Stopping worker...")
+        self.running = False
+
+async def main():
+    worker = AubmWorker()
+    
+    # Handle shutdown signals
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, worker.stop)
+
+    await worker.start()
+
+if __name__ == "__main__":
+    asyncio.run(main())

database/agent_ownership.sql

@@ -0,0 +1,42 @@
+-- Agent ownership and marketplace deploy policies
+-- Apply this migration to existing Supabase projects after schema.sql.
+
+ALTER TABLE public.agents
+ADD COLUMN IF NOT EXISTS user_id UUID REFERENCES auth.users ON DELETE CASCADE;
+
+ALTER TABLE public.agents ENABLE ROW LEVEL SECURITY;
+
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_policies
+        WHERE schemaname = 'public'
+          AND tablename = 'agents'
+          AND policyname = 'Users can create own agents'
+    ) THEN
+        CREATE POLICY "Users can create own agents" ON public.agents
+            FOR INSERT TO authenticated WITH CHECK (auth.uid() = user_id);
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_policies
+        WHERE schemaname = 'public'
+          AND tablename = 'agents'
+          AND policyname = 'Users can update own agents'
+    ) THEN
+        CREATE POLICY "Users can update own agents" ON public.agents
+            FOR UPDATE TO authenticated USING (auth.uid() = user_id) WITH CHECK (auth.uid() = user_id);
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_policies
+        WHERE schemaname = 'public'
+          AND tablename = 'agents'
+          AND policyname = 'Users can delete own agents'
+    ) THEN
+        CREATE POLICY "Users can delete own agents" ON public.agents
+            FOR DELETE TO authenticated USING (auth.uid() = user_id);
+    END IF;
+END $$;
+
+NOTIFY pgrst, 'reload schema';

database/default_agents.sql

@@ -0,0 +1,36 @@
+-- Global default agents
+-- These agents are readable by authenticated users and usable by the backend
+-- orchestrator as fallback agents. They are not owned by a specific user.
+
+INSERT INTO public.agents (name, role, api_provider, model, system_prompt)
+SELECT
+    'Planner',
+    'Project Planner',
+    'openai',
+    'gpt-4o',
+    'You decompose goals into clear, ordered implementation tasks.'
+WHERE NOT EXISTS (
+    SELECT 1 FROM public.agents WHERE user_id IS NULL AND name = 'Planner'
+);
+
+INSERT INTO public.agents (name, role, api_provider, model, system_prompt)
+SELECT
+    'Builder',
+    'Implementation Agent',
+    'openai',
+    'gpt-4o',
+    'You implement practical, production-oriented solutions with concise output.'
+WHERE NOT EXISTS (
+    SELECT 1 FROM public.agents WHERE user_id IS NULL AND name = 'Builder'
+);
+
+INSERT INTO public.agents (name, role, api_provider, model, system_prompt)
+SELECT
+    'Reviewer',
+    'Quality Reviewer',
+    'openai',
+    'gpt-4o',
+    'You review outputs for correctness, security, completeness, and missing tests.'
+WHERE NOT EXISTS (
+    SELECT 1 FROM public.agents WHERE user_id IS NULL AND name = 'Reviewer'
+);