Upload 6 files

main.py

@@ -1,605 +1,447 @@
-import os
-import asyncio
-import httpx
-import json
-import re
-import uuid
-import base64
+import os, asyncio, httpx, re, json as _json
 from io import BytesIO
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 from datetime import datetime
 from pathlib import Path
-
-# python-docx imports
 from docx import Document as DocxDocument
 from docx.shared import Inches, Pt, RGBColor
 from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.oxml.ns import qn
 from docx.oxml import OxmlElement
+import openpyxl
+from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
 
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-GOOGLE_API_KEY     = os.getenv("GOOGLE_API_KEY", "")
-OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
-GROQ_API_KEY       = os.getenv("GROQ_API_KEY", "")
-PEXELS_API_KEY     = os.getenv("PEXELS_API_KEY", "")    # free at pexels.com/api
-HF_API_KEY         = os.getenv("HF_TOKEN", "")           # HuggingFace token for image gen
+GOOGLE_API_KEY     = os.getenv("GOOGLE_API_KEY","")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY","")
+GROQ_API_KEY       = os.getenv("GROQ_API_KEY","")
+PEXELS_API_KEY     = os.getenv("PEXELS_API_KEY","")
+HF_API_KEY         = os.getenv("HF_TOKEN","")
 
 DOCS_DIR = Path("docs")
 DOCS_DIR.mkdir(exist_ok=True)
 
 PROVIDERS = {
-    "gemini": {
-        "name": "Google Gemini", "type": "gemini", "key": GOOGLE_API_KEY,
-    },
-    "openrouter": {
-        "name": "OpenRouter", "type": "openai_compat", "key": OPENROUTER_API_KEY,
-        "base_url": "https://openrouter.ai/api/v1/chat/completions",
-        "headers": {
-            "HTTP-Referer": "https://huggingface.co/spaces/vfven/mission-control-ui",
-            "X-Title": "Mission Control AI",
-        },
-    },
-    "groq": {
-        "name": "Groq", "type": "openai_compat", "key": GROQ_API_KEY,
-        "base_url": "https://api.groq.com/openai/v1/chat/completions",
-        "headers": {},
-    },
+    "gemini":     {"name":"Google Gemini","type":"gemini","key":GOOGLE_API_KEY},
+    "openrouter": {"name":"OpenRouter","type":"openai_compat","key":OPENROUTER_API_KEY,
+                   "base_url":"https://openrouter.ai/api/v1/chat/completions",
+                   "headers":{"HTTP-Referer":"https://huggingface.co/spaces/vfven/mission-control-ui","X-Title":"Mission Control AI"}},
+    "groq":       {"name":"Groq","type":"openai_compat","key":GROQ_API_KEY,
+                   "base_url":"https://api.groq.com/openai/v1/chat/completions","headers":{}},
 }
 
-# ── DEFAULT AGENTS (can be extended via UI) ───────────────────────────────
 DEFAULT_AGENTS = [
-    {
-        "key": "manager", "name": "Manager", "provider": "gemini",
-        "role": "Gerente de proyecto experto en coordinar equipos y planificar estrategias. Cuando el usuario pide un documento o informe, DEBES indicar en tu respuesta qué agentes necesitas activar usando el formato JSON: {\"delegate\": [\"writer\", \"analyst\"]} al final de tu respuesta.",
-        "models": ["gemini-2.5-flash-preview-04-17", "gemini-2.0-flash", "gemini-1.5-flash"],
-    },
-    {
-        "key": "developer", "name": "Developer", "provider": "openrouter",
-        "role": "Programador senior especialista en crear aplicaciones y soluciones técnicas.",
-        "models": ["qwen/qwen3-4b:free", "meta-llama/llama-3.3-70b-instruct:free", "mistralai/mistral-small-3.1-24b-instruct:free", "google/gemma-3-12b-it:free"],
-    },
-    {
-        "key": "analyst", "name": "Analyst", "provider": "openrouter",
-        "role": "Analista de negocios experto en evaluar viabilidad, riesgos y oportunidades. También revisa y critica documentos formales.",
-        "models": ["meta-llama/llama-3.3-70b-instruct:free", "mistralai/mistral-small-3.1-24b-instruct:free", "google/gemma-3-27b-it:free", "qwen/qwen3-4b:free"],
-    },
-    {
-        "key": "writer", "name": "Writer", "provider": "openrouter",
-        "role": "Especialista en redacción de documentos formales, informes ejecutivos y reportes técnicos. Escribe en formato estructurado con secciones claras usando ### para títulos y ** para subtítulos.",
-        "models": ["meta-llama/llama-3.3-70b-instruct:free", "mistralai/mistral-small-3.1-24b-instruct:free", "qwen/qwen3-4b:free", "google/gemma-3-12b-it:free"],
-    },
-    {
-        "key": "image_agent", "name": "ImageAgent", "provider": "gemini",
-        "role": "Agente especializado en buscar y proveer imágenes relevantes. Cuando se te pida imágenes sobre un tema, responde con una lista JSON de términos de búsqueda en inglés: {\"image_queries\": [\"term1\", \"term2\", \"term3\"]}",
-        "models": ["gemini-2.0-flash", "gemini-1.5-flash"],
-    },
+    {"key":"manager","name":"Manager","provider":"gemini",
+     "role":(
+         "Eres el gerente de proyecto. Analiza la solicitud y decide qué agentes trabajarán. "
+         "NUNCA hagas el trabajo tú mismo. Saluda en 1 línea y delega siempre con JSON al final: "
+         '{"delegate":["key1","key2"]}\n'
+         "REGLAS:\n"
+         "- imagen/foto/gato/perro/dibujo → image_agent\n"
+         "- informe/reporte/word/documento → writer + analyst\n"
+         "- excel/planilla/hoja/spreadsheet/registrar → backend_dev\n"
+         "- python/script/groovy/jenkins/api/devops → backend_dev\n"
+         "- html/css/web/interfaz/frontend → frontend_dev\n"
+         "- app completa full-stack → backend_dev + frontend_dev\n"
+         "- analisis/viabilidad/evaluar → analyst"
+     ),
+     "models":["gemini-2.5-flash-preview-04-17","gemini-2.0-flash","gemini-1.5-flash"]},
+    {"key":"backend_dev","name":"Backend","provider":"openrouter",
+     "role":(
+         "Eres programador backend senior. REGLAS ABSOLUTAS:\n"
+         "1. Entrega SOLO el código pedido, sin explicaciones innecesarias.\n"
+         "2. Excel/planilla → responde con EXCEL_TEMPLATE:{\"title\":\"...\",\"sheet_name\":\"...\","
+         "\"headers\":[...],\"sample_rows\":[[...],[...]]}\n"
+         "3. Python → entrega código Python puro y funcional.\n"
+         "4. Groovy/Jenkins → entrega el script completo.\n"
+         "5. Si hay frontend_dev en el equipo, TÚ haces servidor/backend, él hace HTML.\n"
+         "6. Si la tarea no requiere backend → responde: {\"skip\":\"no backend needed\"}"
+     ),
+     "models":["qwen/qwen3-4b:free","meta-llama/llama-3.3-70b-instruct:free",
+               "mistralai/mistral-small-3.1-24b-instruct:free","google/gemma-3-12b-it:free"]},
+    {"key":"frontend_dev","name":"Frontend","provider":"openrouter",
+     "role":(
+         "Eres desarrollador frontend senior. REGLAS ABSOLUTAS:\n"
+         "1. Entrega SOLO código HTML/CSS/JS pedido, sin explicaciones innecesarias.\n"
+         "2. Si hay backend_dev, TÚ haces HTML/interfaz, él hace servidor/lógica.\n"
+         "3. Si la tarea NO requiere frontend → responde: {\"skip\":\"no frontend needed\"}\n"
+         "4. Entrega siempre HTML completo y funcional con los estilos incluidos."
+     ),
+     "models":["meta-llama/llama-3.3-70b-instruct:free","mistralai/mistral-small-3.1-24b-instruct:free",
+               "qwen/qwen3-4b:free","google/gemma-3-12b-it:free"]},
+    {"key":"analyst","name":"Analyst","provider":"openrouter",
+     "role":(
+         "Eres analista de negocios. REGLAS:\n"
+         "1. Solo haz lo que el manager delegó: revisar documentos, evaluar viabilidad, analizar riesgos.\n"
+         "2. NUNCA describas imágenes ni hagas trabajo de otros agentes.\n"
+         "3. Si la tarea no requiere análisis → responde: {\"skip\":\"no analysis needed\"}"
+     ),
+     "models":["meta-llama/llama-3.3-70b-instruct:free","mistralai/mistral-small-3.1-24b-instruct:free",
+               "google/gemma-3-27b-it:free","qwen/qwen3-4b:free"]},
+    {"key":"writer","name":"Writer","provider":"openrouter",
+     "role":(
+         "Eres redactor experto. Escribe SOLO contenido real y extenso (500+ palabras). "
+         "Sin placeholders. Usa ## para secciones y ### para subsecciones. "
+         "Secciones: ## Resumen Ejecutivo, ### Introducción, ### Desarrollo, "
+         "### Hallazgos, ### Conclusiones, ### Recomendaciones"
+     ),
+     "models":["meta-llama/llama-3.3-70b-instruct:free","mistralai/mistral-small-3.1-24b-instruct:free",
+               "qwen/qwen3-4b:free","google/gemma-3-12b-it:free"]},
+    {"key":"image_agent","name":"ImageAgent","provider":"gemini",
+     "role":(
+         "Cuando se te pida imágenes, responde SOLO con: "
+         "{\"image_queries\":[\"english term 1\",\"english term 2\",\"english term 3\"]} "
+         "Los términos deben ser específicos en inglés para encontrar buenas imágenes."
+     ),
+     "models":["gemini-2.0-flash","gemini-1.5-flash"]},
 ]
 
-SUBSTITUTE_MODELS = {
-    "groq": ["llama-3.3-70b-versatile", "llama3-70b-8192", "gemma2-9b-it"],
-}
-
-# Runtime agent registry (can be extended)
 agent_registry = {a["key"]: dict(a) for a in DEFAULT_AGENTS}
 mission_history = []
 
-
-# ── LLM CALLERS ───────────────────────────────────────────────────────────
-async def call_gemini(model: str, system: str, user: str, key: str) -> str:
+async def call_gemini(model,system,user,key):
     url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
-    payload = {
-        "contents": [{"role": "user", "parts": [{"text": f"{system}\n\n{user}"}]}],
-        "generationConfig": {"maxOutputTokens": 2048, "temperature": 0.7},
-    }
-    async with httpx.AsyncClient(timeout=90) as client:
-        r = await client.post(url, json=payload)
+    async with httpx.AsyncClient(timeout=90) as c:
+        r = await c.post(url,json={"contents":[{"role":"user","parts":[{"text":f"{system}\n\n{user}"}]}],"generationConfig":{"maxOutputTokens":2048,"temperature":0.4}})
         r.raise_for_status()
         return r.json()["candidates"][0]["content"]["parts"][0]["text"]
 
-
-async def call_openai_compat(base_url: str, model: str, system: str, user: str,
-                              key: str, extra_headers: dict) -> str:
-    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json", **extra_headers}
-    payload = {
-        "model": model,
-        "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}],
-        "max_tokens": 2048, "temperature": 0.7,
-    }
-    async with httpx.AsyncClient(timeout=90) as client:
-        r = await client.post(base_url, json=payload, headers=headers)
+async def call_compat(base_url,model,system,user,key,headers):
+    h = {"Authorization":f"Bearer {key}","Content-Type":"application/json",**headers}
+    async with httpx.AsyncClient(timeout=90) as c:
+        r = await c.post(base_url,json={"model":model,"messages":[{"role":"system","content":system},{"role":"user","content":user}],"max_tokens":2048,"temperature":0.4},headers=h)
         r.raise_for_status()
         return r.json()["choices"][0]["message"]["content"]
 
-
-async def call_agent_llm(agent: dict, task: str) -> str:
-    prov_key = agent["provider"]
-    provider = PROVIDERS[prov_key]
-    system   = f"Eres {agent['name']}. {agent['role']} Responde en español. Sé conciso y profesional."
-    last_err = None
-
-    for model in agent["models"]:
+async def call_llm(agent,task):
+    p = PROVIDERS[agent["provider"]]
+    err = None
+    for m in agent["models"]:
         try:
-            if provider["type"] == "gemini":
-                return await call_gemini(model, system, task, provider["key"])
-            else:
-                return await call_openai_compat(
-                    provider["base_url"], model, system, task,
-                    provider["key"], provider.get("headers", {}))
-        except Exception as e:
-            last_err = str(e)
-
-    # Groq fallback
-    if GROQ_API_KEY:
-        groq = PROVIDERS["groq"]
-        for m in SUBSTITUTE_MODELS["groq"]:
-            try:
-                return await call_openai_compat(
-                    groq["base_url"], m, system, task, groq["key"], {})
-            except Exception as e:
-                last_err = str(e)
-
-    raise Exception(f"All providers failed: {last_err}")
-
-
-# ── IMAGE FETCHING ─────────────────────────────────────────────────────────
-async def fetch_pexels_image(query: str) -> bytes | None:
-    if not PEXELS_API_KEY:
-        return None
+            if p["type"]=="gemini": return await call_gemini(m,agent["role"],task,p["key"])
+            else: return await call_compat(p["base_url"],m,agent["role"],task,p["key"],p.get("headers",{}))
+        except Exception as e: err=str(e)
+    if GROQ_API_KEY and agent["provider"]!="groq":
+        for m in ["llama-3.3-70b-versatile","llama3-70b-8192","gemma2-9b-it"]:
+            try: return await call_compat(PROVIDERS["groq"]["base_url"],m,agent["role"],task,GROQ_API_KEY,{})
+            except Exception as e: err=str(e)
+    raise Exception(f"All providers failed: {err}")
+
+async def fetch_pexels(q):
+    if not PEXELS_API_KEY: return None
     try:
-        async with httpx.AsyncClient(timeout=20) as client:
-            r = await client.get(
-                "https://api.pexels.com/v1/search",
-                params={"query": query, "per_page": 1, "orientation": "landscape"},
-                headers={"Authorization": PEXELS_API_KEY}
-            )
-            data = r.json()
-            if data.get("photos"):
-                img_url = data["photos"][0]["src"]["medium"]
-                img_r = await client.get(img_url)
-                return img_r.content
-    except Exception:
-        pass
+        async with httpx.AsyncClient(timeout=20) as c:
+            r = await c.get("https://api.pexels.com/v1/search",params={"query":q,"per_page":1,"orientation":"landscape"},headers={"Authorization":PEXELS_API_KEY})
+            d = r.json()
+            if d.get("photos"):
+                ir = await c.get(d["photos"][0]["src"]["medium"])
+                return ir.content
+    except: pass
     return None
 
-
-async def generate_hf_image(prompt: str) -> bytes | None:
-    if not HF_API_KEY:
-        return None
+async def gen_hf_image(p):
+    if not HF_API_KEY: return None
     try:
-        async with httpx.AsyncClient(timeout=60) as client:
-            r = await client.post(
-                "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0",
-                headers={"Authorization": f"Bearer {HF_API_KEY}"},
-                json={"inputs": prompt, "parameters": {"width": 512, "height": 384}},
-            )
-            if r.status_code == 200 and r.headers.get("content-type", "").startswith("image"):
+        async with httpx.AsyncClient(timeout=60) as c:
+            r = await c.post("https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0",
+                headers={"Authorization":f"Bearer {HF_API_KEY}"},json={"inputs":p,"parameters":{"width":512,"height":384}})
+            if r.status_code==200 and "image" in r.headers.get("content-type",""):
                 return r.content
-    except Exception:
-        pass
+    except: pass
     return None
 
+async def get_image(q):
+    return await fetch_pexels(q) or await gen_hf_image(q)
 
-async def get_image_for_query(query: str) -> bytes | None:
-    img = await fetch_pexels_image(query)
-    if img:
-        return img
-    return await generate_hf_image(query)
-
+def classify(task):
+    lo = task.lower()
+    return {
+        "img":    any(w in lo for w in ["imagen","image","foto","picture","gato","cat","dog","perro","dibuja","genera una imagen","crea una imagen","ilustra"]),
+        "excel":  any(w in lo for w in ["excel","xlsx","planilla","hoja de calculo","hoja de cálculo","spreadsheet","registro de","registrar alumnos","tabla de alumnos","plantilla de"]),
+        "word":   any(w in lo for w in ["informe","reporte","report","documento word","docx","redacta un informe","escribe un informe"]),
+        "anal":   any(w in lo for w in ["analiza","evalua","evalúa","viabilidad","riesgo","revisar"]),
+        "back":   any(w in lo for w in ["python","script","groovy","jenkins","api","backend","fastapi","flask","devops","pipeline",".py"]),
+        "front":  any(w in lo for w in ["html","css","frontend","web page","página web","pagina web","sitio web","interfaz web"]),
+        "both":   any(w in lo for w in ["hola mundo","full stack","fullstack","app completa"]) and any(w in lo for w in ["python","backend",".py"]) and any(w in lo for w in ["html","web","ver en","interfaz"]),
+    }
 
-# ── DOCX BUILDER ──────────────────────────────────────────────────────────
-def build_docx(title: str, sections: dict, images: list[bytes], analyst_review: str) -> bytes:
-    doc = DocxDocument()
+def parse_delegates(text):
+    m = re.search(r'\{"delegate"\s*:\s*\[([^\]]*)\]\}',text)
+    return re.findall(r'"(\w+)"',m.group(1)) if m else []
 
-    # Page margins
-    for section in doc.sections:
-        section.top_margin    = Inches(1)
-        section.bottom_margin = Inches(1)
-        section.left_margin   = Inches(1.2)
-        section.right_margin  = Inches(1.2)
+def clean(text):
+    text = re.sub(r'\{"delegate"[^}]*\}','',text)
+    text = re.sub(r'\{"image_queries"[^}]*\}','',text)
+    return text.strip()
 
-    # Title
-    title_para = doc.add_heading(title, 0)
-    title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    run = title_para.runs[0]
-    run.font.color.rgb = RGBColor(0x1a, 0x56, 0xdb)
+def is_skip(text): return '"skip"' in text.lower()
+
+def build_excel(task,backend_text):
+    m = re.search(r'EXCEL_TEMPLATE:\s*(\{.*?\})\s*$',backend_text,re.DOTALL|re.MULTILINE)
+    if not m:
+        m = re.search(r'EXCEL_TEMPLATE:\s*(\{.*)',backend_text,re.DOTALL)
+    if not m: return None
+    try: structure = _json.loads(m.group(1))
+    except: return None
+    wb = openpyxl.Workbook(); ws = wb.active
+    ws.title = structure.get("sheet_name","Datos")[:31]
+    headers = structure.get("headers",[])
+    rows    = structure.get("sample_rows",[])
+    title   = structure.get("title",task[:50])
+    thin    = Side(style="thin",color="D1D5DB")
+    bdr     = Border(left=thin,right=thin,top=thin,bottom=thin)
+    row_off = 1
+    if title and headers:
+        ws.merge_cells(f"A1:{chr(64+len(headers))}1")
+        c = ws["A1"]; c.value=title
+        c.font=Font(bold=True,size=13,color="FFFFFF")
+        c.fill=PatternFill("solid",fgColor="1a56db")
+        c.alignment=Alignment(horizontal="center",vertical="center")
+        ws.row_dimensions[1].height=28; row_off=2
+    for col,h in enumerate(headers,1):
+        c=ws.cell(row=row_off,column=col,value=h)
+        c.font=Font(bold=True,color="FFFFFF",size=10)
+        c.fill=PatternFill("solid",fgColor="2563eb")
+        c.alignment=Alignment(horizontal="center",vertical="center")
+        c.border=bdr
+        ws.column_dimensions[c.column_letter].width=max(len(str(h))+6,14)
+    ws.row_dimensions[row_off].height=20
+    alt=PatternFill("solid",fgColor="EFF6FF")
+    for ri,row in enumerate(rows,row_off+1):
+        for col,val in enumerate(row,1):
+            c=ws.cell(row=ri,column=col,value=val)
+            c.border=bdr; c.alignment=Alignment(vertical="center")
+            if ri%2==0: c.fill=alt
+        ws.row_dimensions[ri].height=18
+    ws.freeze_panes=f"A{row_off+1}"
+    buf=BytesIO(); wb.save(buf); buf.seek(0)
+    return buf.read()
 
-    # Date + subtitle
-    sub = doc.add_paragraph()
-    sub.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    sub.add_run(f"Mission Control AI — {datetime.now().strftime('%B %d, %Y')}").italic = True
+def build_docx(title,writer_text,images,analyst_text):
+    doc=DocxDocument()
+    for s in doc.sections: s.top_margin=s.bottom_margin=Inches(1); s.left_margin=s.right_margin=Inches(1.2)
+    tp=doc.add_heading(title,0); tp.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    if tp.runs: tp.runs[0].font.color.rgb=RGBColor(0x1a,0x56,0xdb)
+    sub=doc.add_paragraph(); sub.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    sub.add_run(f"Mission Control AI — {datetime.now().strftime('%B %d, %Y')}").italic=True
     doc.add_paragraph()
-
-    # Horizontal rule
-    p = doc.add_paragraph()
-    pPr = p._p.get_or_add_pPr()
-    pBdr = OxmlElement("w:pBdr")
-    bottom = OxmlElement("w:bottom")
-    bottom.set(qn("w:val"), "single")
-    bottom.set(qn("w:sz"), "6")
-    bottom.set(qn("w:color"), "1a56db")
-    pBdr.append(bottom)
-    pPr.append(pBdr)
-
-    img_index = 0
-
-    # Writer content sections
-    writer_text = sections.get("writer", "")
-    current_lines = []
-
-    def flush_lines():
-        nonlocal current_lines
-        if current_lines:
-            para_text = " ".join(current_lines).strip()
-            if para_text:
-                p = doc.add_paragraph(para_text)
-                p.paragraph_format.space_after = Pt(6)
-            current_lines = []
-
+    p=doc.add_paragraph(); pPr=p._p.get_or_add_pPr(); pBdr=OxmlElement("w:pBdr")
+    bot=OxmlElement("w:bottom"); bot.set(qn("w:val"),"single"); bot.set(qn("w:sz"),"6"); bot.set(qn("w:color"),"1a56db")
+    pBdr.append(bot); pPr.append(pBdr)
+    ii=0; pending=[]
+    def flush():
+        nonlocal pending
+        t=" ".join(pending).strip()
+        if t: p2=doc.add_paragraph(t); p2.paragraph_format.space_after=Pt(6)
+        pending.clear()
     for line in writer_text.split("\n"):
-        stripped = line.strip()
-        if not stripped:
-            flush_lines()
-            continue
-        if stripped.startswith("### "):
-            flush_lines()
-            h = doc.add_heading(stripped[4:], level=2)
-            # Insert image after each major section heading if available
-            if img_index < len(images) and images[img_index]:
-                try:
-                    img_stream = BytesIO(images[img_index])
-                    doc.add_picture(img_stream, width=Inches(5))
-                    last_para = doc.paragraphs[-1]
-                    last_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-                    cap = doc.add_paragraph(f"Figure {img_index + 1}")
-                    cap.alignment = WD_ALIGN_PARAGRAPH.CENTER
-                    cap.runs[0].italic = True
-                    cap.runs[0].font.size = Pt(9)
-                    img_index += 1
-                except Exception:
-                    pass
-        elif stripped.startswith("## "):
-            flush_lines()
-            doc.add_heading(stripped[3:], level=1)
-        elif stripped.startswith("**") and stripped.endswith("**"):
-            flush_lines()
-            p = doc.add_paragraph()
-            run = p.add_run(stripped.strip("**"))
-            run.bold = True
-        elif stripped.startswith("- ") or stripped.startswith("* "):
-            flush_lines()
-            doc.add_paragraph(stripped[2:], style="List Bullet")
-        else:
-            current_lines.append(stripped)
-
-    flush_lines()
-
-    # Remaining images
-    while img_index < len(images):
-        if images[img_index]:
-            try:
-                img_stream = BytesIO(images[img_index])
-                doc.add_picture(img_stream, width=Inches(5))
-                last_para = doc.paragraphs[-1]
-                last_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-                img_index += 1
-            except Exception:
-                img_index += 1
-        else:
-            img_index += 1
-
-    # Analyst review section
-    if analyst_review:
-        doc.add_page_break()
-        doc.add_heading("Análisis y Revisión", level=1)
-        for line in analyst_review.split("\n"):
-            if line.strip():
-                doc.add_paragraph(line.strip())
-
-    # Footer
-    doc.add_paragraph()
-    footer_p = doc.add_paragraph()
-    footer_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    footer_run = footer_p.add_run("— Generado por Mission Control AI —")
-    footer_run.italic = True
-    footer_run.font.size = Pt(9)
-    footer_run.font.color.rgb = RGBColor(0x6b, 0x72, 0x80)
-
-    buf = BytesIO()
-    doc.save(buf)
-    buf.seek(0)
+        s=line.strip()
+        if not s: flush(); continue
+        if s.startswith("## "):
+            flush(); doc.add_heading(s[3:],level=1)
+            if ii<len(images) and images[ii]:
+                try: doc.add_picture(BytesIO(images[ii]),width=Inches(5)); doc.paragraphs[-1].alignment=WD_ALIGN_PARAGRAPH.CENTER; ii+=1
+                except: pass
+        elif s.startswith("### "): flush(); doc.add_heading(s[4:],level=2)
+        elif s.startswith("- ") or s.startswith("* "): flush(); doc.add_paragraph(s[2:],style="List Bullet")
+        else: pending.append(s)
+    flush()
+    while ii<len(images):
+        if images[ii]:
+            try: doc.add_picture(BytesIO(images[ii]),width=Inches(5)); doc.paragraphs[-1].alignment=WD_ALIGN_PARAGRAPH.CENTER
+            except: pass
+        ii+=1
+    if analyst_text and not is_skip(analyst_text):
+        doc.add_page_break(); doc.add_heading("Análisis y Revisión",level=1)
+        for line in analyst_text.split("\n"):
+            if line.strip(): doc.add_paragraph(line.strip())
+    fp=doc.add_paragraph(); fp.alignment=WD_ALIGN_PARAGRAPH.CENTER
+    fr=fp.add_run("— Generado por Mission Control AI —"); fr.italic=True; fr.font.size=Pt(9); fr.font.color.rgb=RGBColor(0x6b,0x72,0x80)
+    buf=BytesIO(); doc.save(buf); buf.seek(0)
     return buf.read()
 
-
-# ── PARSE MANAGER DELEGATION ───────────────────────────────────────────────
-def parse_delegation(manager_text: str) -> list[str]:
-    match = re.search(r'\{[^}]*"delegate"\s*:\s*\[([^\]]*)\][^}]*\}', manager_text)
-    if match:
-        raw = match.group(1)
-        keys = re.findall(r'"(\w+)"', raw)
-        return keys
-    # Heuristic fallback: detect keywords in manager response
-    delegates = []
-    lower = manager_text.lower()
-    if any(w in lower for w in ["informe", "documento", "redact", "escrib", "report", "word"]):
-        delegates.extend(["writer"])
-    if any(w in lower for w in ["imagen", "image", "foto", "visual", "ilustr"]):
-        delegates.extend(["image_agent"])
-    if any(w in lower for w in ["analiz", "revisar", "evalua", "critic"]):
-        delegates.extend(["analyst"])
-    return list(dict.fromkeys(delegates))  # deduplicate
-
-
-def parse_image_queries(image_agent_text: str) -> list[str]:
-    match = re.search(r'"image_queries"\s*:\s*\[([^\]]*)\]', image_agent_text)
-    if match:
-        return re.findall(r'"([^"]+)"', match.group(1))
-    return []
-
-
-def clean_text(text: str) -> str:
-    # Remove JSON blocks from display text
-    text = re.sub(r'\{[^}]*"delegate"[^}]*\}', '', text)
-    text = re.sub(r'\{[^}]*"image_queries"[^}]*\}', '', text)
-    return text.strip()
-
-
-# ── ROUTES ─────────────────────────────────────────────────────────────────
-@app.get("/", response_class=HTMLResponse)
-async def root():
-    return HTMLResponse(Path("templates/index.html").read_text())
-
+@app.get("/",response_class=HTMLResponse)
+async def root(): return HTMLResponse(Path("templates/index.html").read_text())
 
 @app.get("/api/agents")
-async def get_agents():
-    return {"agents": [
-        {"key": a["key"], "name": a["name"], "role": a["role"]}
-        for a in agent_registry.values()
-    ]}
-
+async def get_agents(): return {"agents":[{"key":a["key"],"name":a["name"],"role":a["role"]} for a in agent_registry.values()]}
 
 @app.post("/api/agents/add")
-async def add_agent(request: Request):
-    body = await request.json()
-    key  = re.sub(r'\W+', '_', body.get("key", "").lower().strip())
-    if not key:
-        return JSONResponse({"error": "key required"}, status_code=400)
-    agent_registry[key] = {
-        "key":      key,
-        "name":     body.get("name", key.capitalize()),
-        "role":     body.get("role", "Agente de propósito general."),
-        "provider": body.get("provider", "openrouter"),
-        "models":   body.get("models", ["meta-llama/llama-3.3-70b-instruct:free"]),
-    }
-    return {"success": True, "agent": agent_registry[key]}
-
+async def add_agent(request:Request):
+    body=await request.json(); key=re.sub(r'\W+','_',body.get("key","").lower().strip())
+    if not key: return JSONResponse({"error":"key required"},status_code=400)
+    agent_registry[key]={"key":key,"name":body.get("name",key.capitalize()),"role":body.get("role","General purpose agent."),"provider":body.get("provider","openrouter"),"models":body.get("models",["meta-llama/llama-3.3-70b-instruct:free"])}
+    return {"success":True,"agent":agent_registry[key]}
 
 @app.delete("/api/agents/{key}")
-async def delete_agent(key: str):
-    if key in ("manager", "developer", "analyst"):
-        return JSONResponse({"error": "Cannot delete core agents"}, status_code=400)
-    if key in agent_registry:
-        del agent_registry[key]
-    return {"success": True}
-
+async def del_agent(key:str):
+    if key in {"manager","backend_dev","frontend_dev","analyst"}: return JSONResponse({"error":"Cannot delete core agents"},status_code=400)
+    agent_registry.pop(key,None); return {"success":True}
 
 @app.get("/api/history")
-async def get_history():
-    return {"history": mission_history[-20:]}
-
+async def get_history(): return {"history":mission_history[-20:]}
 
 @app.get("/api/docs/{filename}")
-async def download_doc(filename: str):
-    path = DOCS_DIR / filename
-    if not path.exists() or not filename.endswith(".docx"):
-        return JSONResponse({"error": "File not found"}, status_code=404)
-    return FileResponse(
-        path,
-        media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        filename=filename,
-    )
-
+async def dl_doc(filename:str):
+    path=DOCS_DIR/filename
+    if not path.exists(): return JSONResponse({"error":"not found"},status_code=404)
+    ext=Path(filename).suffix.lower()
+    mt={".docx":"application/vnd.openxmlformats-officedocument.wordprocessingml.document",".xlsx":"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",".html":"text/html",".py":"text/plain",".groovy":"text/plain",".jpg":"image/jpeg",".png":"image/png"}.get(ext,"application/octet-stream")
+    return FileResponse(path,media_type=mt,filename=filename)
 
 @app.post("/api/mission")
-async def run_mission(request: Request):
-    body = await request.json()
-    task = body.get("task", "").strip()
-    if not task:
-        return JSONResponse({"error": "No task provided"}, status_code=400)
-
-    started_at = datetime.now().isoformat()
-    results    = {}
-    doc_file   = None
-    events     = []   # orchestration event log
-
-    def log(msg: str):
-        events.append({"time": datetime.now().strftime("%H:%M:%S"), "msg": msg})
-
-    # ── STEP 1: Manager plans ──────────────────────────────────────────────
-    log("Manager analyzing task...")
-    manager_agent = agent_registry["manager"]
+async def run_mission(request:Request):
+    body=await request.json(); task=body.get("task","").strip()
+    if not task: return JSONResponse({"error":"No task"},status_code=400)
+    started=datetime.now().isoformat(); results={}; events=[]; doc_file=None
+    tc=classify(task)
+    def log(m): events.append({"time":datetime.now().strftime("%H:%M:%S"),"msg":m})
+
+    # Manager
+    log("Manager planning...")
     try:
-        manager_raw = await call_agent_llm(manager_agent, task)
-        delegates   = parse_delegation(manager_raw)
-        manager_msg = clean_text(manager_raw)
-        results["manager"] = {
-            "status": "active", "message": manager_msg,
-            "model": manager_agent["models"][0],
-            "delegates": delegates,
-        }
-        log(f"Manager delegated to: {delegates or 'none'}")
+        mgr_raw=await call_llm(agent_registry["manager"],task)
+        mgr_del=parse_delegates(mgr_raw)
+        results["manager"]={"status":"active","message":clean(mgr_raw),"model":agent_registry["manager"]["models"][0],"delegates":mgr_del}
+        log(f"Manager delegated: {mgr_del}")
     except Exception as e:
-        results["manager"] = {"status": "resting", "message": str(e), "model": ""}
-        delegates = []
-        log(f"Manager failed: {e}")
-
-    # ── STEP 2: Run delegated agents ───────────────────────────────────────
-    image_bytes  = []
-    writer_text  = ""
-    analyst_text = ""
-
-    async def run_delegated(key: str):
-        nonlocal writer_text, analyst_text
-        if key not in agent_registry:
-            log(f"Agent '{key}' not found in registry")
-            return
-
-        agent = agent_registry[key]
-        log(f"{agent['name']} starting...")
-
-        if key == "image_agent":
-            try:
-                img_prompt = f"Proporciona consultas de búsqueda de imágenes en inglés para ilustrar: {task}"
-                raw = await call_agent_llm(agent, img_prompt)
-                queries = parse_image_queries(raw)
-                if not queries:
-                    queries = [task[:40]]
-                log(f"ImageAgent searching: {queries}")
-                imgs = await asyncio.gather(*[get_image_for_query(q) for q in queries[:3]])
+        results["manager"]={"status":"resting","message":str(e),"model":""}; mgr_del=[]
+        log(f"Manager error: {e}")
+
+    # Merge manager + classifier
+    delegates=list(mgr_del)
+    safety_map=[("img","image_agent"),("excel","backend_dev"),("word","writer"),("anal","analyst"),("back","backend_dev"),("front","frontend_dev")]
+    for flag,key in safety_map:
+        if tc[flag] and key not in delegates: delegates.append(key)
+    if tc["both"]:
+        for k in ["backend_dev","frontend_dev"]:
+            if k not in delegates: delegates.append(k)
+    delegates=[k for k in delegates if k in agent_registry]
+    log(f"Final plan: {delegates}")
+
+    image_bytes=[]; writer_text=""; analyst_text=""; backend_text=""; frontend_text=""
+
+    async def run_one(key):
+        nonlocal writer_text,analyst_text,backend_text,frontend_text
+        agent=agent_registry[key]
+        log(f"{agent['name']} started...")
+        try:
+            if key=="image_agent":
+                raw=await call_llm(agent,f"Find images for this request: {task}")
+                m=re.search(r'"image_queries"\s*:\s*\[([^\]]*)\]',raw)
+                queries=re.findall(r'"([^"]+)"',m.group(1)) if m else [task[:50]]
+                log(f"ImageAgent queries: {queries[:3]}")
+                imgs=await asyncio.gather(*[get_image(q) for q in queries[:3]])
                 for img in imgs:
-                    if img:
-                        image_bytes.append(img)
-                results["image_agent"] = {
-                    "status": "active",
-                    "message": f"Encontradas {len(image_bytes)} imágenes para: {', '.join(queries[:3])}",
-                    "model": agent["models"][0],
-                }
-                log(f"ImageAgent: {len(image_bytes)} images found")
-            except Exception as e:
-                results["image_agent"] = {"status": "resting", "message": str(e), "model": ""}
-                log(f"ImageAgent failed: {e}")
-
-        elif key == "writer":
-            try:
-                manager_context = results.get("manager", {}).get("message", "")
-                writer_prompt = (
-                    f"Eres un redactor experto. Escribe el contenido REAL y COMPLETO del siguiente informe.\n\n"
-                    f"TEMA DEL INFORME: {task}\n\n"
-                    f"INSTRUCCIONES DEL MANAGER:\n{manager_context[:500]}\n\n"
-                    "INSTRUCCIONES IMPORTANTES:\n"
-                    "- Escribe contenido REAL, detallado y específico sobre el tema. NO uses placeholders ni corchetes.\n"
-                    "- El informe debe tener mínimo 600 palabras de contenido real.\n"
-                    "- Usa datos, hechos y ejemplos concretos relacionados con el tema.\n"
-                    "- Estructura con estos encabezados EXACTOS (sin corchetes, solo el contenido real):\n\n"
-                    "## Resumen Ejecutivo\n"
-                    "(Escribe aquí 2-3 párrafos resumiendo los puntos clave del informe)\n\n"
-                    "### Introducción\n"
-                    "(Escribe aquí contexto e importancia del tema)\n\n"
-                    "### Desarrollo\n"
-                    "(Escribe aquí el análisis detallado con datos y hechos reales)\n\n"
-                    "### Hallazgos Principales\n"
-                    "(Escribe aquí los descubrimientos o puntos más importantes)\n\n"
-                    "### Conclusiones\n"
-                    "(Escribe aquí las conclusiones derivadas del análisis)\n\n"
-                    "### Recomendaciones\n"
-                    "(Escribe aquí recomendaciones concretas y accionables)\n\n"
-                    "IMPORTANTE: Escribe contenido real y sustancioso. Nada de '[contenido]' ni placeholders."
-                )
-                writer_text = await call_agent_llm(agent, writer_prompt)
-                results["writer"] = {
-                    "status": "active",
-                    "message": writer_text[:200] + "..." if len(writer_text) > 200 else writer_text,
-                    "model": agent["models"][0],
-                }
-                log("Writer completed document")
-            except Exception as e:
-                results["writer"] = {"status": "resting", "message": str(e), "model": ""}
-                log(f"Writer failed: {e}")
-
-        elif key == "analyst":
-            try:
-                content_to_review = writer_text or manager_msg
-                analyst_prompt = (
-                    f"Revisa y analiza el siguiente contenido sobre: {task}\n\n"
-                    f"Contenido:\n{content_to_review[:1000]}\n\n"
-                    "Proporciona: 1) Evaluación de calidad, 2) Puntos fuertes, "
-                    "3) Áreas de mejora, 4) Conclusión final."
-                )
-                analyst_text = await call_agent_llm(agent, analyst_prompt)
-                results["analyst"] = {
-                    "status": "active",
-                    "message": analyst_text[:200] + "..." if len(analyst_text) > 200 else analyst_text,
-                    "model": agent["models"][0],
-                }
-                log("Analyst review completed")
-            except Exception as e:
-                results["analyst"] = {"status": "resting", "message": str(e), "model": ""}
-                log(f"Analyst failed: {e}")
-
-        else:
-            # Generic agent
-            try:
-                raw = await call_agent_llm(agent, task)
-                results[key] = {"status": "active", "message": raw, "model": agent["models"][0]}
-                log(f"{agent['name']} completed")
-            except Exception as e:
-                results[key] = {"status": "resting", "message": str(e), "model": ""}
-
-    # Run image_agent and writer in parallel, then analyst
-    parallel_first = [k for k in delegates if k in ("writer", "image_agent")]
-    sequential_after = [k for k in delegates if k == "analyst"]
-    other = [k for k in delegates if k not in ("writer", "image_agent", "analyst")]
-
-    if parallel_first or other:
-        await asyncio.gather(*[run_delegated(k) for k in parallel_first + other])
-
-    if sequential_after:
-        for k in sequential_after:
-            await run_delegated(k)
-
-    # ── STEP 3: Build .docx if writer was involved ─────────────────────────
+                    if img: image_bytes.append(img)
+                results["image_agent"]={"status":"active","message":f"{len(image_bytes)} image(s) found: {', '.join(queries[:3])}","model":agent["models"][0]}
+                if image_bytes:
+                    safe=re.sub(r'[^\w]','_',task[:30])
+                    for i,ib in enumerate(image_bytes):
+                        fp=DOCS_DIR/f"{safe}_img{i+1}.jpg"; fp.write_bytes(ib)
+                    results["image_agent"]["doc_file"]=f"{safe}_img1.jpg"
+                log(f"ImageAgent: {len(image_bytes)} saved")
+
+            elif key=="writer":
+                prompt=f"Escribe informe formal completo sobre: {task}\nContexto: {results.get('manager',{}).get('message','')[:300]}\nContenido real 500+ palabras. Secciones: ## Resumen Ejecutivo, ### Introducción, ### Desarrollo, ### Hallazgos, ### Conclusiones, ### Recomendaciones"
+                writer_text=await call_llm(agent,prompt)
+                results["writer"]={"status":"active","message":writer_text[:200]+"...","model":agent["models"][0]}
+                log("Writer done")
+
+            elif key=="analyst":
+                content=writer_text or results.get("manager",{}).get("message",task)
+                raw=await call_llm(agent,f"Tarea: {task}\nContenido:\n{content[:1500]}\nEvalúa calidad, puntos fuertes, áreas de mejora, conclusión.")
+                if is_skip(raw): results["analyst"]={"status":"idle","message":"","model":""}
+                else: results["analyst"]={"status":"active","message":raw[:200]+"...","model":agent["models"][0]}; analyst_text=raw
+                log("Analyst done")
+
+            elif key=="backend_dev":
+                has_fe="frontend_dev" in delegates
+                collab=" Tu compañero Frontend hará el HTML/interfaz. TÚ solo haces servidor/lógica/backend." if has_fe else ""
+                if tc["excel"]:
+                    prompt=(f"Crea plantilla Excel para: {task}\n"
+                            "Responde SOLO con:\nEXCEL_TEMPLATE:{\"title\":\"...\",\"sheet_name\":\"...\",\"headers\":[\"Col1\",\"Col2\",...],\"sample_rows\":[[\"val1\",\"val2\",...],[\"val1\",\"val2\",...],[\"val1\",\"val2\",...]]}\n"
+                            "Incluye 3+ filas de ejemplo con datos REALES y relevantes.")
+                else:
+                    prompt=f"Tarea: {task}\n{collab}\nEntrega SOLO el código solicitado. Sin explicaciones innecesarias."
+                raw=await call_llm(agent,prompt)
+                if is_skip(raw): results["backend_dev"]={"status":"idle","message":"","model":""}
+                else: results["backend_dev"]={"status":"active","message":raw[:300]+("..." if len(raw)>300 else ""),"model":agent["models"][0]}; backend_text=raw
+                log("Backend done")
+
+            elif key=="frontend_dev":
+                be_ctx=backend_text[:500] if backend_text else ""
+                prompt=(f"Tarea: {task}\n"+(f"Backend hizo: {be_ctx}\n" if be_ctx else "")
+                        +"Entrega SOLO el código HTML/CSS/JS. Si no se necesita frontend → {\"skip\":\"no frontend needed\"}")
+                raw=await call_llm(agent,prompt)
+                if is_skip(raw): results["frontend_dev"]={"status":"idle","message":"","model":""}
+                else: results["frontend_dev"]={"status":"active","message":raw[:300]+("..." if len(raw)>300 else ""),"model":agent["models"][0]}; frontend_text=raw
+                log("Frontend done")
+            else:
+                raw=await call_llm(agent,task)
+                results[key]={"status":"active","message":raw,"model":agent["models"][0]}
+                log(f"{agent['name']} done")
+        except Exception as e:
+            results[key]={"status":"resting","message":str(e),"model":""}; log(f"{key} error: {e}")
+
+    # Execution order: backend first, then image+writer in parallel, then frontend+analyst
+    be=[k for k in delegates if k=="backend_dev"]
+    par=[k for k in delegates if k in ("image_agent","writer")]
+    seq=[k for k in delegates if k in ("frontend_dev","analyst")]
+    oth=[k for k in delegates if k not in be+par+seq]
+    if be: await asyncio.gather(*[run_one(k) for k in be])
+    if par+oth: await asyncio.gather(*[run_one(k) for k in par+oth])
+    for k in seq: await run_one(k)
+
+    # Build files
+    safe=re.sub(r'[^\w\-]','_',task[:40]); ts=datetime.now().strftime('%Y%m%d_%H%M%S')
+
     if writer_text:
-        log("Assembling Word document...")
         try:
-            doc_bytes = build_docx(task, {"writer": writer_text}, image_bytes, analyst_text)
-            safe_name = re.sub(r'[^\w\-]', '_', task[:40])
-            doc_filename = f"{safe_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
-            (DOCS_DIR / doc_filename).write_bytes(doc_bytes)
-            doc_file = doc_filename
-            results["manager"]["doc_file"] = doc_filename
-            log(f"Document ready: {doc_filename}")
-        except Exception as e:
-            log(f"Document build failed: {e}")
-
-    # Mark idle agents
-    for key in agent_registry:
-        if key not in results:
-            results[key] = {"status": "idle", "message": "", "model": ""}
-
-    final = results.get("manager", {}).get("message", "")[:300]
-
-    entry = {
-        "id": len(mission_history) + 1,
-        "task": task,
-        "started_at": started_at,
-        "ended_at": datetime.now().isoformat(),
-        "results": results,
-        "final": final,
-        "doc_file": doc_file,
-        "events": events,
-    }
-    mission_history.append(entry)
+            db=build_docx(task,writer_text,image_bytes,analyst_text)
+            fn=f"{safe}_{ts}.docx"; (DOCS_DIR/fn).write_bytes(db)
+            doc_file=fn; results["manager"]["doc_file"]=fn; log(f"Docx: {fn}")
+        except Exception as e: log(f"Docx error: {e}")
 
