sync: 192 file da Baida98/AI@6bb6a205 (2026-08-26 18:57 UTC) [deploy-all]

agents/html_fast_path.py

@@ -0,0 +1,60 @@
+"""Classificazione locale del fast path per mini-app HTML a file singolo.
+
+Il classificatore è deliberatamente conservativo: in caso di dubbio restituisce
+False. Non usa LLM, rete o stato globale e quindi non aggiunge latenza misurabile.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+
+
+@dataclass(frozen=True)
+class HtmlFastPathDecision:
+    eligible: bool
+    reason: str
+    path: str = "index.html"
+
+
+_HTML_RE = re.compile(r"\b(?:html5?|html|pagina\s+web|single[- ]page|landing\s+page)\b", re.I)
+_CREATE_RE = re.compile(r"\b(?:crea|genera|scrivi|realizza|implementa|build|create|generate|make)\b", re.I)
+_SINGLE_FILE_RE = re.compile(
+    r"\b(?:un\s+solo\s+file|singolo\s+file|one\s+file|single\s+file|file\s+unico)\b", re.I
+)
+_PATH_RE = re.compile(r"(?<![\w./-])([\w./-]+\.html)(?![\w.-])", re.I)
+_FORBIDDEN_RE = re.compile(
+    r"\b(?:deploy|pubblica|publish|rilascia|release|github|git|npm|pnpm|yarn|install|"
+    r"api|backend|server|database|db|auth|login|pagamento|payment|webhook|secret|token|"
+    r"shell|bash|terminal|esegui\s+comandi|execute\s+commands|multi[- ]file|pi[uù]\s+file|"
+    r"react|vue|angular|next(?:\.js)?|vite|typescript|python|sql)\b",
+    re.I,
+)
+_EXTERNAL_RE = re.compile(r"\b(?:fetch|axios|websocket|stripe|supabase|firebase|oauth)\b|https?://", re.I)
+
+
+def classify_html_fast_path(goal: str) -> HtmlFastPathDecision:
+    """Return an eligible decision only for a safe, self-contained HTML request."""
+    text = " ".join(str(goal or "").split())
+    if not text:
+        return HtmlFastPathDecision(False, "empty_goal")
+    if len(text) > 500:
+        return HtmlFastPathDecision(False, "goal_too_long")
+    if not _HTML_RE.search(text):
+        return HtmlFastPathDecision(False, "not_html_goal")
+    if not _CREATE_RE.search(text):
+        return HtmlFastPathDecision(False, "not_creation_goal")
+    if not _SINGLE_FILE_RE.search(text):
+        return HtmlFastPathDecision(False, "single_file_not_explicit")
+    if _FORBIDDEN_RE.search(text):
+        return HtmlFastPathDecision(False, "contains_project_or_sensitive_operation")
+    if _EXTERNAL_RE.search(text):
+        return HtmlFastPathDecision(False, "external_dependency_or_network")
+
+    paths = _PATH_RE.findall(text)
+    path = paths[0] if paths else "index.html"
+    if "/" in path or path.startswith("."):
+        return HtmlFastPathDecision(False, "nested_path_not_allowed", path)
+    return HtmlFastPathDecision(True, "self_contained_single_html", path)
+
+
+__all__ = ["HtmlFastPathDecision", "classify_html_fast_path"]

agents/unified_loop.py

@@ -550,9 +550,29 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
         # F17+B7: planner per task di progettazione/implementazione — soglia ridotta a 10 chars
         # Bug: "crea app react" (14 chars) non attivava mai il planner (soglia era 50).
         # _NEEDS_PLAN_RE filtra già query semplici — len guard serve solo per 1-8 char input.
+        try:
+            from agents.html_fast_path import classify_html_fast_path
+            _html_fast_decision = classify_html_fast_path(state.goal)
+        except Exception as _html_cls_exc:
+            _logger.debug("[html-fast-path] classifier unavailable: %s", type(_html_cls_exc).__name__)
+            _html_fast_decision = None
+        _html_fast_plan = None
+        if _html_fast_decision is not None and _html_fast_decision.eligible and not tool_results:
+            _html_fast_plan = {
+                "summary": "Piano locale mini-app HTML a file singolo",
+                "goal": state.goal,
+                "subtasks": [
+                    {"id": 1, "description": f"Scrivi {_html_fast_decision.path}: {state.goal}", "tool": "write_file", "requires": []},
+                    {"id": 2, "description": f"Rileggi {_html_fast_decision.path} e verifica la scrittura", "tool": "read_file", "requires": [1]},
+                ],
+                "complexity": "low",
+                "source": "local_html_fast_path",
+            }
+            _logger.info("[html-fast-path] planner bypass: %s", _html_fast_decision.path)
         _should_plan = (
             self.planner
             and not tool_results
+            and _html_fast_plan is None
             and bool(self._NEEDS_PLAN_RE.search(state.goal[:200]))
             and len(state.goal) > 10
         )
@@ -569,7 +589,7 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
             }
             _logger.info("S-FMT-ORCH fast-fix: piano sintetico iniettato, skip ARCHITECT")
         _t0_plan = asyncio.get_running_loop().time()  # Sprint 5 ITEM 13: plan_ms timing
-        if _should_plan:
+        if _should_plan or _html_fast_plan is not None:
             if on_step:
                 await _maybe_await(on_step({
                     "loop": 0, "action": "plan", "status": "started",
@@ -578,7 +598,10 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
                 }))
             # S640: timeout planner + S-FMT-ORCH fast-fix bypass
             # Se _fast_fix_plan disponibile, salta ARCHITECT (~15s risparmiati)
-            if _fast_fix_plan is not None:
+            if _html_fast_plan is not None:
+                plan = _html_fast_plan
+                _logger.info("[html-fast-path] ARCHITECT bypassato")
+            elif _fast_fix_plan is not None:
                 plan = _fast_fix_plan
                 _logger.info("S-FMT-ORCH fast-fix: ARCHITECT bypassato")
             else:
@@ -3777,29 +3800,6 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
         except Exception:
             pass  # decision_memory non disponibile — continua normalmente
 
-        # B5-ORDER: una spiegazione completa e non operativa è già un intento
-        # sufficiente. Deve bypassare le guardie di ambiguità, che sono riservate a
-        # comandi realmente vaghi; le guardie in _is_pure_explanation() proteggono
-        # file, mutazioni, dati realtime e richieste troppo lunghe.
-        # Sprint 5 ITEM 13: classify_ms — tempo routing/classificazione goal (sync, <1ms)
-        _t0_classify = _time.monotonic()
-        if self._is_pure_explanation(goal):
-            try:
-                from api.state import record_timing as _rtcB5
-                _rtcB5("classify_ms", (_time.monotonic() - _t0_classify) * 1000)
-            except Exception:
-                pass
-            await self._transition_state(state, AgentState.THINKING, on_step)
-            _r = await _finish(await self._run_fallback(state, on_step))
-            _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000)
-            _r["effective_max_steps"] = state.max_steps
-            if _sid_token is not None:
-                try: _sid_var.reset(_sid_token)
-                except Exception: pass
-            if self._session_files:
-                asyncio.ensure_future(self._vfs_git_backup())
-            return _r
-
         # P29-B1: gate ambiguità strutturale — _is_goal_ambiguous() era P28-B2 dead code (mai chiamata).
         # Zero LLM, <0.1ms. Lingua-aware via self._run_lang (P28-B1). Fires dopo blacklist e prima del routing.
         if _is_goal_ambiguous(goal):
@@ -3963,6 +3963,9 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
             return _r_bl
 
 
+        # Sprint 5 ITEM 13: classify_ms — tempo routing/classificazione goal (sync, <1ms)
+        _t0_classify = _time.monotonic()
+
         # S402: Fast Path — greeting/ack/identità semplice → bypass tutto l'overhead
         if self._is_simple_query(goal):
             try:
@@ -4012,6 +4015,27 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
         # già — "direct tools + fallback" — ma il codice faceva solo _run_fallback senza tool).
         # Bug: query meteo/news/cerca non chiamavano mai i tool reali → LLM allucinava i dati
         # → ResponseVerifier girava su risposta inventata → retry → 20-60s inutili.
+        # B5: query spiegazione pura → _run_fallback diretta (-20-30s risparmio)
+        # Scenari: "cos'è X", "spiegami Y", "how does Z work?", "explain W"
+        # Fail-open: se regex troppo larga → path normale (nessuna perdita)
+        if self._is_pure_explanation(goal):
+            try:
+                from api.state import record_timing as _rtcB5
+                _rtcB5("classify_ms", (_time.monotonic() - _t0_classify) * 1000)
+            except Exception:
+                pass
+            await self._transition_state(state, AgentState.THINKING, on_step)
+            _r = await _finish(await self._run_fallback(state, on_step))
+            _r["timing_ms"] = int((_time.monotonic() - _t_run) * 1000)
+            _r["effective_max_steps"] = state.max_steps
+            if _sid_token is not None:
+                try: _sid_var.reset(_sid_token)
+                except Exception: pass
+            if self._session_files:
+                asyncio.ensure_future(self._vfs_git_backup())
+            return _r
+
+
         # P36: Hybrid Execution Router — Python code analysis fast path.
         # Se goal contiene keyword analisi + codice Python nel context/goal,
         # chiama python_analyze direttamente (<5ms) saltando planner+LLM (5-15s).

api/agent.py

@@ -849,8 +849,8 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
         # tool. È il backstop per client SSE che non applicano il fast path UI.
         _literal_response = task.get('literal_response')
         if isinstance(_literal_response, str) and _literal_response:
-            _agent_tasks[task_id]['status'] = 'SUCCESS'
-            asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)
+            _agent_tasks[task_id]['status'] = 'COMPLETED'
+            asyncio.create_task(sb_update_status(task_id, 'COMPLETED')).add_done_callback(_log_task_exc)
             literal_event = json.dumps(_sanitize_for_json({
                 'event': 'task_done', 'taskId': task_id, 'result': _literal_response,
             }))
@@ -899,7 +899,7 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
         sb_events = await sb_get_events(task_id)
         if sb_events:
             task_status = task.get('status', 'UNKNOWN')
-            terminal    = task_status in ('SUCCESS', 'ERROR', 'CANCELLED')
+            terminal    = task_status in ('COMPLETED', 'SUCCESS', 'ERROR', 'CANCELLED')
             # Replay buffer from resume point
             for evt_str in sb_events[_resume_from:]:
                 yield evt_str
@@ -1005,8 +1005,8 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
                 # È emesso direttamente nello stream affinché i client SSE non possano bypassarlo.
                 _literal_response = task.get('literal_response')
                 if isinstance(_literal_response, str) and _literal_response:
-                    _agent_tasks[task_id]['status'] = 'SUCCESS'
-                    asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)
+                    _agent_tasks[task_id]['status'] = 'COMPLETED'
+                    asyncio.create_task(sb_update_status(task_id, 'COMPLETED')).add_done_callback(_log_task_exc)
                     _sse('task_done', {'taskId': task_id, 'result': _literal_response})
                     return
 
@@ -1453,8 +1453,13 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
                         except Exception as _artifact_exc:
                             _logger.warning('[agent] artifact fallback failed: %s', type(_artifact_exc).__name__)
 
-                _agent_tasks[task_id]['status'] = 'SUCCESS'
-                asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)
+                # Lifecycle separato: l'esecuzione primaria è completa quando VFS e risultato
+                # sono confermati; la verifica qualità successiva non deve tenere il task RUNNING.
+                _agent_tasks[task_id]['status'] = 'COMPLETED'
+                _agent_tasks[task_id]['quality_status'] = (
+                    'QUALITY_CHECK_PENDING' if _run_quality_check else 'NOT_REQUIRED'
+                )
+                asyncio.create_task(sb_update_status(task_id, 'COMPLETED')).add_done_callback(_log_task_exc)
                 # ARCH-K2.2: pubblica lifecycle event via Kernel
                 if _KERNEL_AVAILABLE and _kernel is not None:
                     asyncio.create_task(_kernel.publish_event(
@@ -1470,17 +1475,46 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
                     # confermato il task. Su errore/cancellazione lo staging rimane
                     # intenzionalmente non committato.
                     _sse('vfs_sync_complete', _vfs_commit)
-                _sse('task_done', {'taskId': task_id, 'result': _result_text[:8000]})
+                if _run_quality_check:
+                    _sse('quality_check_pending', {
+                        'taskId': task_id,
+                        'status': 'QUALITY_CHECK_PENDING',
+                        'primaryStatus': 'COMPLETED',
+                    })
+                _sse('task_done', {
+                    'taskId': task_id,
+                    'result': _result_text[:8000],
+                    'status': 'COMPLETED',
+                    'qualityStatus': _agent_tasks[task_id].get('quality_status', 'NOT_REQUIRED'),
+                })
                 asyncio.create_task(_tg_done(task_id, task.get('goal', ''), _result_text[:500], _task_started_ms)).add_done_callback(_log_task_exc)
 
-                # S363: fire-and-forget quality check when code detected in output
+                # Quality check non bloccante: aggiorna solo quality_status, mai lo stato
+                # primario del task e mai il commit VFS già confermato.
                 if _run_quality_check:
                     _qg_result = str(result.get('output', result) if isinstance(result, dict) else result)
-                    if len(_qg_result) > 500 and _qg_result.count('```') >= 2:  # S373: threshold raised — evita QG su snippet brevi
-                        asyncio.create_task(_run_quality_check(
-                            task_id, task['goal'], _qg_result,
-                            on_event=lambda ev: _sse(ev.get('type', 'test_result'), ev),
-                        )).add_done_callback(_log_task_exc)
+                    if len(_qg_result) > 500 and _qg_result.count('```') >= 2:
+                        async def _run_quality_background() -> None:
+                            try:
+                                await _run_quality_check(
+                                    task_id, task['goal'], _qg_result,
+                                    on_event=lambda ev: _sse(ev.get('type', 'test_result'), ev),
+                                )
+                                _agent_tasks.get(task_id, {})['quality_status'] = 'QUALITY_CHECK_DONE'
+                                _sse('quality_check_done', {
+                                    'taskId': task_id,
+                                    'status': 'QUALITY_CHECK_DONE',
+                                    'primaryStatus': 'COMPLETED',
+                                })
+                            except Exception as _q_exc:
+                                _agent_tasks.get(task_id, {})['quality_status'] = 'QUALITY_CHECK_ERROR'
+                                _sse('quality_check_done', {
+                                    'taskId': task_id,
+                                    'status': 'QUALITY_CHECK_ERROR',
+                                    'primaryStatus': 'COMPLETED',
+                                    'error': type(_q_exc).__name__,
+                                })
+                        asyncio.create_task(_run_quality_background()).add_done_callback(_log_task_exc)
 
 
             except asyncio.CancelledError:
@@ -1495,8 +1529,8 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
                 _sse('task_cancelled', {'taskId': task_id})
 
             except (ImportError, ModuleNotFoundError):
-                _agent_tasks[task_id]['status'] = 'SUCCESS'
-                asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)
+                _agent_tasks[task_id]['status'] = 'COMPLETED'
+                asyncio.create_task(sb_update_status(task_id, 'COMPLETED')).add_done_callback(_log_task_exc)
                 _sse('step_done', {'taskId': task_id, 'step': {'name': 'Ragionamento', 'index': 0}})
                 _sse('task_done', {'taskId': task_id, 'result': (
                     f'Goal ricevuto: {task["goal"]}\n\n'

tests/test_html_fast_path.py

@@ -0,0 +1,36 @@
+from agents.html_fast_path import classify_html_fast_path
+
+
+def test_accepts_self_contained_single_html():
+    decision = classify_html_fast_path(
+        "Crea una mini-app lista spesa in un solo file index.html con aggiunta e filtro"
+    )
+    assert decision.eligible is True
+    assert decision.path == "index.html"
+    assert decision.reason == "self_contained_single_html"
+
+
+def test_accepts_explicit_html_file_without_network():
+    decision = classify_html_fast_path(
+        "Genera una pagina web HTML in un solo file todo.html con CSS e JavaScript inline"
+    )
+    assert decision.eligible is True
+    assert decision.path == "todo.html"
+
+
+def test_rejects_deploy_and_external_dependencies():
+    assert not classify_html_fast_path(
+        "Crea una mini-app HTML in un solo file index.html e pubblicala su GitHub"
+    ).eligible
+    assert not classify_html_fast_path(
+        "Crea una pagina HTML single-file che usa fetch https://api.example.com"
+    ).eligible
+
+
+def test_rejects_multi_file_or_sensitive_tasks():
+    assert not classify_html_fast_path(
+        "Crea una app React multi-file con backend API"
+    ).eligible
+    assert not classify_html_fast_path(
+        "Crea una pagina HTML in un solo file con login e database"
+    ).eligible