fix: move files to root and update Dockerfile

Dockerfile

@@ -3,7 +3,7 @@ FROM python:3.11-slim
 ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
     PORT=7860 \
-    PYTHONPATH=/home/user/app \
+    FRONTEND_DIST=/home/user/app/static \
     PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
 
 WORKDIR /app
@@ -15,12 +15,13 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libxfixes3 libxrandr2 libgbm1 libasound2 \
     && rm -rf /var/lib/apt/lists/*
 
-# Space has backend/ subdir (full repo push) — copy from backend/
-COPY backend/requirements.txt /app/requirements.txt
+# hf-sync copia backend/* nella root dello Space — nessun prefisso backend/
+COPY requirements.txt /app/requirements.txt
 RUN pip install --no-cache-dir -r /app/requirements.txt \
     && playwright install chromium \
     && chmod -R 755 /ms-playwright
 
+# S356: ttyd — terminale web per accesso da iPhone Safari (binario statico, zero dep)
 ARG TTYD_VERSION=1.7.7
 RUN ARCH=$(uname -m) && \
     TTYD_ARCH=$([ "$ARCH" = "aarch64" ] && echo "aarch64" || echo "x86_64") && \
@@ -33,8 +34,8 @@ USER user
 ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
 
 WORKDIR /home/user/app
-# Copy only backend/ contents → main.py lands at /home/user/app/main.py
-COPY --chown=user backend/ /home/user/app/
+COPY --chown=user . /home/user/app/
 
 EXPOSE 7860
+
 CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT:-7860} --workers 1"]

README.md

@@ -1,11 +1,42 @@
 ---
-title: AI Backend Collab
+title: Agente AI Backend
 emoji: 🤖
-colorFrom: blue
-colorTo: green
+colorFrom: indigo
+colorTo: blue
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-# AI Backend Collab
-Backend di failover per il progetto Agente AI.
+# Agente AI — Backend FastAPI
+
+Backend Python FastAPI per Agente AI. Streaming LLM, memoria, esecuzione codice, terminal PTY.
+
+## Endpoints principali
+
+- `GET  /health`              — stato backend
+- `GET  /api/status`          — versione + config
+- `POST /api/reason/loop`     — agent reasoning loop
+- `POST /api/exec`            — esecuzione codice Python
+- `POST /api/execute-shell`   — shell commands
+- `POST /api/search`          — web search proxy
+- `POST /api/fetch-page`      — page fetch proxy
+- `WS   /ws/terminal`         — PTY WebSocket terminal
+
+## Stack
+
+- Python 3.11 + FastAPI + uvicorn
+- smolagents>=1.14.0 + litellm>=1.40.0
+- supabase (opzionale)
+
+## Variabili ambiente
+
+| Variabile | Descrizione |
+|-----------|-------------|
+| GROQ_API_KEY | Groq API key |
+| GEMINI_API_KEY | Google Gemini key |
+| OPENROUTER_API_KEY | OpenRouter key |
+| HF_TOKEN | HuggingFace token |
+| SUPABASE_URL | Supabase URL (opzionale) |
+| SUPABASE_ANON_KEY | Supabase anon key (opzionale) |
+| ALLOWED_ORIGINS | CORS origins comma-separated |

agents/unified_loop.py

@@ -1660,19 +1660,6 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
                     exec_warn.insert(0, self._tdd_fail_inject)
                     _logger.info("GAP-NEW-2: TDD fail iniettato in exec_warn (%d chars)", len(self._tdd_fail_inject))
                     self._tdd_fail_inject = None
-                # GAP-4: StrategicHealer — analisi LLM pattern di fallimento (integra GAP-SELFHEAL v2)
-                if exec_errors and getattr(self, '_strategic_healer', None):
-                    try:
-                        _sh_ctx_str = "\n".join(str(w) for w in exec_warn[-10:] if isinstance(w, str))
-                        _sh_decision = await self._strategic_healer.analyze_and_decide(exec_errors, _sh_ctx_str)
-                        if _sh_decision and getattr(_sh_decision, 'strategy_prompt', None):
-                            exec_warn.insert(0, _sh_decision.strategy_prompt)
-                            _logger.info("GAP-4: StrategicHealer strategy iniettata in exec_warn")
-                        if _sh_decision and getattr(_sh_decision, 'should_stop', False):
-                            _logger.info("GAP-4: StrategicHealer → should_stop, interruzione loop")
-                            break
-                    except Exception as _sh_loop_err:
-                        _logger.debug("GAP-4: StrategicHealer loop silenced — %s", _sh_loop_err)
                 # GAP-SELFHEAL v2: dual-mode fingerprinting — raw + error-class extraction.
                 # PROBLEMA v1: MD5("ModuleNotFoundError: requests") ≠ MD5("ModuleNotFoundError: pandas")
                 # → 3 librerie diverse con stesso errore NON triggheravano il cambio strategia.
@@ -3420,20 +3407,6 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
 
         state = UnifiedLoopState(goal=goal, context=context, max_steps=max_steps, session_id=session_id)
 
-        # GAP-4: StrategicHealer — init + load past failures (LLM-based self-healing cognitivo)
-        try:
-            from agents.strategic_healer import StrategicHealer as _SHClass
-            self._strategic_healer = _SHClass(
-                getattr(self, 'llm', None) or getattr(self, '_llm', None),
-                state.goal,
-                memory=getattr(self, 'memory', None) or getattr(self, '_memory', None)
-            )
-            await self._strategic_healer.load_past_failures()
-            _logger.info("GAP-4: StrategicHealer inizializzato per goal '%s'", state.goal[:60])
-        except Exception as _sh_init_err:
-            self._strategic_healer = None
-            _logger.debug("GAP-4: StrategicHealer init silenced — %s", _sh_init_err)
-
         # P17-F2: inject blackboard critical entries at loop start.
         # I delegate frontend scrivono su Upstash; il loop legge e inietta nel context.
         if session_id:

api/exec.py

@@ -5,20 +5,6 @@ import ast as _ast_mod
 from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel, model_validator
 from .auth_guard import require_role, AuthRole
-try:
-    from .priority import realtime_job as _realtime_job, background_job as _background_job
-except ImportError:
-    # Fallback graceful se priority.py non ancora deployato
-    from contextlib import asynccontextmanager
-    import asyncio as _asyncio_fallback
-    _FALLBACK_REALTIME_SEM  = _asyncio_fallback.Semaphore(6)
-    _FALLBACK_BACKGROUND_SEM = _asyncio_fallback.Semaphore(2)
-    @asynccontextmanager
-    async def _realtime_job(**_):
-        async with _FALLBACK_REALTIME_SEM: yield
-    @asynccontextmanager
-    async def _background_job(**_):
-        async with _FALLBACK_BACKGROUND_SEM: yield
 
 import logging
 _logger = logging.getLogger("api.exec")
@@ -287,63 +273,59 @@ async def exec_code(req: ExecRequest, request: Request):
             return {'stdout': '', 'stderr': f'Blocked (AST): {_ast_reason}', 'exit_code': 1, 'durationMs': 0}
 
     t0 = int(time.time() * 1000)
-    try:
-        async with _realtime_job(timeout_s=120.0):
-            with tempfile.TemporaryDirectory() as tmpdir:
-                try:
-                    if lang == 'python':
-                        cmd = [_get_venv_python(), '-c', code]
-                    elif lang in ('javascript', 'js'):
-                        cmd = ['node', '-e', code]
-                    elif lang in ('typescript', 'ts'):
-                        fname = os.path.join(tmpdir, 'snippet.ts')
-                        with open(fname, 'w') as f:
-                            f.write(code)
-                        cmd = ['npx', '--yes', 'ts-node', '--transpile-only', fname]
-                    else:
-                        return {'stdout': '', 'stderr': f'Unsupported lang: {lang}', 'exit_code': 1, 'durationMs': 0}
-
-                    proc = await asyncio.create_subprocess_exec(
-                        *cmd,
-                        stdout=asyncio.subprocess.PIPE,
-                        stderr=asyncio.subprocess.PIPE,
-                        cwd=tmpdir,
-                        preexec_fn=_child_resource_limits,  # GAP-EXEC-FIX: RLIMIT_AS/CPU/NOFILE/NPROC
-                        env={
-                            'HOME': tmpdir, 'TMPDIR': tmpdir, 'NODE_ENV': 'production',
-                            'PATH': os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin'),
-                            # NPM-CACHE: usa /data/npm-cache persistente — riduce re-download
-                            'npm_config_cache': '/data/npm-cache',
-                            # NODE-MEM: limita heap V8 a 384MB per stare in Railway 512MB
-                            'NODE_OPTIONS': '--max-old-space-size=384',
-                        },
-                    )
-                    stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=15)
-                    return {
-                        'stdout':     stdout.decode('utf-8', errors='replace')[:8000],
-                        'stderr':     stderr.decode('utf-8', errors='replace')[:4000],
-                        'exit_code':   proc.returncode,
-                        'durationMs': int(time.time() * 1000) - t0,
-                    }
-                except asyncio.TimeoutError:
-                    # S758-ProgExec: capture partial stdout before kill — progressive execution
-                    _partial_out, _partial_err = b'', b''
-                    try:
-                        _killpg(proc)  # P40-A: kill intero process group
-                        _partial_out, _partial_err = await asyncio.wait_for(proc.communicate(), timeout=2)
-                    except Exception as _exc:
-                        _logger.debug("[exec] silenced %s", type(_exc).__name__)  # noqa: BLE001
-                    return {
-                        'stdout':     _partial_out.decode('utf-8', errors='replace')[:8000],
-                        'stderr':     f'⚠️ Timeout 15s — output parziale\n' + _partial_err.decode('utf-8', errors='replace')[:2000],
-                        'exit_code':  -1,
-                        'durationMs': 15000,
-                        'partial':    True,
-                    }
-                except Exception as e:
-                    return {'stdout': '', 'stderr': str(e), 'exit_code': -1, 'durationMs': int(time.time() * 1000) - t0}
-    except asyncio.TimeoutError:
-        return {'stdout': '', 'stderr': '⚠️ Nessun slot exec disponibile (server occupato). Riprova tra qualche secondo.', 'exit_code': -1, 'durationMs': int(time.time() * 1000) - t0}
+    with tempfile.TemporaryDirectory() as tmpdir:
+        try:
+            if lang == 'python':
+                cmd = [_get_venv_python(), '-c', code]
+            elif lang in ('javascript', 'js'):
+                cmd = ['node', '-e', code]
+            elif lang in ('typescript', 'ts'):
+                fname = os.path.join(tmpdir, 'snippet.ts')
+                with open(fname, 'w') as f:
+                    f.write(code)
+                cmd = ['npx', '--yes', 'ts-node', '--transpile-only', fname]
+            else:
+                return {'stdout': '', 'stderr': f'Unsupported lang: {lang}', 'exit_code': 1, 'durationMs': 0}
+
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=tmpdir,
+                preexec_fn=_child_resource_limits,  # GAP-EXEC-FIX: RLIMIT_AS/CPU/NOFILE/NPROC
+                env={
+                    'HOME': tmpdir, 'TMPDIR': tmpdir, 'NODE_ENV': 'production',
+                    'PATH': os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin'),
+                    # NPM-CACHE: usa /data/npm-cache persistente — riduce re-download
+                    'npm_config_cache': '/data/npm-cache',
+                    # NODE-MEM: limita heap V8 a 384MB per stare in Railway 512MB
+                    'NODE_OPTIONS': '--max-old-space-size=384',
+                },
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=15)
+            return {
+                'stdout':     stdout.decode('utf-8', errors='replace')[:8000],
+                'stderr':     stderr.decode('utf-8', errors='replace')[:4000],
+                'exit_code':   proc.returncode,
+                'durationMs': int(time.time() * 1000) - t0,
+            }
+        except asyncio.TimeoutError:
+            # S758-ProgExec: capture partial stdout before kill — progressive execution
+            _partial_out, _partial_err = b'', b''
+            try:
+                _killpg(proc)  # P40-A: kill intero process group
+                _partial_out, _partial_err = await asyncio.wait_for(proc.communicate(), timeout=2)
+            except Exception as _exc:
+                _logger.debug("[exec] silenced %s", type(_exc).__name__)  # noqa: BLE001
+            return {
+                'stdout':     _partial_out.decode('utf-8', errors='replace')[:8000],
+                'stderr':     f'⚠️ Timeout 15s — output parziale\n' + _partial_err.decode('utf-8', errors='replace')[:2000],
+                'exit_code':  -1,
+                'durationMs': 15000,
+                'partial':    True,
+            }
+        except Exception as e:
+            return {'stdout': '', 'stderr': str(e), 'exit_code': -1, 'durationMs': int(time.time() * 1000) - t0}
 
 
 @router.post('/api/execute-shell')
@@ -356,42 +338,38 @@ async def execute_shell(cmd: ShellCmd, request: Request):
         if bad in raw:
             raise HTTPException(400, 'Command blocked for safety')
     timeout = min(max(cmd.timeout, 1), 60)
-    try:
-        async with _realtime_job(timeout_s=90.0):
-            with tempfile.TemporaryDirectory() as tmpdir:
-                try:
-                    proc = await asyncio.create_subprocess_shell(
-                        raw,
-                        stdout=asyncio.subprocess.PIPE,
-                        stderr=asyncio.subprocess.PIPE,
-                        cwd=tmpdir,
-                        preexec_fn=_child_resource_limits,  # GAP-EXEC-FIX: RLIMIT_AS/CPU/NOFILE/NPROC
-                        env={**os.environ, 'HOME': tmpdir, 'TMPDIR': tmpdir},
-                    )
-                    stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
-                    return {
-                        'stdout':    stdout.decode('utf-8', errors='replace')[:8000],
-                        'stderr':    stderr.decode('utf-8', errors='replace')[:4000],
-                        'exit_code': proc.returncode,
-                    }
-                except asyncio.TimeoutError:
-                    # S758-ProgExec: capture partial stdout before kill — progressive execution
-                    _partial_out, _partial_err = b'', b''
-                    try:
-                        _killpg(proc)  # P40-A: kill intero process group
-                        _partial_out, _partial_err = await asyncio.wait_for(proc.communicate(), timeout=2)
-                    except Exception as _exc:
-                        _logger.debug("[exec] silenced %s", type(_exc).__name__)  # noqa: BLE001
-                    return {
-                        'stdout':    _partial_out.decode('utf-8', errors='replace')[:8000],
-                        'stderr':    f'⚠️ Timeout {timeout}s — output parziale\n' + _partial_err.decode('utf-8', errors='replace')[:2000],
-                        'exit_code': -1,
-                        'partial':   True,
-                    }
-                except Exception as e:
-                    return {'stdout': '', 'stderr': str(e), 'exit_code': -1}
-    except asyncio.TimeoutError:
-        return {'stdout': '', 'stderr': '⚠️ Nessun slot shell disponibile. Riprova tra qualche secondo.', 'exit_code': -1}
+    with tempfile.TemporaryDirectory() as tmpdir:
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                raw,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=tmpdir,
+                preexec_fn=_child_resource_limits,  # GAP-EXEC-FIX: RLIMIT_AS/CPU/NOFILE/NPROC
+                env={**os.environ, 'HOME': tmpdir, 'TMPDIR': tmpdir},
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+            return {
+                'stdout':    stdout.decode('utf-8', errors='replace')[:8000],
+                'stderr':    stderr.decode('utf-8', errors='replace')[:4000],
+                'exit_code': proc.returncode,
+            }
+        except asyncio.TimeoutError:
+            # S758-ProgExec: capture partial stdout before kill — progressive execution
+            _partial_out, _partial_err = b'', b''
+            try:
+                _killpg(proc)  # P40-A: kill intero process group
+                _partial_out, _partial_err = await asyncio.wait_for(proc.communicate(), timeout=2)
+            except Exception as _exc:
+                _logger.debug("[exec] silenced %s", type(_exc).__name__)  # noqa: BLE001
+            return {
+                'stdout':    _partial_out.decode('utf-8', errors='replace')[:8000],
+                'stderr':    f'⚠️ Timeout {timeout}s — output parziale\n' + _partial_err.decode('utf-8', errors='replace')[:2000],
+                'exit_code': -1,
+                'partial':   True,
+            }
+        except Exception as e:
+            return {'stdout': '', 'stderr': str(e), 'exit_code': -1}
 
 
 @router.post('/api/pip-install')
@@ -407,11 +385,6 @@ async def pip_install(
     for p in pkgs:
         if not safe.match(p):
             raise HTTPException(400, f'Invalid package name: {p}')
-    try:
-        async with _background_job(timeout_s=30.0):
-            pass  # slot acquisito — pip gira fuori dal semaphore (subprocess indipendente)
-    except asyncio.TimeoutError:
-        raise HTTPException(429, 'Server occupato con altri job pesanti. Riprova tra 30s.')
     # CHUNKED-PIP: installa in batch da 3 pacchetti — previene OOM su Railway free.
     # Ogni batch ha timeout 45s indipendente: un batch lento non blocca i successivi.
     # pip cache su /data/pip-cache (persistente tra restart HF Space / Railway).