회기 집계와 기록 복귀 및 감독 근거 링크 수정

apps/api/app/services/supervision_research_producer.py

@@ -81,7 +81,7 @@ def _signal_id(*parts: object) -> str:
 
 
 def _route(session_id: object) -> str:
-    return f"/teacher/sessions/{session_id}"
+    return f"/teach/session/{session_id}/review"
 
 
 def _pointer(
@@ -94,7 +94,7 @@ def _pointer(
         ledger=ledger,
         event_id=str(event_id),
         session_id=str(session_id) if session_id else None,
-        route_hint=_route(session_id) if session_id else "/teacher/dashboard",
+        route_hint=_route(session_id) if session_id else "/teach",
     )
 
 

apps/api/app/session_dashboard_projection.py

@@ -301,10 +301,15 @@ def dashboard_achievements(
     sessions: list[InProcSession],
     review_ready: dict[str, bool],
 ) -> list[LearnerDashboardAchievement]:
-    completed = sum(1 for sess in sessions if sess.ended)
+    practice_sessions = [
+        sess
+        for sess in sessions
+        if any(turn.speaker in ("counselor", "learner") for turn in sess.turns)
+    ]
+    completed = sum(1 for sess in practice_sessions if sess.ended)
     active = sum(1 for sess in sessions if not sess.ended)
     review_count = sum(1 for ready in review_ready.values() if ready)
-    by_persona = Counter(sess.persona_code for sess in sessions)
+    by_persona = Counter(sess.persona_code for sess in practice_sessions)
     max_persona_sessions = max(by_persona.values(), default=0)
     persona_coverage = len(by_persona)
     return [

apps/api/app/test_dashboard_projection_tdd.py

@@ -6,8 +6,9 @@ from uuid import uuid4
 
 from app.deps import Principal, Role
 from app.services import session_metrics, state_machine
-from app.services.persona import P1, P2
+from app.services.persona import P1, P2, P3
 from app.session_dashboard_projection import (
+    dashboard_achievements,
     dashboard_overview,
     dashboard_persona_progress,
     dashboard_training_exposure,
@@ -23,7 +24,7 @@ def _make_session(
     ended: bool = True,
     turns: list[TurnRecord] | None = None,
 ) -> InProcSession:
-    persona = {P1.code: P1, P2.code: P2}.get(persona_code, P1)
+    persona = {P1.code: P1, P2.code: P2, P3.code: P3}.get(persona_code, P1)
     state = state_machine.init_state(params=persona.openness_params())
     state.stage = state_machine.Stage.EXPLORE
     sess = InProcSession(
@@ -118,6 +119,121 @@ class DashboardProjectionTDDTests(unittest.TestCase):
         self.assertEqual(p2_row.sessions, 1)
         self.assertEqual(p2_row.completed_sessions, 1)
 
+    def test_achievements_ignore_zero_turn_ended_sessions(self) -> None:
+        """무발화 종료 회기는 성취를 열지 않는다."""
+        learner_id = "00000000-0000-0000-0000-000000000111"
+        zero_turn = _make_session("sess-zero", 1, learner_id, ended=True, turns=[])
+
+        achievements = {
+            item.id: item
+            for item in dashboard_achievements(
+                [zero_turn],
+                {},
+            )
+        }
+
+        self.assertEqual(achievements["first_session_complete"].state, "locked")
+        self.assertEqual(achievements["review_ready"].state, "locked")
+        self.assertEqual(achievements["review_ready"].detail, "현재 리뷰 가능한 회기 0건입니다.")
+
+    def test_achievements_ignore_zero_turn_repeat_and_coverage(self) -> None:
+        """무발화 회기는 반복 및 페르소나 연습 기록으로 집계하지 않는다."""
+        learner_id = "00000000-0000-0000-0000-000000000111"
+        zero_turns = [
+            _make_session(
+                "sess-zero-1", 1, learner_id, ended=True, turns=[]
+            ),
+            _make_session(
+                "sess-zero-2", 2, learner_id, persona_code="P2", ended=True, turns=[]
+            ),
+            _make_session(
+                "sess-zero-3", 3, learner_id, persona_code="P3", ended=True, turns=[]
+            ),
+        ]
+
+        achievements = {
+            item.id: item
+            for item in dashboard_achievements(zero_turns, {})
+        }
+
+        self.assertEqual(achievements["persona_repeat"].state, "locked")
+        self.assertEqual(achievements["persona_coverage"].state, "locked")
+
+    def test_achievements_ignore_client_only_ended_session(self) -> None:
+        """내담자 발화만 있는 종료 회기는 학습 성취를 만들지 않는다."""
+        learner_id = "00000000-0000-0000-0000-000000000111"
+        client_only = _make_session("sess-client-only", 1, learner_id, ended=True)
+        client_only.turns[0].speaker = "client"
+
+        achievements = {
+            item.id: item
+            for item in dashboard_achievements(
+                [client_only],
+                {},
+            )
+        }
+
+        self.assertEqual(achievements["first_session_complete"].state, "locked")
+        self.assertEqual(achievements["review_ready"].state, "locked")
+        self.assertEqual(achievements["persona_repeat"].state, "locked")
+
+    def test_achievements_keep_dialogue_sessions_and_active_progress(self) -> None:
+        """학습자 발화와 진행 중 회기의 기존 성취 흐름을 유지한다."""
+        learner_id = "00000000-0000-0000-0000-000000000111"
+        completed = [
+            _make_session(f"sess-p1-{index}", index, learner_id, ended=True)
+            for index in range(1, 4)
+        ]
+        completed.extend(
+            [
+                _make_session("sess-p2", 4, learner_id, persona_code="P2", ended=True),
+                _make_session("sess-p3", 5, learner_id, persona_code="P3", ended=True),
+            ]
+        )
+        active = _make_session("sess-active", 6, learner_id, ended=False)
+
+        achievements = {
+            item.id: item
+            for item in dashboard_achievements(
+                [*completed, active],
+                {completed[0].session_id: True},
+            )
+        }
+
+        self.assertEqual(achievements["first_session_complete"].state, "done")
+        self.assertEqual(achievements["review_ready"].state, "done")
+        self.assertEqual(achievements["persona_repeat"].state, "done")
+        self.assertEqual(achievements["persona_coverage"].state, "done")
+
+        active_only = {
+            item.id: item
+            for item in dashboard_achievements([active], {})
+        }
+        self.assertEqual(active_only["first_session_complete"].state, "available")
+        self.assertEqual(active_only["persona_repeat"].state, "available")
+
+        learner_alias = _make_session("sess-learner", 7, learner_id, ended=True)
+        learner_alias.turns[0].speaker = "learner"
+        learner_alias_achievements = {
+            item.id: item
+            for item in dashboard_achievements(
+                [learner_alias],
+                {learner_alias.session_id: True},
+            )
+        }
+        self.assertEqual(learner_alias_achievements["first_session_complete"].state, "done")
+        self.assertEqual(learner_alias_achievements["review_ready"].state, "done")
+
+        empty_active = _make_session(
+            "sess-empty-active", 8, learner_id, ended=False, turns=[]
+        )
+        empty_active_achievements = {
+            item.id: item
+            for item in dashboard_achievements([empty_active], {})
+        }
+        self.assertEqual(empty_active_achievements["first_session_complete"].state, "available")
+        self.assertEqual(empty_active_achievements["persona_repeat"].state, "locked")
+
 
 class TeacherDashboardProjectionTDDTests(unittest.IsolatedAsyncioTestCase):
     """Teacher dashboard projection alignment for zero-turn sessions."""
@@ -212,4 +328,3 @@ class TeacherDashboardProjectionTDDTests(unittest.IsolatedAsyncioTestCase):
             1,
             "Teacher learner analysis summary.ended_sessions must exclude 0-turn ended sessions",
         )
-

apps/api/app/test_supervision_research_producer.py

@@ -225,6 +225,66 @@ class SupervisionResearchProducerDerivationTest(TestCase):
         serialized = str([item.signal.model_dump(mode="json") for item in derived])
         self.assertNotIn("transcript", serialized.lower())
 
+    def test_produced_pointer_uses_canonical_session_review_route(self) -> None:
+        """세션이 있는 생산 신호는 교수자 세션 리뷰 경로를 가리킨다."""
+        derived = derive_attention_signals(
+            trajectory_rows=[
+                {
+                    "learner_id": LEARNER_A,
+                    "revision_id": UUID("20000000-0000-0000-0000-000000000003"),
+                    "anchor_session_id": SESSION_A,
+                    "revision_no": 1,
+                    "assessment": {
+                        "sessions": [
+                            {
+                                "session_no": 1,
+                                "status": "off_track",
+                                "axes": [{"uncertainty": 0.2}],
+                            }
+                        ]
+                    },
+                }
+            ],
+            rupture_rows=[],
+            calibration_rows=[],
+            transfer_rows=[],
+            practice_rows=[],
+        )
+
+        self.assertEqual(len(derived), 1)
+        self.assertEqual(
+            derived[0].signal.evidence[0].route_hint,
+            f"/teach/session/{SESSION_A}/review",
+        )
+
+    def test_produced_pointer_without_session_falls_back_to_teach(self) -> None:
+        """세션 없는 생산 신호는 교수자 첫 화면으로 안전하게 돌아간다."""
+        derived = derive_attention_signals(
+            trajectory_rows=[],
+            rupture_rows=[],
+            calibration_rows=[],
+            transfer_rows=[
+                {
+                    "learner_id": LEARNER_A,
+                    "competency_id": "competency.empathy",
+                    "transfer_assessment_id": UUID(
+                        "50000000-0000-0000-0000-000000000003"
+                    ),
+                    "session_id": None,
+                    "assessment_payload": {
+                        "eligible": True,
+                        "transfer_verified": False,
+                        "error_interval": {"lower": 0.1, "upper": 0.3},
+                    },
+                    "observed_sequence": 1,
+                }
+            ],
+            practice_rows=[],
+        )
+
+        self.assertEqual(len(derived), 1)
+        self.assertEqual(derived[0].signal.evidence[0].route_hint, "/teach")
+
     def test_requires_repeated_overconfidence_and_retry_for_persistent_signals(
         self,
     ) -> None: