============================= test session starts ==============================
platform darwin -- Python 3.10.11, pytest-9.0.2, pluggy-1.6.0 -- /Users/kimjaeheung/Desktop/Desktop/Dev/project9_cortex_mcp/.venv310/bin/python3.10
cachedir: .pytest_cache
rootdir: /Users/kimjaeheung/Desktop/Desktop/Dev/project9_cortex_mcp/cortex_mcp
configfile: pyproject.toml
plugins: anyio-4.12.0, asyncio-1.3.0, cov-7.0.0
asyncio: mode=auto, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collecting ... collected 780 items

<Package cortex_mcp>
  <Package tests>
    <Dir e2e>
      <Module test_needle_in_haystack.py>
        Cortex MCP - Needle in a Haystack 테스트
        RAG 검색 정확도 100% 검증 (QA 기준)
        <Class TestNeedleInHaystack>
          Needle in a Haystack 테스트
          
          목표: 5단계 깊이 폴더에 숨긴 정보 100% 회수
          QA 기준: RAG 검색 정확도 100%
          <Function test_find_secret_code>
            비밀 코드 검색
          <Function test_find_secret_location>
            비밀 위치 검색
          <Function test_find_secret_password>
            비밀 비밀번호 검색
          <Function test_find_api_key>
            API 키 검색
          <Function test_find_secret_meeting>
            비밀 회의 검색
          <Function test_100_percent_recall>
            100% 회수율 테스트
            모든 니들이 검색 가능해야 함
        <Class TestDeepHierarchySearch>
          깊은 계층 구조에서의 검색 테스트
          <Function test_search_in_deep_branches>
            5단계 깊이 브랜치에서 검색
      <Module test_phase_c_lazy_resolve.py>
        Phase C Lazy Semantic Resolution E2E 테스트
        
        테스트 시나리오:
        1. initialize_context (FULL 모드) - Context Graph 생성 (모든 노드 SHALLOW)
        2. search_context - 결과 없음 (RAG DB 비어있음)
        3. Phase C 자동 트리거 - SHALLOW → DEEP + RAG 인덱싱
        4. 재검색 - 결과 있음 (RAG DB에서 검색 성공)
        
        이 테스트는 전체 워크플로우가 정상 작동하는지 검증합니다.
        <Class TestPhaseCLazyResolve>
          Phase C Lazy Semantic Resolution E2E 테스트
          <Function test_end_to_end_workflow>
            E2E 워크플로우 테스트: initialize → search (empty) → Phase C → search (success)
          <Function test_phase_c_auto_trigger_via_search>
            Phase C 자동 트리거 테스트 (search_context 내부 로직)
            
            이 테스트는 cortex_tools.py의 search_context 핸들러가
            자동으로 Phase C를 트리거하는지 검증합니다.
            
            주의: 이 테스트는 실제 MCP 서버를 실행하지 않고,
            핸들러 로직을 직접 호출하는 방식으로 진행합니다.
      <Module test_token_savings.py>
        Cortex MCP - Smart Context 토큰 절감율 E2E 테스트
        
        QA 기준: 70% 토큰 절감율
        <Class TestTokenSavings>
          Smart Context 토큰 절감율 테스트
          
          목표: 70% 이상의 토큰 절감율 (압축 후)
          
          테스트 시나리오:
          1. 여러 크기의 맥락 파일 생성 (소/중/대)
          2. 압축 전 토큰 수 측정 (full_content)
          3. Smart Context 압축 적용 (metadata + summary만 유지)
          4. 압축 후 토큰 수 측정 (metadata + summary)
          5. 절감율 = (압축 전 - 압축 후) / 압축 전 * 100
          <Function test_smart_context_compression>
            Smart Context 압축 기능 테스트
            
            압축 전후 토큰 수를 비교하여 절감율 측정
          <Function test_lazy_loading_efficiency>
            Lazy Loading 효율성 테스트
            
            필요한 맥락만 로드하여 토큰 사용량 최소화
        <Class TestCompressionQuality>
          압축 품질 테스트 (Zero-Loss 원칙 검증)
          <Function test_compression_preserves_summary>
            압축 후에도 핵심 요약이 유지되는지 검증
            
            Zero-Loss 원칙: 압축은 하되, 사실은 지워지면 안 된다.
    <Dir functional>
      <Module test_mcp_tools.py>
        Cortex MCP - MCP Tools 기능 테스트
        모든 MCP 도구의 기능 검증
        <Class TestInitializeContext>
          initialize_context 도구 테스트
          <Function test_initialize_full_mode>
            FULL 모드 초기화
          <Function test_initialize_light_mode>
            LIGHT 모드 초기화
          <Function test_initialize_none_mode>
            NONE 모드 초기화
        <Class TestCreateBranch>
          create_branch 도구 테스트
          <Function test_create_branch_basic>
            기본 브랜치 생성
          <Function test_create_branch_with_parent>
            부모 브랜치 지정 생성
        <Class TestSearchContext>
          search_context 도구 테스트
          <Function test_search_basic>
            기본 검색
          <Function test_search_with_top_k>
            top_k 지정 검색
        <Class TestUpdateMemory>
          update_memory 도구 테스트
          <Function test_update_memory_user>
            사용자 메시지 업데이트
          <Function test_update_memory_assistant>
            어시스턴트 메시지 업데이트
        <Class TestGetActiveSummary>
          get_active_summary 도구 테스트
          <Function test_get_summary_basic>
            기본 요약 조회
        <Class TestLoadContext>
          load_context 도구 테스트
          <Function test_load_context_basic>
            컨텍스트 로드
        <Class TestSuggestContexts>
          suggest_contexts 도구 테스트
          <Function test_suggest_basic>
            기본 추천
        <Class TestCreateNode>
          create_node 도구 테스트
          <Function test_create_node_basic>
            노드 생성
        <Class TestLinkGitBranch>
          link_git_branch 도구 테스트
          <Function test_link_branch>
            Git 브랜치 연동
        <Class TestDashboard>
          get_dashboard_url 도구 테스트
          <Function test_get_dashboard_url>
            대시보드 URL 조회
        <Class TestSnapshotTools>
          스냅샷 도구 테스트
          <Function test_create_snapshot>
            스냅샷 생성
          <Function test_list_snapshots>
            스냅샷 목록
          <Function test_restore_snapshot>
            스냅샷 복원
        <Class TestAutomationTools>
          자동화 도구 테스트
          <Function test_get_automation_status>
            자동화 상태 조회
          <Function test_record_feedback>
            피드백 기록
          <Function test_should_confirm>
            확인 필요 여부
          <Function test_set_mode>
            모드 설정
        <Class TestCloudSync>
          클라우드 동기화 도구 테스트
          <Function test_sync_to_cloud>
            클라우드 업로드 (Mock)
          <Function test_sync_from_cloud>
            클라우드 다운로드 (Mock)
        <Class TestBackupHistory>
          백업 히스토리 도구 테스트
          <Function test_get_backup_history>
            백업 히스토리 조회
      <Module test_plan_ab_system.py>
        Cortex MCP - Plan A/B 시스템 기능 테스트
        자동화 모드 전환 및 피드백 시스템 검증
        <Class TestPlanAOperations>
          Plan A (자동 모드) 기능 테스트
          <Function test_plan_a_no_confirmation>
            Plan A: 확인 없이 자동 실행
          <Function test_plan_a_auto_branch_creation>
            Plan A: 자동 브랜치 생성
          <Function test_plan_a_auto_context_load>
            Plan A: 자동 컨텍스트 로드
        <Class TestPlanBOperations>
          Plan B (반자동 모드) 기능 테스트
          <Function test_plan_b_requires_confirmation>
            Plan B: 확인 필요
          <Function test_plan_b_preview_action>
            Plan B: 작업 미리보기
        <Class TestModeTransition>
          모드 전환 테스트
          <Function test_transition_to_plan_b_on_rejections>
            거부율 30%+ 시 Plan B 전환
          <Function test_transition_back_to_plan_a>
            거부율 15% 이하 시 Plan A 복귀
        <Class TestFeedbackSystem>
          피드백 시스템 테스트
          <Function test_feedback_types>
            피드백 유형 검증
          <Function test_feedback_statistics>
            피드백 통계
          <Function test_action_type_statistics>
            액션 타입별 통계
        <Class TestAutoSwitchControl>
          자동 전환 제어 테스트
          <Function test_disable_auto_switch>
            자동 전환 비활성화
          <Function test_no_switch_when_disabled>
            비활성화 시 전환 안함
          <Function test_enable_auto_switch>
            자동 전환 재활성화
        <Class TestStatusAndRecommendation>
          상태 및 권장사항 테스트
          <Function test_get_status>
            상태 조회
          <Function test_recommendation_insufficient_data>
            데이터 부족 시 권장사항
          <Function test_recommendation_with_data>
            데이터 충분 시 권장사항
        <Class TestActionHistory>
          작업 히스토리 테스트
          <Function test_get_history>
            히스토리 조회
          <Function test_filtered_history>
            필터링된 히스토리
        <Class TestEdgeCases>
          경계 케이스 테스트
          <Function test_insufficient_samples_no_switch>
            샘플 부족 시 전환 안함
          <Function test_rapid_feedback_changes>
            빠른 피드백 변화
          <Function test_invalid_mode_setting>
            잘못된 모드 설정
    <Dir integration>
      <Module test_context_reference_integration.py>
        Cortex MCP - Context + Reference History 통합 테스트
        컨텍스트 로드/압축과 참조 이력 연동 검증
        <Class TestContextReferenceFlow>
          컨텍스트-참조 이력 연동 플로우
          <Function test_memory_update_records_reference>
            메모리 업데이트 시 참조 이력 기록 가능
          <Function test_suggest_contexts_basic>
            기본 컨텍스트 추천
        <Class TestCompressionReferenceIntegration>
          압축-참조 통합 테스트
          <Function test_compressed_context_still_referenced>
            압축된 컨텍스트도 참조 가능
          <Function test_load_after_compression>
            압축 후 로드 가능
        <Class TestMultiContextReference>
          다중 컨텍스트 참조 테스트
          <Function test_record_multiple_context_reference>
            여러 컨텍스트 동시 참조 기록
          <Function test_co_occurrence_analysis>
            동시 참조 분석
        <Class TestFeedbackContextIntegration>
          피드백-컨텍스트 통합 테스트
          <Function test_feedback_recording>
            피드백 기록
          <Function test_statistics_tracking>
            통계 추적
      <Module test_git_memory_integration.py>
        Cortex MCP - Git + Memory 통합 테스트
        Git 브랜치 연동과 메모리 관리 통합 검증
        <Class TestGitMemorySync>
          Git-메모리 동기화 테스트
          <Function test_git_branch_link_to_cortex>
            Git 브랜치와 Cortex 브랜치 연결
          <Function test_get_linked_cortex_branch>
            연결된 Cortex 브랜치 조회
        <Class TestGitBranchDetection>
          Git 브랜치 감지 테스트
          <Function test_detect_current_branch>
            현재 Git 브랜치 감지
          <Function test_get_git_info>
            Git 정보 조회
        <Class TestBranchChangeDetection>
          브랜치 변경 감지 테스트
          <Function test_check_branch_change>
            브랜치 변경 감지
        <Class TestMultiRepoProject>
          다중 저장소 프로젝트 테스트
          <Function test_list_all_linked_branches>
            연결된 브랜치 목록 조회
          <Function test_unlink_git_branch>
            Git 브랜치 연결 해제
        <Class TestBranchMergeContext>
          브랜치 병합 컨텍스트 테스트
          <Function test_merge_combines_contexts>
            브랜치 병합 시 컨텍스트 통합
          <Function test_conflict_context_preserved>
            충돌 시 양쪽 컨텍스트 보존
      <Module test_memory_rag_integration.py>
        Cortex MCP - Memory + RAG 통합 테스트
        메모리 업데이트 -> RAG 인덱싱 -> 검색 플로우 검증
        <Class TestMemoryRAGFlow>
          메모리-RAG 연동 플로우 테스트
          <Function test_memory_update_triggers_indexing>
            메모리 업데이트 시 RAG 자동 인덱싱
          <Function test_memory_search_returns_context>
            메모리 검색이 컨텍스트 반환
          <Function test_cross_branch_search>
            여러 브랜치에서 통합 검색
        <Class TestSummaryRAGIntegration>
          요약-RAG 통합 테스트
          <Function test_summary_indexed_for_search>
            요약이 검색 가능하도록 인덱싱
        <Class TestBranchMemoryConsistency>
          브랜치-메모리 일관성 테스트
          <Function test_branch_deletion_removes_contexts>
            브랜치 삭제 시 관련 컨텍스트 제거
          <Function test_hierarchy_preserved_on_update>
            업데이트 시 계층 구조 보존
      <Module test_rag_hierarchical_integration.py>
        RAG Engine - Hierarchical RAG 통합 테스트
        
        검증 사항:
        1. 기존 RAG Engine 동작 유지 (use_hierarchical=False)
        2. Hierarchical RAG 활성화 시 정상 작동 (use_hierarchical=True)
        3. Fallback 메커니즘 작동
        4. 성능 개선 확인
        <Class TestRAGEngineHierarchicalIntegration>
          RAG Engine - Hierarchical RAG 통합 테스트
          <Function test_default_rag_mode>
            기본 RAG 모드 테스트 (use_hierarchical=False)
          <Function test_hierarchical_rag_mode>
            Hierarchical RAG 모드 테스트 (use_hierarchical=True)
          <Function test_hierarchical_rag_fallback>
            Hierarchical RAG 초기화 실패 시 Fallback 테스트
          <Function test_performance_comparison>
            기존 RAG vs Hierarchical RAG 성능 비교
          <Function test_result_format_compatibility>
            기존 RAG와 Hierarchical RAG 결과 형식 호환성 테스트
    <Dir load>
      <Module test_load.py>
        Cortex MCP - 부하 테스트
        대규모 요청 처리 능력 검증
        <Class TestHighLoadScenarios>
          고부하 시나리오 테스트
          <Function test_massive_branch_creation>
            대량 브랜치 생성 (100개)
          <Function test_massive_memory_updates>
            대량 메모리 업데이트 (500개)
          <Function test_massive_indexing>
            대량 인덱싱 (500개)
        <Class TestConcurrentLoad>
          동시 접속 부하 테스트
          <Function test_concurrent_searches>
            동시 검색 부하 (50개)
          <Function test_concurrent_memory_operations>
            동시 메모리 작업 부하
        <Class TestSustainedLoad>
          지속적 부하 테스트
          <Function test_sustained_operations>
            30초 지속 부하
        <Class TestResourceLimits>
          리소스 제한 테스트
          <Function test_memory_growth>
            메모리 증가 모니터링
          <Function test_file_descriptor_limit>
            파일 디스크립터 한계
    <Dir performance>
      <Module test_memory_performance.py>
        Cortex MCP - 메모리 관리 성능 테스트
        브랜치 생성, 메모리 업데이트, 요약 생성 성능 측정
        <Class TestBranchCreationPerformance>
          브랜치 생성 성능 테스트
          <Function test_single_branch_creation>
            단일 브랜치 생성 시간 (< 50ms)
          <Function test_multiple_branch_creation>
            다중 브랜치 생성 (10개 < 500ms)
          <Function test_hierarchical_branch_creation>
            계층적 브랜치 생성
        <Class TestMemoryUpdatePerformance>
          메모리 업데이트 성능 테스트
          <Function test_single_update>
            단일 메모리 업데이트 (< 30ms)
          <Function test_batch_updates>
            배치 메모리 업데이트 (100개 < 3초)
          <Function test_large_content_update>
            대용량 콘텐츠 업데이트
        <Class TestSummaryPerformance>
          요약 생성 성능 테스트
          <Function test_get_summary_speed>
            요약 조회 속도 (< 50ms)
          <Function test_summary_update_speed>
            요약 업데이트 속도 (< 100ms)
        <Class TestHierarchyPerformance>
          계층 구조 조회 성능 테스트
          <Function test_get_hierarchy_simple>
            단순 계층 조회 (< 50ms)
          <Function test_get_hierarchy_complex>
            복잡한 계층 조회
        <Class TestNodePerformance>
          노드 관련 성능 테스트
          <Function test_create_node_speed>
            노드 생성 속도 (< 30ms)
          <Function test_list_nodes_speed>
            노드 목록 조회 속도
        <Class TestConcurrentMemoryOperations>
          동시 메모리 작업 테스트
          <Function test_concurrent_updates>
            동시 업데이트 처리
      <Module test_rag_performance.py>
        Cortex MCP - RAG 성능 테스트
        검색 속도, 인덱싱 속도, 메모리 사용량 측정
        <Class TestRAGSearchPerformance>
          RAG 검색 성능 테스트
          <Function test_search_response_time_small>
            소규모 데이터 검색 응답 시간 (< 100ms)
          <Function test_search_response_time_medium>
            중규모 데이터 검색 응답 시간 (< 500ms)
          <Function test_search_response_time_large>
            대규모 데이터 검색 응답 시간 (< 2000ms)
        <Class TestRAGIndexingPerformance>
          RAG 인덱싱 성능 테스트
          <Function test_single_document_indexing>
            단일 문서 인덱싱 시간 (< 50ms)
          <Function test_batch_indexing_performance>
            배치 인덱싱 성능 (100개 < 2초)
        <Class TestEmbeddingPerformance>
          임베딩 생성 성능 테스트
          <Function test_embedding_generation_speed>
            임베딩 생성 속도 (< 100ms)
          <Function test_batch_embedding_speed>
            배치 임베딩 생성 (10개 < 500ms)
        <Class TestConcurrentSearch>
          동시 검색 성능 테스트
          <Function test_concurrent_searches>
            동시 검색 처리
        <Class TestMemoryUsage>
          메모리 사용량 테스트
          <Function test_memory_after_indexing>
            인덱싱 후 메모리 사용량
        <Class TestSearchAccuracy>
          검색 정확도 성능 테스트
          <Function test_top_k_relevance>
            Top-K 결과 관련성
    <Dir security>
      <Module test_access_control.py>
        Cortex MCP - 접근 제어 보안 테스트
        프로젝트 격리, 데이터 접근 제어 검증
        <Class TestProjectIsolation>
          프로젝트 격리 테스트
          <Function test_project_data_isolation>
            다른 프로젝트 데이터 격리
          <Function test_branch_isolation_within_project>
            프로젝트 내 브랜치 격리
        <Class TestUnauthorizedAccess>
          무단 접근 테스트
          <Function test_nonexistent_project_access>
            존재하지 않는 프로젝트 접근
          <Function test_nonexistent_branch_access>
            존재하지 않는 브랜치 접근
          <Function test_cross_project_snapshot_access>
            다른 프로젝트 스냅샷 접근
        <Class TestInputSanitization>
          입력 살균 테스트
          <Function test_html_sanitization>
            HTML 살균
          <Function test_special_chars_in_branch_topic>
            브랜치 주제에 특수문자
          <Function test_control_chars_removal>
            제어 문자 제거
        <Class TestRateLimiting>
          요청 제한 테스트
          <Function test_rapid_branch_creation_limit>
            빠른 브랜치 생성 제한
          <Function test_rapid_search_limit>
            빠른 검색 제한
        <Class TestDataLeakagePrevention>
          데이터 유출 방지 테스트
          <Function test_error_messages_no_sensitive_data>
            에러 메시지에 민감 정보 없음
          <Function test_search_results_no_other_project_data>
            검색 결과에 다른 프로젝트 데이터 없음
        <Class TestFileSystemSecurity>
          파일 시스템 보안 테스트
          <Function test_safe_file_path_creation>
            안전한 파일 경로 생성
          <Function test_file_permissions>
            파일 권한 확인
      <Module test_comprehensive_security.py>
        Cortex MCP - Comprehensive Security Tests
        종합 보안 테스트
        
        테스트 항목:
        - OWASP Top 10 취약점
        - 침투 테스트 시나리오
        - 데이터 유출 방지
        - 암호화 검증
        - 세션 보안
        <Class TestOWASPTop10>
          OWASP Top 10 취약점 테스트
          <Function test_a01_broken_access_control>
            A01: 취약한 접근 제어
          <Function test_a02_cryptographic_failures>
            A02: 암호화 실패
          <Function test_a03_injection>
            A03: 인젝션
          <Function test_a04_insecure_design>
            A04: 불안전한 설계
          <Function test_a05_security_misconfiguration>
            A05: 보안 설정 오류
          <Function test_a06_vulnerable_components>
            A06: 취약한 컴포넌트
          <Function test_a07_auth_failures>
            A07: 인증 실패
          <Function test_a08_data_integrity_failures>
            A08: 데이터 무결성 실패
          <Function test_a09_logging_monitoring_failures>
            A09: 로깅 및 모니터링 실패
          <Function test_a10_ssrf>
            A10: SSRF (Server-Side Request Forgery)
        <Class TestPenetrationScenarios>
          침투 테스트 시나리오
          <Function test_license_key_brute_force>
            라이센스 키 브루트포스 공격
          <Function test_session_hijacking_prevention>
            세션 하이재킹 방지
          <Function test_privilege_escalation>
            권한 상승 시도
          <Function test_data_exfiltration_prevention>
            데이터 유출 방지
        <Class TestDataLeakagePrevention>
          데이터 유출 방지 테스트
          <Function test_error_messages_no_sensitive_info>
            에러 메시지에 민감 정보 없음
          <Function test_logs_no_sensitive_data>
            로그에 민감 데이터 없음
          <Function test_memory_content_not_in_telemetry>
            메모리 내용이 텔레메트리에 포함되지 않음
        <Class TestCryptographicSecurity>
          암호화 보안 테스트
          <Function test_device_id_hash_strength>
            기기 ID 해시 강도
          <Function test_install_id_randomness>
            설치 ID 무작위성
          <Function test_license_key_randomness>
            라이센스 키 무작위성
        <Class TestRateLimitingAndDoS>
          Rate Limiting 및 DoS 방지 테스트
          <Function test_rapid_license_checks>
            빠른 라이센스 확인 시도
          <Function test_large_input_handling>
            대용량 입력 처리
          <Function test_many_devices_same_license>
            동일 라이센스에 많은 기기 바인딩 시도
      <Module test_crypto_security.py>
        Cortex MCP - 암호화 보안 테스트
        E2E 암호화, 키 관리, 데이터 보호 검증
        <Class TestEncryption>
          암호화 테스트
          <Function test_encrypt_decrypt_roundtrip>
            암호화-복호화 왕복
          <Function test_different_keys_different_output>
            다른 키는 다른 출력
          <Function test_wrong_key_decryption_fails>
            잘못된 키로 복호화 실패
          <Function test_empty_data_encryption>
            빈 데이터 암호화
          <Function test_large_data_encryption>
            대용량 데이터 암호화
          <Function test_unicode_data_encryption>
            유니코드 데이터 암호화
        <Class TestKeyManagement>
          키 관리 테스트
          <Function test_key_derivation>
            키 유도 일관성
          <Function test_weak_key_rejection>
            약한 키 거부
        <Class TestDataProtection>
          데이터 보호 테스트
          <Function test_sensitive_data_not_in_logs>
            민감 데이터가 로그에 노출되지 않음
          <Function test_memory_cleanup>
            메모리 정리
        <Class TestCloudSyncSecurity>
          클라우드 동기화 보안 테스트
          <Function test_data_encrypted_before_upload>
            업로드 전 암호화
          <Function test_license_key_validation>
            라이센스 키 검증
        <Class TestZeroTrustPrinciple>
          Zero-Trust 원칙 테스트
          <Function test_no_external_api_for_encryption>
            암호화에 외부 API 사용 안함
          <Function test_no_data_leakage_to_logs>
            로그에 데이터 유출 없음
        <Class TestIntegrityProtection>
          무결성 보호 테스트
          <Function test_tampered_data_detection>
            변조된 데이터 감지
          <Function test_checksum_verification>
            체크섬 검증
      <Module test_input_validation.py>
        Cortex MCP - 보안 테스트: 입력 검증
        SQL Injection, Path Traversal, Command Injection 등 방어 테스트
        <Class TestSQLInjection>
          SQL Injection 방어 테스트
          <Function test_branch_topic_sql_injection>
            브랜치 이름에 SQL Injection 시도
          <Function test_search_query_sql_injection>
            검색 쿼리에 SQL Injection 시도
        <Class TestPathTraversal>
          Path Traversal 방어 테스트
          <Function test_project_id_path_traversal>
            프로젝트 ID에 Path Traversal 시도
          <Function test_file_path_traversal_in_scan>
            초기 스캔 시 Path Traversal 방어
        <Class TestCommandInjection>
          Command Injection 방어 테스트
          <Function test_git_command_injection>
            Git 명령어 Injection 시도
        <Class TestXSSPrevention>
          XSS 방어 테스트 (Dashboard)
          <Function test_branch_topic_xss>
            브랜치 이름에 XSS 스크립트 삽입
          <Function test_memory_content_xss>
            메모리 내용에 XSS 스크립트 삽입
        <Class TestLargeInputHandling>
          대용량 입력 처리 테스트
          <Function test_large_content_input>
            매우 큰 내용 입력
          <Function test_many_branches_dos>
            대량 브랜치 생성 (DoS 시도)
        <Class TestSpecialCharacters>
          특수문자 처리 테스트
          <Function test_null_byte_injection>
            Null 바이트 삽입 시도
          <Function test_unicode_normalization>
            유니코드 정규화 테스트
      <Module test_license_security.py>
        Cortex MCP - License Security Tests
        라이센스 시스템 보안 테스트
        
        테스트 항목:
        - 라이센스 키 위조 방지
        - 기기 바인딩 우회 시도
        - 부정 사용 감지
        - 차단 메커니즘
        - 데이터 무결성
        <Class TestLicenseKeySecurity>
          라이센스 키 보안 테스트
          <Function test_license_key_format_validation>
            라이센스 키 형식 검증
          <Function test_license_key_uniqueness>
            라이센스 키 고유성 확인
          <Function test_license_key_entropy>
            라이센스 키 엔트로피 확인
        <Class TestDeviceBindingSecurity>
          기기 바인딩 보안 테스트
          <Function test_device_id_consistency>
            동일 기기에서 동일 ID 생성 확인
          <Function test_device_binding_prevents_sharing>
            기기 바인딩으로 공유 방지
          <Function test_device_spoofing_detection>
            기기 ID 위조 감지
        <Class TestAbuseDetection>
          부정 사용 감지 테스트
          <Function test_auto_block_after_threshold>
            임계치 초과 시 자동 차단
          <Function test_blocked_license_cannot_be_used>
            차단된 라이센스 사용 불가
        <Class TestDataIntegrity>
          데이터 무결성 테스트
          <Function test_corrupted_license_file_handling>
            손상된 라이센스 파일 처리
          <Function test_tampered_local_license_detection>
            변조된 로컬 라이센스 감지
        <Class TestExpiredLicenseSecurity>
          만료된 라이센스 보안 테스트
          <Function test_expired_license_cannot_activate>
            만료된 라이센스 활성화 불가
          <Function test_cannot_extend_expiration_locally>
            로컬에서 만료일 연장 불가
        <Class TestGitHubAuthSecurity>
          GitHub 인증 보안 테스트
          <Function test_auth_data_not_exposed_in_logs>
            인증 데이터가 로그에 노출되지 않음
          <Function test_auth_file_permissions>
            인증 파일 권한 확인
        <Class TestInputSanitization>
          입력 살균 테스트
          <Function test_sql_injection_in_email>
            이메일 필드 SQL 인젝션 방지
          <Function test_path_traversal_in_license_key>
            라이센스 키 경로 탐색 공격 방지
    <Module test_bayesian_updater.py>
      Bayesian Updater 테스트
      Phase 1: Track 1 - Product Engineering
      
      테스트 원칙:
      1. 베이지안 추론 수식 검증
      2. Prior, Likelihood, Posterior 정확도 검증
      3. Reference History 통합 검증
      4. Edge cases 처리 검증
      <Function test_calculate_prior_default>
        기본 Prior 계산 테스트
      <Function test_calculate_prior_with_history>
        Reference History 반영 Prior 계산 테스트
      <Function test_calculate_prior_with_context_history>
        Context 이력 반영 Prior 계산 테스트
      <Function test_calculate_likelihood_single_evidence>
        단일 Evidence Likelihood 계산 테스트
      <Function test_calculate_likelihood_multiple_evidence>
        다중 Evidence Likelihood 계산 테스트
      <Function test_calculate_likelihood_no_evidence>
        Evidence 없을 때 Likelihood 테스트
      <Function test_calculate_posterior_normal>
        정상 Posterior 계산 테스트
      <Function test_calculate_posterior_boundary>
        경계값 Posterior 테스트
      <Function test_determine_confidence_level>
        Confidence Level 결정 테스트
      <Function test_update_posterior_full_flow>
        전체 업데이트 플로우 테스트
      <Function test_update_posterior_with_history>
        History 반영 업데이트 테스트
      <Function test_batch_update>
        일괄 업데이트 테스트
      <Function test_get_statistics>
        통계 생성 테스트
      <Function test_get_statistics_empty>
        빈 결과 통계 테스트
      <Function test_unknown_claim_type>
        알 수 없는 Claim Type 처리 테스트
      <Function test_unknown_evidence_type>
        알 수 없는 Evidence Type 처리 테스트
      <Function test_high_evidence_count_bonus_cap>
        Evidence 개수 보너스 상한 테스트
    <Module test_claim_extraction.py>
      Claim 추출 단위 테스트
      
      Cortex Phase 9: Hallucination Detection System
      ClaimExtractor 클래스의 모든 핵심 기능을 테스트합니다.
      
      테스트 항목:
      - Claim 추출 (각 Claim 타입별)
      - 타입 필터링
      - 구현 완료 Claim 추출
      - 기존 참조 Claim 추출
      - 확신도 표현 감지
      - 중복 제거 (50% 겹침 기준)
      - 통계 생성
      <UnitTestCase TestClaimExtractorInitialization>
        ClaimExtractor 초기화 테스트
        <TestCaseFunction test_initialization>
          ClaimExtractor 초기화 테스트
      <UnitTestCase TestImplementationCompleteClaims>
        구현 완료 Claim 추출 테스트
        <TestCaseFunction test_extract_implementation_complete_detailed>
          상세 구현 완료 패턴 테스트
        <TestCaseFunction test_extract_implementation_complete_simple>
          단순 구현 완료 패턴 테스트
        <TestCaseFunction test_extract_implementation_with_subject>
          주체가 있는 구현 완료 패턴 테스트
        <TestCaseFunction test_extract_successful_implementation>
          성공적 구현 패턴 테스트
      <UnitTestCase TestExtensionClaims>
        기존 코드 확장 Claim 추출 테스트
        <TestCaseFunction test_extract_extension_simple>
          단순 확장 패턴 테스트
        <TestCaseFunction test_extract_integration>
          통합 패턴 테스트
      <UnitTestCase TestReferenceExistingClaims>
        기존 참조 Claim 추출 테스트
        <TestCaseFunction test_extract_already_implemented>
          이미 구현됨 패턴 테스트
        <TestCaseFunction test_extract_existing_usage>
          기존 사용 패턴 테스트
      <UnitTestCase TestModificationClaims>
        파일/코드 수정 Claim 추출 테스트
        <TestCaseFunction test_extract_file_modification>
          파일 수정 패턴 테스트
        <TestCaseFunction test_extract_line_modification>
          라인 수정 패턴 테스트
        <TestCaseFunction test_extract_modification_simple>
          단순 수정 패턴 테스트
      <UnitTestCase TestVerificationClaims>
        테스트/검증 Claim 추출 테스트
        <TestCaseFunction test_extract_normal_operation>
          정상 작동 패턴 테스트
        <TestCaseFunction test_extract_test_complete>
          테스트 완료 패턴 테스트
        <TestCaseFunction test_extract_test_passed>
          테스트 통과 패턴 테스트
      <UnitTestCase TestBugFixClaims>
        버그 수정 Claim 추출 테스트
        <TestCaseFunction test_extract_bug_fix_simple>
          단순 버그 수정 패턴 테스트
        <TestCaseFunction test_extract_error_fix>
          에러 수정 패턴 테스트
      <UnitTestCase TestClaimTypeFiltering>
        Claim 타입 필터링 테스트
        <TestCaseFunction test_extract_claims_by_type_multiple>
          다중 타입 필터링 테스트
        <TestCaseFunction test_extract_claims_by_type_single>
          단일 타입 필터링 테스트
        <TestCaseFunction test_get_implementation_claims>
          구현 완료 Claim만 추출 테스트
        <TestCaseFunction test_get_reference_claims>
          기존 참조 Claim만 추출 테스트
      <UnitTestCase TestConfidenceDetection>
        확신도 표현 감지 테스트
        <TestCaseFunction test_high_confidence>
          높은 확신도 표현 테스트
        <TestCaseFunction test_low_confidence>
          낮은 확신도 표현 테스트
        <TestCaseFunction test_medium_confidence>
          중간 확신도 표현 테스트
        <TestCaseFunction test_very_high_confidence>
          매우 높은 확신도 표현 테스트
      <UnitTestCase TestDuplicateHandling>
        중복 Claim 처리 테스트
        <TestCaseFunction test_no_duplicate_claims>
          중복 Claim 제거 테스트 - 50% 겹침 기준
      <UnitTestCase TestClaimStatistics>
        Claim 통계 생성 테스트
        <TestCaseFunction test_get_stats_empty>
          빈 Claim 리스트 통계 테스트
        <TestCaseFunction test_get_stats_multiple_types>
          다중 타입 통계 테스트
        <TestCaseFunction test_get_stats_single_type>
          단일 타입 통계 테스트
        <TestCaseFunction test_get_stats_with_confidence>
          확신도 포함 통계 테스트
      <UnitTestCase TestEdgeCases>
        엣지 케이스 테스트
        <TestCaseFunction test_claim_positions>
          Claim 위치 정보 테스트
        <TestCaseFunction test_empty_text>
          빈 텍스트 테스트
        <TestCaseFunction test_long_text>
          긴 텍스트 테스트
        <TestCaseFunction test_mixed_language>
          한영 혼합 텍스트 테스트
        <TestCaseFunction test_no_matching_patterns>
          매칭되는 패턴이 없는 텍스트 테스트
    <Module test_contradiction.py>
      ContradictionDetector 단위 테스트
      
      Cortex Phase 9: Hallucination Detection System
      자기 모순 감지 시스템 테스트
      <UnitTestCase TestContradictionDetectorInitialization>
        ContradictionDetector V2 초기화 테스트
        <TestCaseFunction test_initialization>
          정상 초기화 테스트
        <TestCaseFunction test_patterns_compiled>
          패턴 컴파일 확인
      <UnitTestCase TestDirectNegation>
        직접 부정 모순 테스트
        <TestCaseFunction test_direct_negation_detected>
          직접 부정 모순 감지
        <TestCaseFunction test_direct_negation_english>
          영어 부정 표현 감지
        <TestCaseFunction test_direct_negation_korean>
          한국어 부정 표현 감지
        <TestCaseFunction test_no_negation_same_sentiment>
          같은 감정은 모순 아님
      <UnitTestCase TestTemporalContradiction>
        시간 순서 모순 테스트
        <TestCaseFunction test_no_temporal_contradiction_same_time>
          같은 시간 표현은 모순 아님
        <TestCaseFunction test_temporal_before_after_contradiction>
          before와 after 모순 감지
        <TestCaseFunction test_temporal_english_before_after>
          영어 before/after 모순
        <TestCaseFunction test_temporal_korean_before>
          한국어 이전 표현 감지
      <UnitTestCase TestComparisonContradiction>
        비교/수치 모순 테스트
        <TestCaseFunction test_comparison_english_increase_decrease>
          영어 증가/감소 모순
        <TestCaseFunction test_comparison_greater_lesser_contradiction>
          크다/작다 모순 감지
        <TestCaseFunction test_comparison_korean_greater>
          한국어 비교 표현 (더 큰)
        <TestCaseFunction test_no_comparison_contradiction_same_direction>
          같은 방향 비교는 모순 아님
      <UnitTestCase TestTypeContradiction>
        Claim 타입 모순 테스트
        <TestCaseFunction test_no_type_contradiction_different_subjects>
          다른 주제는 타입 모순 아님
        <TestCaseFunction test_type_implementation_vs_reference>
          구현 완료 vs 기존 참조 모순
      <UnitTestCase TestSeverityCalculation>
        심각도 계산 테스트
        <TestCaseFunction test_severity_critical_with_critical_contradiction>
          치명적 모순 1개 - critical
        <TestCaseFunction test_severity_critical_with_two_high>
          높은 모순 2개 - critical
        <TestCaseFunction test_severity_high_with_one_high>
          높은 모순 1개 - high
        <TestCaseFunction test_severity_high_with_three_medium>
          중간 모순 3개 - high
        <TestCaseFunction test_severity_medium_with_one_medium>
          중간 모순 1개 - medium
        <TestCaseFunction test_severity_none_no_contradictions>
          모순 없음 - none
      <UnitTestCase TestDetectContradictions>
        전체 모순 감지 테스트
        <TestCaseFunction test_detect_multiple_contradictions>
          여러 모순 감지
        <TestCaseFunction test_detect_no_contradictions>
          모순 없는 응답
        <TestCaseFunction test_detect_with_claims>
          Claim이 있는 응답 모순 감지
      <UnitTestCase TestCompareResponses>
        여러 응답 비교 테스트
        <TestCaseFunction test_compare_best_worst_index>
          최고/최악 응답 인덱스
        <TestCaseFunction test_compare_two_responses>
          두 응답 비교
      <UnitTestCase TestContradictionTrend>
        모순 추이 분석 테스트
        <TestCaseFunction test_trend_change_calculation>
          추세 변화량 계산
        <TestCaseFunction test_trend_improving>
          모순 감소 추세
        <TestCaseFunction test_trend_insufficient_data>
          데이터 부족 시 에러
        <TestCaseFunction test_trend_stable>
          안정적인 추세
        <TestCaseFunction test_trend_worsening>
          모순 증가 추세
      <UnitTestCase TestEdgeCases>
        엣지 케이스 테스트
        <TestCaseFunction test_empty_text>
          빈 텍스트 처리
        <TestCaseFunction test_mixed_korean_english>
          한영 혼합 텍스트
        <TestCaseFunction test_single_claim>
          Claim이 하나만 있을 때
        <TestCaseFunction test_special_characters>
          특수 문자 처리
        <TestCaseFunction test_very_long_text>
          매우 긴 텍스트 처리
      <UnitTestCase TestInterpretation>
        모순 해석 테스트
        <TestCaseFunction test_interpretation_critical>
          치명적 모순 해석
        <TestCaseFunction test_interpretation_high>
          높은 모순 해석
        <TestCaseFunction test_interpretation_low>
          낮은 모순 해석
        <TestCaseFunction test_interpretation_medium>
          중간 모순 해석
        <TestCaseFunction test_interpretation_none>
          모순 없음 해석
    <Module test_contradiction_simple.py>
      모순 감지 시스템 간소화 테스트
      
      Cortex Phase 9: Hallucination Detection System
      내부 로직 중심의 테스트 (ClaimExtractor의 한계를 우회)
      <UnitTestCase TestContradictionDetectorCore>
        핵심 모순 감지 로직 테스트
        <TestCaseFunction test_comparison_english_increase_decrease>
          영어 increase/decrease 감지
        <TestCaseFunction test_comparison_korean_greater_lesser>
          한국어 크다/작다 감지
        <TestCaseFunction test_detect_no_contradictions>
          모순 없는 응답
        <TestCaseFunction test_direct_negation_english>
          영어 부정 표현 감지
        <TestCaseFunction test_direct_negation_korean>
          한국어 부정 표현 감지
        <TestCaseFunction test_empty_text>
          빈 텍스트 처리
        <TestCaseFunction test_initialization>
          초기화 테스트
        <TestCaseFunction test_interpretation_critical>
          치명적 모순 해석
        <TestCaseFunction test_interpretation_high>
          높은 모순 해석
        <TestCaseFunction test_interpretation_low>
          낮은 모순 해석
        <TestCaseFunction test_interpretation_medium>
          중간 모순 해석
        <TestCaseFunction test_interpretation_none>
          모순 없음 해석
        <TestCaseFunction test_no_negation_same_sentiment>
          같은 감정은 모순 아님
        <TestCaseFunction test_severity_critical_with_critical_contradiction>
          치명적 모순 1개 - critical
        <TestCaseFunction test_severity_high_with_one_high>
          높은 모순 1개 - high
        <TestCaseFunction test_severity_medium_with_one_medium>
          중간 모순 1개 - medium
        <TestCaseFunction test_severity_none_no_contradictions>
          모순 없음 - none
        <TestCaseFunction test_single_claim>
          Claim이 하나만 있을 때
        <TestCaseFunction test_temporal_english_before_after>
          영어 before/after 감지
        <TestCaseFunction test_temporal_korean_before_after>
          한국어 이전/이후 감지
        <TestCaseFunction test_type_implementation_vs_reference>
          구현 완료 vs 기존 참조 모순
    <Module test_control_state.py>
      Control State Manager 테스트
      Phase 2: Control Theory Plan A/B
      
      테스트 원칙:
      1. Hysteresis 로직 검증
      2. Plan A/B 전환 조건 검증
      3. 거부율 계산 정확도 검증
      4. 최소 전환 간격 (10분) 검증
      5. State persistence (export/import) 검증
      <Function test_record_interaction>
        상호작용 기록 테스트
      <Function test_record_multiple_interactions>
        다중 상호작용 기록 테스트
      <Function test_record_accepted_interaction>
        수락 상호작용 카운터 테스트
      <Function test_record_rejected_interaction>
        거부 상호작용 카운터 테스트
      <Function test_calculate_reject_rate_empty>
        빈 상태에서 거부율 계산 테스트
      <Function test_calculate_reject_rate_all_accepted>
        모두 수락된 경우 거부율 테스트
      <Function test_calculate_reject_rate_all_rejected>
        모두 거부된 경우 거부율 테스트
      <Function test_calculate_reject_rate_mixed>
        혼합 피드백 거부율 테스트
      <Function test_calculate_reject_rate_modified_counted>
        MODIFIED도 거부로 간주되는지 테스트
      <Function test_can_transition_initial>
        초기 상태에서 전환 가능 여부 테스트
      <Function test_can_transition_within_interval>
        최소 간격 내에서 전환 불가 테스트
      <Function test_can_transition_after_interval>
        최소 간격 이후 전환 가능 테스트
      <Function test_plan_a_to_b_transition_threshold>
        Plan A → Plan B 전환 임계값 테스트
      <Function test_plan_a_consecutive_counter_reset>
        Plan A에서 연속 카운터 리셋 테스트
      <Function test_plan_b_to_a_recovery_threshold>
        Plan B → Plan A 복귀 임계값 테스트
      <Function test_get_statistics>
        통계 정보 반환 테스트
      <Function test_export_state>
        상태 내보내기 테스트
      <Function test_import_state>
        상태 불러오기 테스트
      <Function test_export_import_roundtrip>
        내보내기/불러오기 왕복 테스트
      <Function test_decide_mode_no_interactions>
        상호작용 없을 때 모드 결정 테스트
      <Function test_transition_records_history>
        모드 전환 시 이력 기록 테스트
      <Function test_transition_resets_counters>
        모드 전환 시 카운터 리셋 테스트
    <Module test_critical_fixes.py>
      긴급 수정 사항 테스트 (2025-12-20)
      
      Critical-1: update_memory KeyError 수정
      Critical-2: TelemetryClient 메서드 구현
      Issue-3: 초기 브랜치 생성 확인
      <Class TestCritical1UpdateMemoryKeyError>
        Critical-1: update_memory Phase 9 자동 할루시네이션 검증 테스트
        <Function test_automatic_hallucination_verification>
          Phase 9 자동 할루시네이션 검증이 정상 작동하는지 확인
        <Function test_update_memory_with_verified_flag>
          verified=True로 호출 시 검증 건너뛰기 테스트
      <Class TestCritical2TelemetryClientMethods>
        Critical-2: TelemetryClient emit_event, track_error 메서드 테스트
        <Function test_emit_event_method_exists>
          emit_event 메서드가 존재하는지 확인
        <Function test_track_error_method_exists>
          track_error 메서드가 존재하는지 확인
        <Function test_emit_event_execution>
          emit_event가 정상적으로 실행되는지 확인
        <Function test_track_error_execution>
          track_error가 정상적으로 실행되는지 확인
        <Function test_emit_event_fail_safe>
          emit_event의 Fail-Safe 동작 확인 (잘못된 입력에도 예외 없음)
      <Class TestIssue3InitialBranchCreation>
        Issue-3: initialize_context 시 브랜치 자동 생성 확인
        <Function test_initialize_creates_branch>
          initialize_context 호출 시 브랜치가 자동으로 생성되는지 확인
        <Function test_first_conversation_without_manual_branch_creation>
          브랜치 수동 생성 없이 첫 대화 시작 가능한지 확인
      <Function test_all_critical_fixes_integration>
        통합 테스트: 세 가지 수정사항이 모두 정상 작동하는지 확인
    <Module test_e2e_integration.py>
      E2E 통합 테스트 (v3.0)
      
      Cortex MCP 전체 시스템 End-to-End 테스트
      
      테스트 시나리오:
      1. 프로젝트 초기화 → 브랜치 생성 → 맥락 저장 → 검색
      2. 퍼지 온톨로지 → CoT Prompt → RAG 검색 통합
      3. Smart Context 압축 → 해제 → 토큰 절감
      4. Reference History 기록 → 추천 → 피드백
      
      KPI 목표:
      - 맥락 추천 정확도: 95%
      - 토큰 절감율: 70%
      - RAG 검색 정확도: 100%
      - 자동화 성공률: 80%+
      <UnitTestCase TestE2EFuzzyOntologyIntegration>
        퍼지 온톨로지 통합 E2E 테스트
        <TestCaseFunction test_e2e_query_classification_to_prompt>
          쿼리 분류 → Prompt 컨텍스트 생성 E2E
        <TestCaseFunction test_e2e_rag_enhancement>
          RAG 결과 퍼지 강화 E2E
      <UnitTestCase TestE2ESmartContext>
        Smart Context E2E 테스트
        <TestCaseFunction test_e2e_context_lifecycle>
          맥락 생명주기 E2E: 생성 → 저장 → 로드
        <TestCaseFunction test_e2e_token_savings>
          토큰 절감 E2E 테스트
      <UnitTestCase TestE2EReferenceHistory>
        Reference History E2E 테스트
        <TestCaseFunction test_e2e_context_suggestion>
          맥락 추천 E2E
        <TestCaseFunction test_e2e_reference_recording>
          참조 이력 기록 E2E
      <UnitTestCase TestE2EAlphaLogger>
        Alpha Logger E2E 테스트
        <TestCaseFunction test_e2e_logging_workflow>
          로깅 워크플로우 E2E
        <TestCaseFunction test_e2e_stats_summary>
          통계 요약 E2E
      <UnitTestCase TestE2EKPITracking>
        KPI 추적 E2E 테스트
        <TestCaseFunction test_e2e_kpi_dashboard>
          KPI 대시보드 E2E
        <TestCaseFunction test_e2e_kpi_recording>
          KPI 기록 E2E
      <UnitTestCase TestE2EFullWorkflow>
        전체 워크플로우 E2E 테스트
        <TestCaseFunction test_e2e_complete_workflow>
          완전한 워크플로우 E2E
          
          시나리오:
          1. 사용자 쿼리 입력
          2. 퍼지 온톨로지 분류
          3. CoT Prompt 컨텍스트 생성
          4. RAG 검색 (시뮬레이션)
          5. 결과 강화
          6. KPI 기록
    <Module test_fuzzy_analyzer.py>
      Fuzzy Claim Analyzer 테스트
      
      Cortex Phase 9: Hallucination Detection System
      퍼지 확신도 분석 시스템의 단위 테스트
      <UnitTestCase TestFuzzyClaimAnalyzerInitialization>
        FuzzyClaimAnalyzer 초기화 테스트
        <TestCaseFunction test_confidence_score_values>
          확신도 점수 값 확인
        <TestCaseFunction test_confidence_scores_exist>
          확신도 점수 정의 확인
        <TestCaseFunction test_initialization>
          정상 초기화 테스트
        <TestCaseFunction test_patterns_compiled>
          패턴 컴파일 확인
      <UnitTestCase TestConfidenceDetection>
        확신도 레벨 감지 테스트
        <TestCaseFunction test_detect_high_confidence>
          높은 확신도 감지
        <TestCaseFunction test_detect_high_confidence_거의>
          높은 확신도 감지 - 거의
        <TestCaseFunction test_detect_low_confidence>
          낮은 확신도 감지
        <TestCaseFunction test_detect_low_confidence_회의적>
          낮은 확신도 감지 - 회의적
        <TestCaseFunction test_detect_medium_confidence>
          중간 확신도 감지
        <TestCaseFunction test_detect_medium_confidence_추측>
          중간 확신도 감지 - 추측
        <TestCaseFunction test_detect_none_confidence>
          확신도 표현 없음 감지
        <TestCaseFunction test_detect_very_high_confidence>
          매우 높은 확신도 감지
        <TestCaseFunction test_detect_very_high_confidence_확실>
          매우 높은 확신도 감지 - 확실
        <TestCaseFunction test_priority_conservative_approach_high_over_very_high>
          보수적 접근: 여러 레벨 매칭 시 가장 낮은 레벨 반환 (high < very_high)
        <TestCaseFunction test_priority_conservative_approach_medium_over_high>
          보수적 접근: 여러 레벨 매칭 시 가장 낮은 레벨 반환 (medium < high)
      <UnitTestCase TestVagueExpressionDetection>
        모호한 표현 감지 테스트
        <TestCaseFunction test_detect_multiple_vague>
          여러 모호한 표현 감지
        <TestCaseFunction test_detect_vague_english_might>
          모호한 표현 감지 - might
        <TestCaseFunction test_detect_vague_같은것>
          모호한 표현 감지 - 것 같
        <TestCaseFunction test_detect_vague_대충>
          모호한 표현 감지 - 대충
        <TestCaseFunction test_detect_vague_아마>
          모호한 표현 감지 - 아마
        <TestCaseFunction test_detect_vague_어쩌면>
          모호한 표현 감지 - 어쩌면
        <TestCaseFunction test_has_vague_expression_false>
          모호한 표현 존재 확인 (False)
        <TestCaseFunction test_has_vague_expression_true>
          모호한 표현 존재 확인 (True)
        <TestCaseFunction test_no_vague_expressions>
          모호한 표현 없음
      <UnitTestCase TestFuzzyScoring>
        퍼지 점수 계산 테스트
        <TestCaseFunction test_score_high_confidence>
          높은 확신도 점수
        <TestCaseFunction test_score_low_confidence>
          낮은 확신도 점수
        <TestCaseFunction test_score_medium_confidence>
          중간 확신도 점수
        <TestCaseFunction test_score_very_high_confidence>
          매우 높은 확신도 점수
        <TestCaseFunction test_vague_expression_penalty>
          모호한 표현 패널티 (30% 감점)
      <UnitTestCase TestSingleClaimAnalysis>
        단일 Claim 분석 테스트
        <TestCaseFunction test_analyze_claim_context_extraction>
          Claim 컨텍스트 추출 확인
        <TestCaseFunction test_analyze_claim_with_high_confidence>
          높은 확신도 Claim 분석
        <TestCaseFunction test_analyze_claim_with_vague_expression>
          모호한 표현이 있는 Claim 분석
      <UnitTestCase TestResponseAnalysis>
        전체 응답 분석 테스트
        <TestCaseFunction test_analyze_response_interpretation>
          응답 해석 확인
        <TestCaseFunction test_analyze_response_vague_count>
          모호한 표현 개수 카운트
        <TestCaseFunction test_analyze_response_with_claims>
          Claim이 있는 응답 분석
        <TestCaseFunction test_analyze_response_without_claims>
          Claim이 없는 응답 분석
      <UnitTestCase TestRiskLevelCalculation>
        위험도 계산 테스트
        <TestCaseFunction test_critical_risk_very_low_confidence>
          매우 높은 위험도 - 매우 낮은 확신도
        <TestCaseFunction test_high_risk_low_confidence>
          높은 위험도 - 낮은 확신도
        <TestCaseFunction test_low_risk_high_confidence>
          낮은 위험도 - 높은 확신도
        <TestCaseFunction test_medium_risk_medium_confidence>
          중간 위험도 - 중간 확신도
        <TestCaseFunction test_vague_count_escalation_3to4>
          모호한 표현 3-4개 시 위험도 상승
        <TestCaseFunction test_vague_count_escalation_5plus>
          모호한 표현 5개 이상 시 위험도 상승
      <UnitTestCase TestCompareResponses>
        여러 응답 비교 테스트
        <TestCaseFunction test_compare_best_response_index>
          최고 응답 인덱스 확인
        <TestCaseFunction test_compare_risk_distribution>
          위험도 분포 확인
        <TestCaseFunction test_compare_two_responses>
          두 응답 비교
      <UnitTestCase TestConfidenceTrend>
        확신도 추이 분석 테스트
        <TestCaseFunction test_trend_change_calculation>
          추세 변화량 계산
        <TestCaseFunction test_trend_declining>
          확신도 하락 추세
        <TestCaseFunction test_trend_improving>
          확신도 상승 추세
        <TestCaseFunction test_trend_insufficient_data>
          데이터 부족 시 에러
        <TestCaseFunction test_trend_stable>
          확신도 안정 추세
      <UnitTestCase TestEdgeCases>
        경계 케이스 테스트
        <TestCaseFunction test_analyze_text_confidence_empty_sentences>
          빈 문장이 포함된 텍스트
        <TestCaseFunction test_context_boundary_end>
          Claim이 텍스트 끝 부분에 있을 때
        <TestCaseFunction test_context_boundary_start>
          Claim이 텍스트 시작 부분에 있을 때
        <TestCaseFunction test_empty_text>
          빈 텍스트 처리
        <TestCaseFunction test_mixed_korean_english>
          한영 혼합 텍스트
        <TestCaseFunction test_special_characters>
          특수 문자 처리
        <TestCaseFunction test_unicode_text>
          유니코드 텍스트 처리
        <TestCaseFunction test_very_long_text>
          매우 긴 텍스트 처리
      <UnitTestCase TestIntegrationWithClaimExtractor>
        ClaimExtractor 통합 테스트
        <TestCaseFunction test_integration_confidence_detection>
          확신도 표현 감지 통합 확인
        <TestCaseFunction test_integration_full_pipeline>
          전체 파이프라인 통합 테스트
        <TestCaseFunction test_integration_vague_detection>
          모호한 표현 감지 통합 확인
    <Module test_fuzzy_prompt.py>
      Fuzzy Prompt Integrator 테스트 (v3.0)
      
      CoT Prompt 통합 모듈 테스트
      <UnitTestCase TestFuzzyPromptIntegrator>
        FuzzyPromptIntegrator 테스트
        <TestCaseFunction test_ambiguity_detection>
          모호성 감지 테스트
        <TestCaseFunction test_custom_strategy_init>
          커스텀 전략 초기화 테스트
        <TestCaseFunction test_enhance_rag_results>
          RAG 결과 강화 테스트
        <TestCaseFunction test_enhance_rag_results_empty>
          빈 RAG 결과 강화 테스트
        <TestCaseFunction test_enhanced_rag_result_to_dict>
          EnhancedRAGResult to_dict 테스트
        <TestCaseFunction test_generate_prompt_context_detailed>
          상세 전략 Prompt 컨텍스트 생성 테스트
        <TestCaseFunction test_generate_prompt_context_minimal>
          최소 전략 Prompt 컨텍스트 생성 테스트
        <TestCaseFunction test_generate_prompt_context_standard>
          표준 전략 Prompt 컨텍스트 생성 테스트
        <TestCaseFunction test_get_statistics>
          통계 정보 테스트
        <TestCaseFunction test_init>
          초기화 테스트
        <TestCaseFunction test_inject_into_system_prompt_after>
          System Prompt 주입 테스트 (뒤)
        <TestCaseFunction test_inject_into_system_prompt_before>
          System Prompt 주입 테스트 (앞)
        <TestCaseFunction test_prompt_context_to_dict>
          PromptContext to_dict 테스트
        <TestCaseFunction test_prompt_strategies>
          Prompt 전략 enum 테스트
        <TestCaseFunction test_singleton_instance>
          싱글톤 인스턴스 테스트
        <TestCaseFunction test_to_system_prompt>
          System Prompt 변환 테스트
      <UnitTestCase TestPromptContextIntegration>
        Prompt Context 통합 테스트
        <TestCaseFunction test_coding_query_context>
          코딩 쿼리 컨텍스트 테스트
        <TestCaseFunction test_document_query_context>
          문서 쿼리 컨텍스트 테스트
        <TestCaseFunction test_latency_tracking>
          지연 시간 추적 테스트
    <Module test_grounding_score_accuracy.py>
      Grounding Score 정확도 종합 테스트
      
      실제 프로젝트 구조와 유사한 복잡한 시나리오에서
      Grounding Score가 정확하게 계산되는지 검증합니다.
      
      테스트 시나리오:
      1. 다중 파일 참조 주장
      2. 부분 정확성 주장 (일부만 맞음)
      3. 계층 구조 파일 참조
      4. Context 간 관계 포함
      <Class TestGroundingScoreAccuracy>
        Grounding Score 계산 정확도 종합 테스트
        <Function test_multi_file_accurate_claim>
          시나리오 1: 여러 파일을 정확하게 언급한 주장
          - 3개 파일 모두 존재
          - 예상: grounding_score = 1.0, verified_claims = 3
        <Function test_partial_accuracy_claim>
          시나리오 2: 부분 정확성 주장
          - 3개 파일 중 1개만 존재
          - 예상: grounding_score 약 0.33, verified_claims = 1
        <Function test_hierarchical_file_structure>
          시나리오 3: 계층 구조 파일 참조
          - 중첩된 디렉토리 구조
          - 예상: 정확한 경로 인식 및 검증
        <Function test_no_files_complete_hallucination>
          시나리오 4: 완전 할루시네이션 (파일 없음)
          - 모든 파일이 존재하지 않음
          - 예상: grounding_score = 0.0, verified_claims = 0
        <Function test_mixed_accuracy_with_confidence>
          시나리오 5: 혼합 정확성 + 확신도 분석
          - 일부는 맞고 일부는 틀림 + 높은 확신도 표현
          - 예상: average_confidence 높음 + grounding_score 중간 = medium risk
    <Module test_hallucination_verification.py>
      Phase 9 할루시네이션 검증 시스템 E2E 테스트
      
      Evidence Graph 자동 업데이트 및 검증 정확도 테스트
      <Class TestHallucinationVerification>
        Phase 9 할루시네이션 검증 E2E 테스트
        <Function test_true_positive_real_file_exists>
          Scenario 1: True Positive (실제 구현된 파일)
          
          LLM이 "test_module.py에 함수 구현" 주장 → 실제 파일 존재
          → verified_claims > 0, grounding_score > 0.5
        <Function test_true_negative_hallucination_detected>
          Scenario 2: True Negative (거짓 주장 감지)
          
          LLM이 "nonexistent.py 구현" 주장 → 파일 없음
          → verified_claims = 0, grounding_score < 0.3
    <Module test_initial_scanner.py>
      Initial Scanner 통합 테스트
      Context Graph 기반 프로젝트 스캔 기능 테스트
      <Class TestContextGraph>
        Context Graph 모듈 테스트
        <Function test_import_context_graph>
          context_graph 모듈 임포트 테스트
        <Function test_create_context_graph>
          Context Graph 생성 테스트
        <Function test_add_node>
          노드 추가 테스트
        <Function test_add_edge>
          엣지 추가 테스트
        <Function test_get_statistics>
          통계 조회 테스트
      <Class TestASTParser>
        AST Parser 모듈 테스트
        <Function test_import_ast_parser>
          ast_parser 모듈 임포트 테스트
        <Function test_python_parser>
          Python 파서 테스트
        <Function test_javascript_parser>
          JavaScript 파서 테스트
        <Function test_parser_factory>
          파서 팩토리 테스트
      <Class TestInitialScanner>
        Initial Scanner 모듈 테스트
        <Function test_import_initial_scanner>
          initial_scanner 모듈 임포트 테스트
        <Function test_scan_mode_enum>
          ScanMode enum 테스트
        <Function test_scan_estimate>
          스캔 예상 비용 조회 테스트
        <Function test_scan_project_none_mode>
          NONE 모드 스캔 테스트
        <Function test_scan_project_light_mode>
          LIGHT 모드 스캔 테스트
      <Class TestMCPToolIntegration>
        MCP Tool 통합 테스트
        <Function test_tool_imports>
          MCP Tool import 테스트
        <Function test_scanner_mode_enum>
          ScannerMode enum 테스트
    <Module test_initial_scanner_e2e.py>
      Initial Scanner E2E 통합 테스트
      실제 프로젝트 스캔부터 Context Graph 생성까지 전체 흐름 테스트
      <Class TestInitialScannerE2E>
        Initial Scanner E2E 테스트
        <Function test_full_scan_workflow>
          전체 스캔 워크플로우 테스트 (FULL 모드)
        <Function test_light_scan_workflow>
          LIGHT 모드 스캔 워크플로우 테스트
        <Function test_none_scan_workflow>
          NONE 모드 스캔 워크플로우 테스트
        <Function test_context_graph_integration>
          Context Graph 통합 테스트
        <Function test_ast_parsing_integration>
          AST 파싱 통합 테스트
        <Function test_javascript_parsing_integration>
          JavaScript 파싱 통합 테스트
        <Function test_mcp_tool_integration>
          MCP Tool 통합 테스트
        <Function test_incremental_rescan>
          증분 재스캔 테스트
        <Function test_scan_with_gitignore>
          gitignore 처리 테스트
        <Function test_large_project_estimation>
          대규모 프로젝트 예상 비용 테스트
      <Class TestContextGraphE2E>
        Context Graph E2E 테스트
        <Function test_graph_persistence>
          그래프 인메모리 테스트 (영속성 미구현 - 인메모리 검증)
        <Function test_graph_query>
          그래프 쿼리 테스트
      <Class TestASTParserE2E>
        AST Parser E2E 테스트
        <Function test_complex_python_parsing>
          복잡한 Python 파싱 테스트
        <Function test_typescript_parsing>
          TypeScript 파싱 테스트
    <Module test_integration_full.py>
      test_integration_full.py
      
      Phase 0-7 전체 통합 테스트
      모든 Phase의 컴포넌트가 제대로 통합되어 작동하는지 검증합니다.
      
      테스트 시나리오:
      1. Phase 간 데이터 흐름 검증
      2. 실제 사용 시나리오 E2E 테스트
      3. Silent Failure Detection 전체 파이프라인 검증
      <Function test_integration_phase4_phase3_centrality_to_priority>
        Phase 4와 Phase 3 통합: Graph Centrality → Context Prioritization
        
        검증 내용:
        1. EvidenceGraph에서 centrality 계산
        2. ContextManager가 centrality를 사용하여 우선순위 결정
        3. 상위 3개 context만 active 유지
      <Function test_integration_phase5_phase1_fuzzy_grounding>
        Phase 5와 Phase 1 통합: Fuzzy Claim Analyzer → Grounding Scorer
        
        검증 내용:
        1. FuzzyClaimAnalyzer가 Claim 분석
        2. GroundingScorer가 Evidence 평가
        3. assess_claim이 두 confidence를 결합 (min-confidence rule)
      <Function test_integration_phase6_scan_strategy>
        Phase 6: Scan Optimizer 통합 검증
        
        검증 내용:
        1. Expected Loss 계산이 올바른지
        2. 파일 중요도 스코어링이 작동하는지
        3. 스캔 순서 최적화가 작동하는지
      <Function test_integration_phase7_trust_pipeline>
        Phase 7: Trust UX 전체 파이프라인 통합
        
        검증 내용:
        1. 검증 결과를 받아서 Trust Prefix 추가
        2. Claim Assessment 포맷팅
        3. Complete Report 생성
      <Function test_integration_phase2_control_automation>
        Phase 2: Control State + Automation Manager 통합
        
        검증 내용:
        1. ControlStateManager가 interaction 기록
        2. Hysteresis logic이 모드 전환 결정
        3. AutomationManager가 Control State 사용
      <Function test_e2e_full_pipeline>
        E2E: 전체 Silent Failure Detection 파이프라인
        
        시나리오:
        1. 프로젝트 스캔 (Phase 6)
        2. Context 우선순위 결정 (Phase 3, 4)
        3. LLM 응답 분석 (Phase 5, 1)
        4. Trust UX 표시 (Phase 7)
        5. 사용자 피드백 수집 (Phase 2)
    <Module test_mcp_scanner_integration.py>
      MCP Tool + Initial Scanner 통합 테스트
      실제 MCP Tool 호출 시 Initial Scanner가 올바르게 동작하는지 검증
      <Class TestMCPScannerIntegration>
        MCP Tool + Initial Scanner 통합 테스트
        <Coroutine test_mcp_initialize_context_uses_initial_scanner>
          MCP initialize_context가 Initial Scanner를 사용하는지 검증
        <Coroutine test_mcp_full_mode_with_initial_scanner>
          FULL 모드 스캔 테스트
        <Coroutine test_mcp_none_mode_skips_scanning>
          NONE 모드는 스캔을 건너뛰는지 검증
        <Coroutine test_scanner_returns_context_graph_info>
          스캔 결과에 Context Graph 정보가 포함되는지 검증
      <Class TestRealProjectScanning>
        실제 프로젝트 스캔 테스트
        <Coroutine test_scan_website_project>
          실제 website 프로젝트 스캔 테스트
        <Coroutine test_scan_cortex_mcp_project>
          실제 cortex_mcp 프로젝트 스캔 테스트
    <Module test_multi_session_sync.py>
      Cortex MCP - Multi-Session Sync 테스트
      
      여러 터미널로 병렬 개발하며 맥락을 자동 머지하는 기능을 테스트합니다.
      <Function test_session_creation>
        세션 생성 테스트
      <Function test_session_activity_update>
        세션 활동 업데이트 테스트
      <Function test_active_sessions_list>
        활성 세션 목록 조회 테스트
      <Function test_session_statistics>
        세션 통계 조회 테스트
      <Function test_session_sync_without_other_sessions>
        다른 세션 없이 동기화 테스트
      <Function test_session_close>
        세션 종료 테스트
      <Function test_multi_session_parallel_simulation>
        멀티세션 병렬 작업 시뮬레이션
        
        실제로 여러 터미널을 띄울 수 없으므로,
        여러 매니저 인스턴스를 생성하여 시뮬레이션합니다.
    <Module test_physical_verification.py>
      test_physical_verification.py
      
      실제 물리적 테스트 (시뮬레이션 아님)
      - 실제 파일 시스템에 데이터 쓰기/읽기
      - AlphaLogger가 실제로 로그 파일 생성하는지 확인
      - Context Manager가 실제로 맥락 관리하는지 확인
      - Reference History가 실제로 참조 이력 기록하는지 확인
      <Function test_physical_alpha_logger_writes_real_files>
        AlphaLogger가 실제로 파일을 생성하는지 검증
        
        검증 항목:
        1. logs/ 폴더에 실제 JSON 파일이 생성되는지
        2. 파일 내용이 올바른 JSON 형식인지
        3. 예상한 필드들이 존재하는지
      <Function test_physical_context_manager_file_operations>
        Context Manager가 실제로 파일 작업을 수행하는지 검증
        
        검증 항목:
        1. memory/ 폴더에 실제 프로젝트 디렉토리 생성되는지
        2. 실제 .md 파일이 생성되는지
        3. YAML frontmatter가 올바르게 작성되는지
      <Function test_physical_scan_optimizer_actual_calculation>
        Scan Optimizer가 실제로 계산을 수행하는지 검증
        
        검증 항목:
        1. Expected Loss 계산이 실제로 수행되는지
        2. 계산 결과가 올바른 범위인지
        3. 로깅이 실제로 기록되는지
      <Function test_physical_fuzzy_analyzer_real_text_processing>
        Fuzzy Claim Analyzer가 실제로 텍스트를 처리하는지 검증
        
        검증 항목:
        1. 실제 텍스트에서 확신도 표현 추출되는지
        2. 퍼지 멤버십 계산이 올바른지
        3. Conservative rule 적용되는지
      <Function test_physical_evidence_graph_actual_graph_operations>
        Evidence Graph가 실제로 그래프 연산을 수행하는지 검증
        
        검증 항목:
        1. 노드 추가가 실제로 수행되는지
        2. Centrality 계산이 올바른지
        3. NetworkX 라이브러리가 제대로 작동하는지
      <Function test_physical_response_formatter_actual_string_formatting>
        Response Formatter가 실제로 문자열 포맷팅을 수행하는지 검증
        
        검증 항목:
        1. Trust prefix가 실제로 추가되는지
        2. 이모지가 올바르게 표시되는지
        3. 포맷팅된 문자열이 원본보다 긴지
      <Function test_physical_e2e_real_file_system_workflow>
        E2E 물리적 테스트: 실제 파일 시스템에서 전체 워크플로우 검증
        
        검증 항목:
        1. 실제 프로젝트 폴더 생성
        2. 실제 맥락 파일 생성
        3. 실제 로그 파일 생성
        4. 모든 컴포넌트가 실제로 작동하는지
    <Module test_research_logger.py>
      Test suite for Research Logger (Phase 0)
      
      Tests cover:
      1. Unit tests: Basic functionality
      2. Integration tests: Full workflow
      3. GDPR compliance
      4. Performance (async, buffering)
      5. Edge cases
      
      Design Principles (세계 최고 수준):
      - 100% code coverage target
      - Test all success paths and error paths
      - Test GDPR compliance (consent, anonymization, deletion)
      - Test performance optimizations (async, buffering, rotation)
      <Function test_logger_disabled_by_default>
        Test that logger is disabled by default (opt-in principle)
      <Function test_enable_requires_consent>
        Test that enabling requires explicit consent
      <Function test_anonymization>
        Test user ID anonymization (SHA-256 with salt)
      <Function test_event_id_generation>
        Test event ID generation
      <Function test_session_id_generation>
        Test session ID generation
      <Function test_consent_logging>
        Test consent logging (GDPR compliance)
      <Function test_disable_logging>
        Test disabling logging
      <Coroutine test_event_logging_workflow>
        Test full event logging workflow
      <Coroutine test_buffer_writing>
        Test buffered writing (performance optimization)
      <Coroutine test_log_rotation>
        Test log rotation when file size exceeds limit
      <Coroutine test_flush>
        Test manual buffer flush
      <Function test_export_session_data>
        Test session data export (GDPR Article 20: Right to data portability)
      <Function test_delete_all_data>
        Test data deletion (GDPR Article 17: Right to erasure)
      <Function test_create_llm_response_event>
        Test LLM response event creation
      <Function test_create_cortex_intervention_event>
        Test Cortex intervention event creation
      <Function test_create_user_response_event>
        Test user response event creation
      <Function test_create_silent_failure_event>
        Test Silent Failure event creation
      <Coroutine test_logging_when_disabled>
        Test that logging silently fails when disabled
      <Function test_anonymous_user_id>
        Test enabling without explicit user ID
      <Coroutine test_concurrent_logging>
        Test concurrent event logging (async safety)
      <Function test_singleton_pattern>
        Test that get_research_logger returns singleton
    <Module test_response_formatter.py>
      test_response_formatter.py
      
      Phase 7: Trust UX 테스트
      response_formatter.py의 모든 기능을 검증합니다.
      <Function test_get_trust_level_high>
        High confidence 레벨 결정
      <Function test_get_trust_level_medium>
        Medium confidence 레벨 결정
      <Function test_get_trust_level_low>
        Low confidence 레벨 결정
      <Function test_get_trust_level_boundary_high>
        Boundary: 0.7 → HIGH
      <Function test_get_trust_level_boundary_medium>
        Boundary: 0.4 → MEDIUM
      <Function test_get_trust_level_zero>
        0.0 → LOW
      <Function test_get_trust_level_perfect>
        1.0 → HIGH
      <Function test_add_trust_prefix_high_confidence>
        High confidence prefix 추가
      <Function test_add_trust_prefix_medium_confidence>
        Medium confidence prefix 추가
      <Function test_add_trust_prefix_low_confidence>
        Low confidence prefix 추가 (경고 포함)
      <Function test_add_trust_prefix_with_contexts>
        Context 목록 포함
      <Function test_add_trust_prefix_many_contexts>
        Context 목록 많을 때 (+N more 표시)
      <Function test_add_trust_prefix_no_claims>
        Claim 없을 때
      <Function test_format_verification_summary_high>
        High confidence 검증 요약
      <Function test_format_verification_summary_medium>
        Medium confidence 검증 요약
      <Function test_format_verification_summary_no_claims>
        Claim 없을 때 검증 요약
      <Function test_format_claim_assessment_accept>
        ACCEPT decision 포맷팅
      <Function test_format_claim_assessment_caution>
        CAUTION decision 포맷팅
      <Function test_format_claim_assessment_warn>
        WARN decision 포맷팅
      <Function test_format_evidence_list_basic>
        기본 Evidence 목록 포맷팅
      <Function test_format_evidence_list_empty>
        빈 Evidence 목록
      <Function test_format_evidence_list_max_items>
        Max items 제한
      <Function test_format_context_summary_basic>
        기본 Context 목록 포맷팅
      <Function test_format_context_summary_empty>
        빈 Context 목록
      <Function test_format_context_summary_max_items>
        Max items 제한
      <Function test_format_complete_report_full>
        완전한 보고서 생성
      <Function test_format_complete_report_minimal>
        최소 정보로 보고서 생성
      <Function test_export_trust_metrics>
        Trust Metrics 내보내기
      <Function test_export_trust_metrics_low>
        Low confidence metrics
      <Function test_integration_scenario_high_trust>
        통합 시나리오: High trust 응답
      <Function test_integration_scenario_low_trust>
        통합 시나리오: Low trust 응답
    <Module test_scan_optimizer.py>
      test_scan_optimizer.py
      
      Phase 6: Expected Loss Scan Strategy 테스트
      scan_optimizer.py의 모든 기능을 검증합니다.
      <Function test_compute_expected_loss_full_mode>
        FULL 모드 Expected Loss 계산
      <Function test_compute_expected_loss_light_mode>
        LIGHT 모드 Expected Loss 계산
      <Function test_compute_expected_loss_none_mode>
        NONE 모드 Expected Loss 계산
      <Function test_compute_expected_loss_small_project>
        작은 프로젝트의 Expected Loss
      <Function test_compute_expected_loss_large_complex_project>
        크고 복잡한 프로젝트의 Expected Loss
      <Function test_recommend_scan_mode_small_project>
        작은 프로젝트 - FULL 추천 (MISS_PENALTY가 크기 때문)
      <Function test_recommend_scan_mode_large_complex_project>
        크고 복잡한 프로젝트 - FULL 추천
      <Function test_recommend_scan_mode_with_budget>
        예산 제약이 있는 경우
      <Function test_recommend_scan_mode_insufficient_budget>
        예산 부족 - NONE 추천
      <Function test_score_file_importance_critical>
        CRITICAL 파일 스코어링
      <Function test_score_file_importance_high>
        HIGH 파일 스코어링
      <Function test_score_file_importance_low>
        LOW 파일 스코어링 (테스트 파일)
      <Function test_score_file_importance_medium>
        MEDIUM 파일 스코어링 (일반 코드)
      <Function test_score_file_importance_setup_py>
        setup.py - CRITICAL
      <Function test_score_file_importance_package_json>
        package.json - HIGH
      <Function test_optimize_scan_order_basic>
        기본 스캔 순서 최적화
      <Function test_optimize_scan_order_with_change_probs>
        변경 확률 고려한 스캔 순서
      <Function test_optimize_scan_order_empty_list>
        빈 파일 목록
      <Function test_optimize_scan_order_single_file>
        단일 파일
      <Function test_justify_full_scan_high_complexity>
        복잡도 높은 프로젝트 - FULL 정당화됨
      <Function test_justify_full_scan_low_complexity>
        복잡도 낮은 프로젝트 - MISS_PENALTY가 크면 FULL이 정당화됨
      <Function test_justify_full_scan_fields>
        정당성 결과 필드 검증
      <Function test_integration_scenario_startup_project>
        통합 시나리오: 스타트업 프로젝트
      <Function test_integration_scenario_enterprise_project>
        통합 시나리오: 엔터프라이즈 프로젝트
      <Function test_export_statistics>
        통계 내보내기
      <Function test_edge_case_zero_project_size>
        프로젝트 크기 0
      <Function test_edge_case_max_complexity>
        최대 복잡도
      <Function test_edge_case_unknown_file_extension>
        알 수 없는 확장자
      <Function test_pattern_matching_wildcard_start>
        패턴 매칭: *로 시작
      <Function test_pattern_matching_wildcard_end>
        패턴 매칭: *로 끝남
      <Function test_pattern_matching_exact>
        패턴 매칭: 정확한 매칭
    <Module test_telemetry_integration.py>
      텔레메트리 통합 레이어 테스트
      
      기존 core/telemetry.py API와 새로운 telemetry_integration.py 호환성 검증
      <Class TestTelemetryIntegration>
        텔레메트리 통합 레이어 테스트
        <Function test_initialization>
          텔레메트리 초기화 테스트
        <Function test_track_tool_call>
          도구 호출 추적 테스트 (기존 API 호환)
        <Function test_track_error>
          에러 추적 테스트 (기존 API 호환)
        <Function test_track_performance>
          성능 메트릭 추적 테스트 (기존 API 호환)
        <Function test_track_feature_usage>
          기능 사용 추적 테스트 (기존 API 호환)
        <Function test_enable_disable>
          텔레메트리 활성화/비활성화 테스트
        <Function test_singleton_instance>
          텔레메트리 싱글톤 테스트
      <Class TestBackwardCompatibility>
        기존 core/telemetry.py와의 호환성 테스트
        <Function test_class_alias>
          클래스 별칭 테스트
        <Function test_api_compatibility>
          기존 API 메서드 존재 확인
    <Module test_telemetry_system.py>
      텔레메트리 시스템 통합 테스트
      
      텔레메트리 base + storage 레이어 동작 검증
      <Class TestTelemetryBase>
        텔레메트리 기본 기능 테스트
        <Function test_telemetry_event_creation>
          TelemetryEvent 생성 테스트
        <Function test_telemetry_event_to_dict>
          TelemetryEvent to_dict() 테스트
        <Function test_telemetry_event_to_json>
          TelemetryEvent to_json() 테스트
        <Function test_get_user_id_hash>
          사용자 ID 해시 생성 테스트
        <Function test_get_user_tier>
          사용자 티어 조회 테스트
      <Class TestTelemetryStorage>
        텔레메트리 저장소 테스트
        <Function test_storage_initialization>
          저장소 초기화 테스트
        <Function test_save_event>
          이벤트 저장 테스트
        <Function test_get_events_with_filters>
          필터링 조회 테스트
        <Function test_get_user_sessions>
          사용자 세션 조회 테스트
        <Function test_aggregate_daily_metrics>
          일일 메트릭 집계 테스트
      <Class TestTelemetryClient>
        텔레메트리 클라이언트 테스트
        <Function test_client_initialization>
          클라이언트 초기화 테스트
        <Function test_track_event>
          이벤트 추적 테스트
        <Function test_client_shutdown>
          클라이언트 종료 테스트
      <Class TestTelemetryIntegration>
        텔레메트리 통합 테스트
        <Function test_end_to_end_flow>
          엔드투엔드 흐름 테스트
        <Function test_fail_safe_behavior>
          Fail-Safe 동작 테스트 (저장 실패 시 핵심 기능 영향 없음)
    <Module test_telemetry_v2_storage.py>
      Telemetry v2.0 Storage Layer 테스트
      
      새로운 스키마(event_name, channel, is_paid_user 등)가 제대로 작동하는지 확인
      <Function test_save_event_with_new_schema>
        새 스키마로 이벤트 저장 테스트
      <Function test_save_error>
        에러 저장 테스트
      <Function test_save_trace>
        추적 저장 테스트
      <Function test_backward_compatibility>
        하위 호환성 테스트 - 구 필드명 사용
    <Module test_verification_e2e.py>
      E2E 할루시네이션 검증 통합 테스트
      
      Cortex Phase 9: Hallucination Detection System
      전체 검증 파이프라인을 실제 시나리오로 테스트합니다.
      
      테스트 시나리오:
      1. 신뢰할 수 있는 응답 (충분한 근거)
      2. 할루시네이션 의심 응답 (근거 없는 주장)
      3. 자기 모순 응답 (앞뒤가 맞지 않음)
      4. 코드 참조 오류 (존재하지 않는 파일 언급)
      5. 낮은 확신도 응답 (불확실한 표현 다수)
      <UnitTestCase TestVerificationE2E>
        E2E 할루시네이션 검증 통합 테스트
        <TestCaseFunction test_scenario1_reliable_response>
          시나리오 1: 신뢰할 수 있는 응답
          
          특징:
          - Claim이 명확함
          - 모든 Claim이 Evidence Graph에서 검증 가능
          - 확신도가 높음
          - 모순 없음
        <TestCaseFunction test_scenario2_hallucination_suspected>
          시나리오 2: 할루시네이션 의심 응답
          
          특징:
          - 존재하지 않는 파일 언급
          - 구현하지 않은 기능 주장
          - Evidence Graph에서 검증 불가
        <TestCaseFunction test_scenario3_self_contradictory_response>
          시나리오 3: 자기 모순 응답
          
          특징:
          - 응답 내에서 서로 모순되는 주장
          - Claim 자체는 명확하지만 일관성 없음
        <TestCaseFunction test_scenario4_code_reference_errors>
          시나리오 4: 코드 참조 오류
          
          특징:
          - 실제 파일 경로와 다른 경로 언급
          - 존재하지 않는 함수/클래스 참조
        <TestCaseFunction test_scenario5_low_confidence_response>
          시나리오 5: 낮은 확신도 응답
          
          특징:
          - 모호한 표현 다수 ("아마도", "일 것 같습니다")
          - 불확실한 주장
          - 확신도 점수 낮음
      <UnitTestCase TestVerificationIntegration>
        Phase 9 모듈 간 통합 테스트
        <TestCaseFunction test_all_components_together>
          전체 컴포넌트 통합 테스트
        <TestCaseFunction test_claim_extractor_to_verifier_pipeline>
          Claim 추출 → 검증 파이프라인 테스트
        <TestCaseFunction test_fuzzy_analyzer_to_contradiction_detector>
          확신도 분석 → 모순 감지 통합 테스트
    <Dir unit>
      <Module test_auto_verifier.py>
        Cortex Phase 9.1 - Auto-verification 시스템 Unit 테스트
        
        검증 사항:
        1. AutoVerifier 초기화
        2. 확신도 분석 및 자동 검증
        3. Grounding Score 계산
        4. 재수행 트리거
        <Class TestAutoVerifier>
          AutoVerifier 기본 기능 테스트
          <Function test_auto_verifier_initialization>
            AutoVerifier 싱글톤 초기화 테스트
          <Function test_low_confidence_skip_verification>
            확신도 낮은 응답은 검증 건너뛰기
          <Function test_high_confidence_trigger_verification>
            확신도 높은 응답은 자동 검증 트리거
          <Function test_verify_with_evidence_success>
            Evidence 제공 시 검증 성공
          <Function test_verify_without_evidence_fail>
            Evidence 없이 확신 주장 시 재수행 트리거
          <Function test_grounding_score_threshold>
            Grounding Score 임계값 테스트
          <Function test_confidence_level_mapping>
            확신도 레벨 → 점수 매핑 테스트
          <Function test_format_retry_message>
            재수행 메시지 포맷 테스트
          <Function test_format_verified_message>
            검증 완료 메시지 포맷 테스트
        <Class TestAutoVerifierIntegration>
          AutoVerifier 통합 시나리오 테스트
          <Function test_hallucination_detection_flow>
            할루시네이션 감지 플로우 테스트
          <Function test_verified_response_flow>
            검증 통과 플로우 테스트
      <Module test_automation_manager.py>
        Cortex MCP - AutomationManager 단위 테스트
        Plan A/B 시스템 검증
        <Class TestAutomationManagerBasic>
          기본 기능 테스트
          <Function test_init_default_mode>
            초기화 시 기본 모드는 Plan A (auto)
          <Function test_get_status>
            상태 조회
          <Function test_set_mode_to_plan_b>
            Plan B로 수동 전환
          <Function test_set_mode_to_plan_a>
            Plan A로 수동 전환
          <Function test_set_mode_invalid>
            잘못된 모드 설정
        <Class TestFeedbackRecording>
          피드백 기록 테스트
          <Function test_record_accepted_feedback>
            수락 피드백 기록
          <Function test_record_rejected_feedback>
            거부 피드백 기록
          <Function test_record_modified_feedback>
            수정 피드백 기록
          <Function test_record_multiple_feedbacks>
            여러 피드백 기록
        <Class TestPlanSwitching>
          Plan A/B 자동 전환 테스트
          <Function test_switch_to_plan_b_on_high_rejection>
            거부율 30% 이상 3회 연속 시 Plan B로 전환 (Hysteresis)
          <Function test_stay_plan_a_under_threshold>
            거부율 30% 미만 시 Plan A 유지
          <Function test_switch_back_to_plan_a>
            거부율 15% 이하 연속 조건 만족 시 Plan A로 복귀 (Hysteresis)
          <Function test_no_switch_with_insufficient_consecutive>
            연속 조건 부족 시 전환 안함 (Hysteresis)
        <Class TestShouldConfirm>
          확인 필요 여부 판단 테스트
          <Function test_plan_a_no_confirm>
            Plan A: 확인 불필요
          <Function test_plan_b_requires_confirm>
            Plan B: 확인 필요
        <Class TestFeedbackStatistics>
          피드백 통계 테스트
          <Function test_get_feedback_stats_empty>
            빈 통계 조회
          <Function test_get_feedback_stats_with_data>
            데이터가 있는 통계 조회
          <Function test_stats_by_action_type>
            작업 유형별 통계
        <Class TestAutoSwitchToggle>
          자동 전환 활성화/비활성화 테스트
          <Function test_disable_auto_switch>
            자동 전환 비활성화
          <Function test_no_auto_switch_when_disabled>
            자동 전환 비활성화 시 전환 안함
          <Function test_enable_auto_switch>
            자동 전환 재활성화
        <Class TestActionHistory>
          작업 히스토리 테스트
          <Function test_get_action_history>
            작업 히스토리 조회
          <Function test_get_action_history_filtered>
            필터링된 작업 히스토리
        <Class TestRecommendation>
          권장 사항 테스트
          <Function test_recommendation_insufficient_data>
            데이터 부족 시 권장 사항
          <Function test_recommendation_with_data>
            데이터 충분 시 권장 사항
      <Module test_backup_manager.py>
        Cortex MCP - BackupManager 단위 테스트
        스냅샷 생성/복원/관리 검증
        <Class TestSnapshotCreation>
          스냅샷 생성 테스트
          <Function test_create_snapshot_success>
            스냅샷 생성 성공
          <Function test_create_snapshot_with_type>
            스냅샷 타입 지정 생성
          <Function test_create_snapshot_nonexistent_project>
            존재하지 않는 프로젝트 스냅샷
          <Function test_create_multiple_snapshots>
            여러 스냅샷 생성
        <Class TestSnapshotListing>
          스냅샷 목록 테스트
          <Function test_list_snapshots_empty>
            빈 스냅샷 목록
          <Function test_list_snapshots_with_data>
            스냅샷 목록 조회
          <Function test_list_snapshots_filtered_by_type>
            타입별 스냅샷 필터링
        <Class TestSnapshotRestore>
          스냅샷 복원 테스트
          <Function test_restore_snapshot_success>
            스냅샷 복원 성공
          <Function test_restore_nonexistent_snapshot>
            존재하지 않는 스냅샷 복원
        <Class TestSnapshotInfo>
          스냅샷 정보 테스트
          <Function test_get_snapshot_info>
            스냅샷 상세 정보 조회
        <Class TestSnapshotDeletion>
          스냅샷 삭제 테스트
          <Function test_delete_snapshot>
            스냅샷 삭제
        <Class TestSnapshotComparison>
          스냅샷 비교 테스트
          <Function test_compare_snapshots>
            두 스냅샷 비교
        <Class TestBackupHistory>
          백업 히스토리 테스트
          <Function test_get_history>
            히스토리 조회
      <Module test_context_manager.py>
        Cortex MCP - ContextManager 단위 테스트
        Smart Context 시스템 (압축/해제, Lazy Loading) 검증
        <Class TestContextCompression>
          컨텍스트 압축 테스트
          <Function test_compress_context_success>
            컨텍스트 압축 성공
          <Function test_compress_already_compressed>
            이미 압축된 컨텍스트 재압축
        <Class TestLazyLoading>
          Lazy Loading 테스트
          <Function test_load_context_on_demand>
            필요 시 로드
        <Class TestContextInfo>
          컨텍스트 정보 테스트
          <Function test_get_loaded_contexts>
            로드된 컨텍스트 목록 조회
          <Function test_get_context_summary>
            컨텍스트 요약 조회
        <Class TestContextPriority>
          컨텍스트 우선순위 테스트
          <Function test_get_context_priority_info>
            컨텍스트 우선순위 정보 조회
      <Module test_git_sync.py>
        Cortex MCP - GitSync 단위 테스트
        Git 연동 및 자동 전환 검증
        <Class TestGitBranchDetection>
          Git 브랜치 감지 테스트
          <Function test_get_current_git_branch>
            현재 Git 브랜치 감지
          <Function test_get_git_info>
            Git 정보 조회
        <Class TestGitBranchLinking>
          Git 브랜치 연결 테스트
          <Function test_link_git_branch>
            Git 브랜치와 Cortex 브랜치 연결
          <Function test_get_linked_cortex_branch>
            연결된 Cortex 브랜치 조회
          <Function test_list_linked_branches>
            연결된 브랜치 목록 조회
          <Function test_unlink_git_branch>
            Git 브랜치 연결 해제
        <Class TestGitBranchChange>
          Git 브랜치 변경 감지 테스트
          <Function test_check_branch_change>
            브랜치 변경 감지
      <Module test_hierarchical_rag.py>
        Cortex MCP - Hierarchical RAG Engine 단위 테스트
        <Class TestHierarchicalDocument>
          HierarchicalDocument 데이터 클래스 테스트
          <Function test_create_document>
            문서 생성 테스트
          <Function test_to_dict>
            딕셔너리 변환 테스트
        <Class TestSearchResult>
          SearchResult 데이터 클래스 테스트
          <Function test_create_search_result>
            검색 결과 생성 테스트
          <Function test_to_dict>
            딕셔너리 변환 테스트
        <Class TestHierarchicalRAGEngine>
          Hierarchical RAG Engine 테스트
          <Function test_init>
            엔진 초기화 테스트
          <Function test_generate_summary>
            요약 생성 테스트
          <Function test_chunk_content>
            콘텐츠 청킹 테스트
          <Function test_chunk_content_short>
            짧은 콘텐츠 청킹 테스트
          <Function test_index_document_mock>
            문서 인덱싱 테스트 (Mock)
          <Function test_build_filter_no_filter>
            필터 없는 경우 테스트
          <Function test_build_filter_project_only>
            프로젝트 필터만 있는 경우
          <Function test_build_filter_branch_only>
            브랜치 필터만 있는 경우
          <Function test_build_filter_both>
            프로젝트 + 브랜치 필터
          <Function test_search_no_results>
            검색 결과 없는 경우
          <Function test_search_with_results>
            검색 결과 있는 경우
          <Function test_get_stats>
            통계 조회 테스트
          <Function test_delete_document>
            문서 삭제 테스트
        <Class TestSingletonInstance>
          싱글톤 인스턴스 테스트
          <Function test_get_hierarchical_rag_engine>
            싱글톤 인스턴스 가져오기
          <Function test_reset_hierarchical_rag_engine>
            싱글톤 재초기화
      <Module test_memory_manager.py>
        Cortex MCP - MemoryManager 단위 테스트
        <Class TestMemoryManagerBranch>
          브랜치 관련 테스트
          <Function test_create_branch_success>
            브랜치 생성 성공 테스트
          <Function test_create_branch_with_parent>
            부모 브랜치가 있는 브랜치 생성
          <Function test_create_branch_special_characters>
            특수문자가 포함된 브랜치 이름
          <Function test_create_multiple_branches>
            여러 브랜치 생성
        <Class TestMemoryManagerUpdate>
          메모리 업데이트 테스트
          <Function test_update_memory_success>
            메모리 업데이트 성공
          <Function test_update_memory_long_content>
            긴 내용 업데이트
          <Function test_update_memory_unicode>
            유니코드 내용 업데이트
          <Function test_update_memory_invalid_branch>
            존재하지 않는 브랜치 업데이트
        <Class TestMemoryManagerSummary>
          요약 관련 테스트
          <Function test_get_active_summary>
            활성 요약 조회
          <Function test_get_active_summary_no_branch>
            브랜치 ID 없이 요약 조회
          <Function test_update_summary>
            요약 직접 업데이트
        <Class TestMemoryManagerHierarchy>
          계층 구조 테스트
          <Function test_get_hierarchy>
            계층 구조 조회
          <Function test_create_node>
            Node 생성
          <Function test_list_nodes>
            Node 목록 조회
          <Function test_suggest_node_grouping>
            Node 그룹핑 제안
      <Module test_ontology_retry.py>
        Cortex MCP - Ontology Retry Logic Unit Tests
        
        재시도 로직 검증:
        1. 첫 번째 시도 성공
        2. 재시도 후 성공
        3. 모든 재시도 실패 → general 분류 반환
        4. Exponential backoff 검증
        <Class TestOntologyRetryLogic>
          Ontology 재시도 로직 테스트
          <Function test_first_attempt_success>
            첫 번째 시도에서 성공하는 케이스
          <Function test_retry_success_on_second_attempt>
            두 번째 시도에서 성공하는 케이스
          <Function test_retry_success_on_third_attempt>
            세 번째 시도에서 성공하는 케이스
          <Function test_all_retries_fail_fallback_to_general>
            모든 재시도 실패 시 general 분류 반환
          <Function test_exponential_backoff_timing>
            Exponential backoff 타이밍 검증
          <Function test_different_exception_types>
            다양한 예외 타입에서 재시도 동작 확인
          <Function test_retry_logging>
            재시도 로그 기록 검증
        <Class TestOntologyRetryEdgeCases>
          Ontology 재시도 엣지 케이스 테스트
          <Function test_disabled_ontology_no_retry>
            Ontology 비활성화 시 재시도 없음
          <Function test_none_embedding_model_no_retry>
            임베딩 모델이 None일 때 재시도 없음
      <Module test_pay_attention_extended 2.py>
        Cortex MCP - Pay Attention Extended Test Cases
        
        추가 테스트 시나리오 (10개):
        7. Multi-Topic Conversation (다중 토픽 대화)
        8. Deep Context Injection (깊은 컨텍스트 주입)
        9. Attention Priority Ranking (주의 우선순위 랭킹)
        10. Token Budget Management (토큰 예산 관리)
        11. Cross-Branch Reference (브랜치 간 참조)
        12. Temporal Decay (시간 경과에 따른 우선순위 감소)
        13. Topic Clustering (토픽 클러스터링)
        14. Attention Heatmap (주의 히트맵)
        15. Redundancy Detection (중복 컨텍스트 감지)
        16. Performance Stress Test (성능 스트레스 테스트)
        <Class TestMultiTopicConversation>
          Test 7: 다중 토픽 대화
          <Function test_multi_topic_tracking>
            여러 토픽을 동시에 추적
          <Function test_multi_topic_injection>
            다중 토픽 컨텍스트 주입
          <Function test_topic_relevance_filtering>
            관련 토픽만 필터링
        <Class TestDeepContextInjection>
          Test 8: 깊은 컨텍스트 주입
          <Function test_nested_topic_injection>
            중첩된 토픽 컨텍스트 주입
          <Function test_max_depth_limit>
            최대 깊이 제한 테스트
        <Class TestAttentionPriorityRanking>
          Test 9: 주의 우선순위 랭킹
          <Function test_recency_priority>
            최근 메시지 우선순위
          <Function test_relevance_priority>
            관련성 기반 우선순위
        <Class TestTokenBudgetManagement>
          Test 10: 토큰 예산 관리
          <Function test_token_budget_enforcement>
            토큰 예산 강제 적용
          <Function test_session_clear>
            세션 클리어 기능 테스트
        <Class TestCrossBranchReference>
          Test 11: 브랜치 간 참조
          <Function test_branch_isolation>
            브랜치 간 격리
        <Class TestTemporalDecay>
          Test 12: 시간 경과에 따른 우선순위 감소
          <Function test_old_messages_decay>
            오래된 메시지 우선순위 감소
        <Class TestTopicClustering>
          Test 13: 토픽 클러스터링
          <Function test_related_topics_clustering>
            관련 토픽 클러스터링
        <Class TestAttentionHeatmap>
          Test 14: 주의 히트맵
          <Function test_attention_score_tracking>
            주의 점수 추적
        <Class TestRedundancyDetection>
          Test 15: 중복 컨텍스트 감지
          <Function test_duplicate_message_handling>
            중복 메시지 처리
          <Function test_similar_content_deduplication>
            유사 콘텐츠 중복 제거
        <Class TestPerformanceStressTest>
          Test 16: 성능 스트레스 테스트
          <Function test_large_message_volume>
            대량 메시지 처리 성능
          <Function test_injection_latency>
            주입 레이턴시 테스트
          <Function test_memory_efficiency>
            메모리 효율성 테스트
        <Class TestMessageFiltering>
          Test 11: 메시지 필터링
          <Function test_old_message_filtering>
            오래된 메시지 필터링 테스트
        <Class TestIncrementalUpdates>
          Test 12: 점진적 업데이트
          <Function test_incremental_message_addition>
            점진적 메시지 추가 안정성 테스트
      <Module test_pay_attention_extended.py>
        Cortex MCP - Pay Attention Extended Test Cases
        
        추가 테스트 시나리오 (10개):
        7. Multi-Topic Conversation (다중 토픽 대화)
        8. Deep Context Injection (깊은 컨텍스트 주입)
        9. Attention Priority Ranking (주의 우선순위 랭킹)
        10. Token Budget Management (토큰 예산 관리)
        11. Cross-Branch Reference (브랜치 간 참조)
        12. Temporal Decay (시간 경과에 따른 우선순위 감소)
        13. Topic Clustering (토픽 클러스터링)
        14. Attention Heatmap (주의 히트맵)
        15. Redundancy Detection (중복 컨텍스트 감지)
        16. Performance Stress Test (성능 스트레스 테스트)
        <Class TestMultiTopicConversation>
          Test 7: 다중 토픽 대화
          <Function test_multi_topic_tracking>
            여러 토픽을 동시에 추적
          <Function test_multi_topic_injection>
            다중 토픽 컨텍스트 주입
          <Function test_topic_relevance_filtering>
            관련 토픽만 필터링
        <Class TestDeepContextInjection>
          Test 8: 깊은 컨텍스트 주입
          <Function test_nested_topic_injection>
            중첩된 토픽 컨텍스트 주입
          <Function test_max_depth_limit>
            최대 깊이 제한 테스트
        <Class TestAttentionPriorityRanking>
          Test 9: 주의 우선순위 랭킹
          <Function test_recency_priority>
            최근 메시지 우선순위
          <Function test_relevance_priority>
            관련성 기반 우선순위
        <Class TestTokenBudgetManagement>
          Test 10: 토큰 예산 관리
          <Function test_token_budget_enforcement>
            토큰 예산 강제 적용
          <Function test_session_clear>
            세션 클리어 기능 테스트
        <Class TestCrossBranchReference>
          Test 11: 브랜치 간 참조
          <Function test_branch_isolation>
            브랜치 간 격리
        <Class TestTemporalDecay>
          Test 12: 시간 경과에 따른 우선순위 감소
          <Function test_old_messages_decay>
            오래된 메시지 우선순위 감소
        <Class TestTopicClustering>
          Test 13: 토픽 클러스터링
          <Function test_related_topics_clustering>
            관련 토픽 클러스터링
        <Class TestAttentionHeatmap>
          Test 14: 주의 히트맵
          <Function test_attention_score_tracking>
            주의 점수 추적
        <Class TestRedundancyDetection>
          Test 15: 중복 컨텍스트 감지
          <Function test_duplicate_message_handling>
            중복 메시지 처리
          <Function test_similar_content_deduplication>
            유사 콘텐츠 중복 제거
        <Class TestPerformanceStressTest>
          Test 16: 성능 스트레스 테스트
          <Function test_large_message_volume>
            대량 메시지 처리 성능
          <Function test_injection_latency>
            주입 레이턴시 테스트
          <Function test_memory_efficiency>
            메모리 효율성 테스트
        <Class TestMessageFiltering>
          Test 11: 메시지 필터링
          <Function test_old_message_filtering>
            오래된 메시지 필터링 테스트
        <Class TestIncrementalUpdates>
          Test 12: 점진적 업데이트
          <Function test_incremental_message_addition>
            점진적 메시지 추가 안정성 테스트
      <Module test_rag_engine.py>
        Cortex MCP - RAGEngine 단위 테스트
        벡터 검색, 인덱싱, Hybrid 검색 검증
        <Class TestRAGIndexing>
          RAG 인덱싱 테스트
          <Function test_index_content_success>
            콘텐츠 인덱싱 성공
          <Function test_index_content_unicode>
            유니코드 콘텐츠 인덱싱
          <Function test_index_multiple_contents>
            여러 콘텐츠 인덱싱
        <Class TestRAGSearch>
          RAG 검색 테스트
          <Function test_search_context_basic>
            기본 검색
          <Function test_search_context_with_top_k>
            top_k 지정 검색
          <Function test_search_context_empty_query>
            빈 쿼리 검색
          <Function test_search_context_similarity_score>
            유사도 점수 검증
        <Class TestHybridSearch>
          Hybrid 검색 테스트
          <Function test_hybrid_search_basic>
            Hybrid 검색 기본
        <Class TestRAGDeletion>
          RAG 삭제 테스트
          <Function test_delete_by_branch>
            브랜치별 삭제
        <Class TestRAGStatistics>
          RAG 통계 테스트
          <Function test_get_stats>
            전체 통계 조회
      <Module test_reference_history.py>
        Cortex MCP - ReferenceHistory 단위 테스트
        참조 이력 기록 및 추천 시스템 검증
        <Class TestReferenceRecording>
          참조 기록 테스트
          <Function test_record_reference_success>
            참조 기록 성공
          <Function test_record_reference_with_query>
            쿼리 포함 참조 기록
          <Function test_record_multiple_references>
            여러 참조 기록
        <Class TestContextRecommendation>
          컨텍스트 추천 테스트
          <Function test_suggest_contexts_basic>
            기본 추천
          <Function test_suggest_contexts_with_top_k>
            top_k 지정 추천
        <Class TestFeedbackLearning>
          피드백 학습 테스트
          <Function test_update_feedback>
            피드백 업데이트
        <Class TestCoOccurrenceAnalysis>
          동시 참조 분석 테스트
          <Function test_get_co_occurring_contexts>
            동시 참조 분석
        <Class TestReferenceStatistics>
          참조 통계 테스트
          <Function test_get_statistics>
            참조 통계 조회

=============================== warnings summary ===============================
tests/benchmark/ab_test_framework.py:46
  /Users/kimjaeheung/Desktop/Desktop/Dev/project9_cortex_mcp/cortex_mcp/tests/benchmark/ab_test_framework.py:46: PytestCollectionWarning: cannot collect test class 'TestCase' because it has a __init__ constructor (from: tests/test_e2e_integration.py)
    @dataclass

tests/benchmark/ab_test_framework.py:38
  /Users/kimjaeheung/Desktop/Desktop/Dev/project9_cortex_mcp/cortex_mcp/tests/benchmark/ab_test_framework.py:38: PytestCollectionWarning: cannot collect test class 'TestDomain' because it has a __new__ constructor (from: tests/test_e2e_integration.py)
    class TestDomain(Enum):

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
========================= 780 tests collected in 0.54s =========================
