feat(stt): actions cluster via Hermes — contexte « agent » + exécuteur hermes-exec

Asa peut AGIR sur le homelab (l'autre moitié de la vision), via le vrai agent Hermes,
profil par défaut, tous ses outils — avec confirmation et jeton.

Découverte : Hermes n'a pas d'API HTTP (appli TUI), mais un mode one-shot `hermes -z
"<prompt>" --yolo`. On s'appuie dessus.

storage-01 — exécuteur :
- tools/hermes-exec/server.py : service HTTP qui lance `hermes -z --yolo` en user hermes,
  derrière un jeton Bearer (compare_digest), timeout + audit, une action à la fois.
- rôle Ansible hermes_exec : systemd (User=hermes, env hermes-agent), jeton via
  EnvironmentFile 0640 (Vault vault_hermes_exec_token) ; ajouté au playbook storage-01.

STT-server (0.5.0 → 0.6.0) :
- agent.py : pont vers hermes-exec (jeton) + détection confirme/annule.
- contexts.py : contexte « agent » (court-circuite le LLM).
- app.py : flux dédié — handshake 2 temps par session (pending action) → sur « confirme »,
  appelle hermes-exec ; « annule » annule. /v1/contexts masque « agent » si désactivé.
- config : STT_ACTIONS_ENABLED (opt-in, défaut false) + URL + jeton (secret k8s).
- deployment : env actions + secret stt-server-secrets/hermes-exec-token (optionnel).

Sécurité : opt-in désactivé par défaut ; jeton obligatoire (sinon contexte caché + exécuteur
refuse tout) ; --yolo atteint seulement jeton+confirmation en main ; audit storage-01.
Client : AUCUN changement (le contexte « agent » apparaît tout seul dans le sélecteur).

Validé en local : exécuteur (401 sans/mauvais jeton, exec avec bon jeton via echo),
handshake serveur (TestClient : confirme→exécute, annule→annule, agent masqué si OFF).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

stt/server/stt_server/app.py

@@ -19,6 +19,7 @@ from stt_server import __version__
 from stt_server import brain
 from stt_server.brain import ask as brain_ask
 from stt_server.config import settings
+from stt_server import agent
 from stt_server.contexts import CONTEXTS, assemble, get_context
 from stt_server.knowledge import Knowledge
 from stt_server.longterm import LongTermMemory
@@ -39,6 +40,13 @@ sessions = SessionStore()
 longterm = LongTermMemory() if settings.memory_longterm else None
 knowledge = Knowledge() if settings.docs_rag else None
 
+# Contexte « agent » : action en attente de confirmation, par session.
+pending_actions: dict[str, str] = {}
+
+
+def _actions_available() -> bool:
+    return settings.actions_enabled and bool(settings.hermes_exec_token)
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -91,6 +99,8 @@ async def v1_contexts() -> dict:
         "contexts": [
             {"id": c.id, "label": c.label, "icon": c.icon, "description": c.description}
             for c in CONTEXTS.values()
+            # le contexte « agent » n'apparaît que si les actions sont activées + jeton
+            if c.id != "agent" or _actions_available()
         ],
     }
 
@@ -122,6 +132,44 @@ async def v1_reset(req: AskRequest) -> dict:
     return {"status": "reset"}
 
 
+def _agent_context_debug(detail: dict) -> dict:
+    """Structure de visualisation pour le contexte agent (transparence du handshake)."""
+    return {
+        "id": "agent", "label": "Agent (actions)", "icon": "🤖",
+        "system_prompt": "Flux agent : la demande est confirmée puis exécutée par "
+        "le vrai agent Hermes (hermes -z --yolo).",
+        "blocks": [{"source": "agent", "title": "Action", "text": str(detail)}],
+        "docs": [], "memories": [],
+    }
+
+
+async def _handle_agent(req: AskRequest, text: str) -> AskReply:
+    """Handshake de confirmation puis exécution via hermes-exec. Court-circuite le LLM."""
+    sid = req.session_id or "anon"
+    if not _actions_available():
+        return AskReply(
+            reply="Les actions sont désactivées côté serveur.",
+            model=settings.model, context_id="agent",
+            context=_agent_context_debug({"disabled": True}),
+        )
+    pending = pending_actions.get(sid)
+    if pending and agent.is_confirmation(text):
+        pending_actions.pop(sid, None)
+        out = await agent.run_action(pending)
+        log.info("agent EXEC sid=%s prompt=%r", sid, pending[:120])
+        return AskReply(reply=out, model=settings.model, context_id="agent",
+                        context=_agent_context_debug({"executed": pending, "result": out[:300]}))
+    if pending and agent.is_cancellation(text):
+        pending_actions.pop(sid, None)
+        return AskReply(reply="C'est annulé.", model=settings.model, context_id="agent",
+                        context=_agent_context_debug({"cancelled": pending}))
+    # nouvelle demande (ou remplacement) → on stocke et on demande confirmation
+    pending_actions[sid] = text
+    reply = f"Tu veux que j'exécute : « {text} » ? Dis « confirme » ou « annule »."
+    return AskReply(reply=reply, model=settings.model, context_id="agent",
+                    context=_agent_context_debug({"pending": text}))
+
+
 @app.post("/v1/ask", response_model=AskReply)
 async def v1_ask(req: AskRequest, background: BackgroundTasks) -> AskReply:
     text = req.text.strip()
@@ -134,6 +182,9 @@ async def v1_ask(req: AskRequest, background: BackgroundTasks) -> AskReply:
             detail=f"modèle '{model}' non autorisé ; dispo : {settings.allowed_models}",
         )
     ctx = get_context(req.context)
+    # Contexte « agent » : flux dédié (confirmation 2 temps → hermes-exec), sans LLM.
+    if ctx.id == "agent":
+        return await _handle_agent(req, text)
     t0 = time.perf_counter()
     history = sessions.history(req.session_id) if req.session_id else None
     # recall : timeout serré, dégrade vite ; renvoie aussi le vecteur (réutilisé ci-dessous)