lct-20: АРМ диспетчера ДДС и цепочка 112 → ДДС

Возврат карточки — самая ценная механика цепочки: неполнота КИО
перестаёт быть процентом в отчёте и становится сорванным выездом
с конкретной причиной. В разборе это отметка E6: «не заполнено floor,
victims_count — выезд сорван».

Снимок карточки не меняется после передачи: оператор не дописывает
задним числом поле, которое забыл. Тест правит карточку после передачи
и проверяет, что в снимке этого нет.

Диспетчер садится за АРМ, когда вызов уже идёт, — станция, подключённая
после передачи, всё равно получает карточку.

У станции нет аудио вообще: ни VAD, ни распознавания, ни синтеза.

backend/app/api/ws/call.py

@@ -120,6 +120,9 @@ async def _handle(session_id: UUID, state, event) -> None:
         case "dds.dispatch":
             state.on_event("dds.dispatch")
             state.dispatch(event.service.value)
+            # Карточка замораживается снимком и уходит диспетчеру: оператор
+            # не должен иметь возможности дописать поле задним числом.
+            hub.to_station(session_id, state.card_received_event())
             hub.to_observers(session_id, KioState(kio=state.kio))
             hub.to_observers(session_id, TimerTick(timers=state.timers.snapshot()))
 

backend/app/api/ws/station.py

@@ -0,0 +1,89 @@
+"""Сокет диспетчера ДДС.
+
+**Только JSON: аудио здесь нет вообще** — значит, нет ни VAD, ни распознавания,
+ни синтеза. Голосовой контур станция не трогает (docs/arch/CONTRACT.md).
+
+Самая ценная механика цепочки — `card.bounce`: диспетчер видит, что не указан
+этаж, и отбивает карточку обратно. Неполнота КИО перестаёт быть процентом
+в отчёте и становится сорванным выездом с конкретной причиной.
+"""
+
+import asyncio
+import logging
+from uuid import UUID
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from pydantic import TypeAdapter, ValidationError
+
+from app.domain.events import ErrorEvent, ErrorKind, StationToServer
+from app.session.hub import hub
+from app.session.state import now_utc
+
+log = logging.getLogger(__name__)
+router = APIRouter()
+
+_adapter = TypeAdapter(StationToServer)
+
+
+async def _handle(session_id: UUID, state, event) -> None:
+    match event.type:
+        case "card.ack":
+            state.on_event("card.ack")
+            state.dds_log.append(("card.ack", now_utc(), None))
+        case "card.bounce":
+            # Карточка вернулась: в разборе это E6 с конкретной причиной.
+            state.bounced_fields = list(event.missing_fields)
+            state.dds_log.append(("card.bounce", now_utc(), event.comment))
+        case "zone.decision":
+            state.on_event("zone.decision")
+            state.dds_log.append(("zone.decision", now_utc(), "в зоне" if event.in_zone else "не в зоне"))
+        case "crew.dispatched":
+            state.kio = state.kio.model_copy(update={"dispatch_order_at": event.at})
+            state.dds_log.append(("crew.dispatched", now_utc(), None))
+        case "crew.arrived":
+            state.on_event("crew.arrived")
+            state.kio = state.kio.model_copy(update={"arrival_at": event.at})
+            state.dds_log.append(("crew.arrived", now_utc(), None))
+    hub.to_observers(session_id, state.snapshot())
+
+
+async def _pump(ws: WebSocket, queue: asyncio.Queue) -> None:
+    while True:
+        event = await queue.get()
+        await ws.send_text(event.model_dump_json())
+
+
+@router.websocket("/ws/station/{session_id}")
+async def station(ws: WebSocket, session_id: UUID, role: str = "dds") -> None:
+    await ws.accept()
+
+    state = hub.get(session_id)
+    if state is None:
+        await ws.send_text(
+            ErrorEvent(code=ErrorKind.SESSION_NOT_FOUND, message="Занятие не запущено").model_dump_json()
+        )
+        await ws.close()
+        return
+
+    with hub.station(session_id) as queue:
+        sender = asyncio.create_task(_pump(ws, queue))
+        try:
+            # Карточка, переданная до подключения станции, не теряется:
+            # диспетчер садится за АРМ, когда вызов уже идёт.
+            if state.dispatched_card is not None:
+                hub.to_station(session_id, state.card_received_event())
+            while True:
+                payload = await ws.receive_json()
+                try:
+                    event = _adapter.validate_python(payload)
+                except ValidationError:
+                    hub.to_station(
+                        session_id,
+                        ErrorEvent(code=ErrorKind.UNSUPPORTED_EVENT, message=str(payload)[:200]),
+                    )
+                    continue
+                await _handle(session_id, state, event)
+        except WebSocketDisconnect:
+            return
+        finally:
+            sender.cancel()

backend/app/main.py

@@ -13,6 +13,7 @@ from app.api.http import trainees
 from app.api.ws import call as call_ws
 from app.api.ws import control as control_ws
 from app.api.ws import observe as observe_ws
+from app.api.ws import station as station_ws
 from app.config import get_settings
 from app.db.base import get_sessionmaker
 from app.dialog.runtime import get_embedder
@@ -65,6 +66,7 @@ app.include_router(trainees.router)
 app.include_router(call_ws.router)
 app.include_router(observe_ws.router)
 app.include_router(control_ws.router)
+app.include_router(station_ws.router)
 
 
 @app.get("/api/health")

backend/app/scoring/gost.py

@@ -18,6 +18,7 @@ from app.scoring.taxonomy import METRIC_MAP, METRIC_WEIGHTS
 from app.session.timers import SessionTimers
 
 SOURCE_BY_CODE = {
+    "E6": FindingSource.CHAIN,
     "E1": FindingSource.SLOTS,
     "E2": FindingSource.GROUND_TRUTH,
     "E3": FindingSource.TIMERS,
@@ -110,6 +111,7 @@ def evaluate(
     timers: SessionTimers,
     revealed_facts: list[str] | None,
     end_reason: CallEndReason | None = None,
+    bounced_fields: list[str] | None = None,
 ) -> GostResult:
     """Посчитать детерминированный слой по завершённому занятию.
 
@@ -230,4 +232,15 @@ def evaluate(
             finding=f"Не заполнены обязательные поля: {', '.join(empty)}" if empty else None,
         )
 
+    # ── цепочка 112 → ДДС, E6 ──
+    if bounced_fields:
+        build.add(
+            "dds_chain", "Карточка принята ДДС",
+            f"возвращена на уточнение: {', '.join(bounced_fields)}",
+            "карточка пригодна для выезда",
+            passed=False,
+            ref="цепочка 112 → ДДС",
+            finding=f"Диспетчер вернул карточку: не заполнено {', '.join(bounced_fields)} — выезд сорван",
+        )
+
     return build.result

backend/app/scoring/taxonomy.py

@@ -9,6 +9,7 @@ from app.domain.taxonomy import Competency, ErrorCode
 #: Метрика → (код ошибки при провале, компетенция радара).
 METRIC_MAP: dict[str, tuple[ErrorCode, Competency]] = {
     "answer_time": (ErrorCode.E3, Competency.INTAKE),
+    "dds_chain": (ErrorCode.E6, Competency.CARD),
     "callback": (ErrorCode.E3, Competency.INTAKE),
     "checklist_completeness": (ErrorCode.E1, Competency.INTERVIEW),
     "interview_time": (ErrorCode.E3, Competency.NORMS),
@@ -36,6 +37,7 @@ METRIC_WEIGHTS: dict[str, float] = {
     "victims_count": 1.0,
     "answer_time": 1.0,
     "callback": 1.0,
+    "dds_chain": 2.0,
 }
 
 #: Вес детерминированного слоя в итоговой оценке. Остальное — LLM-судья

backend/app/session/finish.py

@@ -32,6 +32,7 @@ async def finish(session_id: UUID, state) -> None:
         timers=state.timers,
         revealed_facts=[fact.id for fact in state.slots.revealed_facts()] if state.slots else None,
         end_reason=state.end_reason,
+        bounced_fields=state.bounced_fields,
     )
     # Сводка числами: по ней считается дельта между попытками в профиле.
     # Вытаскивать её разбором текста метрик («94 с») — путь к тихим ошибкам.

backend/app/session/hub.py

@@ -45,6 +45,7 @@ class SessionHub:
         self._sessions: dict[UUID, SessionState] = {}
         self._observers: dict[UUID, set[asyncio.Queue]] = {}
         self._trainees: dict[UUID, set[asyncio.Queue]] = {}
+        self._stations: dict[UUID, set[asyncio.Queue]] = {}
         self._tickers: dict[UUID, asyncio.Task] = {}
 
     # ── реестр ──
@@ -77,6 +78,9 @@ class SessionHub:
     def trainee(self, session_id: UUID):
         return self._subscribe(self._trainees, session_id)
 
+    def station(self, session_id: UUID):
+        return self._subscribe(self._stations, session_id)
+
     # ── вещание ──
 
     @staticmethod
@@ -93,6 +97,9 @@ class SessionHub:
     def to_trainee(self, session_id: UUID, event: BaseModel | bytes) -> None:
         self._put(self._trainees.get(session_id, set()), event)
 
+    def to_station(self, session_id: UUID, event: BaseModel) -> None:
+        self._put(self._stations.get(session_id, set()), event)
+
     def broadcast(self, session_id: UUID, event: BaseModel) -> None:
         self.to_trainee(session_id, event)
         self.to_observers(session_id, event)

backend/app/session/state.py

@@ -77,6 +77,10 @@ class SessionState:
     ended_at: datetime | None = None
     end_reason: CallEndReason | None = None
     dispatched_card: KIO | None = None
+    dispatched_at: datetime | None = None
+    #: Поля, из-за которых диспетчер вернул карточку, — основание E6.
+    bounced_fields: list[str] = field(default_factory=list)
+    dds_log: list[tuple[str, datetime, str | None]] = field(default_factory=list)
 
     def on_event(self, event_type: str) -> None:
         """Единственная точка, где событие двигает таймеры."""
@@ -102,8 +106,19 @@ class SessionState:
         возможности дописать задним числом поле, которое забыл."""
         self.kio = apply_patch(self.kio, {"dds": service, "response_status": "transferred"})
         self.dispatched_card = self.kio.model_copy(deep=True)
+        self.dispatched_at = now_utc()
         return self.dispatched_card
 
+    def card_received_event(self):
+        """Снимок карточки для станции ДДС."""
+        from app.domain.events import CardReceived
+
+        return CardReceived(
+            card=self.dispatched_card,
+            from_operator=self.trainee_name or "оператор 112",
+            at=self.dispatched_at or now_utc(),
+        )
+
     @property
     def ended(self) -> bool:
         return self.ended_at is not None