sync: 40 changed, 0 deleted — 9b07012a (2026-06-20 18:00)

agents/dynamic_replanner.py

@@ -78,20 +78,36 @@ async def replan(
     failures_str = "\n".join(exec_warn[-3:]) if exec_warn else "nessun dettaglio"
     done_str     = ", ".join(exec_done[-5:])  if exec_done else "nessuno"
 
+    # P16-B6: estrai tool/approcci falliti — guida il replanner a evitarli
+    # P18: rimosso import re lazy — usa re module-level (già importato riga 20)
+    _tool_fails: list[str] = []
+    for _w in exec_warn[-5:]:
+        _m = re.search(
+            r"(web_search|run_python|write_file|read_file|web_fetch|"
+            r"trigger_webhook|pip_install|shell_exec|delegate)\w*",
+            _w, re.IGNORECASE,
+        )
+        if _m:
+            _tool_fails.append(_m.group(0))
+    _avoid_str = ", ".join(set(_tool_fails)) if _tool_fails else ""
+
     enriched_goal = (
         f"{original_goal}\n\n"
-        f"[CONTESTO RE-PLAN — tentativo precedente fallito]\n"
-        f"Subtask già completati (NON ripetere): {done_str}.\n"
+        f"[CONTESTO RE-PLAN \u2014 tentativo precedente fallito]\n"
+        f"Subtask gi\u00e0 completati (NON ripetere): {done_str}.\n"
         f"Problemi riscontrati:\n{failures_str}\n"
     )
+    if _avoid_str:
+        enriched_goal += f"Tool che hanno fallito (usa ALTERNATIVE): {_avoid_str}.\n"
     if error_context:
         enriched_goal += f"Analisi errore: {error_context[:300]}\n"
+    _avoid_hint = f"Evita: {_avoid_str}. " if _avoid_str else ""
     enriched_goal += (
         "[ISTRUZIONE] Genera un piano ALTERNATIVO che eviti gli stessi problemi. "
+        f"{_avoid_hint}"
         "Usa approcci diversi per i subtask falliti. "
         "Se un tool ha fallito, usa un tool alternativo."
     )
-
     try:
         new_plan = await asyncio.wait_for(
             planner.create_plan(enriched_goal),  # type: ignore[attr-defined]

agents/reasoning_core.py

@@ -190,12 +190,31 @@ Regole:
 
         return _base_prompt + _ctx_section
 
+    @staticmethod
+    def _extract_json(raw: str) -> str | None:
+        """P16-B3: depth-counting bilanciato — sostituisce regex greedy r'{[\s\S]+}'
+        che su JSON nested (es. patch con oggetti interni) estraeva dal primo { all'ULTIMO }
+        producendo JSON malformato → action='continue' per default → agente in loop.
+        Pattern identico a safeJsonParse.ts già in produzione sul frontend."""
+        depth = 0
+        start = -1
+        for i, ch in enumerate(raw):
+            if ch == '{':
+                if depth == 0:
+                    start = i
+                depth += 1
+            elif ch == '}':
+                depth -= 1
+                if depth == 0 and start != -1:
+                    return raw[start:i + 1]
+        return None
+
     def _parse(self, raw: str) -> ReasoningResult:
         try:
-            m = re.search(r'\{[\s\S]+\}', raw)
-            data = json.loads(m.group()) if m else {}
+            candidate = self._extract_json(raw)
+            data = json.loads(candidate) if candidate else {}
         except Exception:
-            return ReasoningResult(action="continue", steps=[], reason="Parsing error fallback", confidence=0.2)
+            return ReasoningResult(action='continue', steps=[], reason='Parsing error fallback', confidence=0.2)
 
         return ReasoningResult(
             action=data.get("action", "continue"),

agents/skill_tracker.py

@@ -358,3 +358,43 @@ _skill_tracker = SkillTracker()
 def get_skill_tracker() -> SkillTracker:
     """Restituisce il singleton SkillTracker. Thread-safe in CPython (GIL)."""
     return _skill_tracker
+
+
+# ─── P17-B2: FastAPI router per sync frontend ─────────────────────────────────
+# Endpoint REST che permette al frontend (Dexie) di leggere e scrivere skill stats.
+# Montato in backend/main.py tramite _on_startup() se importato.
+
+try:
+    from fastapi import APIRouter as _APIRouter
+    from pydantic import BaseModel as _BM
+
+    skill_router = _APIRouter(prefix="/api/agent", tags=["skill-tracker"])
+
+    class _SkillRecordBody(_BM):
+        success:    bool
+        latency_ms: float = 0.0
+        error_msg:  str   = ""
+
+    @skill_router.get("/skill-stats/{session_id}")
+    async def api_get_skill_stats(session_id: str):
+        """Restituisce stats tool per sessione — per merge con Dexie frontend."""
+        return get_skill_tracker().get_stats(session_id)
+
+    @skill_router.post("/skill-record/{session_id}/{tool_name}")
+    async def api_record_skill(session_id: str, tool_name: str, body: _SkillRecordBody):
+        """Registra un risultato tool dal frontend (es. tool chiamato via browser)."""
+        get_skill_tracker().record(
+            session_id, tool_name,
+            success=body.success,
+            latency_ms=body.latency_ms,
+        )
+        return {"ok": True, "session_id": session_id, "tool": tool_name}
+
+    @skill_router.delete("/skill-stats/{session_id}")
+    async def api_clear_skill_session(session_id: str):
+        """Pulisce la sessione skill tracker alla fine del task."""
+        get_skill_tracker().clear_session(session_id)
+        return {"ok": True}
+
+except ImportError:
+    skill_router = None  # type: ignore[assignment]  # FastAPI non disponibile (unit test env)

agents/unified_loop.py

@@ -61,12 +61,55 @@ class UnifiedLoopState:
     steps: list[dict[str, Any]] = field(default_factory=list)
     errors: list[str] = field(default_factory=list)
     has_files: bool = False  # B10: flag separato — evita di inquinare il context string
+    session_id: str = ""  # P17-F2: blackboard session key per sync Upstash
 
 
 async def _maybe_await(val: Any) -> None:
     if asyncio.iscoroutine(val) or asyncio.isfuture(val):
         await val
 
+# P17-F2: Upstash REST reader — chiamata dal loop all'avvio per iniettare
+# le scoperte critiche dei delegate frontend nel context dell'agente backend.
+# Pattern identico a blackboard.py; duplicato qui per zero import circolare.
+async def _read_bb_upstash(session_id: str) -> str:
+    """Legge le entry critiche dal blackboard Upstash. Ritorna '' se non disponibile."""
+    _url   = os.getenv("UPSTASH_REDIS_REST_URL", "")
+    _token = os.getenv("UPSTASH_REDIS_REST_TOKEN", "")
+    if not _url or not _token or not session_id:
+        return ""
+    import json as _bb_json
+    import httpx as _bb_httpx
+    try:
+        async with _bb_httpx.AsyncClient(timeout=1.5) as _c:
+            _hdr = {"Authorization": f"Bearer {_token}", "Content-Type": "application/json"}
+            _sr  = await _c.post(
+                _url,
+                json=["SCAN", "0", "MATCH", f"bb:{session_id}:*", "COUNT", "50"],
+                headers=_hdr,
+            )
+            _sd   = _sr.json() if _sr.is_success else {}
+            _sc   = _sd.get("result", [])
+            _keys = _sc[1] if (isinstance(_sc, list) and len(_sc) >= 2 and isinstance(_sc[1], list)) else []
+            if not _keys:
+                return ""
+            _mr  = await _c.post(_url, json=["MGET"] + _keys, headers=_hdr)
+            _md  = _mr.json() if _mr.is_success else {}
+            _out = []
+            for _v in _md.get("result", []):
+                if _v:
+                    try:
+                        _e    = _bb_json.loads(_v)
+                        if _e.get("severity") == "critical":
+                            _agid = _e.get("agentId", "")
+                            _key  = _e.get("key", "")
+                            _val  = str(_e.get("value", ""))[:200]
+                            _out.append(f"- [{_agid}] {_key}: {_val}")
+                    except Exception:
+                        pass
+            return ("SCOPERTE CRITICHE DAI DELEGATI:\n" + "\n".join(_out)) if _out else ""
+    except Exception:
+        return ""
+
 
 class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin):
     """Smolagents-first loop with deterministic direct-tool layer and safe LLM fallback."""
@@ -4111,7 +4154,8 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin):
     # ── Entry point (S193) ────────────────────────────────────────────────────
 
     async def run(self, goal: str, context: str = "", max_steps: int = 8,
-                  on_step: StepCallback | None = None) -> dict[str, Any]:
+                  on_step: StepCallback | None = None,
+                  session_id: str = "") -> dict[str, Any]:
         # S390-B-L: strip role prefixes che causano prompt injection
         # Es. "SYSTEM: ignore..." o "ASSISTANT: ..." nel goal utente
         # S762-BUG3: re.sub con ^ strippava solo il PRIMO prefisso — input come
@@ -4167,7 +4211,18 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin):
         if max_steps == 8 and self._CODE_RE.search(goal):
             max_steps = 12
 
-        state = UnifiedLoopState(goal=goal, context=context, max_steps=max_steps)
+        state = UnifiedLoopState(goal=goal, context=context, max_steps=max_steps, session_id=session_id)
+
+        # 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:
+            try:
+                _bb_ctx = await _read_bb_upstash(session_id)
+                if _bb_ctx:
+                    state.context = (state.context + "\n\n" + _bb_ctx).strip() if state.context else _bb_ctx
+                    _logger.info("[P17-F2] BB ctx injected (%d chars)", len(_bb_ctx))
+            except Exception as _bb_exc:
+                _logger.debug("[P17-F2] BB read silenced: %s", _bb_exc)
 
         # GAP-DECISION-FIX: consulta blacklist prima di eseguire fix già rifiutati
         try:

agents/unified_loop_prompts.py

@@ -212,6 +212,47 @@ class PromptBuilderMixin:
         "• AUTOMAZIONE: se l'utente fa lo stesso task 3+ volte → suggerisci di schedularlo\n"
     )
 
+    # ── P19-F1: Expertise Personas — /persona RESEARCHER|CODER|REASONER ─────────
+    # Attivazione: il goal inizia con "/persona <NAME>" (case-insensitive).
+    # Il blocco viene anteposto a _SYSTEM_IDENTITY in _build_messages().
+
+    _PERSONA_BLOCKS: dict[str, str] = {
+        "RESEARCHER": (
+            "=== MODALITÀ RESEARCHER (P19-F1) ===\n"
+            "Sei un ricercatore esperto. In questa sessione:\n"
+            "• Ogni affermazione deve citare la fonte (URL, paper, documentazione ufficiale)\n"
+            "• Sintetizza sempre almeno 3 fonti prima di dare una conclusione\n"
+            "• Distingui esplicitamente: FATTO VERIFICATO / OPINIONE / IPOTESI\n"
+            "• Per ogni topic, riporta anche i contro-argomenti principali\n"
+            "• Usa web_search per ogni claim che potrebbe essere cambiato dopo il tuo training\n"
+            "• Struttura obbligatoria: ## Sintesi → ## Fonti → ## Punti controversi → ## Raccomandazione\n"
+            "• Aggiungi sempre: 'Ultimo aggiornamento disponibile: [data da fonte]'\n"
+        ),
+        "CODER": (
+            "=== MODALITÀ CODER (P19-F1) ===\n"
+            "Sei un senior software engineer. In questa sessione:\n"
+            "• Ogni snippet: TypeScript strict / Python typed / con gestione errori esplicita\n"
+            "• Applica TDD: scrivi prima i test, poi l'implementazione\n"
+            "• Struttura modulare: funzioni pure, single-responsibility, DI-friendly\n"
+            "• Commenti solo per il WHY, mai per il WHAT (codice self-documenting)\n"
+            "• Per ogni soluzione: complessità Big-O, edge cases, dipendenze esplicite\n"
+            "• Se rilevi codice smell: nomina il pattern (God Object, Shotgun Surgery, ecc.)\n"
+            "• Struttura obbligatoria: ## Interfaccia pubblica → ## Implementazione → ## Test → ## Edge cases\n"
+            "• Aggiungi sempre: 'Stack: [linguaggio] [runtime] [framework]'\n"
+        ),
+        "REASONER": (
+            "=== MODALITÀ REASONER (P19-F1) ===\n"
+            "Sei un ragionatore logico sistematico. In questa sessione:\n"
+            "• Esponi il ragionamento passo per passo — ZERO conclusioni saltate\n"
+            "• Per ogni problema: enumera le assunzioni esplicite e implicite\n"
+            "• Usa sillogismi e alberi decisionali quando la logica è ramificata\n"
+            "• Identifica i presupposti contestabili con [ASSUNZIONE]\n"
+            "• Per problemi ambigui: mostra 2-3 interpretazioni prima di scegliere\n"
+            "• Struttura obbligatoria: ## Premesse → ## Ragionamento → ## Conclusione → ## Verifica\n"
+            "• Aggiungi sempre la confidence: [ALTA/MEDIA/BASSA] con motivazione\n"
+        ),
+    }
+
     # ── S200: Context-aware rule injection ──────────────────────────────────────
     # Seleziona solo le regole rilevanti per il task corrente.
     # Con llama-3.1-8b-instant (8K context), mettere tutto nel system prompt
@@ -1111,8 +1152,57 @@ class PromptBuilderMixin:
             "[3 modifiche prioritizzate in ordine di impatto — chiedi conferma prima di applicarle]"
         ),
 
+        # ── P19-F2: Webhook/n8n/Pipedream/Zapier recipe hints ──────────────────
+        # Trigger: utente chiede automazione, webhook, notifiche o integrazioni esterne.
+        # Fornisce URL pattern e payload d'esempio per trigger_webhook.
+        (
+            ["n8n", "pipedream", "zapier", "make.com", "webhook", "notifica",
+             "automazione esterna", "automation", "notificami", "invia notifica",
+             "zap ", "workflow esterno", "trigger esterno", "discord webhook",
+             "slack webhook", "integromat", "integrazione esterna"],
+            "WEBHOOK AUTOMATION (P19-F2):\n"
+            "Usa il tool trigger_webhook per inviare dati a qualsiasi servizio esterno.\n"
+            "\n"
+            "PATTERN n8n (webhook node):\n"
+            "  url: 'https://your-n8n.app.n8n.cloud/webhook/<uuid>'\n"
+            "  payload: {'event': 'task_done', 'data': {...}, 'agent': 'agente-ai'}\n"
+            "  method: POST (default)\n"
+            "\n"
+            "PATTERN Pipedream:\n"
+            "  url: 'https://eo<id>.m.pipedream.net'\n"
+            "  payload: {'source': 'agente-ai', 'result': '...', 'ts': '<iso timestamp>'}\n"
+            "\n"
+            "PATTERN Zapier (Catch Hook):\n"
+            "  url: 'https://hooks.zapier.com/hooks/catch/<id>/<hash>/'\n"
+            "  payload: {'subject': '...', 'body': '...'}\n"
+            "\n"
+            "PATTERN Discord Webhook:\n"
+            "  url: 'https://discord.com/api/webhooks/<id>/<token>'\n"
+            "  payload: {'content': 'Messaggio...', 'username': 'Agente AI'}\n"
+            "  headers: {'Content-Type': 'application/json'}\n"
+            "\n"
+            "REGOLE trigger_webhook:\n"
+            "  - Richiedi sempre l'URL all'utente se non fornito\n"
+            "  - Timeout max 10s — non blocca il loop\n"
+            "  - Payload max 32KB — tronca output lunghi prima di inviarli\n"
+            "  - Controlla ok=True nella risposta e logga il body\n"
+            "  - Mai esporre dati sensibili (token, password) nel payload"
+        ),
+
       ]
 
+    @staticmethod
+    def _extract_persona(goal: str) -> "tuple[str | None, str]":
+        """P19-F1: Estrae persona dal goal se inizia con /persona <NAME>.
+        Ritorna (persona_name | None, goal_senza_prefisso).
+        """
+        import re as _re
+        _m = _re.match(r'^/persona\s+(RESEARCHER|CODER|REASONER)\b', goal.strip(), _re.IGNORECASE)
+        if _m:
+            clean = goal.strip()[_m.end():].strip()
+            return _m.group(1).upper(), clean if clean else goal.strip()
+        return None, goal
+
     def _pick_context_rules(self, goal: str) -> str:
         """Seleziona regole contestuali basate sul task. Max 3 per non saturare il contesto."""
         goal_lower = goal.lower()
@@ -1153,8 +1243,10 @@ class PromptBuilderMixin:
     def _build_messages(self, state: UnifiedLoopState, tool_results: str = "",
                          tool_exec_successes: int = 0, tool_exec_errors: int = 0,
                          session_files: "dict[str, str] | None" = None) -> list[dict]:
+        # P19-F1: estrai persona dal goal (/persona RESEARCHER|CODER|REASONER ...)
+        _p19_persona, _p19_goal = self._extract_persona(state.goal)
         # S197: estrai code-block grandi in file virtuali per evitare timeout provider
-        goal_display, files_ctx = self._compress_goal(state.goal)
+        goal_display, files_ctx = self._compress_goal(_p19_goal)
         mem_hint = "Tieni conto della memoria per preferenze e contesto utente.\n" if self.memory else ""
         # GAP-5: tronca tool_results a max 6000 chars per evitare context explosion su Groq 128k.
         # Header 500 chars (dichiarazione tool) + tail 4000 chars (risultati recenti).
@@ -1212,6 +1304,10 @@ class PromptBuilderMixin:
         context_part = f"Contesto sessione: {_raw_ctx}\n\n" if _raw_ctx and _raw_ctx != "nessuno" else ""
         files_part  = f"{files_ctx}\n\n" if files_ctx else ""
         # S200: regole contestuali iniettate ALLA FINE del user message (recency bias)
+        # P19-F1: persona block se attivo
+        _p19_persona_prefix = ""
+        if _p19_persona and _p19_persona in self._PERSONA_BLOCKS:
+            _p19_persona_prefix = self._PERSONA_BLOCKS[_p19_persona] + "\n\n"
         ctx_rules = self._pick_context_rules(goal_display)
         # S375: format directive — garantisce coerenza di formato anche sul path backend
         fmt_directive = self._classify_format_directive(state.goal)
@@ -1284,7 +1380,7 @@ class PromptBuilderMixin:
             state.has_files = True
         # S375: format directive iniettata nel system prompt (non nel user msg)
         # per evitare confusione con i dati tool nel user content
-        system_with_fmt = f"{self._SYSTEM_IDENTITY}\n\n{fmt_directive}"
+        system_with_fmt = f"{_p19_persona_prefix}{self._SYSTEM_IDENTITY}\n\n{fmt_directive}"
         return [
             {"role": "system", "content": system_with_fmt},
             {"role": "user",   "content": user_content},

agents/unified_loop_tools.py

@@ -854,7 +854,10 @@ class DirectToolsMixin:
         r"directory[\s_]tree|albero\s+(?:del\s+)?(?:progetto|directory)|"
         r"struttura\s+(?:del\s+)?progetto|elenca\s+(?:file|cartell[ae])|"
         r"cerca\s+nel\s+(?:codice|progetto)|grep\s+|file[\s_]search|"
-        r"type[\s_]check|verifica\s+tipi|typescript\s+check|mypy\s+)\b",
+        r"type[\s_]check|verifica\s+tipi|typescript\s+check|mypy\s+|"
+        # R9: webhook/call_api keywords — mancanti da _TOOL_NEEDED_RE
+        r"webhook|trigger\s+webhook|chiama\s+(?:il\s+)?webhook|send\s+webhook|"
+        r"call[\s_]api|chiama\s+api|http\s+(?:post|get|request)|zapier|n8n)\b",
         re.IGNORECASE,
     )
 

api/agent.py

@@ -1,3 +1,4 @@
+71753
 """backend/api/agent.py — Agent tasks, SSE streaming, checkpoints, loops, kernel (S359, S369).
 
 S358: stream_agent_task() usa _loop_registry per evitare re-run al reconnect SSE.
@@ -196,6 +197,7 @@ async def agent_run_stream(body: ReasonLoopIn, request: Request):
                 result = await loop.run(
                     goal=body.goal, context=context_str,
                     max_steps=body.max_steps, on_step=step_cb,
+                    session_id=getattr(body, "session_id", "") or "",
                 )
                 await queue.put({
                     '__done__': True,
@@ -394,7 +396,7 @@ async def reason_loop(body: ReasonLoopIn):
                 'action': step_data.get('action', ''),
                 'output': str(step_data.get('output', ''))[:400],  # S577: 200→400
             })
-        result = await loop.run(goal=body.goal, context=context_str, max_steps=body.max_steps, on_step=_on_step)
+        result = await loop.run(goal=body.goal, context=context_str, max_steps=body.max_steps, on_step=_on_step, session_id=getattr(body, "session_id", "") or "")
         if isinstance(result, dict):
             output_text = result.get('output', '') or ''
             engine_used = result.get('engine', 'unknown')
@@ -527,6 +529,7 @@ async def create_agent_task(body: AgentTaskIn):
         'learning_hints':    body.learning_hints,   # S456-X4
         'resume_from_step':  body.resume_from_step, # P16-F3: passo resume dalla coda
         'persona':           body.persona,           # P17-F5: expertise persona hint
+        'session_id':        body.session_id or '',   # P17-F2: BB session key (normalize None→'')
     }
     # WRITE-AHEAD: persiste il task su Supabase immediatamente, prima del checkpoint
     # periodico (15-60s). Finestra di perdita per la fase di creazione → zero.
@@ -971,6 +974,8 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0):
                     _tool_key_narr = _action.replace('executor:', '') if _action.startswith('executor:') else _action
                     _narration = _STEP_NARRATIONS.get(_tool_key_narr,
                         _action.replace('executor:', '').replace('_', ' ').capitalize())
+                    # P16-B4: propaga 'truncated' dal loop (finish_reason==length) → frontend
+                    _step_truncated = bool(step_data.get('truncated', False))
                     _sse('step_done', {
                         'taskId': task_id,
                         'step': {
@@ -979,6 +984,7 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0):
                             'status':      step_data.get('status', 'done'),
                             'result':      str(step_data.get('result', step_data.get('output', '')))[:500],
                             'explanation': _narration,  # S363-Blueprint: narrative field
+                            'truncated':   _step_truncated,  # P16-B4: segnala max_tokens raggiunto
                         },
                     })
                     # TG-STEP: notifica step intermedio rilevante (fire-and-forget, rate-limited 30s)
@@ -1101,6 +1107,7 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0):
                     context=context_str,
                     max_steps=task.get('_resume_max_steps', task.get('max_steps', 8)),  # AG-BUG-1: _resume_max mai definito in questo scope
                     on_step=step_cb,
+                    session_id=task.get('session_id', '') or '',
                 )
                 _agent_tasks[task_id]['status'] = 'SUCCESS'
                 asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)