feat: complete all 15 next recommendations

Frontend wiring:
- Wire useMarkdownWorker into Markdown component (worker-first, sync fallback)
- Wire useIndexedDB as primary storage in useChatHistory (500 msg cap, localStorage fallback)

Backend depth:
- Persistent audit store (SQLite, thread-safe, WAL mode) with record/query/filter
- Wire audit store into session routes (session.create, prompt.submit events)
- Wire audit store into audit export routes (persistent-first, telemetry fallback)
- CSRF double-submit cookie pattern (token generation, cookie set, header validation)

Production:
- Helm chart CI: helm lint + helm template validation
- Database migration CI: verify step in pipeline
- Prometheus alerting rules (error rate, latency, pod restarts, memory, CPU, queue, health)
- Rate limiting per API key (3x IP limit, sliding window, advisory)
- WebSocket SSE fallback (auto-downgrade after MAX_RETRIES WS failures)

Tests: 605 Python + 56 frontend = 661 total, 0 ruff errors
Co-Authored-By: Nakamoto, S <defi@defi-oracle.io>

fusionagi/api/routes/audit_export.py

@@ -15,6 +15,7 @@ from fastapi import APIRouter, Query
 from fastapi.responses import StreamingResponse
 
 from fusionagi._logger import logger
+from fusionagi.api.audit_store import get_audit_events
 from fusionagi.api.dependencies import get_telemetry_tracer
 
 router = APIRouter()
@@ -25,7 +26,16 @@ def _get_audit_records(
     limit: int = 1000,
     since: float | None = None,
 ) -> list[dict[str, Any]]:
-    """Collect audit records from telemetry tracer."""
+    """Collect audit records from persistent store, falling back to telemetry tracer."""
+    # Try persistent audit store first
+    try:
+        records = get_audit_events(limit=limit, since=since)
+        if records:
+            return records
+    except Exception:
+        pass
+
+    # Fallback to telemetry tracer
     tracer = get_telemetry_tracer()
     if not tracer:
         return []

fusionagi/api/routes/sessions.py

@@ -5,12 +5,15 @@ from typing import Any
 
 from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect
 
+from fusionagi.api.audit_store import record_audit_event
 from fusionagi.api.dependencies import (
     get_event_bus,
     get_orchestrator,
     get_safety_pipeline,
     get_session_store,
 )
