Richer CV experience, sharper STT, livelier LUNA voice

- CV parsing now captures each role's responsibilities/description (not just
title+company); experience/education are split on newlines so descriptions
with commas stay intact
- Interview prompts direct LUNA to ask specific questions about the candidate's
actual projects and technologies
- Speech-to-text: default to the English small.en Whisper model and bias
decoding with a technical-vocabulary initial_prompt (fixes "roles"->"Rolls")
- LUNA's voice now speaks ~15% faster (tunable via LUNA_TTS_RATE)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

app.py

@@ -125,6 +125,7 @@ def apply(job_id):
             return render_template('apply.html', job=job)
 
         def parse_entries(raw_value: str):
+            # Skills: split on commas/semicolons/newlines (many short items).
             import re
             entries = []
             if raw_value:
@@ -134,19 +135,32 @@ def apply(job_id):
                         entries.append(item)
             return entries
 
+        def parse_lines(raw_value: str):
+            # Experience/education: split on newlines (and semicolons) only, so a
+            # role's comma-containing description stays as one entry.
+            import re
+            entries = []
+            if raw_value:
+                for item in re.split(r'[\n;]+', raw_value):
+                    item = item.strip()
+                    if item:
+                        entries.append(item)
+            return entries
+
         skills_input = request.form.get('skills', '')
         experience_input = request.form.get('experience', '')
         education_input = request.form.get('education', '')
 
         manual_features = {
             "skills": parse_entries(skills_input),
-            "experience": parse_entries(experience_input),
-            "education": parse_entries(education_input)
+            "experience": parse_lines(experience_input),
+            "education": parse_lines(education_input)
         }
 
         # Auto-parse the uploaded CV so the candidate's profile reflects their
         # real resume even when the form fields are left blank.  Anything the
         # user typed manually takes precedence; otherwise we use the parsed CV.
+        _splitters = {"skills": parse_entries, "experience": parse_lines, "education": parse_lines}
         parsed_features = {"skills": [], "experience": [], "education": []}
         try:
             if filepath:
@@ -154,7 +168,7 @@ def apply(job_id):
                 for key in parsed_features:
                     value = parsed.get(key, '')
                     if value and value != "Not Found":
-                        parsed_features[key] = parse_entries(value)
+                        parsed_features[key] = _splitters[key](value)
         except Exception as parse_err:
             print(f"Auto CV parse failed: {parse_err}", file=sys.stderr)
 

backend/services/interview_engine.py

@@ -104,7 +104,10 @@ def load_whisper_model():
             # lightweight model to improve startup times. Available options
             # include: tiny, base, base.en, small, medium, large. See
             # https://huggingface.co/ggerganov/whisper.cpp for details.
-            model_name = os.getenv("WHISPER_MODEL_NAME", "base")
+            # Default to the English "small" model for noticeably better accuracy
+            # on technical vocabulary. Override with WHISPER_MODEL_NAME=base.en if
+            # transcription feels slow on the free CPU tier.
+            model_name = os.getenv("WHISPER_MODEL_NAME", "small.en")
             whisper_model = WhisperModel(model_name, device=device, compute_type=compute_type)
             logging.info(f"Whisper model '{model_name}' loaded on {device} with {compute_type}")
         except Exception as e:
@@ -262,9 +265,13 @@ def edge_tts_to_file_sync(text, output_path, voice="en-US-AriaNeural"):
             output_path = os.path.join(directory, os.path.basename(output_path))
             os.makedirs(directory, exist_ok=True)
         
+        # Speak a little faster than the default so LUNA feels lively, not slow.
+        # Tunable via LUNA_TTS_RATE (e.g. "+10%", "+20%").
+        tts_rate = os.getenv("LUNA_TTS_RATE", "+15%")
+
         async def generate_audio():
             try:
-                communicate = edge_tts.Communicate(text, voice)
+                communicate = edge_tts.Communicate(text, voice, rate=tts_rate)
                 await communicate.save(output_path)
                 logging.info(f"TTS audio saved to: {output_path}")
             except Exception as e:
@@ -377,6 +384,9 @@ def generate_next_question(profile, job, conversation_history, last_answer):
         Write LUNA's next turn:
         - Start with a brief, natural acknowledgement of their last answer (e.g. "That makes sense," "Great, thanks for sharing that.").
         - Then ask exactly ONE focused follow-up question.
+        - Prefer SPECIFIC questions about the actual projects, responsibilities, and technologies in the
+          candidate's experience above (e.g. "You mentioned building X at Y — how did you handle Z?"),
+          rather than generic questions.
         - Build on what they actually said and what's already been discussed — never repeat an earlier question.
         - Stay anchored to the {job.role} role and its required skills; for technical roles, probe deeper into real skills/tools.
         - Keep it concise, conversational, and human (1-2 sentences for the question).
@@ -433,12 +443,21 @@ def whisper_stt(audio_path):
         # language="en" avoids misdetecting the language; vad_filter drops
         # silence so Whisper doesn't hallucinate phrases on quiet gaps;
         # condition_on_previous_text=False keeps each answer independent.
+        # initial_prompt biases decoding toward technical-interview vocabulary,
+        # which fixes homophone errors like "roles" -> "Rolls".
+        interview_vocab_prompt = (
+            "This is a technical job interview about software engineering, data science, "
+            "machine learning, AI, web development, cloud, and various job roles. "
+            "Common terms include Python, JavaScript, React, SQL, AWS, Docker, Kubernetes, "
+            "APIs, databases, algorithms, data roles, and frameworks."
+        )
         segments, _ = model.transcribe(
             wav_path,
             language="en",
             beam_size=5,
             vad_filter=True,
             condition_on_previous_text=False,
+            initial_prompt=interview_vocab_prompt,
         )
         transcript = " ".join(segment.text for segment in segments)
         return transcript.strip()

backend/services/resume_parser.py

@@ -360,11 +360,14 @@ Return ONLY a JSON object (no markdown, no commentary) with exactly these keys:
 - "name": the candidate's full name as a string (empty string if not found)
 - "skills": an array of individual technical and professional skills (e.g. ["Python", "React", "AWS", "Project Management"])
 - "education": an array of one-line entries, each "<Degree> in <Field> — <Institution>, <Year>" when available
-- "experience": an array of one-line entries, each "<Job Title> — <Company> (<dates or duration>)" when available
+- "experience": an array with ONE entry per role. Each entry is a single line of the form
+  "<Job Title> at <Company> (<dates or duration>): <1-2 sentence summary of the key responsibilities, projects, and technologies for that role>".
+  Base the summary strictly on that role's bullet points in the resume.
 
 Rules:
 - Use the actual content of the resume; never invent information.
-- Keep each array entry concise and on a single line.
+- Keep each entry on a single line (no line breaks inside an entry).
+- For experience, always include the role's responsibilities/description after the colon when the resume provides them.
 - If a section is missing, return an empty array for it.
 
 Resume text: