Deploy Aubm Docker Space

.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

.gitignore

@@ -0,0 +1,9 @@
+backend/.env
+/backend/venv
+/backend/__pycache__
+/backend/venv
+frontend/.env
+__pycache__/
+*.pyc
+
+.vercel

Dockerfile

@@ -0,0 +1,39 @@
+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 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

@@ -1,12 +1,141 @@
 ---
 title: Aubm
-emoji: 🐠
-colorFrom: yellow
-colorTo: purple
 sdk: docker
-pinned: false
+app_port: 7860
 license: mit
 short_description: Automated Business Machines
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 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
+# 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
+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.

backend/.env.example

@@ -0,0 +1,18 @@
+# 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
+
+# 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,41 @@
+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]:
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=self._build_chat_messages(task_description, context, extra_context),
+                response_format={"type": "json_object"},
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+
+            return self._result("amd", response.choices[0].message.content or "")
+        except Exception as e:
+            return {
+                "agent_name": self.name,
+                "provider": "amd",
+                "status": "error",
+                "error": str(e)
+            }

backend/agents/base.py

@@ -0,0 +1,99 @@
+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),
+            })
+
+    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,57 @@
+import logging
+from .base import BaseAgent
+from typing import Dict, Any, List
+import groq
+from services.config import settings, config_service
+from tools.registry import tool_registry
+
+logger = logging.getLogger("uvicorn")
+
+class GroqAgent(BaseAgent):
+    """
+    Agent implementation for Groq.
+    """
+    def __init__(self, name: str, role: str, model: str = "llama-3.3-70b-versatile", system_prompt: str = None):
+        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)
+
+    async def run(self, task_description: str, context: List[Dict[str, Any]], use_tools: bool = False, extra_context: str = "") -> Dict[str, Any]:
+        messages = self._build_chat_messages(task_description, context, extra_context)
+
+        kwargs = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens
+        }
+        
+        if use_tools:
+            kwargs["tools"] = tool_registry.get_tool_definitions()
+            kwargs["tool_choice"] = "auto"
+
+        response = await self.client.chat.completions.create(**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)
+            
+            final_response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+            content = final_response.choices[0].message.content
+        else:
+            content = message.content or ""
+
+        return self._result("groq", content)

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,54 @@
+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]:
+        messages = self._build_chat_messages(task_description, context, extra_context)
+
+        request_kwargs = {
+            "model": self.model,
+            "messages": messages,
+            "response_format": {"type": "json_object"},
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens
+        }
+        if use_tools:
+            request_kwargs["tools"] = tool_registry.get_tool_definitions()
+            request_kwargs["tool_choice"] = "auto"
+
+        response = await self.client.chat.completions.create(**request_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
+            final_response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                response_format={"type": "json_object"},
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+            content = final_response.choices[0].message.content
+        else:
+            content = message.content
+
+        return self._result("openai", content or "")

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,89 @@
+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
+
+# Load environment variables
+load_dotenv()
+FRONTEND_DIST = Path(__file__).resolve().parent.parent / "frontend" / "dist"
+
+# 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="0.1.0"
+)
+
+# CORS Configuration
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "*").split(",")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins,
+    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": "0.1.0"
+    }
+
+# 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", "")),
+    }
+    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,77 @@
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+from services.supabase_service import supabase
+from services.agent_runner_service import AgentRunnerService
+import logging
+
+router = APIRouter()
+logger = logging.getLogger("uvicorn")
+
+def update_task_status(task_id: str, status: str):
+    result = (
+        supabase.table("tasks")
+        .update({"status": status})
+        .eq("id", task_id)
+        .select("id,project_id,status")
+        .single()
+        .execute()
+    )
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Task not found or status was not updated")
+
+    project_id = result.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 result.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 = 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}

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,153 @@
+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
+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.extend([
+            Paragraph("Project Charts", styles["Heading2"]),
+            Paragraph("Completion Status", styles["Heading3"]),
+            _pie_chart(charts.get("status", [])),
+            Spacer(1, 0.1 * inch),
+            Paragraph("Task Categories", styles["Heading3"]),
+            _bar_chart("Task Categories", charts.get("categories", [])),
+            Spacer(1, 0.1 * inch),
+            Paragraph("Project Scores", styles["Heading3"]),
+            _bar_chart("Project Scores", charts.get("scores", [])),
+            Spacer(1, 0.2 * 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/services/agent_runner_service.py

@@ -0,0 +1,116 @@
+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
+
+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."
+    ) -> tuple[dict, str]:
+        task_id = task["id"]
+        project_id = task["project_id"]
+        run_id = None
+
+        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 []
+
+            extra_context = ""
+            if include_semantic_context:
+                extra_context = await semantic_backprop.get_project_context(project_id, task_id)
+
+            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()
+
+            result = await agent.run(task.get("description") or task["title"], context, extra_context=extra_context)
+            if result.get("status") == "error":
+                raise RuntimeError(result.get("error") or "Agent returned an error result.")
+
+            supabase.table("tasks").update({
+                "status": "awaiting_approval",
+                "output_data": result
+            }).eq("id", task_id).execute()
+
+            supabase.table("task_runs").update({
+                "status": "completed",
+                "finished_at": datetime.now(timezone.utc).isoformat()
+            }).eq("id", run_id).execute()
+
+            supabase.table("agent_logs").insert({
+                "task_id": task_id,
+                "run_id": run_id,
+                "action": complete_action,
+                "content": complete_content
+            }).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()
+            supabase.table("tasks").update({
+                "status": "failed",
+                "output_data": {"error": str(e)}
+            }).eq("id", task_id).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,98 @@
+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 = os.getenv("SUPABASE_URL", "")
+    SUPABASE_SERVICE_ROLE_KEY: str = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+    
+    # AI Providers
+    OPENAI_API_KEY: Optional[str] = os.getenv("OPENAI_API_KEY")
+    GROQ_API_KEY: Optional[str] = os.getenv("GROQ_API_KEY")
+    GEMINI_API_KEY: Optional[str] = os.getenv("GEMINI_API_KEY")
+    ANTHROPIC_API_KEY: Optional[str] = os.getenv("ANTHROPIC_API_KEY")
+    AMD_API_KEY: Optional[str] = os.getenv("AMD_API_KEY")
+    
+    # App Config
+    TASK_QUEUE_EMBEDDED_WORKER: bool = os.getenv("TASK_QUEUE_EMBEDDED_WORKER", "true").lower() == "true"
+    OUTPUT_LANGUAGE: str = os.getenv("OUTPUT_LANGUAGE", "en")
+    PORT: int = int(os.getenv("PORT", 8000))
+    SENTRY_DSN: Optional[str] = os.getenv("SENTRY_DSN")
+    
+    class Config:
+        env_file = ".env"
+
+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,531 @@
+from services.supabase_service import supabase
+from agents.agent_factory import AgentFactory
+import json
+import logging
+from services.config import settings
+from services.agent_runner_service import AgentRunnerService
+
+logger = logging.getLogger("uvicorn")
+
+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():
+            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 _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):
+        return primary
+
+    return "\n".join(_format_value_for_report(primary))
+
+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."
+        )
+    },
+    "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."
+        )
+    }
+}
+
+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 = supabase.table("agents").select("*").eq("id", agent_a_id).single().execute().data
+            agent_b = supabase.table("agents").select("*").eq("id", agent_b_id).single().execute().data
+            
+            # 2. Agent A generates initial response
+            inst_a = AgentFactory.get_agent(agent_a["api_provider"], agent_a["name"], agent_a["role"], agent_a["model"])
+            initial_res = await inst_a.run(task["description"], [])
+            
+            # 3. Agent B reviews and critiques
+            inst_b = AgentFactory.get_agent(agent_b["api_provider"], agent_b["name"], agent_b["role"], agent_b["model"])
+            critique_prompt = 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 inst_b.run(critique_prompt, [])
+            
+            # 4. Agent A refines based on critique
+            refinement_prompt = f"Refine your initial output for the task: '{task['description']}' based on this critique: {json.dumps(critique_res['data'])}"
+            final_res = await inst_a.run(refinement_prompt, [])
+            
+            # 5. Save final result
+            supabase.table("tasks").update({
+                "status": "done",
+                "output_data": {
+                    "initial": initial_res["data"],
+                    "critique": critique_res["data"],
+                    "final": final_res["data"]
+                }
+            }).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"}).eq("id", task_id).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 []
+        )
+
+        # Automatic Decomposition: If no tasks exist, try to decompose the project first
+        if not 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
+
+    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)}")
+
+        report_title = REPORT_VARIANTS[variant]["title"]
+        lines = [
+            f"# {report_title}: {project['name']}",
+            "",
+            "## Project Brief",
+            project.get("description") or "No project description provided.",
+        ]
+
+        if project.get("context"):
+            lines.extend(["", "## Context", project["context"]])
+
+        lines.extend(["", "## Approved Work Summary"])
+
+        for index, task in enumerate(tasks, start=1):
+            lines.extend([
+                "",
+                f"### {index}. {task['title']}",
+                task.get("description") or "No task description provided.",
+                "",
+                _format_output_for_report(task.get("output_data"))
+            ])
+
+        lines.extend([
+            "",
+            "## Completion Status",
+            f"All {len(tasks)} tasks are approved. Project status: completed."
+        ])
+
+        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": len(tasks),
+            "variant": variant,
+            "report": report,
+            "charts": _build_report_charts(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 tasks.
+Project Name: {project['name']}
+Description: {project['description']}
+Context: {project.get('context', 'None')}
+
+Return ONLY a valid JSON array of objects.
+Each object MUST have exactly these keys: 'title', 'description', and 'priority' (integer 1-5).
+IMPORTANT: Do not wrap the list in an object. Return a flat [{{...}}, {{...}}] array.
+"""
+
+        try:
+            result = await planner.run(prompt, [])
+            # Some cleaning might be needed if agent returns markdown
+            content = result["data"]
+            tasks_data = planner._parse_json_output(content) if isinstance(content, str) else content
+
+            # Ensure tasks_data is a list
+            if isinstance(tasks_data, dict):
+                # If agent wrapped it in {"tasks": [...]}, extract it
+                if "tasks" in tasks_data and isinstance(tasks_data["tasks"], list):
+                    tasks_data = tasks_data["tasks"]
+                else:
+                    # Single task as object, wrap in list
+                    tasks_data = [tasks_data]
+            
+            if not isinstance(tasks_data, list):
+                raise ValueError(f"Agent returned invalid format: {type(tasks_data)}. Expected list or dict.")
+
+            # Insert tasks
+            from .project_service import project_service
+            await project_service.add_tasks_to_project(project_id, tasks_data)
+            logger.info(f"Auto-decomposed project {project_id} into {len(tasks_data)} 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/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,35 @@
+from playwright.async_api import async_playwright
+import logging
+
+logger = logging.getLogger("uvicorn")
+
+class BrowserTool:
+    """
+    A tool that allows agents to browse the web and extract content.
+    """
+    async def search_and_extract(self, url: str) -> str:
+        """
+        Navigates to a URL and returns the text content.
+        """
+        logger.info(f"BrowserTool: Navigating to {url}")
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=True)
+            page = await browser.new_page()
+            try:
+                await page.goto(url, wait_until="networkidle", timeout=30000)
+                # Simple extraction: get all text from body
+                content = await page.inner_text("body")
+                # Truncate if too long for LLM context
+                return content[:10000] 
+            except Exception as e:
+                logger.error(f"BrowserTool error: {str(e)}")
+                return f"Error accessing {url}: {str(e)}"
+            finally:
+                await browser.close()
+
+    async def google_search(self, query: str) -> str:
+        """
+        Performs a Google search and returns results.
+        """
+        search_url = f"https://www.google.com/search?q={query}"
+        return await self.search_and_extract(search_url)

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,250 @@
+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.google_search,
+                "description": "Searches the web for a given query and returns the results."
+            },
+            "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 web for information",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "The search query"}
+                        },
+                        "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'
+);

database/enterprise_security.sql

@@ -0,0 +1,53 @@
+-- Enterprise Teams Table
+CREATE TABLE IF NOT EXISTS teams (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    name TEXT NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Team Members Table
+CREATE TABLE IF NOT EXISTS team_members (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    team_id UUID REFERENCES teams(id) ON DELETE CASCADE,
+    user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
+    role TEXT CHECK (role IN ('admin', 'editor', 'viewer')) DEFAULT 'viewer',
+    UNIQUE(team_id, user_id)
+);
+
+-- Add team_id to Projects
+ALTER TABLE projects ADD COLUMN IF NOT EXISTS team_id UUID REFERENCES teams(id);
+
+-- Advanced RLS for Projects
+ALTER TABLE projects ENABLE ROW LEVEL SECURITY;
+
+-- Policy: Users can view projects of their teams
+CREATE POLICY "Team members can view team projects" ON projects
+    FOR SELECT USING (
+        EXISTS (
+            SELECT 1 FROM team_members 
+            WHERE team_members.team_id = projects.team_id 
+            AND team_members.user_id = auth.uid()
+        )
+    );
+
+-- Policy: Only admins and editors can modify projects
+CREATE POLICY "Team admins and editors can modify projects" ON projects
+    FOR ALL USING (
+        EXISTS (
+            SELECT 1 FROM team_members 
+            WHERE team_members.team_id = projects.team_id 
+            AND team_members.user_id = auth.uid()
+            AND team_members.role IN ('admin', 'editor')
+        )
+    );
+
+-- Audit Logs for RLS
+CREATE POLICY "Team members can view audit logs" ON audit_logs
+    FOR SELECT USING (
+        EXISTS (
+            SELECT 1 FROM projects
+            JOIN team_members ON team_members.team_id = projects.team_id
+            WHERE projects.id = audit_logs.task_id -- Simplified link
+            AND team_members.user_id = auth.uid()
+        )
+    );

database/marketplace.sql

@@ -0,0 +1,31 @@
+-- Agent Marketplace Table
+CREATE TABLE IF NOT EXISTS agent_templates (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    name TEXT NOT NULL,
+    role TEXT NOT NULL,
+    description TEXT,
+    model TEXT NOT NULL,
+    api_provider TEXT NOT NULL,
+    system_prompt TEXT,
+    category TEXT, -- e.g., 'Marketing', 'Development', 'Legal'
+    author_id UUID REFERENCES auth.users(id),
+    is_featured BOOLEAN DEFAULT false,
+    usage_count INT DEFAULT 0,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- RLS for Marketplace (Public View)
+ALTER TABLE agent_templates ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "Anyone can view templates" ON agent_templates
+    FOR SELECT USING (true);
+
+CREATE POLICY "Users can create their own templates" ON agent_templates
+    FOR INSERT WITH CHECK (auth.uid() = author_id);
+
+-- Seed some marketplace templates
+INSERT INTO agent_templates (name, role, description, model, api_provider, category, system_prompt)
+VALUES 
+('Growth Hacker', 'Marketing Expert', 'Optimizes funnels and generates viral content ideas.', 'gpt-4o', 'openai', 'Marketing', 'You are a Growth Hacker focused on low-cost, high-impact strategies.'),
+('Code Architect', 'Senior Developer', 'Designs robust software architectures and reviews code.', 'gpt-4o', 'openai', 'Development', 'You are a Code Architect. Focus on scalability, security, and clean code.'),
+('Legal Analyst', 'Legal Advisor', 'Analyzes contracts and identifies legal risks.', 'gpt-4o', 'openai', 'Legal', 'You are a Legal Analyst. Review documents with high precision and caution.');

database/phase3_updates.sql

@@ -0,0 +1,30 @@
+-- Audit Logs Table
+CREATE TABLE IF NOT EXISTS audit_logs (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    user_id UUID REFERENCES auth.users(id),
+    agent_id UUID REFERENCES agents(id),
+    task_id UUID REFERENCES tasks(id),
+    action TEXT NOT NULL,
+    metadata JSONB,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Feedback Table for Fine-tuning
+CREATE TABLE IF NOT EXISTS task_feedback (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    task_id UUID REFERENCES tasks(id) UNIQUE,
+    user_id UUID REFERENCES auth.users(id),
+    rating INT CHECK (rating IN (-1, 1)), -- -1 for dislike, 1 for like
+    comment TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Add RLS to new tables
+ALTER TABLE audit_logs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE task_feedback ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "Users can view their own audit logs" ON audit_logs
+    FOR SELECT USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can manage their own feedback" ON task_feedback
+    FOR ALL USING (auth.uid() = user_id);

database/schema.sql

@@ -0,0 +1,141 @@
+-- Aubm Database Schema
+-- Designed for Supabase (PostgreSQL)
+
+-- 1. Profiles (User Extensions)
+CREATE TABLE IF NOT EXISTS public.profiles (
+    id UUID PRIMARY KEY REFERENCES auth.users ON DELETE CASCADE,
+    role TEXT CHECK (role IN ('user', 'manager', 'admin')) DEFAULT 'user',
+    full_name TEXT,
+    avatar_url TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- 2. Projects
+CREATE TABLE IF NOT EXISTS public.projects (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name TEXT NOT NULL,
+    description TEXT,
+    context TEXT,
+    owner_id UUID REFERENCES auth.users ON DELETE CASCADE,
+    status TEXT CHECK (status IN ('active', 'archived', 'completed')) DEFAULT 'active',
+    is_public BOOLEAN DEFAULT FALSE,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- 3. Agents (AI Identities)
+CREATE TABLE IF NOT EXISTS public.agents (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id UUID REFERENCES auth.users ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    role TEXT,
+    api_provider TEXT NOT NULL,
+    model TEXT NOT NULL,
+    system_prompt TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- 4. Tasks (Units of work)
+CREATE TABLE IF NOT EXISTS public.tasks (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    project_id UUID REFERENCES public.projects ON DELETE CASCADE,
+    assigned_agent_id UUID REFERENCES public.agents ON DELETE SET NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT CHECK (status IN ('todo', 'in_progress', 'awaiting_approval', 'done', 'failed', 'cancelled')) DEFAULT 'todo',
+    priority INTEGER DEFAULT 0,
+    is_critical BOOLEAN DEFAULT FALSE,
+    output_data JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- 5. Task Runs (Execution History)
+CREATE TABLE IF NOT EXISTS public.task_runs (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    task_id UUID REFERENCES public.tasks ON DELETE CASCADE,
+    agent_id UUID REFERENCES public.agents ON DELETE SET NULL,
+    status TEXT CHECK (status IN ('queued', 'running', 'completed', 'failed', 'cancelled')) DEFAULT 'queued',
+    error_message TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    finished_at TIMESTAMPTZ
+);
+
+-- 6. Agent Logs (Execution Traces)
+CREATE TABLE IF NOT EXISTS public.agent_logs (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    task_id UUID REFERENCES public.tasks ON DELETE CASCADE,
+    run_id UUID REFERENCES public.task_runs ON DELETE CASCADE,
+    action TEXT,
+    content TEXT,
+    metadata JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- 7. App Config (Global Settings)
+CREATE TABLE IF NOT EXISTS public.app_config (
+    key TEXT PRIMARY KEY,
+    value JSONB,
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- RLS (Row Level Security) - Initial setup
+ALTER TABLE public.profiles ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.projects ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.agents ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.tasks ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.task_runs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.agent_logs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.app_config ENABLE ROW LEVEL SECURITY;
+
+-- Basic Policies (To be refined)
+-- Projects: Owners can do anything, others can read if public
+CREATE POLICY "Projects visibility" ON public.projects 
+    FOR SELECT USING (auth.uid() = owner_id OR is_public = true);
+
+CREATE POLICY "Projects ownership" ON public.projects 
+    FOR ALL USING (auth.uid() = owner_id);
+
+-- Tasks: Protected by project ownership
+CREATE POLICY "Tasks visibility" ON public.tasks 
+    FOR SELECT USING (EXISTS (
+        SELECT 1 FROM public.projects 
+        WHERE projects.id = tasks.project_id AND (projects.owner_id = auth.uid() OR projects.is_public = true)
+    ));
+
+CREATE POLICY "Project owners can create tasks" ON public.tasks
+    FOR INSERT TO authenticated WITH CHECK (EXISTS (
+        SELECT 1 FROM public.projects
+        WHERE projects.id = tasks.project_id AND projects.owner_id = auth.uid()
+    ));
+
+CREATE POLICY "Project owners can update tasks" ON public.tasks
+    FOR UPDATE TO authenticated USING (EXISTS (
+        SELECT 1 FROM public.projects
+        WHERE projects.id = tasks.project_id AND projects.owner_id = auth.uid()
+    )) WITH CHECK (EXISTS (
+        SELECT 1 FROM public.projects
+        WHERE projects.id = tasks.project_id AND projects.owner_id = auth.uid()
+    ));
+
+CREATE POLICY "Project owners can delete tasks" ON public.tasks
+    FOR DELETE TO authenticated USING (EXISTS (
+        SELECT 1 FROM public.projects
+        WHERE projects.id = tasks.project_id AND projects.owner_id = auth.uid()
+    ));
+
+-- Agents: Marketplace templates are readable by all authenticated users.
+-- Deployed agents are owned by the user who deployed them.
+CREATE POLICY "Agents readable" ON public.agents 
+    FOR SELECT TO authenticated USING (true);
+
+CREATE POLICY "Users can create own agents" ON public.agents
+    FOR INSERT TO authenticated WITH CHECK (auth.uid() = user_id);
+
+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);
+
+CREATE POLICY "Users can delete own agents" ON public.agents
+    FOR DELETE TO authenticated USING (auth.uid() = user_id);

database/seed.sql

@@ -0,0 +1,15 @@
+-- Seed Data for Aubm
+
+-- 1. Default Agents
+INSERT INTO public.agents (name, role, api_provider, model, system_prompt)
+VALUES 
+('GPT-4o', 'General Intelligence', 'openai', 'gpt-4o', 'You are a highly capable AI assistant.'),
+('AMD-4o', 'Performance Specialist', 'amd', 'gpt-4o', 'You are a high-performance agent running on AMD infrastructure.'),
+('Llama-3-70B', 'Fast Logic', 'groq', 'llama3-70b-8192', 'You are a fast and efficient reasoning agent.');
+
+-- 2. Default App Config
+INSERT INTO public.app_config (key, value)
+VALUES 
+('output_language', '"en"'),
+('max_parallel_tasks', '5'),
+('enable_human_loop', 'true');

database/task_owner_policies.sql

@@ -0,0 +1,63 @@
+-- Task ownership policies for project owners
+-- Apply this migration to existing Supabase projects after schema.sql.
+
+ALTER TABLE public.tasks ENABLE ROW LEVEL SECURITY;
+
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_policies
+        WHERE schemaname = 'public'
+          AND tablename = 'tasks'
+          AND policyname = 'Project owners can create tasks'
+    ) THEN
+        CREATE POLICY "Project owners can create tasks" ON public.tasks
+            FOR INSERT TO authenticated WITH CHECK (
+                EXISTS (
+                    SELECT 1 FROM public.projects
+                    WHERE projects.id = tasks.project_id
+                      AND projects.owner_id = auth.uid()
+                )
+            );
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_policies
+        WHERE schemaname = 'public'
+          AND tablename = 'tasks'
+          AND policyname = 'Project owners can update tasks'
+    ) THEN
+        CREATE POLICY "Project owners can update tasks" ON public.tasks
+            FOR UPDATE TO authenticated USING (
+                EXISTS (
+                    SELECT 1 FROM public.projects
+                    WHERE projects.id = tasks.project_id
+                      AND projects.owner_id = auth.uid()
+                )
+            ) WITH CHECK (
+                EXISTS (
+                    SELECT 1 FROM public.projects
+                    WHERE projects.id = tasks.project_id
+                      AND projects.owner_id = auth.uid()
+                )
+            );
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_policies
+        WHERE schemaname = 'public'
+          AND tablename = 'tasks'
+          AND policyname = 'Project owners can delete tasks'
+    ) THEN
+        CREATE POLICY "Project owners can delete tasks" ON public.tasks
+            FOR DELETE TO authenticated USING (
+                EXISTS (
+                    SELECT 1 FROM public.projects
+                    WHERE projects.id = tasks.project_id
+                      AND projects.owner_id = auth.uid()
+                )
+            );
+    END IF;
+END $$;
+
+NOTIFY pgrst, 'reload schema';

frontend/.env.example

@@ -0,0 +1,6 @@
+VITE_API_URL=http://localhost:8000
+VITE_SUPABASE_URL=https://your-project-id.supabase.co
+VITE_SUPABASE_ANON_KEY=your-anon-key-here
+
+# Optional: Sentry
+VITE_SENTRY_DSN=your-sentry-dsn

frontend/.gitignore

@@ -0,0 +1,44 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+# Python virtual env
+venv/
+backend/venv/
+**/venv/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyd
+
+# Env files
+.env
+.env.*
+**/.env
+**/.env.*
+
+# Permitir ejemplos sin secretos
+!.env.example
+!**/.env.example
+

frontend/Dockerfile

@@ -0,0 +1,20 @@
+# Build stage
+FROM node:20-slim AS build-stage
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+# Production stage
+FROM nginx:stable-alpine AS production-stage
+
+COPY --from=build-stage /app/dist /usr/share/nginx/html
+COPY --from=build-stage /app/nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

frontend/README.md

@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```