+from fusionagi.api.error_codes import ErrorCode, error_response
+from fusionagi.api.otel import trace_span
 from fusionagi.api.websocket import handle_stream
 from fusionagi.core import (
     extract_sources_from_head_outputs,
@@ -40,13 +43,18 @@ def create_session(user_id: str | None = None) -> dict[str, Any]:
     Returns:
         JSON with session_id and user_id.
     """
-    _ensure_init()
-    store = get_session_store()
-    if not store:
-        raise HTTPException(status_code=503, detail="Session store not initialized")
-    session_id = str(uuid.uuid4())
-    store.create(session_id, user_id)
-    return {"session_id": session_id, "user_id": user_id}
+    with trace_span("session.create", attributes={"user_id": user_id or "anonymous"}):
+        _ensure_init()
+        store = get_session_store()
+        if not store:
+            raise HTTPException(
+                status_code=503,
+                detail=error_response(ErrorCode.ORCHESTRATOR_UNAVAILABLE, "Session store not initialized"),
+            )
+        session_id = str(uuid.uuid4())
+        store.create(session_id, user_id)
+        record_audit_event("session.create", resource_type="session", resource_id=session_id)
+        return {"session_id": session_id, "user_id": user_id}
 
 
 @router.post("/{session_id}/prompt")
@@ -67,98 +75,123 @@ def submit_prompt(session_id: str, body: dict[str, Any]) -> dict[str, Any]:
         FinalResponse with final_answer, head_contributions, confidence_score,
         and transparency_report.
     """
-    _ensure_init()
-    store = get_session_store()
-    orch = get_orchestrator()
-    bus = get_event_bus()
-    if not store or not orch:
-        raise HTTPException(status_code=503, detail="Service not initialized")
-
-    sess = store.get(session_id)
-    if not sess:
-        raise HTTPException(status_code=404, detail="Session not found")
-
-    prompt = body.get("prompt", "")
-    parsed = parse_user_input(prompt)
-
-    if not prompt or not parsed.cleaned_prompt.strip():
-        if parsed.intent in (UserIntent.SHOW_DISSENT, UserIntent.RERUN_RISK, UserIntent.EXPLAIN_REASONING, UserIntent.SOURCES):
-            hist = sess.get("history", [])
-            if hist:
-                prompt = hist[-1].get("prompt", "")
-            if not prompt:
-                raise HTTPException(status_code=400, detail="No previous prompt; provide a prompt for this command")
-        else:
-            raise HTTPException(status_code=400, detail="prompt is required")
-
-    effective_prompt = parsed.cleaned_prompt.strip() or prompt
-    pipeline = get_safety_pipeline()
-    if pipeline:
-        pre_result = pipeline.pre_check(effective_prompt)
-        if not pre_result.allowed:
-            raise HTTPException(status_code=400, detail=pre_result.reason or "Input moderation failed")
-
-    task_id = orch.submit_task(goal=effective_prompt[:200])
-
-    # Dynamic head selection
-    head_ids = select_heads_for_complexity(effective_prompt)
-    if parsed.intent.value == "head_strategy" and parsed.head_id:
-        head_ids = [parsed.head_id]
-
-    force_second = parsed.intent == UserIntent.RERUN_RISK
-    return_heads = parsed.intent == UserIntent.SOURCES
-
-    result = run_dvadasa(
-        orchestrator=orch,
-        task_id=task_id,
-        user_prompt=effective_prompt,
-        parsed=parsed,
-        head_ids=head_ids if parsed.intent.value != "normal" or body.get("use_all_heads") else None,
-        event_bus=bus,
-        force_second_pass=force_second,
-        return_head_outputs=return_heads,
-    )
-
-    if return_heads and isinstance(result, tuple):
-        final, head_outputs = result
-    else:
-        final = result  # type: ignore[assignment]
-        head_outputs = []
-
-    if not final:
-        raise HTTPException(status_code=500, detail="Failed to produce response")
-
-    if pipeline:
-        post_result = pipeline.post_check(final.final_answer)
-        if not post_result.passed:
+    with trace_span("session.prompt", attributes={"session_id": session_id}):
+        _ensure_init()
+        store = get_session_store()
+        orch = get_orchestrator()
+        bus = get_event_bus()
+        if not store or not orch:
             raise HTTPException(
-                status_code=400,
-                detail=f"Output scan failed: {', '.join(post_result.flags)}",
+                status_code=503,
+                detail=error_response(ErrorCode.ORCHESTRATOR_UNAVAILABLE),
             )
 
-    entry = {
-        "prompt": effective_prompt,
-        "final_answer": final.final_answer,
-        "confidence_score": final.confidence_score,
-        "head_contributions": final.head_contributions,
-    }
-    store.append_history(session_id, entry)
+        sess = store.get(session_id)
+        if not sess:
+            raise HTTPException(
+                status_code=404,
+                detail=error_response(ErrorCode.SESSION_NOT_FOUND),
+            )
 
-    response: dict[str, Any] = {
-        "task_id": task_id,
-        "final_answer": final.final_answer,
-        "transparency_report": final.transparency_report.model_dump(),
-        "head_contributions": final.head_contributions,
-        "confidence_score": final.confidence_score,
-    }
-    if parsed.intent == UserIntent.SHOW_DISSENT:
-        response["response_mode"] = "show_dissent"
-        response["disputed_claims"] = final.transparency_report.agreement_map.disputed_claims
-    elif parsed.intent == UserIntent.EXPLAIN_REASONING:
-        response["response_mode"] = "explain"
-    elif parsed.intent == UserIntent.SOURCES and head_outputs:
-        response["sources"] = extract_sources_from_head_outputs(head_outputs)
-    return response
+        prompt = body.get("prompt", "")
+        parsed = parse_user_input(prompt)
+
+        if not prompt or not parsed.cleaned_prompt.strip():
+            if parsed.intent in (UserIntent.SHOW_DISSENT, UserIntent.RERUN_RISK, UserIntent.EXPLAIN_REASONING, UserIntent.SOURCES):
+                hist = sess.get("history", [])
+                if hist:
+                    prompt = hist[-1].get("prompt", "")
+                if not prompt:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=error_response(ErrorCode.PROMPT_EMPTY, "No previous prompt; provide a prompt for this command"),
+                    )
+            else:
+                raise HTTPException(
+                    status_code=400,
+                    detail=error_response(ErrorCode.PROMPT_EMPTY),
+                )
+
+        effective_prompt = parsed.cleaned_prompt.strip() or prompt
+        pipeline = get_safety_pipeline()
+        if pipeline:
+            pre_result = pipeline.pre_check(effective_prompt)
+            if not pre_result.allowed:
+                raise HTTPException(
+                    status_code=400,
+                    detail=error_response(ErrorCode.INPUT_INVALID, pre_result.reason or "Input moderation failed"),
+                )
+
+        task_id = orch.submit_task(goal=effective_prompt[:200])
+
+        # Dynamic head selection
+        head_ids = select_heads_for_complexity(effective_prompt)
+        if parsed.intent.value == "head_strategy" and parsed.head_id:
+            head_ids = [parsed.head_id]
+
+        force_second = parsed.intent == UserIntent.RERUN_RISK
+        return_heads = parsed.intent == UserIntent.SOURCES
+
+        result = run_dvadasa(
+            orchestrator=orch,
+            task_id=task_id,
+            user_prompt=effective_prompt,
+            parsed=parsed,
+            head_ids=head_ids if parsed.intent.value != "normal" or body.get("use_all_heads") else None,
+            event_bus=bus,
+            force_second_pass=force_second,
+            return_head_outputs=return_heads,
+        )
+
+        if return_heads and isinstance(result, tuple):
+            final, head_outputs = result
+        else:
+            final = result  # type: ignore[assignment]
+            head_outputs = []
+
+        if not final:
+            raise HTTPException(
+                status_code=500,
+                detail=error_response(ErrorCode.ORCHESTRATOR_TIMEOUT),
+            )
+
+        if pipeline:
+            post_result = pipeline.post_check(final.final_answer)
+            if not post_result.passed:
+                raise HTTPException(
+                    status_code=400,
+                    detail=error_response(ErrorCode.GOVERNANCE_DENIED, f"Output scan failed: {', '.join(post_result.flags)}"),
+                )
+
+        entry = {
+            "prompt": effective_prompt,
+            "final_answer": final.final_answer,
+            "confidence_score": final.confidence_score,
+            "head_contributions": final.head_contributions,
+        }
+        store.append_history(session_id, entry)
+        record_audit_event(
+            "prompt.submit",
+            resource_type="session",
+            resource_id=session_id,
+            details={"prompt_length": len(effective_prompt), "confidence": final.confidence_score},
+        )
+
+        response: dict[str, Any] = {
+            "task_id": task_id,
+            "final_answer": final.final_answer,
+            "transparency_report": final.transparency_report.model_dump(),
+            "head_contributions": final.head_contributions,
+            "confidence_score": final.confidence_score,
+        }
+        if parsed.intent == UserIntent.SHOW_DISSENT:
+            response["response_mode"] = "show_dissent"
+            response["disputed_claims"] = final.transparency_report.agreement_map.disputed_claims
+        elif parsed.intent == UserIntent.EXPLAIN_REASONING:
+            response["response_mode"] = "explain"
+        elif parsed.intent == UserIntent.SOURCES and head_outputs:
+            response["sources"] = extract_sources_from_head_outputs(head_outputs)
+        return response
 
 
 @router.websocket("/{session_id}/stream")