v0.4.1

src/main/kotlin/com/cw/vlainter/domain/interview/ai/InterviewAiOrchestrator.kt

@@ -17,8 +17,37 @@ class InterviewAiOrchestrator(
     private val llmProviderRouter: LlmProviderRouter,
     private val objectMapper: ObjectMapper
 ) {
+    private val interviewQuestionEndings = listOf(
+        "설명해 주세요",
+        "말씀해 주세요",
+        "얘기해 주세요",
+        "이야기해 주세요",
+        "알려 주세요",
+        "공유해 주세요",
+        "정리해 주세요",
+        "설명해주세요",
+        "말씀해주세요",
+        "얘기해주세요",
+        "이야기해주세요",
+        "알려주세요",
+        "공유해주세요",
+        "정리해주세요",
+        "무엇인가요",
+        "왜 그런가요",
+        "어떻게 생각하시나요",
+        "어떻게 보시나요",
+        "해주실 수 있나요",
+        "말해주실 수 있나요",
+        "설명해주실 수 있나요"
+    )
+
     private val logger = LoggerFactory.getLogger(javaClass)
 
+    data class DocumentQuestionValidationResult(
+        val accepted: List<GeneratedDocumentQuestion>,
+        val rejectedReasons: List<String>
+    )
+
     fun evaluateTechAnswer(
         question: QaQuestion?,
         userAnswer: String,
@@ -69,8 +98,18 @@ class InterviewAiOrchestrator(
             try {
                 val generated = llmProviderRouter.generateJson(prompt, temperature = temperature)
                 val parsed = parseGeneratedDocumentQuestions(generated.text, fileTypeLabel)
-                val validated = validateGeneratedDocumentQuestions(parsed, fileTypeLabel)
-                validated.forEach { item ->
+                val validation = validateGeneratedDocumentQuestions(parsed, fileTypeLabel)
+                if (validation.rejectedReasons.isNotEmpty()) {
+                    logger.info(
+                        "document question validation summary fileType={} round={} accepted={} rejected={} reasons={}",
+                        fileTypeLabel,
+                        round + 1,
+                        validation.accepted.size,
+                        validation.rejectedReasons.size,
+                        summarizeRejectedReasons(validation.rejectedReasons)
+                    )
+                }
+                validation.accepted.forEach { item ->
                     val key = item.questionText.trim().lowercase()
                     if (key.isNotBlank() && !collected.containsKey(key)) {
                         collected[key] = item.copy(questionNo = collected.size + 1)
@@ -697,48 +736,90 @@ class InterviewAiOrchestrator(
     private fun validateGeneratedDocumentQuestions(
         generated: List<GeneratedDocumentQuestion>,
         fileTypeLabel: String
-    ): List<GeneratedDocumentQuestion> {
+    ): DocumentQuestionValidationResult {
         val seen = linkedSetOf<String>()
-        return generated.mapNotNull { item ->
+        val accepted = mutableListOf<GeneratedDocumentQuestion>()
+        val rejectedReasons = mutableListOf<String>()
+        generated.forEach { item ->
             val normalizedQuestionType = normalizeDocumentQuestionType(item.questionType, fileTypeLabel)
             val normalizedEvidenceKind = normalizeEvidenceKind(item.evidenceKind)
             val normalizedQuestion = item.questionText.replace(Regex("\\s+"), " ").trim()
-            if (!isUsableDocumentQuestion(normalizedQuestion, normalizedQuestionType, normalizedEvidenceKind)) return@mapNotNull null
+            if (!isUsableDocumentQuestion(normalizedQuestion, normalizedQuestionType, normalizedEvidenceKind)) {
+                rejectedReasons += "unusable_question"
+                return@forEach
+            }
 
             val fingerprint = normalizedQuestion
                 .lowercase()
                 .replace(Regex("[^a-z0-9가-힣]+"), "")
-            if (!seen.add(fingerprint)) return@mapNotNull null
+            if (!seen.add(fingerprint)) {
+                rejectedReasons += "duplicate_question"
+                return@forEach
+            }
 
-            if (!isAllowedDocumentQuestionType(normalizedQuestionType, fileTypeLabel, normalizedEvidenceKind)) return@mapNotNull null
-            if (!isCompatibleQuestionForEvidenceKind(normalizedQuestion, normalizedQuestionType, normalizedEvidenceKind)) return@mapNotNull null
+            if (!isAllowedDocumentQuestionType(normalizedQuestionType, fileTypeLabel, normalizedEvidenceKind)) {
+                rejectedReasons += "question_type_mismatch"
+                return@forEach
+            }
+            if (!isCompatibleQuestionForEvidenceKind(normalizedQuestion, normalizedQuestionType, normalizedEvidenceKind)) {
+                rejectedReasons += "question_evidence_kind_mismatch"
+                return@forEach
+            }
 
             val normalizedAnswer = item.referenceAnswer
                 ?.replace(Regex("\\s+"), " ")
                 ?.trim()
-                ?.takeIf {
-                    it.isNotBlank() &&
-                        !isGuideLikeModelAnswer(it) &&
-                        isDocumentAnswerLinkedToQuestion(it, normalizedQuestion, normalizedQuestionType) &&
-                        isCompatibleReferenceAnswer(it, normalizedQuestionType, normalizedEvidenceKind)
+                ?: run {
+                    rejectedReasons += "missing_reference_answer"
+                    return@forEach
                 }
-                ?: return@mapNotNull null
+            if (normalizedAnswer.isBlank()) {
+                rejectedReasons += "blank_reference_answer"
+                return@forEach
+            }
+            if (isGuideLikeModelAnswer(normalizedAnswer)) {
+                rejectedReasons += "guide_like_reference_answer"
+                return@forEach
+            }
+            if (!isDocumentAnswerLinkedToQuestion(normalizedAnswer, normalizedQuestion, normalizedQuestionType)) {
+                rejectedReasons += "reference_answer_not_linked"
+                return@forEach
+            }
+            if (!isCompatibleReferenceAnswer(normalizedAnswer, normalizedQuestionType, normalizedEvidenceKind)) {
+                rejectedReasons += "reference_answer_evidence_kind_mismatch"
+                return@forEach
+            }
 
             val normalizedEvidence = item.evidence
                 .map { it.replace(Regex("\\s+"), " ").trim() }
                 .filter { it.length >= 8 }
                 .distinct()
                 .take(4)
-            if (normalizedEvidence.isEmpty()) return@mapNotNull null
+            if (normalizedEvidence.isEmpty()) {
+                rejectedReasons += "empty_evidence"
+                return@forEach
+            }
 
-            item.copy(
+            accepted += item.copy(
                 questionText = normalizedQuestion,
                 questionType = normalizedQuestionType,
                 evidenceKind = normalizedEvidenceKind,
                 referenceAnswer = normalizedAnswer,
                 evidence = normalizedEvidence
             )
         }
+        return DocumentQuestionValidationResult(
+            accepted = accepted,
+            rejectedReasons = rejectedReasons
+        )
+    }
+
+    private fun summarizeRejectedReasons(reasons: List<String>): String {
+        return reasons.groupingBy { it }
+            .eachCount()
+            .entries
+            .sortedByDescending { it.value }
+            .joinToString(", ") { (reason, count) -> "$reason=$count" }
     }
 
     private fun parseGeneratedTechQuestions(raw: String): List<GeneratedTechQuestion> {
@@ -897,10 +978,18 @@ class InterviewAiOrchestrator(
             commonDomainHints
         }
         if (domainHints.none { lowered.contains(it) }) return false
-        if (!questionText.trim().endsWith("?")) return false
+        if (!hasInterviewQuestionEnding(questionText)) return false
         return true
     }
 
+    private fun hasInterviewQuestionEnding(questionText: String): Boolean {
+        val trimmed = questionText.trim()
+        if (trimmed.endsWith("?")) return true
+
+        val normalized = trimmed.removeSuffix(".").removeSuffix("!").trim()
+        return interviewQuestionEndings.any { normalized.endsWith(it) }
+    }
+
     private fun documentQuestionTypeRules(fileTypeKey: String): List<String> {
         return when (fileTypeKey) {
             "RESUME" -> listOf(

src/main/kotlin/com/cw/vlainter/domain/interview/service/DocumentInterviewService.kt

@@ -822,7 +822,7 @@ class DocumentInterviewService(
         }
 
         if (results.isNotEmpty()) {
-            return results
+            return DocumentQuestionGenerationPolicy.prioritizeSnippets(file.fileType, results)
                 .map(::sanitizePromptSnippet)
                 .filter { isUsablePromptSnippet(file.fileType, it) }
                 .map { it.take(420) }
@@ -913,9 +913,9 @@ class DocumentInterviewService(
 
         val base = when (fileType) {
             FileType.RESUME -> listOf(
-                "이력서에서 실제로 수행한 역할과 책임이 드러나는 경험",
-                "이력서에서 성과나 개선 결과가 드러나는 경험",
-                "이력서에서 협업, 문제 해결, 의사결정이 드러나는 경험"
+                "이력서에서 직무 관련 경력, 인턴, 프로젝트, 연구실 활동처럼 실제로 수행한 역할과 책임이 드러나는 경험",
+                "이력서에서 성과, 수상, 기술적 문제 해결, 개선 결과가 드러나는 경험",
+                "이력서와 지원서 문항에서 지원 동기, 성장 과정, 어려움 극복, 기술적 도전이 드러나는 경험"
             )
             FileType.PORTFOLIO -> listOf(
                 "포트폴리오에서 프로젝트 역할, 기술 선택, 구현 책임이 드러나는 내용",
@@ -946,21 +946,25 @@ class DocumentInterviewService(
             return chunks.take(min(1, snippetBudget)).map { it.take(500) }
         }
 
+        val prioritized = DocumentQuestionGenerationPolicy.prioritizeSnippets(fileType, normalized)
+
         val indexes = when {
-            normalized.size <= snippetBudget -> normalized.indices.toList()
+            prioritized.size <= snippetBudget -> prioritized.indices.toList()
             else -> buildList {
+                val candidateCount = min(prioritized.size, max(snippetBudget, snippetBudget * 2))
+                val candidateLastIndex = candidateCount - 1
                 add(0)
-                val step = max(1, normalized.lastIndex / max(1, snippetBudget - 1))
+                val step = max(1, candidateLastIndex / max(1, snippetBudget - 1))
                 var current = step
-                while (size < snippetBudget - 1 && current < normalized.lastIndex) {
+                while (size < snippetBudget - 1 && current < candidateLastIndex) {
                     add(current)
                     current += step
                 }
-                add(normalized.lastIndex)
+                add(candidateLastIndex)
             }
         }.distinct()
 
-        return indexes.map { normalized[it].take(500) }
+        return indexes.map { prioritized[it].take(500) }
     }
 
     private fun resolveTechCandidates(userId: Long, categoryId: Long, difficulty: QuestionDifficulty?) =

src/main/kotlin/com/cw/vlainter/domain/interview/service/DocumentQuestionGenerationPolicy.kt

@@ -24,6 +24,21 @@ internal data class ClassifiedPromptSnippet(
 }
 
 internal object DocumentQuestionGenerationPolicy {
+    private val resumeRoleSignals = listOf(
+        "경력", "직무관련 경력", "인턴", "프로젝트", "연구실", "학부연구생", "대외 활동",
+        "수상", "해커톤", "백엔드", "개발", "구현", "설계", "개선", "문제", "해결",
+        "성과", "결과", "지원한 이유", "지원동기", "입사 후", "성장과정", "역경", "기술적 도전",
+        "intern", "project", "award", "hackathon", "backend", "implemented", "designed",
+        "improved", "result", "motivation", "growth", "challenge"
+    )
+    private val resumeNoiseSignals = listOf(
+        "지원자", "휴대폰 번호", "전화 번호", "희망근무지역", "주소", "영문", "인적사항",
+        "학점", "평점", "학번", "취득 학점", "과목명", "성적", "수강연도", "학기", "교양", "전공",
+        "phone", "address", "gpa", "grade", "semester", "course"
+    )
+    private val introduceAspirationSignals = listOf(
+        "지원동기", "포부", "가치관", "계획", "성장", "motivation", "value", "plan"
+    )
     private val aspirationMarkers = listOf(
         "싶", "하고자", "하겠습니다", "가지겠습니다", "희망", "포부", "지원 동기", "지원동기",
         "기여", "성장", "배우", "목표", "관심", "꿈", "되고자", "되겠습니다",
@@ -91,6 +106,10 @@ internal object DocumentQuestionGenerationPolicy {
         FileType.PROFILE_IMAGE -> 2
     }
 
+    fun prioritizeSnippets(fileType: FileType, snippets: List<String>): List<String> {
+        return snippets.sortedByDescending { promptSnippetScore(fileType, it) }
+    }
+
     fun classifySnippets(fileType: FileType, snippets: List<String>): List<ClassifiedPromptSnippet> {
         return snippets.map { snippet ->
             ClassifiedPromptSnippet(
@@ -148,6 +167,30 @@ internal object DocumentQuestionGenerationPolicy {
         FileType.PROFILE_IMAGE -> 0.5
     }
 
+    private fun promptSnippetScore(fileType: FileType, snippet: String): Int {
+        val lowered = snippet.lowercase()
+        return when (fileType) {
+            FileType.RESUME -> {
+                val signalHits = resumeRoleSignals.count { lowered.contains(it) } * 18
+                val noiseHits = resumeNoiseSignals.count { lowered.contains(it) } * 16
+                val numberBonus = if (Regex("""\d+[%건명배회]""").containsMatchIn(snippet)) 12 else 0
+                val lengthBonus = min(20, snippet.length / 40)
+                signalHits + numberBonus + lengthBonus - noiseHits
+            }
+            FileType.INTRODUCE -> {
+                val signalHits = resumeRoleSignals.count { lowered.contains(it) } * 10
+                val aspirationHits = introduceAspirationSignals.count { lowered.contains(it) } * 14
+                signalHits + aspirationHits + min(16, snippet.length / 50)
+            }
+            FileType.PORTFOLIO -> {
+                val signalHits = resumeRoleSignals.count { lowered.contains(it) } * 15
+                val numberBonus = if (Regex("""\d+[%건명배회]""").containsMatchIn(snippet)) 10 else 0
+                signalHits + numberBonus + min(18, snippet.length / 45)
+            }
+            FileType.PROFILE_IMAGE -> snippet.length / 10
+        }
+    }
+
     private fun countMarkerHits(text: String, markers: List<String>): Int {
         return markers.count { marker -> text.contains(marker.lowercase()) }
     }

src/test/kotlin/com/cw/vlainter/domain/interview/ai/InterviewAiOrchestratorTests.kt

@@ -151,6 +151,41 @@ class InterviewAiOrchestratorTests {
         assertThat(capturedPrompt).contains("INTRODUCE_MOTIVATION, INTRODUCE_VALUE, INTRODUCE_FUTURE_PLAN, INTRODUCE_EXPERIENCE")
     }
 
+    @Test
+    fun `문서 질문은 설명해 주세요로 끝나는 한국어 면접 문장도 허용한다`() {
+        given(llmProviderRouter.generateJson(anyString(), nullable(Double::class.java))).willReturn(
+            LlmGenerationResult(
+                model = "gemini",
+                modelVersion = "v1",
+                text = """
+                    {
+                      "questions": [
+                        {
+                          "questionText": "JWT 기반 인증을 선택한 이유와 실무 적용 시 장단점을 설명해 주세요.",
+                          "questionType": "RESUME_EXPERIENCE",
+                          "evidenceKind": "ACTUAL_EXPERIENCE",
+                          "referenceAnswer": "프로젝트에서 인증 체계를 빠르게 구축해야 하는 상황이 있었습니다. 당시 저는 서버 API 설계와 인증 로직 구현을 담당했습니다. JWT 기반 인증을 선택한 이유는 세션 방식보다 확장성과 클라이언트 분리 측면에서 유리했기 때문입니다. 실무 적용에서는 토큰 탈취와 무효화 같은 장단점을 함께 고려해 Refresh Token과 Redis 기반 세션 추적을 도입했습니다. 그 결과 인증 상태 관리의 유연성과 보안 통제를 동시에 확보할 수 있었습니다.",
+                          "evidence": [
+                            "JWT, Refresh Token, Redis 기반 인증 구조를 프로젝트에 적용한 경험이 있음"
+                          ]
+                        }
+                      ]
+                    }
+                """.trimIndent()
+            )
+        )
+
+        val generated = orchestrator.generateDocumentQuestions(
+            fileTypeLabel = "RESUME",
+            difficulty = null,
+            questionCount = 1,
+            contextSnippets = listOf("JWT, Refresh Token, Redis 기반 인증 구조를 프로젝트에 적용한 경험이 있다.")
+        )
+
+        assertThat(generated).hasSize(1)
+        assertThat(generated.first().questionText).endsWith("설명해 주세요.")
+    }
+
     @Test
     fun `영어 문서 답변 평가 프롬프트는 평가 출력은 한국어로 유지하고 영어 문법 기준을 명시한다`() {
         var capturedPrompt = ""

src/test/kotlin/com/cw/vlainter/domain/interview/service/DocumentQuestionGenerationPolicyTests.kt

@@ -55,4 +55,20 @@ class DocumentQuestionGenerationPolicyTests {
 
         assertThat(classified.single().kind).isNotEqualTo(DocumentSnippetKind.PROJECT_OR_RESULT)
     }
+
+    @Test
+    fun `이력서 snippet 우선순위는 과목표보다 경력과 수상 경험을 앞세운다`() {
+        val prioritized = DocumentQuestionGenerationPolicy.prioritizeSnippets(
+            fileType = FileType.RESUME,
+            snippets = listOf(
+                "학 사 컴퓨터공학 2023 1 전공 데이터베이스 3 A+ 운영체제 3 A 과목명 취득 학점 성적",
+                "마음AI에서 SW 개발 인턴으로 음성봇 고도화 작업과 백엔드 개발을 담당했습니다.",
+                "AWS 루키 챔피언십에서 Slack 알림 봇을 주제로 OCR 분석과 번역 기능을 접목한 서비스를 제작해 수상했습니다."
+            )
+        )
+
+        assertThat(prioritized.first()).contains("마음AI")
+        assertThat(prioritized[1]).contains("AWS 루키 챔피언십")
+        assertThat(prioritized.last()).contains("과목명")
+    }
 }