-    return JSONResponse({
-        "success": True, "task": task,
-        "results": results, "final": final,
-        "doc_file": doc_file, "events": events,
-        "mission_id": entry["id"],
-    })
+    if backend_text and tc["excel"]:
+        try:
+            xb=build_excel(task,backend_text)
+            if xb:
+                fn=f"{safe}_{ts}.xlsx"; (DOCS_DIR/fn).write_bytes(xb)
+                doc_file=fn; results["backend_dev"]["doc_file"]=fn; log(f"Excel: {fn}")
+        except Exception as e: log(f"Excel error: {e}")
 
+    if backend_text and not tc["excel"] and not is_skip(backend_text):
+        try:
+            code=re.sub(r'```\w*\n?','',backend_text); code=re.sub(r'```','',code).strip()
+            if len(code)>30:
+                ext=".groovy" if ("groovy" in backend_text.lower() or "jenkins" in task.lower()) else ".py"
+                fn=f"{safe}_{ts}{ext}"; (DOCS_DIR/fn).write_text(code,encoding="utf-8")
+                results["backend_dev"]["doc_file"]=fn; log(f"Code: {fn}")
+        except Exception as e: log(f"Code file error: {e}")
+
+    if frontend_text and not is_skip(frontend_text):
+        try:
+            html=re.sub(r'```\w*\n?','',frontend_text); html=re.sub(r'```','',html).strip()
+            if len(html)>30:
+                fn=f"{safe}_frontend_{ts}.html"; (DOCS_DIR/fn).write_text(html,encoding="utf-8")
+                results["frontend_dev"]["doc_file"]=fn
+                if not doc_file: doc_file=fn
+                log(f"HTML: {fn}")
+        except Exception as e: log(f"HTML error: {e}")
+
+    for k in agent_registry:
+        if k not in results: results[k]={"status":"idle","message":"","model":""}
+
+    final=results.get("manager",{}).get("message","")[:300]
+    entry={"id":len(mission_history)+1,"task":task,"started_at":started,"ended_at":datetime.now().isoformat(),"results":results,"final":final,"doc_file":doc_file,"events":events}
+    mission_history.append(entry)
+    return JSONResponse({"success":True,"task":task,"results":results,"final":final,"doc_file":doc_file,"events":events,"mission_id":entry["id"]})
 
 @app.get("/api/health")
 async def health():
-    return {
-        "status": "ok",
-        "providers": {
-            "gemini":     "ok" if GOOGLE_API_KEY     else "missing",
-            "openrouter": "ok" if OPENROUTER_API_KEY else "missing",
-            "groq":       "ok" if GROQ_API_KEY       else "missing",
-            "pexels":     "ok" if PEXELS_API_KEY     else "missing (optional)",
-            "hf_images":  "ok" if HF_API_KEY         else "missing (optional)",
-        }
-    }
+    return {"status":"ok","providers":{"gemini":"ok" if GOOGLE_API_KEY else "missing","openrouter":"ok" if OPENROUTER_API_KEY else "missing","groq":"ok" if GROQ_API_KEY else "missing","pexels":"ok" if PEXELS_API_KEY else "optional","hf_images":"ok" if HF_API_KEY else "optional"}}

requirements.txt

@@ -4,3 +4,4 @@ httpx==0.27.2
 python-multipart==0.0.9
 python-docx==1.1.2
 Pillow==10.4.0
+openpyxl==3.1.5

templates/index.html

@@ -97,9 +97,9 @@ body::after{content:'';position:fixed;inset:0;background:repeating-linear-gradie
 .dtop{height:7px;background:var(--woodl);border-top:2px solid #c09828}
 .kbd{height:6px;background:#c0b090;border:1px solid #a09070;display:flex;gap:1px;padding:1px 2px;align-items:center}
 .kk{flex:1;height:3px;background:#a09070}
-.coffee{position:absolute;bottom:28px;right:8px;z-index:3}
-.person-slot{position:absolute;bottom:20px;left:50%;transform:translateX(-50%);z-index:3}
-.chair-slot{position:absolute;bottom:0;right:3px;z-index:2}
+.coffee{position:absolute;bottom:30px;right:12px;z-index:3}
+.person-slot{position:absolute;bottom:14px;left:52px;z-index:3}
+.chair-slot{position:absolute;bottom:0;left:44px;z-index:2}
 .ooo{position:absolute;inset:0;background:rgba(20,14,0,.75);display:flex;flex-direction:column;align-items:center;justify-content:center;gap:4px;z-index:10}
 .ooot{font-family:'VT323',monospace;font-size:17px;color:var(--A);letter-spacing:2px}
 .ooos{font-size:10px;color:rgba(255,204,68,.5)}
@@ -310,10 +310,10 @@ function runWalkAnimation(task,delegates,onDone){
   const rPos=rooms.map((r,i)=>({x:30+i*(rW+14),y:rY,w:rW,h:rH,key:r.key,name:r.name,color:agentColors[r.key]||'#4a9eff'}));
   const delSet=new Set(delegates);
   const manColor='#00e5a0';
-  let mx=12,my=H/2+8,frame=0,stepI=0,phase='walking',talkF=0;
+  let mx=W/2-8,my=4,frame=0,stepI=0,phase='walking',talkF=0;
   const TALK=85,SPD=2.8;
   const msgs={writer:`"Write full report:\n${task.substring(0,26)}..."`,analyst:`"Review the\ndocument."`,developer:`"Build solution:\n${task.substring(0,24)}..."`,image_agent:`"Find images for:\n${task.substring(0,24)}..."`};
-  const steps=[{key:'__start',x:W*.07,y:H/2,msg:'Planning...'},...rPos.filter(r=>delSet.has(r.key)).map(r=>({key:r.key,x:r.x+r.w/2-8,y:r.y+r.h-26,msg:msgs[r.key]||`"Delegating task..."`})),{key:'__return',x:W*.07,y:H/2,msg:'Briefing complete!'}];
+  const steps=[{key:'__start',x:W/2-8,y:H*.15,msg:'Planning...'},...rPos.filter(r=>delSet.has(r.key)).map(r=>({key:r.key,x:r.x+r.w/2-8,y:r.y+r.h-28,msg:msgs[r.key]||`"Delegating task..."`})),{key:'__return',x:W/2-8,y:H*.15,msg:'Briefing complete!'}];
   const visited=new Set();
   let curMsg='';