M25: expose provenance-aware knowledge statistics

backend/app/api/routers/knowledge.py

@@ -100,6 +100,30 @@ def record_feedback(
 @router.get("/status", response_model=KnowledgeHealth)
 def knowledge_status(
     language: SupportedLanguage = "en-GB",
+    db: Session = Depends(get_db),
     _user: CurrentUser = Depends(get_current_user),
 ) -> KnowledgeHealth:
-    return get_knowledge_provider().health(language)
+    health = get_knowledge_provider().health(language)
+    if health.provider != "ragcore":
+        return health
+
+    latest_sync = db.scalar(
+        select(AuditEvent)
+        .where(AuditEvent.action == "n8n_procedures_synced")
+        .order_by(AuditEvent.occurred_at.desc())
+        .limit(1)
+    )
+    if latest_sync is None:
+        return health
+
+    reported = latest_sync.after_json or {}
+    synced = reported.get("synced")
+    failed = reported.get("failed")
+    return health.model_copy(
+        update={
+            "reported_synced_document_count": synced if isinstance(synced, int) else None,
+            "reported_failed_document_count": failed if isinstance(failed, int) else None,
+            "last_sync_at": latest_sync.occurred_at,
+            "statistics_state": "sync_reported",
+        }
+    )

backend/app/services/knowledge/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 from functools import lru_cache
 from typing import Literal, Protocol
 
@@ -8,6 +9,7 @@ from pydantic import BaseModel
 from app.core.config import get_settings
 
 EvidenceState = Literal["grounded", "insufficient", "unavailable"]
+KnowledgeStatisticsState = Literal["verified", "sync_reported", "not_reported"]
 
 
 class SourceCard(BaseModel):
@@ -36,6 +38,11 @@ class KnowledgeHealth(BaseModel):
     # A provider may be healthy without exposing a corpus-size endpoint. `None` means
     # unknown, never "zero procedures".
     document_count: int | None
+    source_document_count: int
+    reported_synced_document_count: int | None
+    reported_failed_document_count: int | None
+    last_sync_at: datetime | None
+    statistics_state: KnowledgeStatisticsState
 
 
 class KnowledgeProvider(Protocol):

backend/app/services/knowledge/demo.py

@@ -322,6 +322,11 @@ class DemoKnowledgeProvider:
             workspace=self._settings.ragcore_workspace,
             collection=self._settings.ragcore_collection,
             document_count=self._document_count_by_language[language],
+            source_document_count=self._document_count_by_language[language],
+            reported_synced_document_count=None,
+            reported_failed_document_count=None,
+            last_sync_at=None,
+            statistics_state="verified",
         )
 
     def _score(

backend/app/services/knowledge/ragcore.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+from pathlib import Path
+
 import httpx
 
 from app.core.config import get_settings
 from app.services.knowledge import EvidenceState, GroundedAnswer, KnowledgeHealth, SourceCard
+from app.services.knowledge.procedures import iter_procedure_documents
 
 _GROUNDED_ANSWERABILITY = {"answerable", "partially_answerable"}
 
@@ -140,6 +143,10 @@ class RAGcoreKnowledgeProvider:
         except (httpx.HTTPError, ValueError) as exc:
             available = False
             detail = f"RAGcore unavailable: {type(exc).__name__}: {exc}"
+        source_document_count = sum(
+            document.language == language
+            for document in iter_procedure_documents(Path(self._settings.knowledge_dir))
+        )
         return KnowledgeHealth(
             provider=self.name,
             available=available,
@@ -150,6 +157,11 @@ class RAGcoreKnowledgeProvider:
             # RAGcore's retrieval API has no corpus-size endpoint. Unknown is explicit
             # so the UI never turns this into the misleading claim "0 procedures".
             document_count=None,
+            source_document_count=source_document_count,
+            reported_synced_document_count=None,
+            reported_failed_document_count=None,
+            last_sync_at=None,
+            statistics_state="not_reported",
         )
 
     def ask(self, question: str, correlation_id: str, language: str = "en-GB") -> GroundedAnswer: