Prepare PitchFight AI completion

README.md

@@ -5,7 +5,7 @@ colorFrom: red
 colorTo: yellow
 sdk: gradio
 app_file: app.py
-pinned: false
+pinned: true
 ---
 
 # PitchFight AI

app.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 from typing import Any
 
@@ -13,16 +14,22 @@ from gradio import Server
 from core.api_handlers import (
     handle_chat_round,
     handle_deck_critique_placeholder,
-    handle_deal_session_placeholder,
     handle_end_battle,
+    handle_end_deal,
+    handle_deal_round,
     handle_load_sample,
     handle_reset_session,
+    handle_retry_weakest_start,
+    handle_retry_weakest_submit,
+    handle_start_deal_phase,
     handle_start_session,
-    handle_voice_pitch_placeholder,
+    handle_voice_pitch,
+    handle_voice_turn,
 )
 from core import model_router
 
 APP_VERSION = "0.1.0"
+PITCHFIGHT_PORT = int(os.getenv("PITCHFIGHT_PORT", "7860"))
 FRONTEND_DIR = Path(__file__).parent / "frontend"
 
 app = Server()
@@ -65,19 +72,44 @@ def api_end_battle(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     return handle_end_battle(payload)
 
 
+@app.post("/api/retry-weakest-question/start")
+def api_retry_weakest_start(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_retry_weakest_start(payload)
+
+
+@app.post("/api/retry-weakest-question/submit")
+def api_retry_weakest_submit(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_retry_weakest_submit(payload)
+
+
 @app.post("/api/reset-session")
 def api_reset_session(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     return handle_reset_session(payload)
 
 
 @app.post("/api/voice-pitch")
-def api_voice_pitch(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, str]:
-    return handle_voice_pitch_placeholder(payload)
+def api_voice_pitch(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_voice_pitch(payload)
+
+
+@app.post("/api/voice-turn")
+def api_voice_turn(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_voice_turn(payload)
+
+
+@app.post("/api/start-deal-phase")
+def api_start_deal_phase(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_start_deal_phase(payload)
+
+
+@app.post("/api/deal-round")
+def api_deal_round(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_deal_round(payload)
 
 
-@app.post("/api/start-deal-session")
-def api_start_deal_session(payload: dict[str, Any] = Body(default_factory=dict)) -> dict[str, str]:
-    return handle_deal_session_placeholder(payload)
+@app.post("/api/end-deal")
+def api_end_deal(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return handle_end_deal(payload)
 
 
 @app.post("/api/deck-critique")
@@ -131,4 +163,17 @@ app.mount("/frontend", StaticFiles(directory=str(FRONTEND_DIR)), name="frontend"
 
 
 if __name__ == "__main__":
-    app.launch(show_error=True)
+    url = f"http://127.0.0.1:{PITCHFIGHT_PORT}"
+    print(f"Starting PitchFight AI on {url}")
+    try:
+        app.launch(show_error=True, server_port=PITCHFIGHT_PORT)
+    except OSError as exc:
+        if "empty port" in str(exc).lower() or str(PITCHFIGHT_PORT) in str(exc):
+            print(
+                f"\nERROR: Port {PITCHFIGHT_PORT} is already in use by another process.\n"
+                f"Stop the old server (Ctrl+C in its terminal), or free the port:\n"
+                f"  netstat -ano | findstr \":{PITCHFIGHT_PORT}\"\n"
+                f"  taskkill /PID <pid> /F\n"
+                f"Then run: python app.py\n"
+            )
+        raise SystemExit(1) from exc

config/judge_settings.json

@@ -0,0 +1,126 @@
+{
+  "default_profile": "practice",
+  "profiles": {
+    "practice": {
+      "label": "Practice Mode",
+      "description": "Student-friendly pitch practice for first/second-time founders.",
+      "profile_display": {
+        "pressure_labels": {
+          "explore": "Warm-up",
+          "pressure": "Focused",
+          "close": "Final Practice"
+        }
+      },
+      "question_style": {
+        "plain_language": true,
+        "avoid_jargon": true,
+        "avoid_compound_questions": true,
+        "one_question_only": true,
+        "max_sentences": 3,
+        "tone": "challenging_but_supportive",
+        "instruction": "This founder is practicing for the first or second time. Ask ONE clear, short question using plain everyday language. Do NOT use terms like: unit economics, contribution margin, defensibility, TAM, SAM, SOM, moat, CAC, LTV, load-bearing mechanism, demonstrably, quantify match accuracy, precision threshold, or any benchmark jargon. Instead ask things like: 'What number proves this is working?', 'How do you know students need this?', 'How will you get your first 100 users?', 'Why would students choose this over existing options?', 'How do you know users will come back?', 'How much will you charge, and who pays?'. Be challenging and ask for evidence — but keep the language a first-time founder can understand without a business degree."
+      },
+      "coaching_style": {
+        "tone": "encouraging_actionable",
+        "instruction": "Be encouraging but honest. Explain what the founder did right, then show exactly how to make the answer stronger with one specific number, example, or proof point.",
+        "example": "Your answer touched on the right idea. Here's how to make it more convincing with one specific number or example."
+      },
+      "battle_phase_tone": {
+        "explore": "medium",
+        "pressure": "medium_high_but_clear",
+        "close": "firm_but_supportive"
+      },
+      "scoring_calibration": {
+        "attempted_answer_floor": 32,
+        "partial_signal_floor": 38,
+        "concrete_signal_floor": 48,
+        "non_answer_max": 22,
+        "startup_context_max": 48,
+        "vague_on_topic_range": [32, 48],
+        "one_concrete_signal_range": [48, 65],
+        "strong_answer_range": [71, 85],
+        "excellent_answer_range": [86, 100]
+      }
+    },
+    "judge": {
+      "label": "Judge Mode",
+      "description": "Balanced hackathon judge simulation.",
+      "profile_display": {
+        "pressure_labels": {
+          "explore": "Moderate",
+          "pressure": "High",
+          "close": "Panel Ready"
+        }
+      },
+      "question_style": {
+        "plain_language": true,
+        "avoid_jargon": true,
+        "avoid_compound_questions": true,
+        "one_question_only": true,
+        "max_sentences": 3,
+        "tone": "realistic_hackathon_judge",
+        "instruction": "Act like a realistic hackathon judge. Be sharp and specific, but keep questions understandable. Ask one clear question at a time and focus on demo strength, novelty, user pain, and feasibility."
+      },
+      "coaching_style": {
+        "tone": "balanced_judge_feedback",
+        "instruction": "Be direct and fair. Highlight what would convince a hackathon judge and what still needs proof before demo time.",
+        "example": "This answer has a useful signal, but a judge still needs to see proof in the demo. Make the claim measurable and show it quickly."
+      },
+      "battle_phase_tone": {
+        "explore": "medium_high",
+        "pressure": "high_but_fair",
+        "close": "firm_judging_panel"
+      },
+      "scoring_calibration": {
+        "attempted_answer_floor": 30,
+        "partial_signal_floor": 38,
+        "concrete_signal_floor": 48,
+        "non_answer_max": 18,
+        "vague_on_topic_range": [30, 42],
+        "one_concrete_signal_range": [48, 60],
+        "strong_answer_range": [70, 85],
+        "excellent_answer_range": [86, 100]
+      }
+    },
+    "investor": {
+      "label": "Investor Mode",
+      "description": "Harder skeptical VC-style pressure.",
+      "profile_display": {
+        "pressure_labels": {
+          "explore": "High",
+          "pressure": "Very High",
+          "close": "Investor Pressure"
+        }
+      },
+      "question_style": {
+        "plain_language": false,
+        "avoid_jargon": false,
+        "avoid_compound_questions": false,
+        "one_question_only": true,
+        "max_sentences": 4,
+        "tone": "skeptical_investor",
+        "instruction": "Act like a skeptical early-stage investor. Pressure-test market size, moat, retention, revenue logic, distribution, and why now. Be tougher than Practice Mode, but still focus on one main pressure point per round."
+      },
+      "coaching_style": {
+        "tone": "sharp_investor_feedback",
+        "instruction": "Be sharper and more business-focused. Explain what would worry an investor and what proof is needed to reduce that concern.",
+        "example": "This answer lacks defensibility. A real investor needs to hear your moat mechanism, not just what the product does."
+      },
+      "battle_phase_tone": {
+        "explore": "high",
+        "pressure": "very_high",
+        "close": "investment_committee"
+      },
+      "scoring_calibration": {
+        "attempted_answer_floor": 25,
+        "partial_signal_floor": 35,
+        "concrete_signal_floor": 45,
+        "non_answer_max": 15,
+        "vague_on_topic_range": [25, 38],
+        "one_concrete_signal_range": [45, 58],
+        "strong_answer_range": [70, 85],
+        "excellent_answer_range": [86, 100]
+      }
+    }
+  }
+}

core/api_handlers.py

@@ -8,7 +8,7 @@ from typing import Any
 
 from dotenv import load_dotenv
 
-from core.attack_tags import get_attack_tags, get_next_attack_tag
+from core.attack_tags import get_attack_tags, get_next_attack_tag, get_answer_checklist
 from core.persona_builder import build_persona_prompt
 from core.samples import get_sample_startup
 from core.scoring_engine import (
@@ -18,10 +18,18 @@ from core.scoring_engine import (
     build_session_aware_fallback_scorecard,
 )
 from core.claim_extractor import extract_concrete_signals
+from core.judge_settings import normalize_difficulty, get_label, get_pressure_display_label
 from core import battle_flow
 from core import model_router
 from core import session_manager
 from core.output_sanitizer import sanitize_model_output
+from core import voice_handler
+from core import retry_handler
+from core import session_repository
+from core.deal_verdict import build_judge_verdict
+from core.deal_phase import start_deal_phase
+from core.deal_flow import next_deal_round
+from core.deal_scoring_engine import generate_deal_scorecard
 
 load_dotenv()
 
@@ -92,6 +100,37 @@ def get_battle_phase(round_number: int) -> str:
     return "close"
 
 
+import re as _re
+
+_HAS_NUMBER = _re.compile(r"\d")
+_HAS_USER_WORD = _re.compile(
+    r"\b(users?|customers?|students?|people|patients?|teachers?|clients?|founders?|hospitals?)\b",
+    _re.IGNORECASE,
+)
+
+
+def _micro_coach_tip(message: str, quality: str, attack_tag: str, difficulty_profile: str) -> str:
+    """One short, encouraging nudge after a round — teaches the next answer, not the score.
+
+    Local only (no API). Trains the founder toward 'minimum viable answer': one number,
+    one user, one real result. Kept gentle for Practice; empty when nothing useful to add.
+    """
+    text = (message or "").strip()
+    if not text:
+        return ""
+    if quality == "non_answer":
+        return "Take a real guess next time — even one specific detail beats a blank."
+
+    has_number = bool(_HAS_NUMBER.search(text))
+    has_user = bool(_HAS_USER_WORD.search(text))
+
+    if not has_number:
+        return "Good start — next time add one number (a count, a result, or a price)."
+    if not has_user:
+        return "Nice, you gave a number — next time say who it's for or who it's from."
+    return "Solid — to go further, tie that proof directly to the question asked."
+
+
 def _recent_history(session_id: str, max_turns: int = _HISTORY_WINDOW) -> list[dict]:
     """Return at most max_turns recent history entries for live inference."""
     full = session_manager.get_history(session_id)
@@ -221,16 +260,30 @@ def handle_start_session(payload: dict[str, Any]) -> dict[str, Any]:
     """Create a new pitch battle session and return the opening challenge."""
     startup = payload.get("startup") or {}
     persona = payload.get("persona", "technical_judge")
-    difficulty = payload.get("difficulty", "high")
+    # Accept difficulty_profile (new) or difficulty (legacy) — normalize both
+    raw_difficulty = (
+        payload.get("difficulty_profile")
+        or payload.get("difficulty")
+        or "practice"
+    )
+    difficulty_profile = normalize_difficulty(raw_difficulty)
+    difficulty_label = get_label(difficulty_profile)
     input_mode = payload.get("input_mode", "text")
     mode = payload.get("mode", "pitch_battle")
     model_mode = payload.get("model_mode", "premium_nvidia")
 
     session = session_manager.create_session(
-        startup, persona, difficulty, input_mode
+        startup, persona, difficulty_profile, input_mode
     )
     session["mode"] = mode
     session["model_mode"] = model_mode
+    # Store normalized profile so scorecard and chat rounds can use it
+    session["difficulty_profile"] = difficulty_profile
+    session["difficulty_label"] = difficulty_label
+
+    voice_pitch = payload.get("voice_pitch")
+    if input_mode == "voice" and isinstance(voice_pitch, dict):
+        session_manager.set_voice_pitch(session["session_id"], voice_pitch)
 
     mock_attack_tag, mock_ai_message = OPENING_MESSAGES.get(
         persona, OPENING_MESSAGES["technical_judge"]
@@ -244,7 +297,7 @@ def handle_start_session(payload: dict[str, Any]) -> dict[str, Any]:
     model_error: str | None = None
 
     try:
-        messages = _build_opening_messages(startup, persona, difficulty, mock_attack_tag)
+        messages = _build_opening_messages(startup, persona, difficulty_profile, mock_attack_tag)
         result = model_router.generate_opponent_response(
             messages,
             model_mode=model_mode,
@@ -268,12 +321,18 @@ def handle_start_session(payload: dict[str, Any]) -> dict[str, Any]:
 
     session_manager.append_ai_message(session["session_id"], ai_message, attack_tag)
 
+    # Phase 9.5: persist fully-populated session (opening message already in history).
+    session_repository.save_session(session)
+
+    _phase_start = get_battle_phase(1)
     return {
         "session_id": session["session_id"],
         "round": 1,
         "pressure_level": pressure_level(1),
-        "battle_phase": get_battle_phase(1),
+        "battle_phase": _phase_start,
+        "pressure_label": get_pressure_display_label(difficulty_profile, _phase_start),
         "attack_tag": attack_tag,
+        "answer_hint": get_answer_checklist(attack_tag),
         "ai_message": ai_message,
         "model_mode": used_model_mode,
         "provider": provider,
@@ -286,6 +345,8 @@ def handle_start_session(payload: dict[str, Any]) -> dict[str, Any]:
         "battle_complete": False,
         "can_continue": True,
         "next_action": "continue",
+        "difficulty_profile": difficulty_profile,
+        "difficulty_label": difficulty_label,
         **({"model_error": model_error} if model_error else {}),
     }
 
@@ -320,7 +381,11 @@ def handle_chat_round(payload: dict[str, Any]) -> dict[str, Any]:
         session_manager.append_user_message(session_id, message)
 
     persona = session.get("persona", "technical_judge")
-    difficulty = session.get("difficulty", "high")
+    # Use stored normalized profile; fall back to normalizing legacy difficulty field
+    difficulty_profile = session.get("difficulty_profile") or normalize_difficulty(
+        session.get("difficulty", "practice")
+    )
+    difficulty_label = session.get("difficulty_label") or get_label(difficulty_profile)
     startup = session.get("startup", {})
     model_mode = session.get("model_mode", "premium_nvidia")
     next_round = session_manager.increment_round(session_id)
@@ -384,7 +449,7 @@ def handle_chat_round(payload: dict[str, Any]) -> dict[str, Any]:
         messages = _build_followup_messages(
             startup,
             persona,
-            difficulty,
+            difficulty_profile,
             attack_tag,
             recent_history,
             judge_action_result,
@@ -410,12 +475,24 @@ def handle_chat_round(payload: dict[str, Any]) -> dict[str, Any]:
 
     session_manager.append_ai_message(session_id, ai_message, attack_tag)
 
+    # Phase 9.5: persist the new user + judge history entries (last 2 appended above).
+    session_repository.update_round(session_id, session.get("history", [])[-2:])
+
+    input_mode = payload.get("input_mode") or session.get("input_mode", "text")
+    voice_turn_id = payload.get("voice_turn_id", "")
+    if input_mode == "voice" and voice_turn_id and message:
+        voice_handler.confirm_voice_turn(session_id, voice_turn_id, message)
+
+    _phase_chat = get_battle_phase(next_round)
     return {
         "session_id": session_id,
         "round": next_round,
         "pressure_level": pressure_level(next_round),
-        "battle_phase": get_battle_phase(next_round),
+        "battle_phase": _phase_chat,
+        "pressure_label": get_pressure_display_label(difficulty_profile, _phase_chat),
         "attack_tag": attack_tag,
+        "answer_hint": get_answer_checklist(attack_tag),
+        "micro_coach": _micro_coach_tip(message, quality, current_attack_tag, difficulty_profile),
         "ai_message": ai_message,
         "model_mode": used_model_mode,
         "provider": provider,
@@ -436,6 +513,8 @@ def handle_chat_round(payload: dict[str, Any]) -> dict[str, Any]:
             "You have enough material for a scorecard. You can end the battle now or continue practicing."
             if soft_limit else None
         ),
+        "difficulty_profile": difficulty_profile,
+        "difficulty_label": difficulty_label,
         **({"model_error": model_error} if model_error else {}),
     }
 
@@ -469,9 +548,181 @@ def handle_end_battle(payload: dict[str, Any]) -> dict[str, Any]:
             scorecard = mock_scorecard(session)
             scorecard["model_error"] = f"Scorecard generation error: {type(exc).__name__}"
 
+    voice_summary = voice_handler.build_voice_delivery_summary(session)
+    if voice_summary:
+        scorecard["voice_delivery"] = voice_summary
+
+    session["latest_scorecard"] = scorecard
+
+    # Phase 9.5: persist scorecard and battle summary after in-memory mutation.
+    session_repository.save_scorecard(session_id, scorecard)
+    session_repository.update_battle_summary(session_id, {
+        "total_rounds": session.get("round", 0),
+        "final_round": session.get("round", 0),
+        "status": "completed",
+        "battle_complete": True,
+    })
+
+    try:
+        judge_verdict = build_judge_verdict(session, scorecard)
+        session["judge_verdict"] = judge_verdict
+        scorecard["judge_verdict"] = judge_verdict
+        # Phase 9.5: persist judge verdict after it is stored on session.
+        session_repository.save_judge_verdict(session_id, judge_verdict)
+    except Exception as exc:
+        logger.warning("handle_end_battle: judge verdict failed: %s", exc)
+
     return scorecard
 
 
+def handle_start_deal_phase(payload: dict[str, Any]) -> dict[str, Any]:
+    """Start integrated deal phase from pitch session."""
+    session_id = str(payload.get("session_id", "")).strip()
+    if not session_id:
+        return {"error": "session_id is required"}
+
+    session = session_manager.get_session(session_id)
+    if not session:
+        return {"error": "Session not found"}
+
+    try:
+        result = start_deal_phase(session)
+        # Phase 9.5: persist the opening judge deal message after deal_history is populated.
+        if isinstance(result, dict) and "error" not in result:
+            deal_history = session.get("deal_history", [])
+            if deal_history:
+                session_repository.update_deal_round(session_id, deal_history[-1])
+        return result
+    except Exception as exc:
+        logger.warning("handle_start_deal_phase raised: %s", exc)
+        return {"error": "Could not start deal phase."}
+
+
+def handle_deal_round(payload: dict[str, Any]) -> dict[str, Any]:
+    """Process one deal negotiation round."""
+    session_id = str(payload.get("session_id", "")).strip()
+    message = str(payload.get("user_message", "")).strip()
+    input_mode = str(payload.get("input_mode", "text") or "text")
+    voice_turn_id = str(payload.get("voice_turn_id", "") or "")
+
+    if not session_id:
+        return {"error": "session_id is required"}
+
+    session = session_manager.get_session(session_id)
+    if not session:
+        return {"error": "Session not found"}
+
+    if input_mode == "voice" and voice_turn_id and message:
+        voice_handler.confirm_voice_turn(session_id, voice_turn_id, message)
+
+    try:
+        result = next_deal_round(session, message, input_mode=input_mode, voice_turn_id=voice_turn_id)
+        # Phase 9.5: persist the new founder + judge deal entries (last 2 appended above).
+        if isinstance(result, dict) and "error" not in result:
+            deal_history = session.get("deal_history", [])
+            new_entries = deal_history[-2:] if len(deal_history) >= 2 else deal_history
+            if new_entries:
+                session_repository.update_deal_round(session_id, new_entries)
+        return result
+    except Exception as exc:
+        logger.warning("handle_deal_round raised: %s", exc)
+        return {"error": "Could not process deal round."}
+
+
+def handle_end_deal(payload: dict[str, Any]) -> dict[str, Any]:
+    """End deal phase and return deal + combined scorecards."""
+    session_id = str(payload.get("session_id", "")).strip()
+    if not session_id:
+        return {"error": "session_id is required"}
+
+    session = session_manager.get_session(session_id)
+    if not session:
+        return {"error": "Session not found"}
+
+    try:
+        result = generate_deal_scorecard(session)
+        # Phase 9.5: persist deal scorecard + combined scorecard after generation.
+        if isinstance(result, dict) and "error" not in result:
+            session_repository.save_deal_scorecard(
+                session_id,
+                result.get("deal_scorecard") or {},
+                result.get("combined_scorecard") or {},
+            )
+        return result
+    except Exception as exc:
+        logger.warning("handle_end_deal raised: %s", exc)
+        return {"error": "Could not generate deal scorecard."}
+
+
+def handle_retry_weakest_start(payload: dict[str, Any]) -> dict[str, Any]:
+    """Start a retry drill from the latest scorecard answer_to_retry."""
+    session_id = str(payload.get("session_id", "")).strip()
+    if not session_id:
+        return {"error": "session_id is required"}
+
+    session = session_manager.get_session(session_id)
+    if not session:
+        return {"error": "Session not found"}
+
+    try:
+        result = retry_handler.start_retry_drill(session)
+        # Phase 9.5: persist the newly created drill after it is stored on session.
+        retry_id = result.get("retry_id") if isinstance(result, dict) else None
+        if retry_id and "error" not in result:
+            drill = session.get("retry_drills", {}).get(retry_id)
+            if drill:
+                session_repository.save_retry_drill(session_id, drill)
+        return result
+    except Exception as exc:
+        logger.warning("handle_retry_weakest_start raised: %s", exc)
+        return {"error": "Could not start retry drill. Try ending a battle first."}
+
+
+def handle_retry_weakest_submit(payload: dict[str, Any]) -> dict[str, Any]:
+    """Evaluate a retry answer against the original weak answer."""
+    session_id = str(payload.get("session_id", "")).strip()
+    retry_id = str(payload.get("retry_id", "")).strip()
+    retry_answer = str(payload.get("retry_answer", "")).strip()
+    input_mode = str(payload.get("input_mode", "text") or "text")
+    voice_turn_id = str(payload.get("voice_turn_id", "") or "")
+
+    if not session_id:
+        return {"error": "session_id is required"}
+    if not retry_id:
+        return {"error": "retry_id is required"}
+
+    session = session_manager.get_session(session_id)
+    if not session:
+        return {"error": "Session not found"}
+
+    if input_mode == "voice" and voice_turn_id and retry_answer:
+        voice_handler.confirm_voice_turn(session_id, voice_turn_id, retry_answer)
+
+    try:
+        result = retry_handler.evaluate_retry_answer(
+            session,
+            retry_id,
+            retry_answer,
+            input_mode=input_mode,
+            voice_turn_id=voice_turn_id,
+        )
+        # Phase 9.5: persist updated drill, scorecard, and refreshed verdict after eval.
+        if isinstance(result, dict) and "error" not in result:
+            drill = session.get("retry_drills", {}).get(retry_id)
+            if drill:
+                session_repository.save_retry_drill(session_id, drill)
+            latest_scorecard = session.get("latest_scorecard")
+            if isinstance(latest_scorecard, dict):
+                session_repository.save_scorecard(session_id, latest_scorecard)
+            latest_verdict = session.get("judge_verdict")
+            if isinstance(latest_verdict, dict):
+                session_repository.save_judge_verdict(session_id, latest_verdict)
+        return result
+    except Exception as exc:
+        logger.warning("handle_retry_weakest_submit raised: %s", exc)
+        return {"error": "Could not evaluate retry answer. Please try again."}
+
+
 def handle_reset_session(payload: dict[str, Any]) -> dict[str, Any]:
     """Clear a battle session."""
     session_id = payload.get("session_id", "")
@@ -479,15 +730,19 @@ def handle_reset_session(payload: dict[str, Any]) -> dict[str, Any]:
     return {"status": "reset"}
 
 
-def handle_voice_pitch_placeholder(_payload: dict[str, Any] | None = None) -> dict[str, str]:
-    """Reserved endpoint for voice pitch mode."""
-    return {
-        "status": "not_implemented",
-        "message": (
-            "Voice Mode endpoint is reserved and will be connected "
-            "after transcription integration."
-        ),
-    }
+def handle_voice_pitch(payload: dict[str, Any]) -> dict[str, Any]:
+    """Process opening spoken pitch audio via Nemotron Omni."""
+    audio = payload.get("audio") or payload.get("audio_base64") or ""
+    audio_format = payload.get("audio_format", "webm")
+    return voice_handler.process_voice_pitch(str(audio), str(audio_format))
+
+
+def handle_voice_turn(payload: dict[str, Any]) -> dict[str, Any]:
+    """Process one spoken battle answer — returns transcript for confirmation."""
+    session_id = payload.get("session_id", "")
+    audio = payload.get("audio") or payload.get("audio_base64") or ""
+    audio_format = payload.get("audio_format", "webm")
+    return voice_handler.process_voice_turn(session_id, str(audio), str(audio_format))
 
 
 def handle_deal_session_placeholder(_payload: dict[str, Any] | None = None) -> dict[str, str]:

core/attack_tags.py

@@ -36,6 +36,46 @@ ATTACK_TAGS: dict[str, list[str]] = {
 }
 
 
+# "Minimum viable answer" recipes — what a student should try to include for each
+# question type. A recipe, not a script: short, plain, one or two concrete things.
+ANSWER_CHECKLISTS: dict[str, str] = {
+    # skeptical_vc
+    "Market Size": "Try to include: who exactly + roughly how many of them.",
+    "Moat": "Name one thing only you do — and why it's hard to copy.",
+    "Retention": "Give one number: how many came back, or how often.",
+    "Revenue Logic": "Say who pays + one price or amount.",
+    "First 100 Users": "Name where your first users came from.",
+    "Why Now": "One reason this works today and not 2 years ago.",
+    "Competition": "Name one competitor + one thing you do differently.",
+    "Defensibility": "One thing that gets stronger as you grow.",
+    # technical_judge
+    "AI Justification": "Say what breaks if you remove the AI.",
+    "Architecture": "Walk through the main steps, in order.",
+    "Scalability": "One number: users or load you can handle.",
+    "Latency": "Roughly how fast does it respond?",
+    "Data Quality": "Where your data comes from + how much.",
+    "Failure Mode": "What happens when the model is wrong.",
+    "Simpler Alternative": "Why a simpler tool wouldn't be enough.",
+    "Technical Feasibility": "One thing you've already built and tested.",
+    # hackathon_judge
+    "Novelty": "Name one thing that's actually new here.",
+    "Demo Clarity": "Walk through your demo in 3 steps.",
+    "MVP Strength": "What works right now (not someday).",
+    "User Pain": "Who hurts + one proof they care.",
+    "AI Load-Bearing": "Say what the AI does that nothing else could.",
+    "Backyard Fit": "Why this fits a small/scrappy build.",
+    "Practical Impact": "One real result or test you ran.",
+    "Judging Memorability": "The one line you want remembered.",
+}
+
+_DEFAULT_CHECKLIST = "Try to include: one number, one user, or one real result."
+
+
+def get_answer_checklist(attack_tag: str) -> str:
+    """Return a one-line 'minimum viable answer' recipe for a question type."""
+    return ANSWER_CHECKLISTS.get(attack_tag, _DEFAULT_CHECKLIST)
+
+
 def get_attack_tags(persona: str) -> list[str]:
     """Return attack tags for a persona."""
     return list(ATTACK_TAGS.get(persona, ATTACK_TAGS["technical_judge"]))

core/claim_extractor.py

@@ -156,6 +156,120 @@ def _is_non_answer(text: str) -> bool:
 # Main extractor
 # ---------------------------------------------------------------------------
 
+def _accumulate_signals_from_text(
+    text: str,
+    *,
+    all_numbers: list[str],
+    all_pct: list[str],
+    all_pricing: list[str],
+    all_user_counts: list[str],
+    all_validation: list[str],
+    all_colleges: list[str],
+    all_competitors: list[str],
+    all_tech: list[str],
+    all_revenue: list[str],
+    all_retention: list[str],
+    all_gtm: list[str],
+    all_vague: list[str],
+) -> None:
+    """Run regex extractors on a single text block into accumulator lists."""
+    if not text or not str(text).strip():
+        return
+    all_numbers.extend(_match_all(_NUMBER_METRIC, text))
+    all_pct.extend(_match_all(_PERCENTAGE, text))
+    all_pricing.extend(_match_all(_CURRENCY, text))
+    all_user_counts.extend(_match_all(_USER_COUNT, text))
+    all_validation.extend(_match_all(_VALIDATION, text))
+    all_colleges.extend(_match_all(_COLLEGE_CAMPUS, text))
+    all_competitors.extend(_match_all(_COMPETITORS, text))
+    all_tech.extend(_match_all(_TECH_MECHANISM, text))
+    all_revenue.extend(_match_all(_REVENUE, text))
+    all_retention.extend(_match_all(_RETENTION, text))
+    all_gtm.extend(_match_all(_GTM, text))
+    all_vague.extend(_match_all(_VAGUE_PHRASES, text))
+
+
+def extract_startup_context_signals(session: dict) -> dict[str, Any]:
+    """Extract evidence signals from startup form + voice pitch transcript only.
+
+    Used when the founder gave no battle answers but described the idea upfront.
+    Does not include battle Q&A history.
+    """
+    startup = session.get("startup", {}) or {}
+    texts: list[str] = []
+    for key in (
+        "name", "problem", "target_users", "solution",
+        "why_ai", "competitors", "traction", "ask",
+    ):
+        val = str(startup.get(key, "")).strip()
+        if val:
+            texts.append(val)
+
+    voice_pitch = session.get("voice_pitch") or {}
+    if isinstance(voice_pitch, dict):
+        transcript = str(voice_pitch.get("transcript", "")).strip()
+        if transcript:
+            texts.append(transcript)
+
+    all_numbers: list[str] = []
+    all_pct: list[str] = []
+    all_pricing: list[str] = []
+    all_user_counts: list[str] = []
+    all_validation: list[str] = []
+    all_colleges: list[str] = []
+    all_competitors: list[str] = []
+    all_tech: list[str] = []
+    all_revenue: list[str] = []
+    all_retention: list[str] = []
+    all_gtm: list[str] = []
+    all_vague: list[str] = []
+
+    for block in texts:
+        _accumulate_signals_from_text(
+            block,
+            all_numbers=all_numbers,
+            all_pct=all_pct,
+            all_pricing=all_pricing,
+            all_user_counts=all_user_counts,
+            all_validation=all_validation,
+            all_colleges=all_colleges,
+            all_competitors=all_competitors,
+            all_tech=all_tech,
+            all_revenue=all_revenue,
+            all_retention=all_retention,
+            all_gtm=all_gtm,
+            all_vague=all_vague,
+        )
+
+    total_signals = (
+        len(_dedup(all_numbers)) + len(_dedup(all_pct)) +
+        len(_dedup(all_pricing)) + len(_dedup(all_user_counts)) +
+        len(_dedup(all_validation)) + len(_dedup(all_colleges)) +
+        len(_dedup(all_competitors)) + len(_dedup(all_tech)) +
+        len(_dedup(all_revenue))
+    )
+
+    return {
+        "numbers":               _dedup(all_numbers),
+        "percentages":           _dedup(all_pct),
+        "pricing":               _dedup(all_pricing),
+        "user_counts":           _dedup(all_user_counts),
+        "validation":            _dedup(all_validation),
+        "college_mentions":      _dedup(all_colleges),
+        "competitors":           _dedup(all_competitors),
+        "technical_mechanisms":  _dedup(all_tech),
+        "revenue_signals":       _dedup(all_revenue),
+        "retention_signals":     _dedup(all_retention),
+        "gtm_signals":           _dedup(all_gtm),
+        "non_answers":           [],
+        "vague_claims":          _dedup(all_vague),
+        "best_user_quotes":      [t[:200] for t in texts if len(t.split()) >= 6][:3],
+        "all_user_answers":      [],
+        "signal_count":          total_signals,
+        "source":                "startup_context",
+    }
+
+
 def extract_concrete_signals(session: dict) -> dict[str, Any]:
     """Extract evidence signals from all user turns in a session.
 
@@ -209,33 +323,43 @@ def extract_concrete_signals(session: dict) -> dict[str, Any]:
             answer_scores.append((0, ans))
             continue
 
-        nums    = _match_all(_NUMBER_METRIC, ans)
-        pcts    = _match_all(_PERCENTAGE, ans)
-        prices  = _match_all(_CURRENCY, ans)
+        nums: list[str] = []
+        pcts: list[str] = []
+        prices: list[str] = []
+        ucounts: list[str] = []
+        val: list[str] = []
+        cols: list[str] = []
+        comps: list[str] = []
+        techs: list[str] = []
+        revs: list[str] = []
+        rets: list[str] = []
+        gtms: list[str] = []
+        vagues: list[str] = []
+        _accumulate_signals_from_text(
+            ans,
+            all_numbers=all_numbers,
+            all_pct=all_pct,
+            all_pricing=all_pricing,
+            all_user_counts=all_user_counts,
+            all_validation=all_validation,
+            all_colleges=all_colleges,
+            all_competitors=all_competitors,
+            all_tech=all_tech,
+            all_revenue=all_revenue,
+            all_retention=all_retention,
+            all_gtm=all_gtm,
+            all_vague=all_vague,
+        )
+        nums = _match_all(_NUMBER_METRIC, ans)
+        pcts = _match_all(_PERCENTAGE, ans)
+        prices = _match_all(_CURRENCY, ans)
         ucounts = _match_all(_USER_COUNT, ans)
-        val     = _match_all(_VALIDATION, ans)
-        cols    = _match_all(_COLLEGE_CAMPUS, ans)
-        comps   = _match_all(_COMPETITORS, ans)
-        techs   = _match_all(_TECH_MECHANISM, ans)
-        revs    = _match_all(_REVENUE, ans)
-        rets    = _match_all(_RETENTION, ans)
-        gtms    = _match_all(_GTM, ans)
-        vagues  = _match_all(_VAGUE_PHRASES, ans)
-
-        all_numbers.extend(nums)
-        all_pct.extend(pcts)
-        all_pricing.extend(prices)
-        all_user_counts.extend(ucounts)
-        all_validation.extend(val)
-        all_colleges.extend(cols)
-        all_competitors.extend(comps)
-        all_tech.extend(techs)
-        all_revenue.extend(revs)
-        all_retention.extend(rets)
-        all_gtm.extend(gtms)
-        all_vague.extend(vagues)
-
-        # Signal density score for ranking quotes
+        val = _match_all(_VALIDATION, ans)
+        cols = _match_all(_COLLEGE_CAMPUS, ans)
+        comps = _match_all(_COMPETITORS, ans)
+        techs = _match_all(_TECH_MECHANISM, ans)
+        revs = _match_all(_REVENUE, ans)
+
         density = (
             len(nums) + len(pcts) + len(prices) + len(ucounts) +
             len(val) + len(cols) + len(comps) + len(techs) + len(revs)

core/db.py

@@ -0,0 +1,119 @@
+"""
+MongoDB connection utilities for PitchFight AI.
+
+Phase 9.5 rule:
+- MongoDB is optional background persistence only.
+- In-memory session_manager remains the live source of truth.
+- If MongoDB is disabled, missing, or unavailable, the app must continue normally.
+- Never print MongoDB URI, password, API keys, or secrets.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from dotenv import load_dotenv
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from pymongo.database import Database
+from pymongo.errors import PyMongoError, ServerSelectionTimeoutError
+
+
+load_dotenv()
+
+_client: Optional[MongoClient] = None
+_db: Optional[Database] = None
+_connected: bool = False
+
+_warned_disabled: bool = False
+_warned_missing_uri: bool = False
+_warned_connection_failed: bool = False
+
+
+def is_mongodb_enabled() -> bool:
+    """
+    Return True only when MongoDB persistence is explicitly enabled.
+
+    Expected env:
+        MONGODB_ENABLED=true
+    """
+    return os.getenv("MONGODB_ENABLED", "false").strip().lower() == "true"
+
+
+def get_db() -> Optional[Database]:
+    """
+    Return the MongoDB database instance if enabled and reachable.
+
+    Returns None when:
+    - MONGODB_ENABLED is not true
+    - MONGODB_URI is missing
+    - MongoDB connection/ping fails
+
+    This function must never raise DB errors into the main app.
+    """
+    global _client, _db, _connected
+    global _warned_disabled, _warned_missing_uri, _warned_connection_failed
+
+    if not is_mongodb_enabled():
+        if not _warned_disabled:
+            print("[MongoDB] Disabled. Persistence skipped.")
+            _warned_disabled = True
+        return None
+
+    if _db is not None and _connected:
+        return _db
+
+    uri = os.getenv("MONGODB_URI", "").strip()
+    db_name = os.getenv("MONGODB_DB_NAME", "pitchfight_db").strip() or "pitchfight_db"
+
+    if not uri:
+        if not _warned_missing_uri:
+            print("[MongoDB] MONGODB_URI missing. Persistence skipped.")
+            _warned_missing_uri = True
+        return None
+
+    try:
+        _client = MongoClient(uri, serverSelectionTimeoutMS=5000)
+        _client.admin.command("ping")
+
+        _db = _client[db_name]
+        _connected = True
+
+        print(f"[MongoDB] Connected to database: {db_name}")
+        return _db
+
+    except (ServerSelectionTimeoutError, PyMongoError, Exception) as exc:
+        _connected = False
+        _db = None
+
+        if not _warned_connection_failed:
+            print(
+                "[MongoDB] Connection unavailable. "
+                f"App will continue without persistence. Reason: {type(exc).__name__}"
+            )
+            _warned_connection_failed = True
+
+        return None
+
+
+def get_sessions_collection() -> Optional[Collection]:
+    """
+    Return the main sessions collection.
+
+    Target:
+        pitchfight_db.sessions
+    """
+    db = get_db()
+    if db is None:
+        return None
+
+    return db["sessions"]
+
+
+def is_connected() -> bool:
+    """
+    Return True if MongoDB is enabled and currently reachable.
+    """
+    db = get_db()
+    return db is not None and _connected

core/deal_claim_extractor.py

@@ -0,0 +1,178 @@
+"""Deal negotiation signal extractor — local regex/keyword logic."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_ANCHOR = re.compile(
+    r"(?:\d+\.?\d*\s*%)"
+    r"|(?:₹|rs\.?|\$|€)\s*[\d,.]+(?:\s*(?:lakhs?|crores?|cr|k|million|mn))?"
+    r"|(?:\d+\s*(?:weeks?|months?|years?))"
+    r"|(?:\d+\.?\d*\s*(?:equity|stake|ownership))"
+    r"|(?:discount\s*(?:of\s*)?\d+\.?\d*\s*%)"
+    r"|(?:pilot\s*(?:for\s*)?\d+\s*(?:weeks?|months?))",
+    re.IGNORECASE,
+)
+
+_EVIDENCE = re.compile(
+    r"\b(?:users?|patients?|hospitals?|pilots?|mou|loi|contract|deployed|revenue|"
+    r"retention|roi|case study|reference|paying|customers?|clients?|traction)\b",
+    re.IGNORECASE,
+)
+
+_CONCESSION = re.compile(
+    r"\b(?:we can accept|willing to|flexible on|we can reduce|"
+    r"open to|meet you halfway|compromise|we can move|we could give)\b",
+    re.IGNORECASE,
+)
+
+# Weak concession = giving ground with no condition extracted. Bare "ok"/"sure" handled
+# separately so a harmless acknowledgement is NOT treated as a weak concession.
+_WEAK_CONCESSION = re.compile(
+    r"\b(?:okay fine|whatever works|if you insist|i guess|that's okay too|"
+    r"no problem,? we can do that|sure,? take it|you decide|accept whatever|"
+    r"whatever (?:terms|you want)|fine,? we can accept)\b",
+    re.IGNORECASE,
+)
+
+# Alternatives / leverage — credit natural phrasing, not just "BATNA".
+_ALTERNATIVES = re.compile(
+    r"\b(?:other investors?|another offer|other clients?|other (?:colleges?|campuses?|"
+    r"mentors?|partners?|customers?|buyers?)|also talking to|also speaking|in talks with|"
+    r"parallel (?:conversations?|talks)|multiple options|alternatives?|pipeline|"
+    r"not dependent|don'?t depend|batna|backup(?: option| plan)?|another route|"
+    r"we can still|we are also|we'?re also|we already have|we have other)\b",
+    re.IGNORECASE,
+)
+
+_VALUE = re.compile(
+    r"\b(?:roi|return on|value|fair terms|risk.?reward|worth it|payback|"
+    r"cost.?benefit|margin|unit economics|saves?|reduces? cost|cost savings?|"
+    r"efficien\w+|growth|upside|long.?term value)\b",
+    re.IGNORECASE,
+)
+
+_CLOSING = re.compile(
+    r"\b(?:term sheet|next step|follow.?up|finalize|schedule|move forward|"
+    r"pilot agreement|sign|timeline|commit|let'?s proceed|shake on|proceed|"
+    r"confirm(?: today)?|send (?:over )?(?:the )?(?:term sheet|paperwork|contract)|"
+    r"lock (?:in|the metric)|close (?:this|the deal)|wrap (?:this )?up)\b",
+    re.IGNORECASE,
+)
+
+_NUMBERS = re.compile(
+    r"(?:₹|rs\.?|\$)\s*[\d,.]+(?:\s*(?:lakhs?|crores?|cr|k))?"
+    r"|\b\d+\.?\d*\s*%"
+    r"|\b\d[\d,]+\s*(?:users?|patients?|hospitals?|customers?)",
+    re.IGNORECASE,
+)
+
+_COUNTEROFFER = re.compile(
+    r"\b(?:counter|instead(?: of)?|how about|we propose|we'?d accept|offer of|"
+    r"would take|we'?d take|at \d+\.?\d*\s*%|for \d+\.?\d*\s*%)\b",
+    re.IGNORECASE,
+)
+
+_TRADEOFF = re.compile(
+    r"\b(?:in exchange|trade.?off|if you|in return|conditional on|provided that|"
+    r"only if|i can agree if|we can (?:move|agree) if|milestone|vesting|cliff|"
+    r"in turn|as long as|on the condition)\b",
+    re.IGNORECASE,
+)
+
+# Bare one-word acknowledgements — must NOT count as substantive moves or weak concessions.
+_ONE_WORD_ACK = frozenset({
+    "sure", "ok", "okay", "yes", "fine", "yeah", "yep", "agreed", "cool",
+    "alright", "right", "sounds good", "got it", "understood",
+})
+
+# Deal terms whose presence makes even a short message "substantive".
+_DEAL_TERM = re.compile(
+    r"(?:₹|rs\.?|\$|€|\d+\s*%|\bequity\b|\bstake\b|\bpilot\b|\bmilestone\b|"
+    r"\bvaluation\b|\btranche\b|\bdiscount\b|\bmonths?\b|\bweeks?\b|\bsign\b|"
+    r"\bterm sheet\b|\bcounter\b)",
+    re.IGNORECASE,
+)
+
+
+def is_one_word_ack(message: str) -> bool:
+    """True if the message is a bare acknowledgement with no deal term (e.g. 'sure', 'ok')."""
+    t = (message or "").strip().lower().rstrip(".!?")
+    t = re.sub(r"[^a-z ]", "", t).strip()
+    if not t:
+        return True
+    if _DEAL_TERM.search(message or ""):
+        return False
+    return t in _ONE_WORD_ACK
+
+
+def is_substantive_move(message: str) -> bool:
+    """True if a founder message is a real negotiation move worth judging.
+
+    Substantive = longer than 20 characters OR contains a concrete deal term.
+    Bare one-word acknowledgements ('sure', 'ok', 'yes', 'fine') are NOT substantive.
+    """
+    t = (message or "").strip()
+    if not t or is_one_word_ack(t):
+        return False
+    if len(t) > 20:
+        return True
+    if _DEAL_TERM.search(t):
+        return True
+    return len(t.split()) >= 4
+
+
+def _dedup(items: list[str]) -> list[str]:
+    seen: set[str] = set()
+    out: list[str] = []
+    for item in items:
+        k = item.strip().lower()
+        if k and k not in seen:
+            seen.add(k)
+            out.append(item.strip())
+    return out
+
+
+def _match_all(pattern: re.Pattern[str], text: str) -> list[str]:
+    return _dedup([m.group(0).strip() for m in pattern.finditer(text or "")])
+
+
+def extract_deal_signals(deal_history: list[dict], deal_context: dict | None = None) -> dict[str, Any]:
+    """Extract negotiation signals from deal history and context."""
+    texts: list[str] = []
+    user_texts: list[str] = []
+    for entry in deal_history or []:
+        msg = str(entry.get("message", "")).strip()
+        if msg:
+            texts.append(msg)
+            if entry.get("role") == "user":
+                user_texts.append(msg)
+
+    ctx = deal_context or {}
+    for key in ("ask", "opening_offer", "founder_position", "judge_position"):
+        val = str(ctx.get(key, "")).strip()
+        if val:
+            texts.append(val)
+
+    combined = " ".join(texts)
+    user_combined = " ".join(user_texts)
+
+    return {
+        "anchor_points":           _match_all(_ANCHOR, user_combined),
+        "evidence_signals":        _match_all(_EVIDENCE, user_combined),
+        "concession_signals":      _match_all(_CONCESSION, user_combined),
+        "weak_concession_signals": _match_all(_WEAK_CONCESSION, user_combined),
+        "alternative_signals":     _match_all(_ALTERNATIVES, user_combined),
+        "value_signals":           _match_all(_VALUE, user_combined),
+        "closing_signals":         _match_all(_CLOSING, user_combined),
+        "specific_numbers":        _match_all(_NUMBERS, user_combined),
+        "counteroffers":           _match_all(_COUNTEROFFER, user_combined),
+        "tradeoffs":               _match_all(_TRADEOFF, user_combined),
+        "user_turns":              len(user_texts),
+        "signal_count": (
+            len(_match_all(_ANCHOR, user_combined))
+            + len(_match_all(_EVIDENCE, user_combined))
+            + len(_match_all(_NUMBERS, user_combined))
+        ),
+    }

core/deal_flow.py

@@ -0,0 +1,351 @@
+"""Deal negotiation round flow (Phase 9C)."""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import datetime, timezone
+from typing import Any
+
+from core.deal_claim_extractor import extract_deal_signals
+from core.deal_persona_builder import build_deal_system_prompt, build_deal_round_prompt
+from core.deal_phase import NEGOTIATION_TAGS
+from core import model_router
+
+logger = logging.getLogger(__name__)
+
+# Adaptive deal length — measured in FOUNDER replies, not raw round counter.
+MIN_FOUNDER_REPLIES = 3   # below this we never recommend ending
+SOFT_FOUNDER_REPLIES = 4  # ideal length; soft-recommend ending around here
+HARD_MAX_FOUNDER_REPLIES = 6  # never force more than this
+
+# Kept for backward compatibility with existing callers/tests.
+MAX_DEAL_ROUNDS = 8
+SOFT_DEAL_LIMIT = 5
+
+_ALL_DEAL_DIMS = (
+    "anchoring", "evidence", "concession_control",
+    "alternatives", "value_articulation", "closing",
+)
+
+
+def _count_founder_replies(session: dict) -> int:
+    return sum(1 for h in session.get("deal_history", []) if h.get("role") == "user")
+
+
+def evaluate_deal_readiness(session: dict) -> dict[str, Any]:
+    """Decide whether enough negotiation signal exists to score the deal.
+
+    Returns a readiness dict (see schema in PART A). Driven by how many dimensions
+    the founder has actually touched plus the number of founder replies, so the deal
+    can end naturally after 3–4 strong replies instead of grinding fixed rounds.
+    """
+    history = session.get("deal_history") or []
+    deal_context = session.get("deal_context") or {}
+    signals = extract_deal_signals(history, deal_context)
+    replies = _count_founder_replies(session)
+
+    covered: list[str] = []
+    if signals.get("anchor_points") or signals.get("counteroffers"):
+        covered.append("anchoring")
+    if signals.get("evidence_signals") or signals.get("specific_numbers"):
+        covered.append("evidence")
+    has_concession = bool(
+        signals.get("concession_signals")
+        or signals.get("tradeoffs")
+        or signals.get("weak_concession_signals")
+    )
+    if has_concession:
+        covered.append("concession_control")
+    if signals.get("alternative_signals"):
+        covered.append("alternatives")
+    if signals.get("value_signals"):
+        covered.append("value_articulation")
+    if signals.get("closing_signals"):
+        covered.append("closing")
+
+    missing = [d for d in _ALL_DEAL_DIMS if d not in covered]
+
+    # Core negotiation evidence: anchor/counter + proof + a concession/tradeoff + value.
+    core_ready = (
+        ("anchoring" in covered)
+        and ("evidence" in covered)
+        and has_concession
+        and ("value_articulation" in covered)
+    )
+    enough = (replies >= MIN_FOUNDER_REPLIES and core_ready) or replies >= HARD_MAX_FOUNDER_REPLIES
+
+    if len(covered) >= 5 and replies >= SOFT_FOUNDER_REPLIES:
+        confidence = "high"
+    elif enough:
+        confidence = "medium"
+    else:
+        confidence = "low"
+
+    if replies >= HARD_MAX_FOUNDER_REPLIES:
+        action = "force_end"
+        reason = "You have negotiated enough rounds — time to lock in your deal scorecard."
+    elif enough and replies >= SOFT_FOUNDER_REPLIES:
+        action = "recommend_end"
+        reason = "You have enough negotiation material for a scorecard."
+    elif enough:
+        action = "recommend_end"
+        reason = "You have covered the key negotiation points. End now or push one more round."
+    else:
+        action = "continue"
+        reason = "Keep negotiating — anchor your terms, cite proof, and propose a tradeoff."
+
+    return {
+        "enough_to_score": bool(enough),
+        "recommended_action": action,
+        "reason": reason,
+        "covered_dimensions": covered,
+        "missing_dimensions": missing,
+        "rounds_completed": replies,
+        "confidence": confidence,
+    }
+
+_NON_ANSWER = re.compile(
+    r"^(ok|yeah|yes|no|idk|i don'?t know|not sure|maybe|n/?a|pass)\.?$",
+    re.IGNORECASE,
+)
+
+_VALID_ACTIONS = frozenset({
+    "acknowledge_and_counter",
+    "press_harder",
+    "escalate_stakes",
+    "partial_concession",
+    "move_to_close",
+})
+
+
+def classify_deal_answer_quality(
+    user_message: str,
+    deal_context: dict,
+    current_tag: str,
+) -> str:
+    """Classify founder deal answer: strong | partial | weak | non_answer."""
+    text = (user_message or "").strip()
+    if not text or _NON_ANSWER.match(text) or len(text.split()) < 3:
+        return "non_answer"
+
+    signals = extract_deal_signals(
+        [{"role": "user", "message": text}],
+        deal_context,
+    )
+
+    if signals.get("weak_concession_signals") and not signals.get("counteroffers"):
+        return "weak"
+
+    has_proof = bool(
+        signals.get("specific_numbers")
+        or signals.get("evidence_signals")
+        or signals.get("counteroffers")
+    )
+    has_anchor = bool(signals.get("anchor_points") or signals.get("tradeoffs"))
+
+    if current_tag == "Closing Move" and signals.get("closing_signals"):
+        return "strong"
+    if has_proof and has_anchor and len(text.split()) >= 12:
+        return "strong"
+    if has_proof or has_anchor:
+        return "partial"
+    if signals.get("concession_signals") and not has_proof:
+        return "weak"
+    if len(text.split()) >= 8:
+        return "partial"
+    return "weak"
+
+
+def choose_next_negotiation_tag(session: dict) -> str:
+    """Pick next tag based on round and history."""
+    history = session.get("deal_history") or []
+    used = [h.get("negotiation_tag") for h in history if h.get("negotiation_tag")]
+    deal_round = session.get("deal_round", 1)
+
+    if deal_round >= 6:
+        return "Closing Move"
+    if deal_round >= 4 and "Evidence Quality" not in used:
+        return "Evidence Quality"
+    if deal_round >= 3 and "Concession Control" not in used:
+        return "Concession Control"
+
+    for tag in NEGOTIATION_TAGS:
+        if tag not in used:
+            return tag
+    return NEGOTIATION_TAGS[(deal_round - 1) % len(NEGOTIATION_TAGS)]
+
+
+def choose_deal_action(answer_quality: str, tag: str, session: dict) -> str:
+    """Map answer quality + tag to judge action."""
+    if answer_quality == "non_answer":
+        return "press_harder"
+    if answer_quality == "weak":
+        return "escalate_stakes" if tag in ("Anchoring", "Concession Control") else "press_harder"
+    if answer_quality == "strong" and tag == "Closing Move":
+        return "partial_concession"
+    if answer_quality == "strong":
+        return "acknowledge_and_counter"
+    if tag == "Closing Move":
+        return "move_to_close"
+    if tag == "Concession Control":
+        return "press_harder"
+    return "acknowledge_and_counter"
+
+
+def should_soft_limit_deal(session: dict) -> bool:
+    return _count_founder_replies(session) >= SOFT_FOUNDER_REPLIES
+
+
+def _deal_state(signals: dict, answer_quality: str) -> dict[str, str]:
+    weak_con = bool(signals.get("weak_concession_signals"))
+    if answer_quality == "strong":
+        founder = "strong"
+    elif answer_quality in ("partial", "weak") and not weak_con:
+        founder = "mixed"
+    else:
+        founder = "weak"
+
+    if answer_quality == "strong":
+        momentum = "improving"
+    elif answer_quality == "non_answer" or weak_con:
+        momentum = "declining"
+    else:
+        momentum = "neutral"
+
+    concession = "none"
+    if signals.get("concession_signals") and not weak_con:
+        concession = "small"
+    if weak_con:
+        concession = "medium"
+
+    return {
+        "judge_concession_level": concession,
+        "founder_position_strength": founder,
+        "deal_momentum": momentum,
+    }
+
+
+def _generate_deal_ai_message(
+    session: dict,
+    user_message: str,
+    negotiation_tag: str,
+    answer_quality: str,
+    action: str,
+) -> str:
+    deal_context = session.get("deal_context") or {}
+    system = build_deal_system_prompt(session, deal_context, negotiation_tag)
+    user_prompt = build_deal_round_prompt(
+        session, user_message, negotiation_tag, answer_quality, action
+    )
+
+    messages = [{"role": "system", "content": system}]
+    # Token control: only the last 6 deal turns go to the model (full history kept for scoring).
+    for entry in session.get("deal_history", [])[-6:]:
+        role = "assistant" if entry.get("role") == "judge" else "user"
+        messages.append({"role": role, "content": entry.get("message", "")})
+    messages.append({"role": "user", "content": user_prompt})
+
+    model_mode = session.get("model_mode", "premium_nvidia")
+    result = model_router.generate_deal_round_response(messages, model_mode=model_mode)
+    if result.get("ok") and result.get("content"):
+        return str(result["content"]).strip()[:600]
+
+    fallbacks = {
+        "press_harder": "That answer does not give me enough proof to move on terms. Be specific.",
+        "escalate_stakes": "I still see too much risk here. What number or commitment changes that?",
+        "partial_concession": "I can move slightly, but I need a concrete tradeoff from you.",
+        "move_to_close": "If we agree in principle, what is the exact next step and timeline?",
+        "acknowledge_and_counter": "I hear you, but my terms still need to reflect the risk I see.",
+    }
+    logger.warning("deal_flow: Nemotron deal round failed — %s", result.get("error"))
+    return fallbacks.get(action, fallbacks["acknowledge_and_counter"])
+
+
+def next_deal_round(
+    session: dict,
+    user_message: str,
+    input_mode: str = "text",
+    voice_turn_id: str = "",
+) -> dict[str, Any]:
+    """Process one deal negotiation round."""
+    if not session.get("deal_phase_active"):
+        return {"error": "Deal phase is not active. Start deal phase from the judge verdict."}
+
+    message = (user_message or "").strip()
+    if not message:
+        return {"error": "Deal counter cannot be empty."}
+
+    if _count_founder_replies(session) >= HARD_MAX_FOUNDER_REPLIES:
+        return {"error": "Maximum deal rounds reached. End the deal to see your scorecard."}
+
+    current_round = int(session.get("deal_round", 1))
+
+    deal_context = session.get("deal_context") or {}
+    last_tag = "Anchoring"
+    if session.get("deal_history"):
+        for h in reversed(session["deal_history"]):
+            if h.get("negotiation_tag"):
+                last_tag = h["negotiation_tag"]
+                break
+
+    answer_quality = classify_deal_answer_quality(message, deal_context, last_tag)
+    signals = extract_deal_signals(
+        session.get("deal_history", []) + [{"role": "user", "message": message}],
+        deal_context,
+    )
+
+    session.setdefault("deal_history", []).append({
+        "round": current_round,
+        "role": "user",
+        "message": message,
+        "negotiation_tag": last_tag,
+        "answer_quality": answer_quality,
+        "action": "",
+        "input_mode": input_mode or "text",
+        "voice_turn_id": voice_turn_id or "",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    })
+
+    next_round = current_round + 1
+    negotiation_tag = choose_next_negotiation_tag(session)
+    action = choose_deal_action(answer_quality, negotiation_tag, session)
+    if action not in _VALID_ACTIONS:
+        action = "acknowledge_and_counter"
+
+    ai_message = _generate_deal_ai_message(
+        session, message, negotiation_tag, answer_quality, action
+    )
+
+    session["deal_round"] = next_round
+    session["deal_history"].append({
+        "round": next_round,
+        "role": "judge",
+        "message": ai_message,
+        "negotiation_tag": negotiation_tag,
+        "answer_quality": "",
+        "action": action,
+        "input_mode": "",
+        "voice_turn_id": "",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    })
+
+    readiness = evaluate_deal_readiness(session)
+    founder_replies = readiness["rounds_completed"]
+    soft_limit = readiness["recommended_action"] in ("recommend_end", "force_end")
+    can_continue = founder_replies < HARD_MAX_FOUNDER_REPLIES
+
+    return {
+        "session_id": session.get("session_id", ""),
+        "deal_phase_id": session.get("deal_phase_id", ""),
+        "round": next_round,
+        "negotiation_tag": negotiation_tag,
+        "answer_quality": answer_quality,
+        "action": action,
+        "ai_message": ai_message,
+        "deal_state": _deal_state(signals, answer_quality),
+        "readiness": readiness,
+        "soft_limit_reached": soft_limit,
+        "can_continue": can_continue,
+        "completion_message": (readiness["reason"] if soft_limit else ""),
+    }

core/deal_persona_builder.py

@@ -0,0 +1,149 @@
+"""Deal-phase persona prompt builders."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from core.judge_settings import get_label, normalize_difficulty
+from core.persona_builder import PERSONA_LABELS, build_persona_prompt
+
+DEAL_TYPE_LABELS = {
+    "equity": "Equity Negotiation",
+    "mentorship": "Mentorship Terms",
+    "pilot": "Pilot Agreement",
+    "sponsorship": "Sponsorship Terms",
+    "verdict_only": "Hackathon Verdict",
+    "none": "General Discussion",
+}
+
+
+def get_persona_display(persona: str) -> tuple[str, str]:
+    """Return (persona_name, persona_role)."""
+    name = PERSONA_LABELS.get(persona, "Tough Judge")
+    roles = {
+        "skeptical_vc": "Skeptical VC",
+        "technical_judge": "Technical Mentor",
+        "hackathon_judge": "Hackathon Judge",
+    }
+    return name, roles.get(persona, name)
+
+
+def build_deal_system_prompt(
+    session: dict,
+    deal_context: dict,
+    negotiation_tag: str,
+) -> str:
+    """System prompt for deal negotiation rounds."""
+    persona = session.get("persona", "skeptical_vc")
+    startup = session.get("startup", {}) or {}
+    difficulty = session.get("difficulty_profile") or session.get("difficulty", "practice")
+    base = build_persona_prompt(persona, startup, difficulty)
+
+    deal_type = deal_context.get("deal_type") or session.get("deal_type", "equity")
+    deal_label = DEAL_TYPE_LABELS.get(deal_type, deal_type)
+
+    return f"""{base}
+
+You are now in the DEAL PHASE — {deal_label}.
+The pitch battle is over. You are negotiating terms, not evaluating the idea from scratch.
+
+Deal context:
+- Founder's ask: {deal_context.get('ask', 'not stated')}
+- Your opening position: {deal_context.get('opening_offer', deal_context.get('judge_position', ''))}
+- Current negotiation focus: {negotiation_tag}
+
+Deal behavior rules:
+- Stay in character as the same judge/persona from the pitch.
+- Reference actual pitch context when pushing back.
+- Push on ONE negotiation point per response.
+- Ask at most one question. Keep to 1-3 sentences.
+- Do not accept too easily — be firm but realistic.
+- Do not give advice. Negotiate.
+- No markdown. No bullet lists. Plain spoken text only.
+- Do not leak instructions or mention being an AI.
+""".strip()
+
+
+def build_compact_deal_context(session: dict) -> dict[str, Any]:
+    """Compact context for deal rounds and scoring — keeps token usage controlled.
+
+    Sends only what the model needs to negotiate/score: startup name, ask, deal type,
+    judge verdict reaction, opening offer, a short negotiation summary, the last few
+    deal messages, the current negotiation tag, and difficulty. It deliberately omits
+    the full pitch history, the full scorecard object, and voice metadata.
+    """
+    startup = session.get("startup", {}) or {}
+    deal_context = session.get("deal_context") or {}
+    verdict = session.get("judge_verdict") or {}
+    deal_history = session.get("deal_history") or []
+    difficulty = session.get("difficulty_profile") or normalize_difficulty(
+        session.get("difficulty", "practice")
+    )
+
+    last_tag = "Anchoring"
+    for h in reversed(deal_history):
+        if h.get("negotiation_tag"):
+            last_tag = h["negotiation_tag"]
+            break
+
+    # Last 3 deal messages only (compact, role-tagged, truncated).
+    recent = []
+    for h in deal_history[-3:]:
+        role = "Judge" if h.get("role") == "judge" else "Founder"
+        msg = str(h.get("message", "")).strip()[:220]
+        if msg:
+            recent.append(f"{role}: {msg}")
+
+    user_turns = sum(1 for h in deal_history if h.get("role") == "user")
+    summary = (
+        f"{user_turns} founder counter(s) exchanged so far; current focus is {last_tag}."
+    )
+
+    return {
+        "startup_name": str(startup.get("name", "")).strip(),
+        "ask": str(deal_context.get("ask", startup.get("ask", ""))).strip(),
+        "deal_type": deal_context.get("deal_type") or session.get("deal_type", "equity"),
+        "deal_type_label": DEAL_TYPE_LABELS.get(
+            deal_context.get("deal_type") or session.get("deal_type", "equity"),
+            "Deal",
+        ),
+        "judge_verdict": str(verdict.get("judge_reaction", "")).strip()[:240],
+        "opening_offer": str(
+            deal_context.get("opening_offer") or deal_context.get("judge_position", "")
+        ).strip(),
+        "negotiation_summary": summary,
+        "recent_messages": recent,
+        "negotiation_tag": last_tag,
+        "difficulty_profile": difficulty,
+    }
+
+
+def build_deal_round_prompt(
+    session: dict,
+    user_message: str,
+    negotiation_tag: str,
+    answer_quality: str,
+    action: str,
+) -> str:
+    """User-side instruction for the next deal counter."""
+    deal_context = session.get("deal_context") or {}
+    pitch_overall = (session.get("latest_scorecard") or {}).get("overall", 0)
+
+    action_hints = {
+        "acknowledge_and_counter": "Acknowledge one valid point, then counter with your terms.",
+        "press_harder": "The founder's answer was weak — press harder on proof or terms.",
+        "escalate_stakes": "Raise the stakes — explain what risk you still see.",
+        "partial_concession": "Offer a small movement in terms, but extract something in return.",
+        "move_to_close": "Push toward a concrete next step or final terms.",
+    }
+    hint = action_hints.get(action, action_hints["acknowledge_and_counter"])
+
+    return (
+        f"Negotiation tag: {negotiation_tag}\n"
+        f"Founder's answer quality: {answer_quality}\n"
+        f"Your action: {action} — {hint}\n"
+        f"Pitch score context: overall {pitch_overall}/100\n"
+        f"Opening offer on table: {deal_context.get('opening_offer', '')}\n\n"
+        f"Founder's latest counter/answer:\n{user_message}\n\n"
+        "Respond as the judge with one concise negotiation pushback (1-3 sentences)."
+    )

core/deal_phase.py

@@ -0,0 +1,191 @@
+"""Deal phase start helpers (Phase 9B)."""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from core.deal_persona_builder import DEAL_TYPE_LABELS, build_deal_system_prompt, get_persona_display
+from core.judge_settings import get_label
+from core import model_router
+
+logger = logging.getLogger(__name__)
+
+NEGOTIATION_TAGS = [
+    "Anchoring",
+    "Evidence Quality",
+    "Concession Control",
+    "Alternatives",
+    "Value Articulation",
+    "Closing Move",
+]
+
+_DEAL_FIRST_FALLBACK: dict[str, str] = {
+    "equity": (
+        "You mentioned traction in your pitch, but it is not enough for your full ask. "
+        "I would open below your terms. Convince me why I should move closer to what you want."
+    ),
+    "mentorship": (
+        "You clearly need help sharpening execution. I can offer limited mentorship time, "
+        "but I need you to define exactly what outcome you want from me."
+    ),
+    "pilot": (
+        "I am open to a pilot, but I will not approve a long free trial without risk controls. "
+        "What paid pilot structure can you defend?"
+    ),
+    "sponsorship": (
+        "I can consider sponsorship, but I need measurable return and audience quality. "
+        "What do we get for the budget you are asking?"
+    ),
+}
+
+
+def get_deal_negotiation_tags(deal_type: str) -> list[str]:
+    return list(NEGOTIATION_TAGS)
+
+
+def build_deal_context(session: dict) -> dict[str, Any]:
+    """Build deal context from session, scorecard, and verdict."""
+    startup = session.get("startup", {}) or {}
+    verdict = session.get("judge_verdict") or {}
+    scorecard = session.get("latest_scorecard") or {}
+    difficulty_profile = session.get("difficulty_profile") or session.get("difficulty", "practice")
+    deal_type = session.get("deal_type") or verdict.get("deal_type", "equity")
+
+    return {
+        "ask": str(startup.get("ask", "")).strip(),
+        "opening_offer": str(verdict.get("deal_opening_offer", "")).strip(),
+        "founder_position": str(startup.get("ask", "")).strip(),
+        "judge_position": str(verdict.get("deal_opening_offer", "")).strip(),
+        "deal_type": deal_type,
+        "deal_type_label": DEAL_TYPE_LABELS.get(deal_type, deal_type),
+        "pitch_overall": scorecard.get("overall", 0),
+        "traction": str(startup.get("traction", "")).strip(),
+        "startup_name": str(startup.get("name", "")).strip(),
+        "difficulty_profile": difficulty_profile,
+        "difficulty_label": get_label(difficulty_profile),
+    }
+
+
+def _build_first_deal_messages(session: dict, deal_context: dict) -> list[dict[str, str]]:
+    system = build_deal_system_prompt(session, deal_context, "Anchoring")
+    startup = session.get("startup", {}) or {}
+    verdict = session.get("judge_verdict") or {}
+
+    user = (
+        f"Transition from pitch to deal negotiation.\n"
+        f"Startup: {startup.get('name', '')}\n"
+        f"Traction: {startup.get('traction', '')}\n"
+        f"Founder's ask: {deal_context.get('ask', '')}\n"
+        f"Your opening offer: {deal_context.get('opening_offer', '')}\n"
+        f"Verdict reaction: {verdict.get('judge_reaction', '')}\n\n"
+        "Deliver your first deal negotiation message. Reference the pitch if possible. "
+        "1-3 sentences. One pushback or opening terms. Plain text only."
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+def build_first_deal_message(session: dict, deal_context: dict) -> dict[str, str]:
+    """Generate first deal message via Nemotron with local fallback."""
+    deal_type = deal_context.get("deal_type", "equity")
+    fallback = _DEAL_FIRST_FALLBACK.get(deal_type, _DEAL_FIRST_FALLBACK["equity"])
+
+    verdict = session.get("judge_verdict") or {}
+    if verdict.get("judge_reaction"):
+        fallback = str(verdict["judge_reaction"])
+        if deal_context.get("opening_offer"):
+            fallback += f" {deal_context['opening_offer']}"
+
+    messages = _build_first_deal_messages(session, deal_context)
+    model_mode = session.get("model_mode", "premium_nvidia")
+    result = model_router.generate_deal_round_response(messages, model_mode=model_mode)
+
+    if result.get("ok") and result.get("content"):
+        text = str(result["content"]).strip()
+        if text:
+            return {"ai_message": text[:600], "provider": result.get("provider", "nvidia")}
+
+    logger.warning("deal_phase: first message fallback — %s", result.get("error"))
+    return {"ai_message": fallback[:600], "provider": "local"}
+
+
+def start_deal_phase(session: dict) -> dict[str, Any]:
+    """Initialize deal phase on existing pitch session."""
+    if not session.get("latest_scorecard"):
+        return {"error": "No scorecard found. End a battle before starting deal phase."}
+
+    verdict = session.get("judge_verdict")
+    if not verdict:
+        return {"error": "No judge verdict found. End a battle first."}
+
+    if not verdict.get("can_continue_to_deal"):
+        return {
+            "error": (
+                f"Deal phase cannot start because the judge verdict is "
+                f"{verdict.get('interest_level', 'no_interest')}."
+            )
+        }
+
+    if session.get("deal_phase_active") and session.get("deal_history"):
+        deal_context = session.get("deal_context") or build_deal_context(session)
+        last_judge = next(
+            (h for h in reversed(session.get("deal_history", [])) if h.get("role") == "judge"),
+            None,
+        )
+        return {
+            "session_id": session.get("session_id", ""),
+            "deal_phase_id": session.get("deal_phase_id", ""),
+            "deal_type": session.get("deal_type", ""),
+            "persona_name": verdict.get("persona_name", ""),
+            "persona_role": verdict.get("persona_type", ""),
+            "round": session.get("deal_round", 1),
+            "negotiation_tag": last_judge.get("negotiation_tag", "Anchoring") if last_judge else "Anchoring",
+            "ai_message": last_judge.get("message", "") if last_judge else "",
+            "deal_context": deal_context,
+            "can_continue": True,
+            "soft_limit_reached": False,
+        }
+
+    deal_phase_id = str(uuid.uuid4())
+    deal_type = verdict.get("deal_type", "equity")
+    deal_context = build_deal_context(session)
+    persona_name, persona_role = get_persona_display(session.get("persona", "skeptical_vc"))
+
+    first = build_first_deal_message(session, deal_context)
+    ai_message = first["ai_message"]
+    tag = "Anchoring"
+
+    session["deal_phase_active"] = True
+    session["deal_phase_id"] = deal_phase_id
+    session["deal_type"] = deal_type
+    session["deal_context"] = deal_context
+    session["deal_round"] = 1
+    session["deal_history"] = [{
+        "round": 1,
+        "role": "judge",
+        "message": ai_message,
+        "negotiation_tag": tag,
+        "answer_quality": "",
+        "action": "opening",
+        "input_mode": "",
+        "voice_turn_id": "",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }]
+    session["deal_scorecard"] = {}
+    session["combined_scorecard"] = {}
+
+    return {
+        "session_id": session.get("session_id", ""),
+        "deal_phase_id": deal_phase_id,
+        "deal_type": deal_type,
+        "persona_name": persona_name,
+        "persona_role": persona_role,
+        "round": 1,
+        "negotiation_tag": tag,
+        "ai_message": ai_message,
+        "deal_context": deal_context,
+        "can_continue": True,
+        "soft_limit_reached": False,
+    }

core/deal_scoring_engine.py

@@ -0,0 +1,910 @@
+"""Deal scorecard + combined pitch/deal summary (Phase 9D)."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from core.deal_claim_extractor import (
+    extract_deal_signals,
+    is_substantive_move,
+    is_one_word_ack,
+)
+from core.deal_persona_builder import build_compact_deal_context
+from core.judge_settings import get_scoring_calibration, normalize_difficulty
+from core.json_utils import (
+    parse_model_json,
+    parse_json_object,
+    safe_json_parse,
+    extract_partial_string_fields,
+    extract_partial_string_list,
+    ends_abruptly,
+    sanitize_for_log,
+)
+from core import model_router
+
+logger = logging.getLogger(__name__)
+
+DEAL_DIMS = (
+    "anchoring",
+    "evidence",
+    "concession_control",
+    "alternatives",
+    "value_articulation",
+    "closing",
+)
+
+_DIM_LABELS = {
+    "anchoring": "Anchoring",
+    "evidence": "Evidence",
+    "concession_control": "Concession Control",
+    "alternatives": "Alternatives",
+    "value_articulation": "Value Articulation",
+    "closing": "Closing",
+}
+
+
+def _deal_score_label(score: int) -> str:
+    if score >= 80:
+        return "Strong"
+    if score >= 60:
+        return "Solid"
+    if score >= 40:
+        return "Developing"
+    return "Weak"
+
+
+def _clamp(n: int, lo: int = 0, hi: int = 100) -> int:
+    return max(lo, min(hi, n))
+
+
+def _dim_entry(score: int, reason: str, quote: str = "") -> dict[str, Any]:
+    return {
+        "score": _clamp(score),
+        "label": _deal_score_label(score),
+        "reason": reason[:280],
+        "quote": quote[:200],
+    }
+
+
+def _best_user_quote(deal_history: list[dict]) -> str:
+    users = [h.get("message", "") for h in deal_history if h.get("role") == "user"]
+    if not users:
+        return ""
+    return max(users, key=lambda t: len(t.split()))[:200]
+
+
+def _weakest_user_quote(deal_history: list[dict], signals: dict) -> str:
+    users = [h.get("message", "") for h in deal_history if h.get("role") == "user"]
+    if not users:
+        return ""
+    if signals.get("weak_concession_signals"):
+        for u in users:
+            if any(w.lower() in u.lower() for w in signals["weak_concession_signals"]):
+                return u[:200]
+    return min(users, key=lambda t: len(t.split()))[:200]
+
+
+def _move_signal_strength(message: str) -> int:
+    """Rank a single founder message by how much negotiation substance it carries."""
+    s = extract_deal_signals([{"role": "user", "message": message}])
+    score = 0
+    if s["evidence_signals"]:
+        score += 2
+    if s["specific_numbers"]:
+        score += 2
+    if s["counteroffers"] or s["tradeoffs"]:
+        score += 2
+    if s["anchor_points"]:
+        score += 1
+    if s["closing_signals"]:
+        score += 1
+    if s["alternative_signals"]:
+        score += 1
+    return score
+
+
+def select_best_and_weakest_deal_moves(
+    deal_history: list[dict],
+    scores: dict,
+    signals: dict,
+) -> dict[str, str]:
+    """Pick best/weakest founder moves from SUBSTANTIVE messages only.
+
+    One-word acknowledgements ("sure", "ok", "yes", "fine") are never eligible as the
+    weakest move unless they actually conceded a term. Returns human-readable sentences,
+    never a bare quote, so the scorecard explains the move rather than dumping a word.
+    """
+    users = [str(h.get("message", "")).strip() for h in deal_history if h.get("role") == "user"]
+    substantive = [u for u in users if is_substantive_move(u)]
+
+    if not substantive:
+        return {
+            "best_move": "No substantive negotiation move was recorded.",
+            "weakest_move": "No real counters were made — every reply was a bare acknowledgement.",
+            "best_quote": "",
+            "weakest_quote": "",
+        }
+
+    best_quote = max(substantive, key=_move_signal_strength)
+    if _move_signal_strength(best_quote) == 0:
+        best_quote = max(substantive, key=lambda t: len(t.split()))
+
+    # Weakest: prefer a substantive message that conceded without extracting anything.
+    weak_quote = ""
+    for u in substantive:
+        s = extract_deal_signals([{"role": "user", "message": u}])
+        if s["weak_concession_signals"] and not (s["counteroffers"] or s["tradeoffs"]):
+            weak_quote = u
+            break
+    if not weak_quote:
+        candidates = [u for u in substantive if u != best_quote]
+        if candidates:
+            low = min(candidates, key=_move_signal_strength)
+            if _move_signal_strength(low) <= 1:
+                weak_quote = low
+
+    best_move = f'Your strongest moment: "{best_quote[:200]}"'
+    if weak_quote:
+        weakest_move = (
+            f'Watch this moment: "{weak_quote[:200]}" — you gave ground without '
+            "anchoring a counter or extracting a tradeoff."
+        )
+    else:
+        weakest_move = (
+            "No major single weak move detected; the main weakness was that "
+            "alternatives and leverage were underdeveloped."
+        )
+
+    return {
+        "best_move": best_move,
+        "weakest_move": weakest_move,
+        "best_quote": best_quote,
+        "weakest_quote": weak_quote,
+    }
+
+
+def calculate_deal_dimension_scores(
+    deal_signals: dict,
+    deal_history: list[dict],
+    deal_context: dict,
+    difficulty_profile: str,
+) -> dict[str, dict[str, Any]]:
+    """Local rule-based deal dimension scores."""
+    cal = get_scoring_calibration(difficulty_profile)
+    floor = cal.get("attempted_answer_floor", 33)
+    user_turns = deal_signals.get("user_turns", 0)
+    best_q = _best_user_quote(deal_history)
+    weak_q = _weakest_user_quote(deal_history, deal_signals)
+
+    if user_turns == 0:
+        empty = _dim_entry(0, "No deal counters were submitted.", "")
+        return {d: dict(empty) for d in DEAL_DIMS}
+
+    anchors = deal_signals.get("anchor_points", [])
+    numbers = deal_signals.get("specific_numbers", [])
+    evidence = deal_signals.get("evidence_signals", [])
+    weak_con = deal_signals.get("weak_concession_signals", [])
+    concessions = deal_signals.get("concession_signals", [])
+    alts = deal_signals.get("alternative_signals", [])
+    value = deal_signals.get("value_signals", [])
+    closing = deal_signals.get("closing_signals", [])
+    counters = deal_signals.get("counteroffers", [])
+    tradeoffs = deal_signals.get("tradeoffs", [])
+
+    # Anchoring — repeated clear counters should not cap low.
+    anchoring_score = floor
+    if anchors and counters:
+        anchoring_score = 78 if len(counters) >= 2 else 72
+    elif anchors or counters:
+        anchoring_score = 60
+    elif numbers:
+        anchoring_score = 50
+
+    evidence_score = floor
+    if evidence and numbers:
+        evidence_score = 74
+    elif evidence or numbers:
+        evidence_score = 56
+
+    # Concession control — reward trading concessions for conditions; only punish a
+    # bare giveaway with no counter/tradeoff. A harmless "sure" never lands here.
+    concession_score = 52
+    if weak_con and not (counters or tradeoffs):
+        concession_score = 32
+    elif tradeoffs and not weak_con:
+        concession_score = 76
+    elif concessions and counters:
+        concession_score = 70
+    elif concessions or tradeoffs:
+        concession_score = 60
+
+    # Alternatives — credit implied leverage/options, not just exact BATNA wording.
+    alt_score = 38
+    if alts and (numbers or tradeoffs):
+        alt_score = 76
+    elif alts:
+        alt_score = 66
+
+    value_score = floor
+    if value and numbers:
+        value_score = 72
+    elif value:
+        value_score = 56
+
+    closing_score = 32
+    if closing and counters:
+        closing_score = 76
+    elif closing:
+        closing_score = 66
+    elif user_turns >= 3 and counters:
+        closing_score = 50
+
+    raw = {
+        "anchoring": anchoring_score,
+        "evidence": evidence_score,
+        "concession_control": concession_score,
+        "alternatives": alt_score,
+        "value_articulation": value_score,
+        "closing": closing_score,
+    }
+    # Synergy: a well-rounded negotiation (≥5 dimensions already solid) earns a small
+    # lift so a genuinely strong founder can crest into the 80s instead of capping low.
+    if sum(1 for v in raw.values() if v >= 60) >= 5:
+        raw = {k: _clamp(v + 6) for k, v in raw.items()}
+    anchoring_score = raw["anchoring"]
+    evidence_score = raw["evidence"]
+    concession_score = raw["concession_control"]
+    alt_score = raw["alternatives"]
+    value_score = raw["value_articulation"]
+    closing_score = raw["closing"]
+
+    return {
+        "anchoring": _dim_entry(
+            anchoring_score,
+            "Clear term anchors and counteroffers strengthen your position."
+            if anchors else "Terms were not anchored with specific numbers or structure.",
+            best_q,
+        ),
+        "evidence": _dim_entry(
+            evidence_score,
+            "Evidence-backed counters build credibility."
+            if evidence else "Deal counters lacked proof points from traction or pilots.",
+            best_q,
+        ),
+        "concession_control": _dim_entry(
+            concession_score,
+            "You gave up too much too fast."
+            if weak_con else "Concession pacing was acceptable for this stage.",
+            weak_q or best_q,
+        ),
+        "alternatives": _dim_entry(
+            alt_score,
+            "BATNA or alternatives mentioned." if alts else "No alternatives or leverage cited.",
+            best_q,
+        ),
+        "value_articulation": _dim_entry(
+            value_score,
+            "Value and ROI were articulated." if value else "Fair value and ROI were under-explained.",
+            best_q,
+        ),
+        "closing": _dim_entry(
+            closing_score,
+            "Closing signals present." if closing else "No concrete closing step proposed.",
+            best_q,
+        ),
+    }
+
+
+def determine_deal_outcome(scores: dict, deal_history: list[dict], signals: dict) -> str:
+    """Return deal outcome label."""
+    s = {k: int(v.get("score", 0)) for k, v in scores.items()}
+    user_turns = signals.get("user_turns", 0)
+    if user_turns == 0:
+        return "no_deal"
+
+    if signals.get("weak_concession_signals") and s["concession_control"] < 40:
+        return "weak_concession"
+
+    if (
+        s["anchoring"] >= 65
+        and s["evidence"] >= 60
+        and s["concession_control"] >= 55
+        and s["closing"] >= 55
+    ):
+        return "strong_win"
+
+    if s["closing"] >= 50 and s["value_articulation"] >= 50:
+        return "favorable_partial"
+
+    if s["concession_control"] >= 45 and s["anchoring"] >= 45:
+        return "balanced"
+
+    if s["closing"] < 35 and s["value_articulation"] < 40:
+        return "no_deal"
+
+    return "balanced"
+
+
+_DEAL_OUTCOME_LABELS = frozenset({
+    "strong_win", "favorable_partial", "balanced", "weak_concession", "no_deal",
+})
+
+
+def _is_human_deal_summary(text: str) -> bool:
+    t = (text or "").strip()
+    if not t or len(t) < 25:
+        return False
+    normalized = t.lower().replace(" ", "_").replace("-", "_")
+    if normalized in _DEAL_OUTCOME_LABELS:
+        return False
+    return not ends_abruptly(t)
+
+
+_OUTCOME_SUMMARIES = {
+    "strong_win": "You held your position with evidence and moved toward concrete terms.",
+    "favorable_partial": "You negotiated acceptably but left some value on the table.",
+    "balanced": "A mixed negotiation — some strong counters alongside a few gaps.",
+    "weak_concession": "You conceded too quickly without extracting tradeoffs in return.",
+    "no_deal": "No closing path emerged — terms were not defended strongly enough.",
+}
+
+
+def humanize_deal_outcome(outcome: str) -> str:
+    """Return a human-readable sentence for a deal outcome label."""
+    return _OUTCOME_SUMMARIES.get(outcome, _OUTCOME_SUMMARIES["balanced"])
+
+
+# ---------------------------------------------------------------------------
+# Nemotron semantic scoring (Call 1) — primary judge for the 6 deal dimensions
+# ---------------------------------------------------------------------------
+
+_DEAL_SCORING_SCHEMA = (
+    '{"scores":{'
+    '"anchoring":{"score":0,"reason":"","quote":""},'
+    '"evidence":{"score":0,"reason":"","quote":""},'
+    '"concession_control":{"score":0,"reason":"","quote":""},'
+    '"alternatives":{"score":0,"reason":"","quote":""},'
+    '"value_articulation":{"score":0,"reason":"","quote":""},'
+    '"closing":{"score":0,"reason":"","quote":""}},'
+    '"deal_outcome":"strong_win|favorable_partial|balanced|weak_concession|no_deal",'
+    '"best_move":"","weakest_move":""}'
+)
+
+
+def _build_deal_scoring_prompt(
+    session: dict,
+    signals: dict,
+    local_scores: dict,
+) -> list[dict[str, str]]:
+    """Build the scoring-only messages for Nemotron (compact context, full founder turns)."""
+    ctx = build_compact_deal_context(session)
+    deal_history = session.get("deal_history") or []
+
+    # Full founder turns (these are what we score); judge turns truncated for context.
+    transcript_lines: list[str] = []
+    for h in deal_history:
+        role = "FOUNDER" if h.get("role") == "user" else "JUDGE"
+        msg = str(h.get("message", "")).strip()
+        if not msg:
+            continue
+        if role == "FOUNDER":
+            transcript_lines.append(f"FOUNDER: {msg[:400]}")
+        else:
+            transcript_lines.append(f"JUDGE: {msg[:160]}")
+    transcript = "\n".join(transcript_lines[-14:])
+
+    hints = (
+        f"anchors={signals.get('anchor_points', [])[:4]} "
+        f"numbers={signals.get('specific_numbers', [])[:4]} "
+        f"evidence={signals.get('evidence_signals', [])[:4]} "
+        f"alternatives={signals.get('alternative_signals', [])[:4]} "
+        f"tradeoffs={signals.get('tradeoffs', [])[:4]} "
+        f"closing={signals.get('closing_signals', [])[:4]}"
+    )
+
+    system = (
+        "You are an experienced startup negotiation judge scoring a founder's DEAL "
+        "negotiation. Score SEMANTICALLY based on what the founder actually argued — "
+        "not on keyword matching. Return ONLY one JSON object. First character {, last }. "
+        "No markdown. No reasoning. No array.\n\n"
+        "Score each of 6 dimensions 0-100:\n"
+        "  anchoring — did they anchor specific terms/numbers and hold a clear position?\n"
+        "  evidence — did they back terms with proof (traction, pilots, metrics)?\n"
+        "  concession_control — did they trade concessions for conditions, or give ground freely?\n"
+        "  alternatives — did they show leverage/options? Credit this even when phrased "
+        "naturally ('we're also talking to other partners', 'we're not dependent on this') "
+        "without the word BATNA.\n"
+        "  value_articulation — did they explain ROI / why the terms are fair?\n"
+        "  closing — did they push toward a concrete next step or commitment?\n\n"
+        "Scoring rules:\n"
+        "- Do NOT punish a harmless one-word acknowledgement like 'sure' or 'ok' unless it "
+        "clearly conceded a term.\n"
+        "- Pick weakest_move from a SUBSTANTIVE negotiation moment, never the shortest message.\n"
+        "- Allow 80+ when the founder anchors, proves, keeps concession control, shows "
+        "alternatives, articulates value, and closes.\n"
+        "- Do not over-score vague confidence with no specifics.\n"
+        "- quote must be copied from an actual FOUNDER message. Do not invent quotes.\n"
+        "- Each reason: one short sentence.\n\n"
+        f"REQUIRED JSON SCHEMA:\n{_DEAL_SCORING_SCHEMA}"
+    )
+
+    user = (
+        f"Deal type: {ctx.get('deal_type_label', '')}\n"
+        f"Founder ask: {ctx.get('ask', '')}\n"
+        f"Judge opening offer: {ctx.get('opening_offer', '')}\n"
+        f"Local signal hints (reference only, may be incomplete): {hints}\n"
+        f"Local reference scores (do not just copy — judge for yourself): "
+        f"{ {k: v.get('score') for k, v in local_scores.items()} }\n\n"
+        f"NEGOTIATION TRANSCRIPT:\n{transcript}\n\n"
+        "Score the 6 dimensions now. Output the JSON object only."
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+def _extract_deal_scores(parsed: Any) -> dict[str, Any]:
+    """Locate the 6-dimension scores dict, tolerant of model JSON shape.
+
+    The model sometimes nests scores under "scores" and sometimes (after lossy JSON
+    extraction) the dimensions land at the root. Handle both so a valid scorecard is
+    never thrown away over a wrapper key.
+    """
+    if not isinstance(parsed, dict):
+        return {}
+    raw = parsed.get("scores")
+    if isinstance(raw, dict) and any(d in raw for d in DEAL_DIMS):
+        return raw
+    if any(d in parsed for d in DEAL_DIMS):
+        return {d: parsed[d] for d in DEAL_DIMS if d in parsed}
+    return {}
+
+
+def _validate_deal_scoring(parsed: Any) -> bool:
+    """True if all 6 dims have a numeric score AND the scores are not all zero.
+
+    Rejecting an all-zero result is deliberate: it filters out the empty repair
+    skeleton (every score 0) so we fall back to local scoring instead of emitting a
+    bogus overall of 0 for a real negotiation.
+    """
+    scores = _extract_deal_scores(parsed)
+    if not scores:
+        return False
+    total = 0.0
+    for dim in DEAL_DIMS:
+        entry = scores.get(dim)
+        if not isinstance(entry, dict):
+            return False
+        try:
+            total += float(entry.get("score"))
+        except (TypeError, ValueError):
+            return False
+    return total > 0
+
+
+def _normalize_deal_scoring(
+    parsed: dict,
+    deal_history: list[dict],
+    signals: dict,
+) -> dict[str, Any]:
+    """Clamp scores, attach labels, validate outcome, and resolve best/weakest moves."""
+    raw = _extract_deal_scores(parsed)
+    scores: dict[str, dict[str, Any]] = {}
+    for dim in DEAL_DIMS:
+        entry = raw.get(dim, {}) if isinstance(raw.get(dim), dict) else {}
+        try:
+            val = int(round(float(entry.get("score", 0))))
+        except (TypeError, ValueError):
+            val = 0
+        reason = str(entry.get("reason", "")).strip() or "Judged from the negotiation transcript."
+        quote = str(entry.get("quote", "")).strip()
+        scores[dim] = _dim_entry(val, reason, quote)
+
+    outcome = str(parsed.get("deal_outcome", "")).strip().lower().replace(" ", "_")
+    if outcome not in _DEAL_OUTCOME_LABELS:
+        outcome = determine_deal_outcome(scores, deal_history, signals)
+
+    # Best/weakest: trust the model only if its text is substantive; else derive locally.
+    local_moves = select_best_and_weakest_deal_moves(deal_history, scores, signals)
+    best_move = str(parsed.get("best_move", "")).strip()
+    weakest_move = str(parsed.get("weakest_move", "")).strip()
+    if len(best_move) < 12 or is_one_word_ack(best_move):
+        best_move = local_moves["best_move"]
+    if len(weakest_move) < 12 or is_one_word_ack(weakest_move):
+        weakest_move = local_moves["weakest_move"]
+
+    overall = round(sum(s["score"] for s in scores.values()) / len(scores))
+    return {
+        "scores": scores,
+        "deal_outcome": outcome,
+        "best_move": best_move[:300],
+        "weakest_move": weakest_move[:300],
+        "overall": overall,
+        "overall_label": _deal_score_label(overall),
+    }
+
+
+def call_nemotron_deal_scoring(
+    session: dict,
+    signals: dict,
+    local_scorecard: dict,
+) -> dict[str, Any] | None:
+    """Call 1 — Nemotron semantic scoring. Returns normalized scores or None on failure."""
+    messages = _build_deal_scoring_prompt(session, signals, local_scorecard.get("scores", {}))
+    model_mode = session.get("model_mode", "premium_nvidia")
+    result = model_router.generate_deal_scoring_response(messages, model_mode=model_mode)
+
+    if not result.get("ok") or not result.get("content"):
+        logger.warning("deal_scoring: Nemotron scoring call failed — %s", result.get("error"))
+        return None
+
+    parsed = safe_json_parse(result["content"])
+    if not _validate_deal_scoring(parsed):
+        logger.warning(
+            "deal_scoring: scoring JSON invalid, trying repair preview=%r",
+            sanitize_for_log(result["content"]),
+        )
+        repair = model_router.generate_deal_scoring_repair_response(
+            result["content"], model_mode=model_mode
+        )
+        if repair.get("ok") and repair.get("content"):
+            parsed = safe_json_parse(repair["content"])
+
+    if not _validate_deal_scoring(parsed):
+        logger.warning("deal_scoring: scoring fallback used — Nemotron scores unavailable")
+        return None
+
+    return _normalize_deal_scoring(parsed, session.get("deal_history", []), signals)
+
+
+def _parse_deal_coaching_json(raw: str) -> dict[str, Any]:
+    """Best-effort parse of deal coaching JSON."""
+    parsed = parse_json_object(
+        raw,
+        string_fields=[
+            "deal_outcome_summary", "best_move", "weakest_move",
+            "improved_response", "combined_summary", "next_best_action",
+        ],
+    )
+    if not parsed:
+        parsed = extract_partial_string_fields(raw, [
+            "deal_outcome_summary", "best_move", "weakest_move",
+            "improved_response", "combined_summary", "next_best_action",
+        ])
+
+    result: dict[str, Any] = {}
+    for key in (
+        "deal_outcome_summary", "best_move", "weakest_move",
+        "improved_response", "combined_summary", "next_best_action",
+    ):
+        val = str(parsed.get(key, "")).strip()
+        if not val:
+            continue
+        if key == "deal_outcome_summary" and not _is_human_deal_summary(val):
+            continue
+        if ends_abruptly(val) and key in ("best_move", "weakest_move", "next_best_action"):
+            continue
+        if ends_abruptly(val) and key == "improved_response" and len(val) < 40:
+            continue
+        result[key] = val
+
+    q3 = parsed.get("top_3_prep_points")
+    if not isinstance(q3, list) or len(q3) < 3:
+        q3 = extract_partial_string_list(raw, "top_3_prep_points", min_items=3)
+    if isinstance(q3, list):
+        items = [str(q).strip() for q in q3 if str(q).strip() and not ends_abruptly(str(q))]
+        if items:
+            result["top_3_prep_points"] = items[:3]
+    return result
+
+
+def _merge_deal_coaching(local: dict[str, Any], nemotron: dict[str, Any]) -> tuple[dict[str, Any], str]:
+    merged = dict(local)
+    hits = 0
+    for key in (
+        "deal_outcome_summary", "best_move", "weakest_move",
+        "improved_response", "combined_summary", "next_best_action",
+    ):
+        val = str(nemotron.get(key, "")).strip()
+        if val:
+            merged[key] = val[:400 if key == "improved_response" else 300]
+            hits += 1
+    n_q = nemotron.get("top_3_prep_points")
+    if isinstance(n_q, list) and len(n_q) >= 3:
+        merged["top_3_prep_points"] = [str(q).strip() for q in n_q[:3]]
+        hits += 1
+    if hits >= 5:
+        return merged, "nemotron"
+    if hits > 0:
+        return merged, "partial_nemotron_local"
+    return merged, "local"
+
+
+def build_local_deal_coaching(
+    session: dict,
+    scores: dict,
+    signals: dict,
+    outcome: str,
+) -> dict[str, Any]:
+    """Local coaching text when Nemotron unavailable."""
+    deal_context = session.get("deal_context") or {}
+    moves = select_best_and_weakest_deal_moves(
+        session.get("deal_history", []), scores, signals
+    )
+    weakest_dim = min(scores.items(), key=lambda x: x[1]["score"])[0]
+
+    return {
+        "deal_outcome_summary": humanize_deal_outcome(outcome),
+        "best_move": moves["best_move"],
+        "weakest_move": moves["weakest_move"],
+        "improved_response": (
+            f"A stronger {weakest_dim.replace('_', ' ')} counter would anchor specific terms, "
+            "cite one proof point, and propose a tradeoff instead of conceding."
+        ),
+        "top_3_prep_points": [
+            "Anchor every counter with a specific number or term.",
+            "Cite one pilot metric before conceding on price or equity.",
+            "Always propose a tradeoff — never concede without getting something back.",
+        ],
+        "combined_summary": "",
+        "next_best_action": f"Practice {weakest_dim.replace('_', ' ')} in your next deal drill.",
+    }
+
+
+def call_nemotron_deal_coaching(
+    session: dict,
+    local_scorecard: dict,
+    signals: dict,
+) -> dict[str, Any] | None:
+    """Nemotron coaching for deal scorecard."""
+    deal_context = session.get("deal_context") or {}
+    history_text = "\n".join(
+        f"{h.get('role', '').upper()}: {h.get('message', '')[:200]}"
+        for h in (session.get("deal_history") or [])[-12:]
+    )
+
+    system = (
+        "You are a startup negotiation coach. Return ONLY valid JSON.\n"
+        "Return one JSON object only. First character must be {. Last character must be }.\n"
+        "No markdown. No reasoning. No array wrapper.\n"
+        "Keep each field short and complete. Do not end mid-sentence.\n"
+        "Use only provided deal history and signals. Do not hallucinate terms reached.\n"
+        "deal_outcome_summary must be a human-readable explanation (2 sentences max), "
+        "NOT a label like weak_concession or strong_win.\n\n"
+        "FIELD LIMITS:\n"
+        "  deal_outcome_summary: 2 sentences max\n"
+        "  best_move: 1 sentence\n"
+        "  weakest_move: 1 sentence\n"
+        "  improved_response: 3-5 sentences\n"
+        "  each top_3_prep_points item: 1 sentence\n"
+        "  combined_summary: 2 sentences max\n"
+        "  next_best_action: 1 sentence\n\n"
+        "REQUIRED JSON:\n"
+        '{"deal_outcome_summary":"","best_move":"","weakest_move":"",'
+        '"improved_response":"","top_3_prep_points":["","",""],'
+        '"combined_summary":"","next_best_action":""}'
+    )
+
+    user = (
+        f"Deal type: {deal_context.get('deal_type', '')}\n"
+        f"Deal outcome: {local_scorecard.get('deal_outcome', '')}\n"
+        f"Overall deal score: {local_scorecard.get('overall', 0)}\n"
+        f"Dimension scores: {local_scorecard.get('scores', {})}\n"
+        f"Signals: {signals}\n\n"
+        f"Deal history:\n{history_text}\n"
+    )
+
+    messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
+    model_mode = session.get("model_mode", "premium_nvidia")
+    result = model_router.generate_deal_scorecard_coaching_response(messages, model_mode=model_mode)
+
+    if not result.get("ok") or not result.get("content"):
+        return None
+
+    raw = result["content"]
+    local_coaching = build_local_deal_coaching(
+        session,
+        local_scorecard.get("scores", {}),
+        signals,
+        local_scorecard.get("deal_outcome", "balanced"),
+    )
+    nemotron = _parse_deal_coaching_json(raw)
+    if not nemotron.get("deal_outcome_summary"):
+        logger.warning("deal_scoring: coaching parse failed, trying repair preview=%r", sanitize_for_log(raw))
+        repair = model_router.generate_deal_scorecard_repair_response(raw, model_mode=model_mode)
+        if repair.get("ok") and repair.get("content"):
+            repaired = _parse_deal_coaching_json(repair["content"])
+            for k, v in repaired.items():
+                if v and not nemotron.get(k):
+                    nemotron[k] = v
+
+    merged, coaching_source = _merge_deal_coaching(local_coaching, nemotron)
+    if coaching_source == "local":
+        logger.warning("deal_scoring: coaching using local fallback preview=%r", sanitize_for_log(raw))
+        return None
+
+    q3 = list(merged.get("top_3_prep_points") or local_coaching["top_3_prep_points"])
+    while len(q3) < 3:
+        q3.append("Anchor terms with specific numbers.")
+    merged["top_3_prep_points"] = q3[:3]
+    merged["coaching_source"] = coaching_source
+    return merged
+
+
+def build_combined_scorecard(
+    session: dict,
+    pitch_scorecard: dict,
+    deal_scorecard: dict,
+    coaching: dict | None = None,
+) -> dict[str, Any]:
+    """Build combined pitch + deal summary."""
+    pitch_overall = int(pitch_scorecard.get("overall", 0) or 0)
+    deal_overall = int(deal_scorecard.get("overall", 0) or 0)
+    combined = round(pitch_overall * 0.6 + deal_overall * 0.4)
+
+    if pitch_overall >= 70 and deal_overall >= 70:
+        profile = "Strong pitcher, strong negotiator"
+    elif pitch_overall >= 65 and deal_overall < 55:
+        profile = "Strong pitcher, developing negotiator"
+    elif pitch_overall < 55 and deal_overall >= 65:
+        profile = "Developing pitcher, strong negotiator"
+    elif pitch_overall >= 50 and deal_overall >= 50:
+        profile = "Promising founder, needs sharper proof and negotiation control"
+    else:
+        profile = "Early-stage founder, needs stronger fundamentals before investor conversations"
+
+    if combined >= 80:
+        combined_label = "Strong"
+    elif combined >= 60:
+        combined_label = "Solid"
+    elif combined >= 40:
+        combined_label = "Developing"
+    else:
+        combined_label = "Weak"
+
+    coaching = coaching or {}
+    summary = coaching.get("combined_summary") or (
+        f"Pitch scored {pitch_overall}/100; deal negotiation scored {deal_overall}/100. "
+        f"Combined read: {profile}."
+    )
+
+    return {
+        "pitch_overall": pitch_overall,
+        "deal_overall": deal_overall,
+        "combined_overall": combined,
+        "combined_label": combined_label,
+        "founder_profile": profile,
+        "summary": summary[:500],
+        "next_best_action": coaching.get(
+            "next_best_action",
+            "Practice anchoring terms before your next investor conversation.",
+        )[:200],
+    }
+
+
+def build_local_deal_scorecard(session: dict, deal_signals: dict) -> dict[str, Any]:
+    """Full local deal scorecard without Nemotron."""
+    difficulty = session.get("difficulty_profile") or normalize_difficulty(
+        session.get("difficulty", "practice")
+    )
+    deal_context = session.get("deal_context") or {}
+    deal_history = session.get("deal_history") or []
+
+    scores = calculate_deal_dimension_scores(
+        deal_signals, deal_history, deal_context, difficulty
+    )
+    outcome = determine_deal_outcome(scores, deal_history, deal_signals)
+    overall = round(sum(s["score"] for s in scores.values()) / len(scores))
+
+    coaching = build_local_deal_coaching(session, scores, deal_signals, outcome)
+
+    return {
+        "overall": overall,
+        "overall_label": _deal_score_label(overall),
+        "deal_outcome": outcome,
+        "scores": scores,
+        "deal_outcome_summary": coaching["deal_outcome_summary"],
+        "best_move": coaching["best_move"],
+        "weakest_move": coaching["weakest_move"],
+        "improved_response": coaching["improved_response"],
+        "top_3_prep_points": coaching["top_3_prep_points"],
+        "concrete_signals_summary": {
+            "anchor_points": deal_signals.get("anchor_points", [])[:5],
+            "evidence_signals": deal_signals.get("evidence_signals", [])[:5],
+            "specific_numbers": deal_signals.get("specific_numbers", [])[:5],
+            "closing_signals": deal_signals.get("closing_signals", [])[:5],
+        },
+        "scorecard_source": "hybrid_deal_local",
+        "provider": "local",
+        "model_ok": False,
+    }
+
+
+def build_negotiation_transcript(session: dict) -> list[dict[str, Any]]:
+    """Structured transcript for the 'View Negotiation Conversation' UI."""
+    transcript: list[dict[str, Any]] = []
+    for h in session.get("deal_history", []) or []:
+        transcript.append({
+            "round": h.get("round"),
+            "role": "judge" if h.get("role") == "judge" else "founder",
+            "message": str(h.get("message", "")),
+            "negotiation_tag": h.get("negotiation_tag", ""),
+            "answer_quality": h.get("answer_quality", ""),
+            "action": h.get("action", ""),
+            "input_mode": h.get("input_mode", "") or "text",
+        })
+    return transcript
+
+
+def generate_deal_scorecard(session: dict) -> dict[str, Any]:
+    """Generate deal scorecard + combined summary using a split Nemotron call.
+
+    Call 1 (deal_scorecard_scoring) is the PRIMARY judge for the 6 dimension scores and
+    determines scorecard_source. Call 2 (deal_scorecard_coaching) only adds coaching text;
+    its failure falls back to local coaching but never downgrades scorecard_source.
+    """
+    if not session.get("deal_phase_active") and not session.get("deal_history"):
+        return {"error": "No deal phase found. Complete a deal negotiation first."}
+
+    session["deal_phase_active"] = False
+
+    deal_signals = extract_deal_signals(
+        session.get("deal_history", []),
+        session.get("deal_context"),
+    )
+
+    # Local scorecard: reference context for the model + safety fallback.
+    scorecard = build_local_deal_scorecard(session, deal_signals)
+
+    # --- Call 1: Nemotron semantic scoring (determines scorecard_source) ---
+    nem_scoring = call_nemotron_deal_scoring(session, deal_signals, scorecard)
+    if nem_scoring is not None:
+        scorecard["scores"] = nem_scoring["scores"]
+        scorecard["overall"] = nem_scoring["overall"]
+        scorecard["overall_label"] = nem_scoring["overall_label"]
+        scorecard["deal_outcome"] = nem_scoring["deal_outcome"]
+        scorecard["best_move"] = nem_scoring["best_move"]
+        scorecard["weakest_move"] = nem_scoring["weakest_move"]
+        scorecard["deal_outcome_summary"] = humanize_deal_outcome(nem_scoring["deal_outcome"])
+        scorecard["scorecard_source"] = "nemotron_full"
+        scorecard["provider"] = "nvidia"
+        scorecard["model_ok"] = True
+    else:
+        scorecard["scorecard_source"] = "hybrid_deal_local"
+        scorecard["provider"] = "local"
+        scorecard["model_ok"] = False
+        scorecard["model_error"] = "Nemotron deal scoring failed; used local scoring fallback."
+
+    # --- Call 2: Nemotron coaching text (non-fatal; never downgrades source) ---
+    coaching = call_nemotron_deal_coaching(session, scorecard, deal_signals)
+    if coaching:
+        if coaching.get("deal_outcome_summary"):
+            scorecard["deal_outcome_summary"] = coaching["deal_outcome_summary"]
+        scorecard["improved_response"] = coaching.get("improved_response", scorecard["improved_response"])
+        scorecard["top_3_prep_points"] = coaching.get("top_3_prep_points", scorecard["top_3_prep_points"])
+        # Only adopt the model's move text if it is substantive and we don't already
+        # have a semantic-scoring move (scoring-path moves are preferred).
+        if nem_scoring is None:
+            if coaching.get("best_move") and not is_one_word_ack(coaching["best_move"]):
+                scorecard["best_move"] = coaching["best_move"]
+            if coaching.get("weakest_move") and not is_one_word_ack(coaching["weakest_move"]):
+                scorecard["weakest_move"] = coaching["weakest_move"]
+        scorecard["coaching_source"] = coaching.get("coaching_source", "nemotron")
+    else:
+        coaching = build_local_deal_coaching(
+            session, scorecard["scores"], deal_signals, scorecard["deal_outcome"]
+        )
+        scorecard["coaching_source"] = "local"
+
+    pitch_scorecard = session.get("latest_scorecard") or {}
+    combined = build_combined_scorecard(session, pitch_scorecard, scorecard, coaching)
+
+    transcript = build_negotiation_transcript(session)
+    session["deal_scorecard"] = scorecard
+    session["combined_scorecard"] = combined
+
+    return {
+        "session_id": session.get("session_id", ""),
+        "deal_scorecard": scorecard,
+        "combined_scorecard": combined,
+        "negotiation_transcript": transcript,
+    }

core/deal_verdict.py

@@ -0,0 +1,381 @@
+"""Judge verdict engine after pitch scorecard (Phase 9A)."""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from core.deal_persona_builder import get_persona_display
+from core.judge_settings import get_label, normalize_difficulty
+from core.json_utils import parse_model_json, sanitize_for_log
+from core import model_router
+
+logger = logging.getLogger(__name__)
+
+_INTEREST_LABELS = {
+    "strong_interest": "Strong Interest",
+    "mild_interest": "Mild Interest",
+    "too_early": "Too Early",
+    "no_interest": "No Interest",
+}
+
+_DEAL_TYPE_FROM_ASK: list[tuple[str, str]] = [
+    (r"\b(?:seed|series|funding|investment|equity|valuation|lakhs?|crores?|vc|investor)\b", "equity"),
+    (r"\b(?:mentorship|mentor|guidance|advisor|architecture|introduc)\b", "mentorship"),
+    (r"\b(?:pilot|paid pilot|contract|deployment|client|procurement|enterprise)\b", "pilot"),
+    (r"\b(?:sponsor|sponsorship|partnership|event|fest|budget)\b", "sponsorship"),
+]
+
+
+def _get_battle_phase(round_number: int) -> str:
+    if round_number <= 3:
+        return "explore"
+    if round_number <= 6:
+        return "pressure"
+    return "close"
+
+
+def _session_maturity(session: dict) -> dict[str, Any]:
+    history = session.get("history", [])
+    user_turns = sum(1 for m in history if m.get("role") == "user")
+    rounds_completed = max(user_turns, session.get("round", 1) - 1)
+    battle_phase = _get_battle_phase(session.get("round", rounds_completed + 1))
+    enough_context = (
+        rounds_completed >= 4 and battle_phase in ("pressure", "close")
+    ) or (rounds_completed >= 3 and battle_phase == "close")
+    return {
+        "rounds_completed": rounds_completed,
+        "battle_phase_reached": battle_phase,
+        "enough_context": enough_context,
+    }
+
+
+def determine_deal_type(session: dict, pitch_scorecard: dict) -> str:
+    """Infer deal type from persona + ask field."""
+    persona = session.get("persona", "hackathon_judge")
+    difficulty = normalize_difficulty(
+        session.get("difficulty_profile") or session.get("difficulty", "practice")
+    )
+
+    # Practice mode: always allow a deal drill (mentorship terms) even with hackathon persona.
+    if difficulty == "practice":
+        if persona == "hackathon_judge":
+            return "mentorship"
+        # fall through for other personas in practice
+
+    if persona == "hackathon_judge":
+        return "verdict_only"
+
+    startup = session.get("startup", {}) or {}
+    ask = " ".join([
+        str(startup.get("ask", "")),
+        str(startup.get("traction", "")),
+        str(startup.get("problem", "")),
+    ]).lower()
+
+    for pattern, deal_type in _DEAL_TYPE_FROM_ASK:
+        if re.search(pattern, ask, re.IGNORECASE):
+            return deal_type
+
+    if persona == "skeptical_vc":
+        return "equity"
+    if persona == "technical_judge":
+        return "mentorship"
+    return "none"
+
+
+def determine_interest_level(session: dict, pitch_scorecard: dict) -> str:
+    """Return interest_level from score + battle maturity."""
+    overall = int(pitch_scorecard.get("overall", 0) or 0)
+    maturity = _session_maturity(session)
+    rounds = maturity["rounds_completed"]
+    phase = maturity["battle_phase_reached"]
+    enough = maturity["enough_context"]
+    difficulty = normalize_difficulty(
+        session.get("difficulty_profile") or session.get("difficulty", "practice")
+    )
+    is_practice = difficulty == "practice"
+
+    persona = session.get("persona", "hackathon_judge")
+    if persona == "hackathon_judge":
+        return "mild_interest" if overall >= 48 else "no_interest"
+
+    # Practice mode: slightly more room to continue into deal for demo learning.
+    score_for_verdict = overall + (5 if is_practice else 0)
+
+    if rounds < 3 and score_for_verdict < 68:
+        return "too_early"
+    if phase == "explore" and score_for_verdict < 62:
+        return "too_early"
+    if not enough and score_for_verdict < 58:
+        return "too_early"
+
+    if score_for_verdict >= 65 and rounds >= 3:
+        return "strong_interest"
+    if score_for_verdict >= 48 and rounds >= 3:
+        return "mild_interest"
+    if score_for_verdict < 40:
+        return "no_interest"
+    if is_practice and rounds >= 2 and overall >= 42:
+        return "mild_interest"
+    return "mild_interest" if enough else "too_early"
+
+
+def _weakest_dimension(pitch_scorecard: dict) -> tuple[str, int]:
+    scores = pitch_scorecard.get("scores") or {}
+    if not scores:
+        return "business_model", 30
+    dim, data = min(scores.items(), key=lambda x: int(x[1].get("score", 0)))
+    return dim, int(data.get("score", 0))
+
+
+def _strongest_dimension(pitch_scorecard: dict) -> tuple[str, int]:
+    scores = pitch_scorecard.get("scores") or {}
+    if not scores:
+        return "clarity", 50
+    dim, data = max(scores.items(), key=lambda x: int(x[1].get("score", 0)))
+    return dim, int(data.get("score", 0))
+
+
+def build_local_verdict_fallback(
+    session: dict,
+    pitch_scorecard: dict,
+    interest_level: str,
+    deal_type: str,
+) -> dict[str, str]:
+    """Local verdict text when Nemotron is unavailable."""
+    overall = int(pitch_scorecard.get("overall", 0) or 0)
+    weak_dim, weak_score = _weakest_dimension(pitch_scorecard)
+    strong_dim, strong_score = _strongest_dimension(pitch_scorecard)
+    weak_name = weak_dim.replace("_", " ")
+    startup = session.get("startup", {}) or {}
+    ask = str(startup.get("ask", "")).strip() or "your stated ask"
+    persona_name, _ = get_persona_display(session.get("persona", "skeptical_vc"))
+
+    if interest_level == "strong_interest" and deal_type == "equity":
+        reaction = (
+            f"The traction is real enough for me to continue. I am interested, "
+            f"but your valuation needs pressure-testing. I would open below {ask}."
+        )
+        offer = "₹30 lakhs for 15% — subject to due diligence on your pilot metrics."
+        why = f"Strong overall pitch ({overall}/100) but {weak_name} ({weak_score}) still needs proof."
+        next_label = "Continue to Deal Round"
+    elif interest_level == "mild_interest":
+        if deal_type == "mentorship":
+            reaction = (
+                "Good practice session. I see enough promise to walk through mentorship terms — "
+                "what you would get from me and what commitment I expect from you."
+            )
+            offer = "Two hours per week for four weeks focused on your weakest pitch dimension."
+        else:
+            reaction = (
+                "I am not fully convinced yet, but there is enough here to discuss terms. "
+                "My offer would reflect the risk I still see in your market and proof."
+            )
+            offer = "Terms would be conservative until you strengthen your weakest answers."
+        why = (
+            f"Score {overall}/100 — strongest area {strong_dim.replace('_', ' ')} ({strong_score}), "
+            f"still work needed on {weak_name} ({weak_score})."
+        )
+        next_label = "Start Negotiation →"
+    elif interest_level == "too_early":
+        reaction = (
+            "You ended before I could test the harder parts of this business. "
+            "I cannot make a serious deal decision yet."
+        )
+        offer = ""
+        why = "Not enough battle rounds or maturity to negotiate terms credibly."
+        next_label = "Practice More — Negotiate Later"
+    elif deal_type == "verdict_only":
+        reaction = (
+            "You are on the right track, but this is not a deal negotiation. "
+            "What separates you from top submissions is stronger proof, sharper differentiation, "
+            "and a clearer demo story."
+        )
+        offer = ""
+        why = f"Hackathon verdict at {overall}/100 — focus on {weak_name} before finals."
+        next_label = "View Winning Gap Analysis"
+    else:
+        reaction = (
+            "I am not ready to invest at this stage. The weakest part is your "
+            f"{weak_name}, and I would need stronger proof before discussing terms."
+        )
+        offer = ""
+        why = f"Overall {overall}/100 is below the bar for term discussion."
+        next_label = "Retry Weakest Question"
+
+    return {
+        "judge_reaction": reaction,
+        "deal_opening_offer": offer,
+        "why_this_verdict": why,
+        "next_step_label": next_label,
+    }
+
+
+def _build_verdict_nemotron_messages(
+    session: dict,
+    pitch_scorecard: dict,
+    interest_level: str,
+    deal_type: str,
+    maturity: dict,
+) -> list[dict[str, str]]:
+    startup = session.get("startup", {}) or {}
+    persona = session.get("persona", "skeptical_vc")
+    persona_name, persona_role = get_persona_display(persona)
+    weak_dim, weak_score = _weakest_dimension(pitch_scorecard)
+    strong_dim, strong_score = _strongest_dimension(pitch_scorecard)
+    difficulty = session.get("difficulty_profile") or "practice"
+
+    system = (
+        f"You are {persona_name} ({persona_role}) giving a post-pitch verdict.\n"
+        "Return ONLY valid JSON. No markdown. No reasoning. No array wrapper.\n"
+        "Use the persona voice. Do not hallucinate facts. Use only provided context.\n\n"
+        "REQUIRED JSON:\n"
+        '{"judge_reaction":"","deal_opening_offer":"","why_this_verdict":"","next_step_label":""}\n\n'
+        "Rules:\n"
+        "- judge_reaction: 2-3 sentences in character.\n"
+        "- deal_opening_offer: opening terms if deal continues; empty string if not.\n"
+        "- For verdict_only (hackathon): deal_opening_offer must be empty; "
+        "next_step_label = 'View Winning Gap Analysis'.\n"
+        "- For too_early/no_interest: deal_opening_offer empty.\n"
+        "- next_step_label: 'Start Negotiation' if interested; "
+        "'Practice More — Negotiate Later' if too_early; 'Retry Weakest Question' if no_interest."
+    )
+
+    user = (
+        f"Startup: {startup.get('name', '')}\n"
+        f"Ask: {startup.get('ask', '')}\n"
+        f"Traction: {startup.get('traction', '')}\n"
+        f"Pitch overall: {pitch_scorecard.get('overall', 0)}/100\n"
+        f"Weakest dimension: {weak_dim} ({weak_score})\n"
+        f"Strongest dimension: {strong_dim} ({strong_score})\n"
+        f"Interest level (computed): {interest_level}\n"
+        f"Deal type: {deal_type}\n"
+        f"Rounds completed: {maturity.get('rounds_completed')}\n"
+        f"Battle phase: {maturity.get('battle_phase_reached')}\n"
+        f"Difficulty: {difficulty}\n"
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+def generate_judge_reaction_with_nemotron(
+    session: dict,
+    pitch_scorecard: dict,
+    verdict_base: dict[str, str],
+) -> dict[str, str]:
+    """Enhance verdict text via Nemotron; fall back to verdict_base on failure."""
+    messages = _build_verdict_nemotron_messages(
+        session,
+        pitch_scorecard,
+        verdict_base.get("interest_level", "no_interest"),
+        verdict_base.get("deal_type", "none"),
+        verdict_base.get("session_maturity", {}),
+    )
+    model_mode = session.get("model_mode", "premium_nvidia")
+    result = model_router.generate_deal_verdict_response(messages, model_mode=model_mode)
+    if not result.get("ok") or not result.get("content"):
+        return {
+            "judge_reaction": verdict_base.get("judge_reaction", ""),
+            "deal_opening_offer": verdict_base.get("deal_opening_offer", ""),
+            "why_this_verdict": verdict_base.get("why_this_verdict", ""),
+            "next_step_label": verdict_base.get("next_step_label", ""),
+        }
+
+    raw = result["content"]
+    parsed, _ = parse_model_json(raw)
+    if not isinstance(parsed, dict) or not parsed:
+        repair = model_router.generate_deal_verdict_repair_response(raw, model_mode=model_mode)
+        if repair.get("ok") and repair.get("content"):
+            parsed, _ = parse_model_json(repair["content"])
+
+    if isinstance(parsed, dict) and parsed.get("judge_reaction"):
+        return {
+            "judge_reaction": str(parsed.get("judge_reaction", ""))[:500],
+            "deal_opening_offer": str(parsed.get("deal_opening_offer", ""))[:300],
+            "why_this_verdict": str(parsed.get("why_this_verdict", ""))[:400],
+            "next_step_label": str(parsed.get("next_step_label", verdict_base.get("next_step_label", "")))[:80],
+        }
+
+    logger.warning("deal_verdict: Nemotron parse failed preview=%r", sanitize_for_log(raw))
+    return {
+        "judge_reaction": verdict_base.get("judge_reaction", ""),
+        "deal_opening_offer": verdict_base.get("deal_opening_offer", ""),
+        "why_this_verdict": verdict_base.get("why_this_verdict", ""),
+        "next_step_label": verdict_base.get("next_step_label", ""),
+    }
+
+
+def build_judge_verdict(
+    session: dict,
+    pitch_scorecard: dict,
+    local_only: bool = False,
+) -> dict[str, Any]:
+    """Build full judge_verdict object after pitch scorecard."""
+    from core.scoring_engine import _sync_overall_to_dimensions
+
+    pitch_scorecard = _sync_overall_to_dimensions(dict(pitch_scorecard))
+    session["latest_scorecard"] = pitch_scorecard
+
+    persona = session.get("persona", "hackathon_judge")
+    persona_name, persona_role = get_persona_display(persona)
+    maturity = _session_maturity(session)
+    deal_type = determine_deal_type(session, pitch_scorecard)
+    interest_level = determine_interest_level(session, pitch_scorecard)
+
+    startup = session.get("startup", {}) or {}
+    ask_detected = str(startup.get("ask", "")).strip()
+
+    difficulty_profile = session.get("difficulty_profile") or normalize_difficulty(
+        session.get("difficulty", "practice")
+    )
+
+    can_continue = (
+        interest_level in ("strong_interest", "mild_interest")
+        and deal_type not in ("verdict_only", "none")
+    )
+    if deal_type == "verdict_only":
+        can_continue = False
+    if interest_level in ("too_early", "no_interest"):
+        can_continue = False
+    # Practice mode: mild/strong interest always unlocks deal practice.
+    if difficulty_profile == "practice" and interest_level in ("strong_interest", "mild_interest"):
+        can_continue = True
+        if deal_type in ("verdict_only", "none"):
+            deal_type = "mentorship"
+
+    local = build_local_verdict_fallback(session, pitch_scorecard, interest_level, deal_type)
+    verdict_base = {
+        **local,
+        "interest_level": interest_level,
+        "deal_type": deal_type,
+        "session_maturity": maturity,
+    }
+
+    use_local = local_only or bool(pitch_scorecard.get("retry_applied"))
+    if use_local:
+        nemotron_text = {
+            "judge_reaction": local["judge_reaction"],
+            "deal_opening_offer": local["deal_opening_offer"],
+            "why_this_verdict": local["why_this_verdict"],
+            "next_step_label": local["next_step_label"],
+        }
+    else:
+        nemotron_text = generate_judge_reaction_with_nemotron(session, pitch_scorecard, verdict_base)
+
+    return {
+        "interest_level": interest_level,
+        "interest_label": _INTEREST_LABELS.get(interest_level, interest_level),
+        "deal_type": deal_type,
+        "can_continue_to_deal": can_continue,
+        "judge_reaction": nemotron_text.get("judge_reaction", local["judge_reaction"]),
+        "deal_opening_offer": nemotron_text.get("deal_opening_offer", local["deal_opening_offer"]),
+        "why_this_verdict": nemotron_text.get("why_this_verdict", local["why_this_verdict"]),
+        "next_step_label": nemotron_text.get("next_step_label", local["next_step_label"]),
+        "persona_name": persona_name,
+        "persona_type": persona_role,
+        "ask_detected": ask_detected,
+        "session_maturity": maturity,
+        "difficulty_profile": difficulty_profile,
+        "difficulty_label": get_label(difficulty_profile),
+    }

core/json_utils.py

@@ -3,22 +3,35 @@
 from __future__ import annotations
 
 import json
+import logging
 import re
 from typing import Any
 
+logger = logging.getLogger(__name__)
 
-def extract_json_block(text: str) -> str | None:
-    """Extract the first JSON object or array block from text."""
-    if not text:
-        return None
 
-    fenced = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", text, re.IGNORECASE)
+def strip_markdown_fences(text: str) -> str:
+    """Remove markdown code fences and trim surrounding whitespace."""
+    if not text:
+        return ""
+    stripped = text.strip()
+    fenced = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", stripped, re.IGNORECASE)
     if fenced:
         return fenced.group(1).strip()
-
-    for opener, closer in (("{", "}"), ("[", "]")):
-        start = text.find(opener)
-        if start == -1:
+    # Strip lone opening/closing fence lines
+    lines = stripped.splitlines()
+    if lines and lines[0].strip().startswith("```"):
+        lines = lines[1:]
+    if lines and lines[-1].strip() == "```":
+        lines = lines[:-1]
+    return "\n".join(lines).strip()
+
+
+def _balanced_blocks(text: str, opener: str, closer: str) -> list[str]:
+    """Return all balanced opener/closer blocks found in text."""
+    blocks: list[str] = []
+    for start in range(len(text)):
+        if text[start] != opener:
             continue
         depth = 0
         for index in range(start, len(text)):
@@ -28,8 +41,46 @@ def extract_json_block(text: str) -> str | None:
             elif char == closer:
                 depth -= 1
                 if depth == 0:
-                    return text[start : index + 1]
-    return None
+                    blocks.append(text[start : index + 1])
+                    break
+    return blocks
+
+
+def extract_largest_json_object(text: str) -> str | None:
+    """Extract the largest parseable JSON object from mixed model output."""
+    if not text:
+        return None
+
+    cleaned = strip_markdown_fences(text)
+    candidates = _balanced_blocks(cleaned, "{", "}")
+    if not candidates:
+        return None
+
+    # Prefer the largest block that parses cleanly
+    for block in sorted(candidates, key=len, reverse=True):
+        try:
+            parsed = json.loads(block)
+            if isinstance(parsed, dict):
+                return block
+        except json.JSONDecodeError:
+            continue
+
+    # Fall back to largest balanced block even if not yet parseable
+    return max(candidates, key=len)
+
+
+def extract_json_block(text: str) -> str | None:
+    """Extract the largest JSON object block from text (legacy name, improved behavior)."""
+    if not text:
+        return None
+    return extract_largest_json_object(text)
+
+
+def sanitize_for_log(text: str, limit: int = 200) -> str:
+    """Return a safe preview string for debug logs (no secrets, truncated)."""
+    preview = strip_markdown_fences(text or "")
+    preview = re.sub(r"\s+", " ", preview).strip()
+    return preview[:limit]
 
 
 def safe_json_parse(text: str, default: Any = None) -> Any:
@@ -40,16 +91,153 @@ def safe_json_parse(text: str, default: Any = None) -> Any:
     if not text:
         return default
 
+    cleaned = strip_markdown_fences(text)
+
     try:
-        return json.loads(text)
+        return json.loads(cleaned)
     except json.JSONDecodeError:
-        block = extract_json_block(text)
-        if not block:
-            return default
+        pass
+
+    block = extract_largest_json_object(cleaned)
+    if not block:
+        return default
+    try:
+        return json.loads(block)
+    except json.JSONDecodeError:
+        return default
+
+
+def ends_abruptly(text: str) -> bool:
+    """Return True if text looks cut off mid-sentence."""
+    t = (text or "").strip()
+    if not t:
+        return True
+    if t[-1] in ".!?":
+        return False
+    if len(t) < 50:
+        return True
+    last_word = t.split()[-1] if t.split() else ""
+    return len(last_word) <= 2 and len(t) < 80
+
+
+def normalize_parsed_root(parsed: Any) -> dict[str, Any] | None:
+    """Unwrap array-wrapped or nested model JSON into a single object."""
+    if isinstance(parsed, dict):
+        return parsed
+    if isinstance(parsed, list):
+        for item in parsed:
+            if isinstance(item, dict) and item:
+                return item
+    return None
+
+
+def extract_partial_string_fields(text: str, keys: list[str]) -> dict[str, str]:
+    """Best-effort regex extraction of string fields from truncated JSON."""
+    if not text:
+        return {}
+    cleaned = strip_markdown_fences(text)
+    found: dict[str, str] = {}
+    for key in keys:
+        pattern = rf'"{re.escape(key)}"\s*:\s*"((?:[^"\\]|\\.)*)"'
+        match = re.search(pattern, cleaned, re.DOTALL)
+        if match:
+            try:
+                found[key] = json.loads(f'"{match.group(1)}"')
+            except json.JSONDecodeError:
+                found[key] = match.group(1).replace('\\"', '"').strip()
+    return found
+
+
+def extract_partial_string_list(text: str, key: str, min_items: int = 1) -> list[str]:
+    """Extract a JSON string array field from truncated output."""
+    if not text:
+        return []
+    cleaned = strip_markdown_fences(text)
+    match = re.search(rf'"{re.escape(key)}"\s*:\s*\[([\s\S]*?)\]', cleaned)
+    if not match:
+        return []
+    items: list[str] = []
+    for item_match in re.finditer(r'"((?:[^"\\]|\\.)*)"', match.group(1)):
+        try:
+            items.append(json.loads(f'"{item_match.group(1)}"'))
+        except json.JSONDecodeError:
+            items.append(item_match.group(1).replace('\\"', '"').strip())
+    return [i for i in items if i][:max(min_items, 8)]
+
+
+def parse_json_object(
+    text: str,
+    reasoning_fallback: str | None = None,
+    string_fields: list[str] | None = None,
+) -> dict[str, Any]:
+    """Parse model output into a dict using multiple extraction strategies."""
+    parsed, _ = parse_model_json(text, reasoning_fallback=reasoning_fallback)
+    root = normalize_parsed_root(parsed)
+    if root:
+        return root
+
+    partial = extract_partial_string_fields(text, string_fields or [])
+    if partial:
+        return partial
+
+    fallback = safe_json_parse(text)
+    root = normalize_parsed_root(fallback)
+    return root if root else {}
+
+
+def parse_model_json(
+    text: str,
+    reasoning_fallback: str | None = None,
+) -> tuple[Any, bool]:
+    """Parse model JSON output with extraction fallbacks.
+
+    Returns (parsed_value, repair_needed).
+    repair_needed is True when direct parse failed and extraction/reasoning was used.
+    """
+    default: dict[str, Any] = {}
+    if not text and not reasoning_fallback:
+        return default, False
+
+    content = strip_markdown_fences(text or "")
+    repair_needed = False
+
+    if content:
         try:
-            return json.loads(block)
+            parsed = json.loads(content)
+            if isinstance(parsed, dict):
+                return parsed, False
+            if isinstance(parsed, list) and len(parsed) == 1 and isinstance(parsed[0], dict):
+                return parsed[0], True
+            if isinstance(parsed, list):
+                return parsed, True
         except json.JSONDecodeError:
-            return default
+            repair_needed = True
+
+        block = extract_largest_json_object(content)
+        if block:
+            try:
+                parsed = json.loads(block)
+                if isinstance(parsed, (dict, list)):
+                    return parsed, repair_needed
+            except json.JSONDecodeError:
+                pass
+
+    if reasoning_fallback:
+        fb = strip_markdown_fences(reasoning_fallback)
+        block = extract_largest_json_object(fb)
+        if block:
+            try:
+                parsed = json.loads(block)
+                if isinstance(parsed, (dict, list)):
+                    logger.info(
+                        "json_utils: parsed JSON from reasoning_content fallback (len=%d)",
+                        len(fb),
+                    )
+                    return parsed, True
+            except json.JSONDecodeError:
+                pass
+
+    return default, True
 
 
 def fallback_scorecard() -> dict[str, Any]:

core/judge_settings.py

@@ -0,0 +1,324 @@
+"""Difficulty profile loader for PitchFight AI.
+
+Reads config/judge_settings.json and exposes typed accessors for:
+  - question style (tone, jargon avoidance, max sentences)
+  - scoring calibration (floors, ranges per profile)
+  - battle phase tone
+  - coaching style
+
+Safe defaults are embedded here so the app works even if the JSON is missing.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_CONFIG_PATH = os.path.join(
+    os.path.dirname(__file__), "..", "config", "judge_settings.json"
+)
+
+# ---------------------------------------------------------------------------
+# Alias normalization map
+# ---------------------------------------------------------------------------
+
+_ALIAS_MAP: dict[str, str] = {
+    # practice
+    "practice": "practice",
+    "easy": "practice",
+    "beginner": "practice",
+    "student": "practice",
+    # judge
+    "judge": "judge",
+    "medium": "judge",
+    "balanced": "judge",
+    "hackathon": "judge",
+    "high": "judge",       # legacy frontend sent "high"
+    # investor
+    "investor": "investor",
+    "hard": "investor",
+    "vc": "investor",
+    "expert": "investor",
+}
+
+# ---------------------------------------------------------------------------
+# Hardcoded safe defaults (used when config file is absent or invalid)
+# ---------------------------------------------------------------------------
+
+_DEFAULT_SETTINGS: dict[str, Any] = {
+    "default_profile": "practice",
+    "profiles": {
+        "practice": {
+            "label": "Practice Mode",
+            "description": "Student-friendly pitch practice for first/second-time founders.",
+            "profile_display": {
+                "pressure_labels": {
+                    "explore": "Warm-up",
+                    "pressure": "Focused",
+                    "close": "Final Practice",
+                },
+            },
+            "question_style": {
+                "plain_language": True,
+                "avoid_jargon": True,
+                "avoid_compound_questions": True,
+                "one_question_only": True,
+                "max_sentences": 3,
+                "tone": "challenging_but_supportive",
+                "instruction": (
+                    "This founder is practicing for the first or second time. "
+                    "Challenge them enough to help them improve, but do not destroy confidence. "
+                    "Ask one clear focused question at a time. "
+                    "Use plain language and avoid jargon-heavy VC terminology."
+                ),
+            },
+            "coaching_style": {
+                "tone": "encouraging_actionable",
+                "instruction": (
+                    "Be encouraging but honest. Explain what the founder did right, "
+                    "then show exactly how to make the answer stronger with one specific number, "
+                    "example, or proof point."
+                ),
+                "example": (
+                    "Your answer touched on the right idea. "
+                    "Here's how to make it more convincing with one specific number or example."
+                ),
+            },
+            "battle_phase_tone": {
+                "explore": "medium",
+                "pressure": "medium_high_but_clear",
+                "close": "firm_but_supportive",
+            },
+            "scoring_calibration": {
+                "attempted_answer_floor": 35,
+                "partial_signal_floor": 40,
+                "concrete_signal_floor": 52,
+                "non_answer_max": 20,
+                "startup_context_max": 45,
+                "vague_on_topic_range": [35, 45],
+                "one_concrete_signal_range": [52, 62],
+                "strong_answer_range": [71, 85],
+                "excellent_answer_range": [86, 100],
+            },
+        },
+        "judge": {
+            "label": "Judge Mode",
+            "description": "Balanced hackathon judge simulation.",
+            "profile_display": {
+                "pressure_labels": {
+                    "explore": "Moderate",
+                    "pressure": "High",
+                    "close": "Panel Ready",
+                },
+            },
+            "question_style": {
+                "plain_language": True,
+                "avoid_jargon": True,
+                "avoid_compound_questions": True,
+                "one_question_only": True,
+                "max_sentences": 3,
+                "tone": "realistic_hackathon_judge",
+                "instruction": (
+                    "Act like a realistic hackathon judge. Be sharp and specific, "
+                    "but keep questions understandable. Ask one clear question at a time "
+                    "and focus on demo strength, novelty, user pain, and feasibility."
+                ),
+            },
+            "coaching_style": {
+                "tone": "balanced_judge_feedback",
+                "instruction": (
+                    "Be direct and fair. Highlight what would convince a hackathon judge "
+                    "and what still needs proof before demo time."
+                ),
+                "example": (
+                    "This answer has a useful signal, but a judge still needs to see proof "
+                    "in the demo. Make the claim measurable and show it quickly."
+                ),
+            },
+            "battle_phase_tone": {
+                "explore": "medium_high",
+                "pressure": "high_but_fair",
+                "close": "firm_judging_panel",
+            },
+            "scoring_calibration": {
+                "attempted_answer_floor": 30,
+                "partial_signal_floor": 38,
+                "concrete_signal_floor": 48,
+                "non_answer_max": 18,
+                "startup_context_max": 40,
+                "vague_on_topic_range": [30, 42],
+                "one_concrete_signal_range": [48, 60],
+                "strong_answer_range": [70, 85],
+                "excellent_answer_range": [86, 100],
+            },
+        },
+        "investor": {
+            "label": "Investor Mode",
+            "description": "Harder skeptical VC-style pressure.",
+            "profile_display": {
+                "pressure_labels": {
+                    "explore": "High",
+                    "pressure": "Very High",
+                    "close": "Investor Pressure",
+                },
+            },
+            "question_style": {
+                "plain_language": False,
+                "avoid_jargon": False,
+                "avoid_compound_questions": False,
+                "one_question_only": True,
+                "max_sentences": 4,
+                "tone": "skeptical_investor",
+                "instruction": (
+                    "Act like a skeptical early-stage investor. Pressure-test market size, "
+                    "moat, retention, revenue logic, distribution, and why now. "
+                    "Be tougher than Practice Mode, but still focus on one main pressure point per round."
+                ),
+            },
+            "coaching_style": {
+                "tone": "sharp_investor_feedback",
+                "instruction": (
+                    "Be sharper and more business-focused. Explain what would worry an investor "
+                    "and what proof is needed to reduce that concern."
+                ),
+                "example": (
+                    "This answer lacks defensibility. A real investor needs to hear your moat mechanism, "
+                    "not just what the product does."
+                ),
+            },
+            "battle_phase_tone": {
+                "explore": "high",
+                "pressure": "very_high",
+                "close": "investment_committee",
+            },
+            "scoring_calibration": {
+                "attempted_answer_floor": 25,
+                "partial_signal_floor": 35,
+                "concrete_signal_floor": 45,
+                "non_answer_max": 15,
+                "startup_context_max": 35,
+                "vague_on_topic_range": [25, 38],
+                "one_concrete_signal_range": [45, 58],
+                "strong_answer_range": [70, 85],
+                "excellent_answer_range": [86, 100],
+            },
+        },
+    },
+}
+
+# ---------------------------------------------------------------------------
+# Module-level singleton (loaded once)
+# ---------------------------------------------------------------------------
+
+_settings: dict[str, Any] | None = None
+
+
+def load_judge_settings() -> dict[str, Any]:
+    """Load and cache judge_settings.json. Falls back to hardcoded defaults."""
+    global _settings
+    if _settings is not None:
+        return _settings
+
+    path = os.path.abspath(_CONFIG_PATH)
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        if not isinstance(data, dict) or "profiles" not in data:
+            raise ValueError("Missing 'profiles' key")
+        _settings = data
+        logger.info("judge_settings: loaded from %s", path)
+    except FileNotFoundError:
+        logger.warning("judge_settings: config not found at %s — using defaults", path)
+        _settings = _DEFAULT_SETTINGS
+    except Exception as exc:
+        logger.warning("judge_settings: failed to load (%s) — using defaults", exc)
+        _settings = _DEFAULT_SETTINGS
+
+    return _settings
+
+
+def get_default_profile() -> str:
+    s = load_judge_settings()
+    return s.get("default_profile", "practice")
+
+
+def normalize_difficulty(value: str | None) -> str:
+    """Map any incoming difficulty string to a canonical profile name.
+
+    Supports legacy frontend values like "high" → "judge" and aliases like
+    "beginner" → "practice". Unknown values fall back to the default profile.
+    """
+    if not value:
+        return get_default_profile()
+    key = str(value).strip().lower()
+    normalized = _ALIAS_MAP.get(key)
+    if normalized:
+        return normalized
+    # If the value is already a valid profile name, accept it
+    s = load_judge_settings()
+    if key in s.get("profiles", {}):
+        return key
+    logger.warning("judge_settings: unknown difficulty %r — using default", value)
+    return get_default_profile()
+
+
+def get_profile(profile_name: str | None) -> dict[str, Any]:
+    """Return the full profile dict for the given (or default) profile."""
+    s = load_judge_settings()
+    name = normalize_difficulty(profile_name)
+    profiles = s.get("profiles", {})
+    profile = profiles.get(name)
+    if not profile:
+        logger.warning("judge_settings: profile %r not found — falling back to practice", name)
+        profile = profiles.get("practice") or list(profiles.values())[0]
+    return profile
+
+
+def get_question_style(profile_name: str | None) -> dict[str, Any]:
+    return get_profile(profile_name).get("question_style", {})
+
+
+def get_scoring_calibration(profile_name: str | None) -> dict[str, Any]:
+    return get_profile(profile_name).get("scoring_calibration", {})
+
+
+def get_battle_phase_tone(profile_name: str | None, battle_phase: str) -> str:
+    tones = get_profile(profile_name).get("battle_phase_tone", {})
+    return tones.get(battle_phase, "medium")
+
+
+def get_coaching_style(profile_name: str | None) -> dict[str, Any]:
+    return get_profile(profile_name).get("coaching_style", {})
+
+
+def get_label(profile_name: str | None) -> str:
+    return get_profile(profile_name).get("label", "Practice Mode")
+
+
+_PRESSURE_FALLBACKS: dict[str, dict[str, str]] = {
+    "practice": {"explore": "Warm-up", "pressure": "Focused", "close": "Final Practice"},
+    "judge":    {"explore": "Moderate", "pressure": "High", "close": "Panel Ready"},
+    "investor": {"explore": "High", "pressure": "Very High", "close": "Investor Pressure"},
+}
+
+
+def get_pressure_display_label(profile_name: str | None, battle_phase: str) -> str:
+    """Return a human-readable pressure label for the sidebar.
+
+    Never returns "Extreme" for Practice Mode.
+    Falls back to hardcoded defaults if config is missing.
+    """
+    profile = get_profile(profile_name)
+    display = profile.get("profile_display", {})
+    labels = display.get("pressure_labels", {})
+    phase_key = battle_phase if battle_phase in ("explore", "pressure", "close") else "explore"
+    if labels and phase_key in labels:
+        return labels[phase_key]
+    canonical = normalize_difficulty(profile_name)
+    return _PRESSURE_FALLBACKS.get(canonical, _PRESSURE_FALLBACKS["practice"]).get(
+        phase_key, "Warm-up"
+    )

core/model_router.py

@@ -147,6 +147,167 @@ def generate_scorecard_response(
     )
 
 
+def generate_scoring_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Route a dimension-scoring-only request (mode=scorecard_scoring).
+
+    Nemotron judges all 6 dimensions from actual Q&A. Returns scores + best/weakest only.
+    Coaching fields (improved_answer, improved_pitch, top_3_questions) are NOT included.
+    """
+    mode = _resolve_mode(model_mode)
+
+    if mode == "premium_nvidia":
+        try:
+            content = nvidia_client.generate_nemotron_response(
+                messages, mode="scorecard_scoring"
+            )
+            return {"ok": True, "model_mode": mode, "provider": "nvidia", "content": content, "error": None}
+        except RuntimeError as exc:
+            logger.warning("NVIDIA scoring call failed: %s", exc)
+            return {"ok": False, "model_mode": mode, "provider": "nvidia", "content": "", "error": str(exc)}
+
+    return _placeholder_result(mode, "mock", f"Scoring via '{mode}' not implemented.")
+
+
+def generate_scoring_repair_response(
+    raw_bad_content: str,
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Repair a broken scoring-only JSON response (mode=scorecard_scoring_repair)."""
+    mode = _resolve_mode(model_mode)
+
+    if mode != "premium_nvidia":
+        return _placeholder_result(mode, "mock", "Scoring repair only for premium_nvidia.")
+
+    repair_messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a JSON formatter. Convert the input into the exact schema below. "
+                "Return ONLY valid JSON. First character must be { last must be }. "
+                "No markdown. No explanation.\n\n"
+                "REQUIRED SCHEMA:\n"
+                '{"scores":{"clarity":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"problem_understanding":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"market_awareness":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"differentiation":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"business_model":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"objection_handling":{"score":0,"reason":"","quote":"","signals_used":[]}},'
+                '"best_answer":"","weakest_answer":"","why_weak":""}'
+            ),
+        },
+        {
+            "role": "user",
+            "content": "Convert this text into the JSON schema. Output JSON only:\n\n" + raw_bad_content[:4000],
+        },
+    ]
+
+    try:
+        content = nvidia_client.generate_nemotron_response(repair_messages, mode="scorecard_scoring_repair")
+        return {"ok": True, "model_mode": mode, "provider": "nvidia", "content": content, "error": None}
+    except RuntimeError as exc:
+        logger.warning("NVIDIA scoring repair call failed: %s", exc)
+        return {"ok": False, "model_mode": mode, "provider": "nvidia", "content": "", "error": str(exc)}
+
+
+def generate_full_scorecard_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Route a full Nemotron scoring request (mode=scorecard_full).
+
+    Nemotron judges all 6 dimensions from the actual Q&A conversation.
+    Returns the full scorecard JSON including scores + coaching + score_explanation.
+    """
+    mode = _resolve_mode(model_mode)
+
+    if mode == "premium_nvidia":
+        try:
+            content = nvidia_client.generate_nemotron_response(
+                messages, mode="scorecard_full"
+            )
+            return {
+                "ok": True,
+                "model_mode": mode,
+                "provider": "nvidia",
+                "content": content,
+                "error": None,
+            }
+        except RuntimeError as exc:
+            logger.warning("NVIDIA full scorecard call failed: %s", exc)
+            return {
+                "ok": False,
+                "model_mode": mode,
+                "provider": "nvidia",
+                "content": "",
+                "error": str(exc),
+            }
+
+    return _placeholder_result(mode, "mock", f"Full scorecard via '{mode}' not implemented.")
+
+
+def generate_full_scorecard_repair_response(
+    raw_bad_content: str,
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Repair a broken full scorecard JSON using mode=scorecard_full_repair."""
+    mode = _resolve_mode(model_mode)
+
+    if mode != "premium_nvidia":
+        return _placeholder_result(mode, "mock", "Full scorecard repair only for premium_nvidia.")
+
+    repair_messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a JSON formatter. Convert the input into the exact schema below. "
+                "Return ONLY valid JSON. First character must be { last must be }. "
+                "No markdown. No explanation. No preface.\n\n"
+                "REQUIRED SCHEMA (fill all fields, use 0 for missing scores, empty string for text):\n"
+                '{"scores":{"clarity":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"problem_understanding":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"market_awareness":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"differentiation":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"business_model":{"score":0,"reason":"","quote":"","signals_used":[]},'
+                '"objection_handling":{"score":0,"reason":"","quote":"","signals_used":[]}},'
+                '"best_answer":"","weakest_answer":"","why_weak":"",'
+                '"improved_answer":"","improved_pitch":"","top_3_questions":["","",""],'
+                '"score_explanation":{"why_you_scored_this":"","what_stopped_80":"",'
+                '"answer_to_retry":{"round":null,"attack_tag":"","dimension":"","original_answer":"",'
+                '"why_it_hurt":"","retry_advice":"","sample_stronger_answer":""},'
+                '"estimated_score_if_fixed":{"current_overall":0,"estimated_new_overall":0,"reason":""}}}'
+            ),
+        },
+        {
+            "role": "user",
+            "content": "Convert this text into the JSON schema. Output JSON only:\n\n" + raw_bad_content[:5000],
+        },
+    ]
+
+    try:
+        content = nvidia_client.generate_nemotron_response(
+            repair_messages, mode="scorecard_full_repair"
+        )
+        return {
+            "ok": True,
+            "model_mode": mode,
+            "provider": "nvidia",
+            "content": content,
+            "error": None,
+        }
+    except RuntimeError as exc:
+        logger.warning("NVIDIA full scorecard repair call failed: %s", exc)
+        return {
+            "ok": False,
+            "model_mode": mode,
+            "provider": "nvidia",
+            "content": "",
+            "error": str(exc),
+        }
+
+
 def generate_coaching_response(
     messages: list[dict[str, str]],
     model_mode: str | None = None,
@@ -201,7 +362,11 @@ def generate_coaching_repair_response(
                 "Return ONLY valid JSON. First character must be { and last must be }. "
                 "No markdown. No explanation. No preface.\n\n"
                 "REQUIRED SCHEMA:\n"
-                '{"improved_answer": "", "improved_pitch": "", "top_3_questions": ["", "", ""]}'
+                '{"improved_answer":"","improved_pitch":"","top_3_questions":["","",""],'
+                '"score_explanation":{"why_you_scored_this":"","what_stopped_80":"",'
+                '"answer_to_retry":{"round":null,"attack_tag":"","dimension":"","original_answer":"",'
+                '"why_it_hurt":"","retry_advice":"","sample_stronger_answer":""},'
+                '"estimated_score_if_fixed":{"current_overall":0,"estimated_new_overall":0,"reason":""}}}'
             ),
         },
         {
@@ -315,6 +480,230 @@ def generate_scorecard_repair_response(
         }
 
 
+def generate_retry_comparison_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Route a retry answer comparison request (mode=retry_comparison)."""
+    mode = _resolve_mode(model_mode)
+
+    if mode == "premium_nvidia":
+        try:
+            content = nvidia_client.generate_nemotron_response(
+                messages, mode="retry_comparison"
+            )
+            return {
+                "ok": True,
+                "model_mode": mode,
+                "provider": "nvidia",
+                "content": content,
+                "error": None,
+            }
+        except RuntimeError as exc:
+            logger.warning("NVIDIA retry comparison call failed: %s", exc)
+            return {
+                "ok": False,
+                "model_mode": mode,
+                "provider": "nvidia",
+                "content": "",
+                "error": str(exc),
+            }
+
+    return _placeholder_result(mode, "mock", f"Retry comparison via '{mode}' not implemented.")
+
+
+def generate_retry_comparison_repair_response(
+    raw_bad_content: str,
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Repair a broken retry comparison JSON (mode=retry_comparison_repair)."""
+    mode = _resolve_mode(model_mode)
+
+    if mode != "premium_nvidia":
+        return _placeholder_result(mode, "mock", "Retry comparison repair only for premium_nvidia.")
+
+    repair_messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a JSON formatter. Convert the input into the exact schema below. "
+                "Return ONLY valid JSON. First character must be { last must be }.\n\n"
+                "REQUIRED SCHEMA:\n"
+                '{"comparison":{"old_answer_summary":"","new_answer_summary":"","what_improved":"",'
+                '"still_missing":"","specific_tip":"","estimated_dimension_before":0,'
+                '"estimated_dimension_after":0,"estimated_overall_lift":0,'
+                '"verdict":"improved|slightly_improved|needs_more_work"},'
+                '"next_practice_prompt":""}'
+            ),
+        },
+        {
+            "role": "user",
+            "content": "Convert this text into the JSON schema. Output JSON only:\n\n" + raw_bad_content[:4000],
+        },
+    ]
+
+    try:
+        content = nvidia_client.generate_nemotron_response(
+            repair_messages, mode="retry_comparison_repair"
+        )
+        return {
+            "ok": True,
+            "model_mode": mode,
+            "provider": "nvidia",
+            "content": content,
+            "error": None,
+        }
+    except RuntimeError as exc:
+        logger.warning("NVIDIA retry comparison repair call failed: %s", exc)
+        return {
+            "ok": False,
+            "model_mode": mode,
+            "provider": "nvidia",
+            "content": "",
+            "error": str(exc),
+        }
+
+
+def _call_nvidia_json_mode(
+    messages: list[dict[str, str]],
+    nemotron_mode: str,
+    model_mode: str | None,
+    label: str,
+) -> dict[str, Any]:
+    mode = _resolve_mode(model_mode)
+    if mode != "premium_nvidia":
+        return _placeholder_result(mode, "mock", f"{label} only for premium_nvidia.")
+    try:
+        content = nvidia_client.generate_nemotron_response(messages, mode=nemotron_mode)
+        return {"ok": True, "model_mode": mode, "provider": "nvidia", "content": content, "error": None}
+    except RuntimeError as exc:
+        logger.warning("NVIDIA %s call failed: %s", label, exc)
+        return {"ok": False, "model_mode": mode, "provider": "nvidia", "content": "", "error": str(exc)}
+
+
+def _call_nvidia_repair_mode(
+    repair_messages: list[dict[str, str]],
+    nemotron_mode: str,
+    model_mode: str | None,
+    label: str,
+) -> dict[str, Any]:
+    mode = _resolve_mode(model_mode)
+    if mode != "premium_nvidia":
+        return _placeholder_result(mode, "mock", f"{label} repair only for premium_nvidia.")
+    try:
+        content = nvidia_client.generate_nemotron_response(repair_messages, mode=nemotron_mode)
+        return {"ok": True, "model_mode": mode, "provider": "nvidia", "content": content, "error": None}
+    except RuntimeError as exc:
+        logger.warning("NVIDIA %s repair failed: %s", label, exc)
+        return {"ok": False, "model_mode": mode, "provider": "nvidia", "content": "", "error": str(exc)}
+
+
+def generate_deal_verdict_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    return _call_nvidia_json_mode(messages, "deal_verdict", model_mode, "deal verdict")
+
+
+def generate_deal_verdict_repair_response(
+    raw_bad_content: str,
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    repair_messages = [
+        {
+            "role": "system",
+            "content": (
+                "Convert input to JSON. Return ONLY valid JSON.\n"
+                '{"judge_reaction":"","deal_opening_offer":"","why_this_verdict":"","next_step_label":""}'
+            ),
+        },
+        {"role": "user", "content": "Output JSON only:\n\n" + raw_bad_content[:4000]},
+    ]
+    return _call_nvidia_repair_mode(repair_messages, "deal_verdict_repair", model_mode, "deal verdict")
+
+
+def generate_deal_round_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    mode = _resolve_mode(model_mode)
+    if mode == "premium_nvidia":
+        try:
+            content = nvidia_client.generate_nemotron_response(messages, mode="deal_round")
+            return {"ok": True, "model_mode": mode, "provider": "nvidia", "content": content, "error": None}
+        except RuntimeError as exc:
+            logger.warning("NVIDIA deal round call failed: %s", exc)
+            return {"ok": False, "model_mode": mode, "provider": "nvidia", "content": "", "error": str(exc)}
+    return _placeholder_result(mode, "mock", f"Deal round via '{mode}' not implemented.")
+
+
+def generate_deal_scoring_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Route a deal dimension-scoring request (mode=deal_scorecard_scoring).
+
+    Nemotron judges all 6 deal dimensions semantically from the negotiation transcript.
+    Returns scores + deal_outcome + best_move + weakest_move only (no coaching text).
+    """
+    return _call_nvidia_json_mode(messages, "deal_scorecard_scoring", model_mode, "deal scorecard scoring")
+
+
+def generate_deal_scoring_repair_response(
+    raw_bad_content: str,
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    """Repair a broken deal scoring JSON (mode=deal_scorecard_scoring_repair)."""
+    repair_messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a JSON formatter. Convert the input into the exact schema below. "
+                "Return ONLY valid JSON. First character must be { last must be }. "
+                "No markdown. No reasoning. No array.\n\n"
+                "REQUIRED SCHEMA:\n"
+                '{"scores":{"anchoring":{"score":0,"reason":"","quote":""},'
+                '"evidence":{"score":0,"reason":"","quote":""},'
+                '"concession_control":{"score":0,"reason":"","quote":""},'
+                '"alternatives":{"score":0,"reason":"","quote":""},'
+                '"value_articulation":{"score":0,"reason":"","quote":""},'
+                '"closing":{"score":0,"reason":"","quote":""}},'
+                '"deal_outcome":"balanced","best_move":"","weakest_move":""}'
+            ),
+        },
+        {"role": "user", "content": "Output JSON only:\n\n" + raw_bad_content[:4000]},
+    ]
+    return _call_nvidia_repair_mode(
+        repair_messages, "deal_scorecard_scoring_repair", model_mode, "deal scorecard scoring"
+    )
+
+
+def generate_deal_scorecard_coaching_response(
+    messages: list[dict[str, str]],
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    return _call_nvidia_json_mode(messages, "deal_scorecard_coaching", model_mode, "deal scorecard coaching")
+
+
+def generate_deal_scorecard_repair_response(
+    raw_bad_content: str,
+    model_mode: str | None = None,
+) -> dict[str, Any]:
+    repair_messages = [
+        {
+            "role": "system",
+            "content": (
+                "Convert input to JSON. Return ONLY valid JSON.\n"
+                '{"deal_outcome_summary":"","best_move":"","weakest_move":"",'
+                '"improved_response":"","top_3_prep_points":["","",""],'
+                '"combined_summary":"","next_best_action":""}'
+            ),
+        },
+        {"role": "user", "content": "Output JSON only:\n\n" + raw_bad_content[:5000]},
+    ]
+    return _call_nvidia_repair_mode(repair_messages, "deal_scorecard_repair", model_mode, "deal scorecard")
+
+
 # ---------------------------------------------------------------------------
 # Internal helpers
 # ---------------------------------------------------------------------------

core/nvidia_client.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import logging
 import os
+import time
 from typing import Any
 
 from dotenv import load_dotenv
@@ -20,6 +21,22 @@ logger = logging.getLogger(__name__)
 _DEFAULT_BASE_URL = "https://integrate.api.nvidia.com/v1"
 _DEFAULT_MODEL = "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning"
 
+
+class OmniAudioError(RuntimeError):
+    """Structured Omni audio failure — metadata safe for API responses."""
+
+    def __init__(self, message: str, **meta: Any) -> None:
+        super().__init__(message)
+        self.meta = meta
+
+    def to_error_dict(self) -> dict[str, Any]:
+        return {
+            "error": "Omni audio call failed",
+            "detail": str(self),
+            **self.meta,
+        }
+
+
 # Per-mode settings for nemotron-3-nano-omni-30b-a3b-reasoning.
 #
 # enable_thinking: True  → reasoning model uses internal chain-of-thought
@@ -40,17 +57,45 @@ _TASK_DEFAULTS: dict[str, dict[str, Any]] = {
         "temperature": 0.65,
         "top_p": 0.95,
     },
+    "scorecard_scoring": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1700,
+        "temperature": 0.1,
+        "top_p": 0.95,
+    },
+    "scorecard_scoring_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1400,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    "scorecard_full": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 2500,
+        "temperature": 0.1,
+        "top_p": 0.95,
+    },
+    "scorecard_full_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 2200,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
     "scorecard_coaching": {
         "enable_thinking": False,
         "reasoning_budget": 0,
-        "max_tokens": 1600,
+        "max_tokens": 2400,
         "temperature": 0.2,
         "top_p": 0.95,
     },
     "scorecard_coaching_repair": {
         "enable_thinking": False,
         "reasoning_budget": 0,
-        "max_tokens": 1200,
+        "max_tokens": 1600,
         "temperature": 0.0,
         "top_p": 0.95,
     },
@@ -68,13 +113,132 @@ _TASK_DEFAULTS: dict[str, dict[str, Any]] = {
         "temperature": 0.1,
         "top_p": 0.95,
     },
+    "voice_extraction": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1800,
+        "temperature": 0.1,
+        "top_p": 0.95,
+    },
+    "voice_extraction_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1200,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    "voice_turn": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 700,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    "voice_turn_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 600,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    "retry_comparison": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1000,
+        "temperature": 0.15,
+        "top_p": 0.95,
+    },
+    "retry_comparison_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 800,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    "deal_verdict": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1000,
+        "temperature": 0.2,
+        "top_p": 0.95,
+    },
+    "deal_verdict_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 800,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    "deal_round": {
+        "enable_thinking": True,
+        "reasoning_budget": 512,
+        "max_tokens": 900,
+        "temperature": 0.65,
+        "top_p": 0.95,
+    },
+    # Deal phase: semantic dimension scoring (JSON, split call 1 — scores only)
+    "deal_scorecard_scoring": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1700,
+        "temperature": 0.1,
+        "top_p": 0.95,
+    },
+    "deal_scorecard_scoring_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1300,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+    # Deal phase: coaching text (JSON, split call 2 — coaching only)
+    "deal_scorecard_coaching": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 2200,
+        "temperature": 0.2,
+        "top_p": 0.95,
+    },
+    "deal_scorecard_repair": {
+        "enable_thinking": False,
+        "reasoning_budget": 0,
+        "max_tokens": 1200,
+        "temperature": 0.0,
+        "top_p": 0.95,
+    },
+}
+
+_VALID_AUDIO_FORMATS = frozenset({"webm", "wav", "mp3", "m4a", "ogg"})
+
+_AUDIO_MIME: dict[str, str] = {
+    "webm": "audio/webm",
+    "wav": "audio/wav",
+    "mp3": "audio/mpeg",
+    "m4a": "audio/mp4",
+    "ogg": "audio/ogg",
 }
 
 # Modes where the response must be JSON — apply safe extraction from reasoning_content if needed
 _JSON_MODES: frozenset[str] = frozenset({
+    "scorecard_scoring",
+    "scorecard_scoring_repair",
+    "scorecard_full",
+    "scorecard_full_repair",
     "scorecard_coaching",
     "scorecard_coaching_repair",
     "legacy_full_scorecard",
+    "voice_extraction",
+    "voice_extraction_repair",
+    "voice_turn",
+    "voice_turn_repair",
+    "retry_comparison",
+    "retry_comparison_repair",
+    "deal_verdict",
+    "deal_verdict_repair",
+    "deal_scorecard_scoring",
+    "deal_scorecard_scoring_repair",
+    "deal_scorecard_coaching",
+    "deal_scorecard_repair",
 })
 
 
@@ -124,6 +288,181 @@ def health_check() -> dict[str, Any]:
     }
 
 
+def _resolve_mode_params(
+    mode: str,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+) -> tuple[float, int, float, bool, int]:
+    """Return (temp, tokens, top_p, enable_thinking, reasoning_budget) for a mode."""
+    defaults = _TASK_DEFAULTS.get(mode, _TASK_DEFAULTS["opponent"])
+    temp = temperature if temperature is not None else defaults["temperature"]
+    tokens = max_tokens if max_tokens is not None else defaults["max_tokens"]
+    top_p: float = defaults.get("top_p", 0.95)
+    enable_thinking: bool = defaults.get("enable_thinking", True)
+    reasoning_budget: int = defaults.get("reasoning_budget", 0)
+    if mode in _JSON_MODES:
+        enable_thinking = False
+        reasoning_budget = 0
+    reasoning_budget = min(reasoning_budget, tokens)
+    return temp, tokens, top_p, enable_thinking, reasoning_budget
+
+
+def _complete_chat(
+    client: OpenAI,
+    model: str,
+    messages: list[dict],
+    mode: str,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+) -> str:
+    """Shared chat completion with mode-specific token/thinking settings."""
+    temp, tokens, top_p, enable_thinking, reasoning_budget = _resolve_mode_params(
+        mode, temperature, max_tokens
+    )
+    completion = client.chat.completions.create(
+        model=model,
+        messages=messages,  # type: ignore[arg-type]
+        temperature=temp,
+        max_tokens=tokens,
+        top_p=top_p,
+        extra_body={
+            "chat_template_kwargs": {"enable_thinking": enable_thinking},
+            "reasoning_budget": reasoning_budget,
+        },
+    )
+    temp_d, tokens_d, _tp, thinking_d, _rb = _resolve_mode_params(mode, temperature, max_tokens)
+    msg = completion.choices[0].message
+    content = (msg.content or "").strip()
+    reasoning = (getattr(msg, "reasoning_content", None) or "").strip()
+
+    # Diagnostics (no secrets, no full prompt/audio): help spot truncation vs empty content.
+    logger.debug(
+        "Nemotron mode=%s max_tokens=%s thinking=%s content_len=%d reasoning_present=%s",
+        mode, tokens_d, thinking_d, len(content), bool(reasoning),
+    )
+
+    if not content:
+        if mode in _JSON_MODES and reasoning:
+            extracted = _extract_json_from_reasoning(reasoning)
+            if extracted:
+                logger.info(
+                    "Nemotron content empty; extracted JSON block from reasoning_content (mode=%s)",
+                    mode,
+                )
+                content = extracted
+            else:
+                logger.warning(
+                    "Nemotron content empty; checked reasoning_content fallback (mode=%s, no JSON found)",
+                    mode,
+                )
+        elif reasoning:
+            logger.warning(
+                "Nemotron content empty; checked reasoning_content fallback (mode=%s)",
+                mode,
+            )
+            content = reasoning
+
+    if not content:
+        raise RuntimeError(
+            "NVIDIA model returned an empty response. "
+            "The reasoning model may need a larger max_tokens budget."
+        )
+    return content
+
+
+def call_omni_audio_json(
+    prompt: str,
+    audio_base64: str,
+    audio_format: str,
+    mode: str = "voice_extraction",
+    timeout: int = 60,
+    source_format: str | None = None,
+    decoded_bytes: int | None = None,
+) -> str:
+    """Call Nemotron Omni with audio + text prompt; return response text (JSON expected).
+
+    Raises:
+        ValueError: invalid audio input
+        OmniAudioError: API rejected audio or call failed
+    """
+    if not audio_base64 or not str(audio_base64).strip():
+        raise ValueError("audio_base64 is required and must be non-empty")
+    fmt = str(audio_format or "").strip().lower().lstrip(".")
+    if fmt not in _VALID_AUDIO_FORMATS:
+        raise ValueError(
+            f"audio_format must be one of: {', '.join(sorted(_VALID_AUDIO_FORMATS))}"
+        )
+
+    api_key, base_url, model = _get_config()
+    mime = _AUDIO_MIME[fmt]
+    audio_url = f"data:{mime};base64,{audio_base64.strip()}"
+
+    logger.info(
+        "nvidia_client: omni audio call mode=%s format=%s source_format=%s bytes=%s mime=%s",
+        mode,
+        fmt,
+        source_format or fmt,
+        decoded_bytes if decoded_bytes is not None else "unknown",
+        mime,
+    )
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": prompt},
+                {"type": "audio_url", "audio_url": {"url": audio_url}},
+            ],
+        }
+    ]
+
+    client = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
+    try:
+        return _complete_chat(client, model, messages, mode)
+    except APIStatusError as exc:
+        detail = exc.message or str(exc)
+        logger.warning(
+            "NVIDIA Omni audio status error %s: %s (format=%s bytes=%s)",
+            exc.status_code,
+            detail,
+            fmt,
+            decoded_bytes,
+        )
+        raise OmniAudioError(
+            detail,
+            audio_format_sent=fmt,
+            source_format=source_format or fmt,
+            decoded_bytes=decoded_bytes,
+            mode=mode,
+            suggestion=(
+                "Audio was normalized to WAV when possible. "
+                "Verify NVIDIA audio payload schema or install ffmpeg for conversion."
+            ),
+        ) from exc
+    except (APITimeoutError, APIConnectionError) as exc:
+        logger.warning("NVIDIA Omni audio connection error: %s", type(exc).__name__)
+        raise OmniAudioError(
+            f"Connection error: {type(exc).__name__}",
+            audio_format_sent=fmt,
+            source_format=source_format or fmt,
+            decoded_bytes=decoded_bytes,
+            mode=mode,
+            suggestion="Retry the voice request or check NVIDIA API connectivity.",
+        ) from exc
+    except RuntimeError:
+        raise
+    except Exception as exc:
+        logger.warning("NVIDIA Omni audio unexpected error: %s", type(exc).__name__)
+        raise OmniAudioError(
+            type(exc).__name__,
+            audio_format_sent=fmt,
+            source_format=source_format or fmt,
+            decoded_bytes=decoded_bytes,
+            mode=mode,
+            suggestion="Verify NVIDIA audio payload schema or audio conversion.",
+        ) from exc
+
+
 def generate_nemotron_response(
     messages: list[dict[str, str]],
     mode: str = "opponent",
@@ -147,88 +486,49 @@ def generate_nemotron_response(
         RuntimeError: on missing key or any API failure (clean message, no key leak).
     """
     api_key, base_url, model = _get_config()
+    client = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
 
-    defaults = _TASK_DEFAULTS.get(mode, _TASK_DEFAULTS["opponent"])
-    temp = temperature if temperature is not None else defaults["temperature"]
-    tokens = max_tokens if max_tokens is not None else defaults["max_tokens"]
-    top_p: float = defaults.get("top_p", 0.95)
-    enable_thinking: bool = defaults.get("enable_thinking", True)
-    # reasoning_budget must not exceed max_tokens
-    reasoning_budget: int = min(defaults.get("reasoning_budget", 0), tokens)
+    # One retry on transient server/rate errors only — never retry 4xx (e.g. bad audio 400).
+    for attempt in range(2):
+        try:
+            return _complete_chat(client, model, messages, mode, temperature, max_tokens)
 
-    client = OpenAI(
-        api_key=api_key,
-        base_url=base_url,
-        timeout=timeout,
-    )
-
-    try:
-        completion = client.chat.completions.create(
-            model=model,
-            messages=messages,  # type: ignore[arg-type]
-            temperature=temp,
-            max_tokens=tokens,
-            top_p=top_p,
-            extra_body={
-                "chat_template_kwargs": {"enable_thinking": enable_thinking},
-                "reasoning_budget": reasoning_budget,
-            },
-        )
-        msg = completion.choices[0].message
-        content = (msg.content or "").strip()
-        reasoning = (getattr(msg, "reasoning_content", None) or "").strip()
-
-        if not content:
-            if mode in _JSON_MODES and reasoning:
-                # For JSON modes: try to salvage a JSON block from reasoning_content
-                extracted = _extract_json_from_reasoning(reasoning)
-                if extracted:
-                    logger.info(
-                        "Nemotron content empty; extracted JSON block from reasoning_content (mode=%s)",
-                        mode,
-                    )
-                    content = extracted
-                else:
-                    logger.warning(
-                        "Nemotron content empty; checked reasoning_content fallback (mode=%s, no JSON found)",
-                        mode,
-                    )
-            elif reasoning:
-                # Non-JSON mode (e.g. opponent): use reasoning trace as last resort
+        except APITimeoutError:
+            logger.warning("NVIDIA API timed out after %ds (mode=%s)", timeout, mode)
+            raise RuntimeError(
+                f"NVIDIA Nemotron request timed out after {timeout}s. "
+                "Check your connection or increase timeout."
+            )
+        except APIConnectionError as exc:
+            if attempt == 0:
+                logger.warning("NVIDIA connection error (mode=%s) — retrying once", mode)
+                time.sleep(0.8)
+                continue
+            logger.warning("NVIDIA API connection error: %s", exc)
+            raise RuntimeError(
+                "Could not connect to NVIDIA API. "
+                "Verify NVIDIA_BASE_URL and your network connection."
+            )
+        except APIStatusError as exc:
+            transient = exc.status_code in (429, 500, 502, 503)
+            if transient and attempt == 0:
                 logger.warning(
-                    "Nemotron content empty; checked reasoning_content fallback (mode=%s)",
-                    mode,
+                    "NVIDIA transient HTTP %s (mode=%s) — retrying once", exc.status_code, mode
                 )
-                content = reasoning
-
-        if not content:
+                time.sleep(0.8)
+                continue
+            logger.warning(
+                "NVIDIA API status error %s (mode=%s): %s", exc.status_code, mode, exc.message
+            )
             raise RuntimeError(
-                "NVIDIA model returned an empty response. "
-                "The reasoning model may need a larger max_tokens budget."
+                f"NVIDIA API returned HTTP {exc.status_code}. "
+                "Check your NVIDIA_API_KEY and model ID."
+            )
+        except Exception as exc:
+            logger.warning("NVIDIA API unexpected error (mode=%s): %s", mode, type(exc).__name__)
+            raise RuntimeError(
+                f"NVIDIA model call failed ({type(exc).__name__}). See server logs."
             )
 
-        return content
-
-    except APITimeoutError:
-        logger.warning("NVIDIA API timed out after %ds (mode=%s)", timeout, mode)
-        raise RuntimeError(
-            f"NVIDIA Nemotron request timed out after {timeout}s. "
-            "Check your connection or increase timeout."
-        )
-    except APIConnectionError as exc:
-        logger.warning("NVIDIA API connection error: %s", exc)
-        raise RuntimeError(
-            "Could not connect to NVIDIA API. "
-            "Verify NVIDIA_BASE_URL and your network connection."
-        )
-    except APIStatusError as exc:
-        logger.warning("NVIDIA API status error %s: %s", exc.status_code, exc.message)
-        raise RuntimeError(
-            f"NVIDIA API returned HTTP {exc.status_code}. "
-            "Check your NVIDIA_API_KEY and model ID."
-        )
-    except Exception as exc:
-        logger.warning("NVIDIA API unexpected error: %s", type(exc).__name__)
-        raise RuntimeError(
-            f"NVIDIA model call failed ({type(exc).__name__}). See server logs."
-        )
+    # Unreachable (loop either returns or raises) — defensive.
+    raise RuntimeError("NVIDIA model call failed after retry.")

core/output_sanitizer.py

@@ -11,6 +11,7 @@ _LEAKAGE_PATTERNS = [
     r"as instructed\b",
     r"my instructions\b",
     r"according to my system prompt\b",
+    r"according to the system prompt\b",
     r"i am supposed to\b",
     r"i should follow\b",
     r"the rules say\b",
@@ -21,6 +22,11 @@ _LEAKAGE_PATTERNS = [
     r"i should\b.*\binstructions?\b",
     r"per the instructions?\b",
     r"based on the instructions?\b",
+    r"the schema requires\b",
+    r"we must return json\b",
+    r"need to output\b",
+    r"first[,\s]+we need\b",
+    r"i should\b",
 ]
 
 _LEAKAGE_RE = re.compile(
@@ -33,6 +39,28 @@ _SAFE_FALLBACK = (
 )
 
 
+def check_leakage(text: str) -> dict:
+    """Return a structured leakage check result.
+
+    Returns:
+        {"ok": True}  — no leakage detected
+        {"ok": False, "matched_pattern": str, "excerpt": str}  — leakage found
+    """
+    if not text:
+        return {"ok": True}
+    m = _LEAKAGE_RE.search(text)
+    if m:
+        start = max(0, m.start() - 20)
+        end = min(len(text), m.end() + 40)
+        excerpt = text[start:end].replace("\n", " ").strip()
+        return {
+            "ok": False,
+            "matched_pattern": m.group(0),
+            "excerpt": excerpt,
+        }
+    return {"ok": True}
+
+
 def sanitize_model_output(text: str) -> str:
     """Remove instruction-leakage lines from Nemotron judge output.
 
@@ -43,7 +71,6 @@ def sanitize_model_output(text: str) -> str:
     if not text:
         return _SAFE_FALLBACK
 
-    # Split on newlines first, then also on sentence boundaries
     lines = text.splitlines()
     clean_lines: list[str] = []
     for line in lines:
@@ -56,7 +83,6 @@ def sanitize_model_output(text: str) -> str:
 
     result = " ".join(clean_lines).strip()
 
-    # If too little survived, return fallback
     if len(result.split()) < 4:
         return _SAFE_FALLBACK
 

core/persona_builder.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from core.judge_settings import get_question_style, normalize_difficulty
+
 PERSONA_LABELS = {
     "skeptical_vc": "Skeptical VC",
     "technical_judge": "Technical Judge",
@@ -12,19 +14,36 @@ PERSONA_LABELS = {
 def build_persona_prompt(
     persona: str,
     startup: dict,
-    difficulty: str = "high",
+    difficulty: str = "practice",
 ) -> str:
-    """Build a system prompt for the selected opponent persona."""
+    """Build a system prompt for the selected opponent persona.
+
+    The difficulty argument accepts any alias (e.g. "high", "practice",
+    "beginner") — it is normalized to a canonical profile internally.
+    question_style.instruction from the profile is injected so Nemotron
+    adjusts wording complexity, jargon level, and tone accordingly.
+    """
+    profile_name = normalize_difficulty(difficulty)
+    qs = get_question_style(profile_name)
+
     label = PERSONA_LABELS.get(persona, "Tough Judge")
     name = startup.get("name", "this startup")
     problem = startup.get("problem", "")
     solution = startup.get("solution", "")
     why_ai = startup.get("why_ai", "")
 
-    rules = """
-Behavior rules:
-- Ask one sharp question at a time.
-- Keep responses under 4 sentences.
+    # Behavior rules shared across all personas
+    max_sentences = qs.get("max_sentences", 3)
+    avoid_jargon = qs.get("avoid_jargon", False)
+    jargon_note = (
+        "\n- FORBIDDEN WORDS for this profile: unit economics, contribution margin, defensibility, "
+        "TAM, SAM, SOM, moat, CAC, LTV, load-bearing, demonstrably, quantify match accuracy, "
+        "precision threshold. Use plain student-friendly language instead."
+        if avoid_jargon else ""
+    )
+    rules = f"""Behavior rules:
+- Ask one question at a time — never ask two questions in a single response.
+- Keep responses under {max_sentences} sentences.
 - Reference the founder's previous answer when pushing back.
 - Do not give advice during the battle.
 - Do not compliment the founder.
@@ -32,6 +51,8 @@ Behavior rules:
 - Raise difficulty after strong answers.
 - Stay in character at all times.
 - Be firm but not abusive.
+- Use plain, clear language unless the difficulty profile explicitly allows jargon.{jargon_note}
+- Voice-style or casual answers that contain concrete numbers or validation still deserve credit — do not dismiss them for tone.
 """.strip()
 
     persona_focus = {
@@ -52,8 +73,11 @@ Behavior rules:
 
     focus = persona_focus.get(persona, persona_focus["hackathon_judge"])
 
+    # Difficulty-specific question instruction from config
+    question_instruction = qs.get("instruction", "")
+
     return f"""You are {label}, a tough pitch opponent in PitchFight AI.
-Difficulty: {difficulty}
+Difficulty profile: {profile_name}
 
 Startup: {name}
 Problem: {problem}
@@ -62,5 +86,8 @@ Why AI: {why_ai}
 
 {focus}
 
+QUESTION STYLE ({profile_name}):
+{question_instruction}
+
 {rules}
 """

core/retry_handler.py

@@ -0,0 +1,522 @@
+"""Retry weakest-question drill handler (Phase 8)."""
+
+from __future__ import annotations
+
+import logging
+import re
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from core.claim_extractor import extract_concrete_signals
+from core.judge_settings import get_label, normalize_difficulty
+from core.json_utils import parse_model_json, sanitize_for_log, _score_label
+from core.scoring_engine import _sync_overall_to_dimensions
+from core import model_router
+from core.deal_verdict import build_judge_verdict
+
+logger = logging.getLogger(__name__)
+
+_VALID_VERDICTS = frozenset({"improved", "slightly_improved", "needs_more_work"})
+
+_NON_ANSWER_RE = re.compile(
+    r"^(ok|yeah|yes|no|idk|i don'?t know|not sure|maybe|n/?a)\.?$",
+    re.IGNORECASE,
+)
+
+_DIM_RETRY_QUESTIONS: dict[str, str] = {
+    "clarity": (
+        "Explain your product again in one clear sentence. "
+        "Who is it for, what does it do, and what outcome does it create?"
+    ),
+    "problem_understanding": (
+        "Give one specific example that proves this user pain is real and repeated."
+    ),
+    "market_awareness": (
+        "Name your first target segment and one number that proves this market is worth starting with."
+    ),
+    "differentiation": (
+        "Why would someone choose your product over existing alternatives? "
+        "Give one concrete mechanism or proof point."
+    ),
+    "business_model": (
+        "Who pays, how much do they pay, and why does the math work?"
+    ),
+    "objection_handling": (
+        "Answer the judge's objection directly using one specific number, example, or proof point."
+    ),
+}
+
+
+def build_local_retry_question(answer_to_retry: dict) -> str:
+    """Build a coaching retry question from dimension when original judge text is missing."""
+    dim = str(answer_to_retry.get("dimension", "")).strip().lower()
+    return _DIM_RETRY_QUESTIONS.get(
+        dim,
+        _DIM_RETRY_QUESTIONS["objection_handling"],
+    )
+
+
+def _find_original_question(
+    session: dict,
+    round_num: int | None,
+    attack_tag: str,
+) -> str:
+    """Locate the judge question that prompted the weak answer."""
+    history = session.get("history", [])
+    if round_num and int(round_num) > 0:
+        target = int(round_num)
+        user_count = 0
+        for idx, msg in enumerate(history):
+            if msg.get("role") != "user":
+                continue
+            user_count += 1
+            if user_count == target:
+                for j in range(idx - 1, -1, -1):
+                    if history[j].get("role") == "assistant":
+                        return str(history[j].get("content", "")).strip()
+                break
+
+    tag_norm = str(attack_tag or "").lower().replace("_", " ").strip()
+    if tag_norm:
+        for msg in reversed(history):
+            if msg.get("role") != "assistant":
+                continue
+            msg_tag = str(msg.get("attack_tag", "")).lower().replace("_", " ").strip()
+            if msg_tag and (tag_norm in msg_tag or msg_tag in tag_norm):
+                return str(msg.get("content", "")).strip()
+
+    for msg in reversed(history):
+        if msg.get("role") == "assistant":
+            return str(msg.get("content", "")).strip()
+    return ""
+
+
+def _dimension_score(scorecard: dict, dimension: str) -> int:
+    scores = scorecard.get("scores") or {}
+    dim_data = scores.get(dimension) or {}
+    try:
+        return int(dim_data.get("score", 30))
+    except (TypeError, ValueError):
+        return 30
+
+
+def start_retry_drill(session: dict) -> dict[str, Any]:
+    """Prepare a retry drill from the latest scorecard answer_to_retry."""
+    scorecard = session.get("latest_scorecard")
+    if not scorecard:
+        return {"error": "No scorecard found. End a battle before retrying."}
+
+    se = scorecard.get("score_explanation") or {}
+    atr = se.get("answer_to_retry") or {}
+    dimension = str(atr.get("dimension", "")).strip()
+    if not dimension:
+        return {"error": "No answer to retry found in scorecard."}
+
+    session_id = str(session.get("session_id", ""))
+    attack_tag = str(atr.get("attack_tag", ""))
+    round_num = atr.get("round")
+    original_answer = str(atr.get("original_answer", ""))
+    why_it_hurt = str(atr.get("why_it_hurt", ""))
+    sample_stronger = str(atr.get("sample_stronger_answer", ""))
+
+    original_question = _find_original_question(session, round_num, attack_tag)
+    retry_question = original_question or build_local_retry_question(atr)
+
+    difficulty_profile = session.get("difficulty_profile") or normalize_difficulty(
+        session.get("difficulty", "practice")
+    )
+    difficulty_label = session.get("difficulty_label") or get_label(difficulty_profile)
+
+    retry_id = str(uuid.uuid4())
+    drill = {
+        "retry_id": retry_id,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "source": "scorecard_path_to_80",
+        "dimension": dimension,
+        "attack_tag": attack_tag,
+        "original_question": original_question,
+        "retry_question": retry_question,
+        "original_answer": original_answer,
+        "why_it_hurt": why_it_hurt,
+        "sample_stronger_answer": sample_stronger,
+        "input_mode": "",
+        "retry_answer": "",
+        "result": {},
+        "dimension_score_before": _dimension_score(scorecard, dimension),
+    }
+    session.setdefault("retry_drills", {})[retry_id] = drill
+
+    return {
+        "session_id": session_id,
+        "retry_id": retry_id,
+        "retry_question": retry_question,
+        "original_question": original_question,
+        "original_answer": original_answer,
+        "dimension": dimension,
+        "attack_tag": attack_tag,
+        "why_it_hurt": why_it_hurt,
+        "sample_stronger_answer": sample_stronger,
+        "difficulty_profile": difficulty_profile,
+        "difficulty_label": difficulty_label,
+    }
+
+
+def _answer_has_signals(text: str) -> bool:
+    sigs = extract_concrete_signals({
+        "history": [{"role": "user", "content": text}],
+        "startup": {},
+    })
+    return sigs.get("signal_count", 0) > 0 or bool(re.search(r"\d", text))
+
+
+def build_local_retry_fallback(
+    original_answer: str,
+    retry_answer: str,
+    dimension: str,
+    dimension_before: int = 30,
+) -> dict[str, Any]:
+    """Local comparison when Nemotron is unavailable."""
+    original = original_answer.strip()
+    retry = retry_answer.strip()
+    before = max(0, min(100, int(dimension_before)))
+
+    if not retry or _NON_ANSWER_RE.match(retry) or len(retry.split()) < 4:
+        after = before
+        verdict = "needs_more_work"
+        what_improved = "The retry answer was too brief or did not address the question."
+        still_missing = "A specific fact, number, user example, or mechanism is still missing."
+        tip = build_local_retry_question({"dimension": dimension})
+    elif _answer_has_signals(retry) and len(retry) > len(original) + 8:
+        gain = min(26, max(12, len(retry.split()) // 2))
+        after = min(before + gain, 78)
+        verdict = "improved" if gain >= 12 else "slightly_improved"
+        what_improved = "You added concrete evidence or specifics that were missing before."
+        still_missing = (
+            "Tighten the answer further with one sharper proof point tied to the judge's question."
+            if after < 55 else "Good progress — add one more proof point to make it investor-ready."
+        )
+        tip = f"Lead with your strongest number or example when answering {dimension.replace('_', ' ')} questions."
+    elif len(retry) > len(original) + 4:
+        after = min(before + 8, 58)
+        verdict = "slightly_improved" if after > before else "needs_more_work"
+        what_improved = "The retry answer is more complete, but proof is still thin."
+        still_missing = "Add one number, named user segment, or competitor contrast."
+        tip = build_local_retry_question({"dimension": dimension})
+    else:
+        after = before if len(retry) <= len(original) else min(before + 5, 50)
+        verdict = "needs_more_work" if after == before else "slightly_improved"
+        what_improved = "Some extra detail was added, but the core objection may still be open."
+        still_missing = "Answer the exact question with one verifiable fact or example."
+        tip = build_local_retry_question({"dimension": dimension})
+
+    overall_lift = max(0, min(15, int((after - before) * 0.45)))
+    if overall_lift < 4 and after > before:
+        overall_lift = 4
+
+    return {
+        "comparison": {
+            "old_answer_summary": original[:200] or "No substantive prior answer.",
+            "new_answer_summary": retry[:200],
+            "what_improved": what_improved,
+            "still_missing": still_missing,
+            "specific_tip": tip,
+            "estimated_dimension_before": before,
+            "estimated_dimension_after": after,
+            "estimated_overall_lift": overall_lift,
+            "verdict": verdict,
+        },
+        "next_practice_prompt": build_local_retry_question({"dimension": dimension}),
+    }
+
+
+def _build_retry_comparison_messages(
+    session: dict,
+    drill: dict,
+    retry_answer: str,
+) -> list[dict[str, str]]:
+    startup = session.get("startup", {}) or {}
+    scorecard = session.get("latest_scorecard") or {}
+    difficulty_profile = session.get("difficulty_profile") or "practice"
+    difficulty_label = session.get("difficulty_label") or get_label(difficulty_profile)
+    dim = drill.get("dimension", "")
+    dim_before = drill.get("dimension_score_before", _dimension_score(scorecard, dim))
+
+    startup_lines = [
+        f"Name: {startup.get('name', '')}",
+        f"Problem: {startup.get('problem', '')}",
+        f"Solution: {startup.get('solution', '')}",
+        f"Traction: {startup.get('traction', '')}",
+    ]
+
+    system = (
+        "You are a startup pitch coach comparing an old weak answer to a new retry answer.\n"
+        "You are NOT rescoring the whole battle — only one dimension.\n"
+        "Be specific and coaching-oriented. Do not overpraise. Do not hallucinate facts.\n"
+        "Use only the provided text. Return ONLY valid JSON.\n\n"
+        "REQUIRED JSON:\n"
+        '{"comparison":{"old_answer_summary":"","new_answer_summary":"","what_improved":"",'
+        '"still_missing":"","specific_tip":"","estimated_dimension_before":0,'
+        '"estimated_dimension_after":0,"estimated_overall_lift":0,'
+        '"verdict":"improved|slightly_improved|needs_more_work"},'
+        '"next_practice_prompt":""}\n\n'
+        "Rules:\n"
+        f"- estimated_dimension_before should be near {dim_before}.\n"
+        "- estimated_dimension_after must be realistic (do not jump above 75 unless strong proof).\n"
+        "- estimated_overall_lift usually 3–12 points.\n"
+        "- Each text field: 1–2 sentences max.\n"
+        "- next_practice_prompt: one coaching question only.\n"
+        "- verdict must be improved, slightly_improved, or needs_more_work."
+    )
+
+    user = (
+        f"Difficulty: {difficulty_label} ({difficulty_profile})\n"
+        f"Dimension: {dim}\n"
+        f"Attack tag: {drill.get('attack_tag', '')}\n\n"
+        f"Startup context:\n" + "\n".join(startup_lines) + "\n\n"
+        f"Original judge question:\n{drill.get('original_question') or drill.get('retry_question', '')}\n\n"
+        f"Retry question:\n{drill.get('retry_question', '')}\n\n"
+        f"Original weak answer:\n{drill.get('original_answer', '')}\n\n"
+        f"Why it hurt:\n{drill.get('why_it_hurt', '')}\n\n"
+        f"Sample stronger direction:\n{drill.get('sample_stronger_answer', '')}\n\n"
+        f"New retry answer:\n{retry_answer}\n"
+    )
+
+    return [
+        {"role": "system", "content": system},
+        {"role": "user", "content": user},
+    ]
+
+
+def _normalize_comparison_result(
+    parsed: dict,
+    drill: dict,
+    original_answer: str,
+    retry_answer: str,
+) -> dict[str, Any]:
+    comp = parsed.get("comparison") if isinstance(parsed.get("comparison"), dict) else parsed
+    if not isinstance(comp, dict):
+        raise ValueError("missing comparison object")
+
+    before = drill.get("dimension_score_before", 30)
+    try:
+        est_before = int(comp.get("estimated_dimension_before", before))
+    except (TypeError, ValueError):
+        est_before = before
+    try:
+        est_after = int(comp.get("estimated_dimension_after", est_before))
+    except (TypeError, ValueError):
+        est_after = est_before
+
+    est_before = max(0, min(100, est_before))
+    est_after = max(est_before, min(82, est_after))
+    if est_after < est_before:
+        est_after = est_before
+
+    verdict = str(comp.get("verdict", "needs_more_work")).strip().lower()
+    if verdict not in _VALID_VERDICTS:
+        verdict = "slightly_improved" if est_after > est_before else "needs_more_work"
+
+    try:
+        lift = int(comp.get("estimated_overall_lift", 0))
+    except (TypeError, ValueError):
+        lift = max(0, int((est_after - est_before) * 0.35))
+    lift = max(0, min(15, lift))
+    if est_after > est_before and lift < 4:
+        lift = 4
+
+    return {
+        "comparison": {
+            "old_answer_summary": str(comp.get("old_answer_summary", original_answer[:200]))[:300],
+            "new_answer_summary": str(comp.get("new_answer_summary", retry_answer[:200]))[:300],
+            "what_improved": str(comp.get("what_improved", ""))[:300],
+            "still_missing": str(comp.get("still_missing", ""))[:300],
+            "specific_tip": str(comp.get("specific_tip", ""))[:300],
+            "estimated_dimension_before": est_before,
+            "estimated_dimension_after": est_after,
+            "estimated_overall_lift": lift,
+            "verdict": verdict,
+        },
+        "next_practice_prompt": str(
+            parsed.get("next_practice_prompt")
+            or build_local_retry_question({"dimension": drill.get("dimension", "")})
+        )[:300],
+    }
+
+
+def call_nemotron_retry_comparison(
+    session: dict,
+    drill: dict,
+    retry_answer: str,
+    model_mode: str | None = None,
+) -> dict[str, Any] | None:
+    """Call Nemotron to compare old vs new retry answer. Returns None on failure."""
+    messages = _build_retry_comparison_messages(session, drill, retry_answer)
+    resolved = model_mode or session.get("model_mode") or "premium_nvidia"
+    result = model_router.generate_retry_comparison_response(messages, model_mode=resolved)
+    if not result.get("ok") or not result.get("content"):
+        logger.warning("retry_handler: Nemotron comparison failed — %s", result.get("error"))
+        return None
+
+    raw = result["content"]
+    parsed, _ = parse_model_json(raw)
+    if not isinstance(parsed, dict) or not parsed:
+        repair = model_router.generate_retry_comparison_repair_response(raw, model_mode=resolved)
+        if repair.get("ok") and repair.get("content"):
+            parsed, _ = parse_model_json(repair["content"])
+    if not isinstance(parsed, dict) or not parsed:
+        logger.warning(
+            "retry_handler: comparison JSON parse failed preview=%r",
+            sanitize_for_log(raw),
+        )
+        return None
+
+    try:
+        return _normalize_comparison_result(
+            parsed, drill, drill.get("original_answer", ""), retry_answer
+        )
+    except ValueError as exc:
+        logger.warning("retry_handler: comparison normalize failed — %s", exc)
+        return None
+
+
+def apply_retry_to_scorecard(
+    session: dict,
+    drill: dict,
+    comparison: dict,
+) -> dict[str, Any] | None:
+    """Apply retry improvement to stored scorecard so UI reflects the new score."""
+    scorecard = session.get("latest_scorecard")
+    if not scorecard or not isinstance(scorecard, dict):
+        return None
+
+    dim = str(drill.get("dimension", "")).strip()
+    if not dim:
+        return None
+
+    try:
+        after_dim = int(comparison.get("estimated_dimension_after", 0))
+        lift = int(comparison.get("estimated_overall_lift", 0))
+    except (TypeError, ValueError):
+        return None
+
+    verdict = str(comparison.get("verdict", "")).lower()
+    if verdict == "needs_more_work" and after_dim <= int(drill.get("dimension_score_before", 0)):
+        return scorecard
+
+    scores = scorecard.get("scores") or {}
+    dim_data = scores.get(dim)
+
+    # Capture the overall and dimension-sum BEFORE the update so we can apply the
+    # improvement as a delta. This preserves any offset baked into the displayed overall
+    # (e.g. the Practice nudge) instead of silently dropping it on a pure-mean recompute —
+    # which previously made a real dimension gain look like "overall didn't change".
+    old_overall = int(scorecard.get("overall", 0) or 0)
+    n_dims = len(scores) or 1
+    old_sum = sum(int(v.get("score", 0)) for v in scores.values())
+
+    updated = False
+    if isinstance(dim_data, dict) and after_dim > int(dim_data.get("score", 0)):
+        dim_data = dict(dim_data)
+        dim_data["score"] = after_dim
+        dim_data["label"] = _score_label(after_dim)
+        improved = str(comparison.get("what_improved", "")).strip()
+        if improved:
+            dim_data["reason"] = improved[:280]
+        retry_text = str(drill.get("retry_answer", "")).strip()
+        if retry_text:
+            dim_data["quote"] = retry_text[:200]
+        scores[dim] = dim_data
+        scorecard["scores"] = scores
+        updated = True
+
+    if updated:
+        new_sum = sum(int(v.get("score", 0)) for v in scores.values())
+        delta = round((new_sum - old_sum) / n_dims)
+        new_overall = max(0, min(100, old_overall + delta))
+        scorecard["overall"] = new_overall
+        scorecard["overall_label"] = _score_label(new_overall)
+        # Real lift the UI can trust (matches the overall it now displays).
+        actual_lift = new_overall - old_overall
+    else:
+        new_overall = old_overall
+        actual_lift = 0
+
+    se = dict(scorecard.get("score_explanation") or {})
+    esif = dict(se.get("estimated_score_if_fixed") or {})
+    esif["current_overall"] = new_overall
+    esif["estimated_new_overall"] = min(95, max(new_overall + 4, int(esif.get("estimated_new_overall", new_overall))))
+    se["estimated_score_if_fixed"] = esif
+    atr = dict(se.get("answer_to_retry") or {})
+    if drill.get("retry_answer"):
+        atr["original_answer"] = str(drill["retry_answer"])[:300]
+    se["answer_to_retry"] = atr
+    scorecard["score_explanation"] = se
+
+    if drill.get("retry_answer"):
+        scorecard["weakest_answer"] = str(drill["retry_answer"])[:400]
+
+    scorecard["retry_applied"] = True
+    scorecard["retry_dimension"] = dim
+    scorecard["retry_overall_lift"] = actual_lift
+    session["latest_scorecard"] = scorecard
+    return scorecard
+
+
+def evaluate_retry_answer(
+    session: dict,
+    retry_id: str,
+    retry_answer: str,
+    input_mode: str = "text",
+    voice_turn_id: str = "",
+) -> dict[str, Any]:
+    """Evaluate a retry answer and store the result on the session."""
+    session_id = str(session.get("session_id", ""))
+    drills = session.get("retry_drills") or {}
+    drill = drills.get(retry_id)
+    if not drill:
+        return {"error": "Retry drill not found. Start a new retry from the scorecard."}
+
+    answer = str(retry_answer or "").strip()
+    if not answer:
+        return {"error": "Retry answer cannot be empty."}
+
+    drill["retry_answer"] = answer
+    drill["input_mode"] = input_mode or "text"
+    if voice_turn_id:
+        drill["voice_turn_id"] = voice_turn_id
+
+    comparison_result = call_nemotron_retry_comparison(session, drill, answer)
+    if comparison_result is None:
+        comparison_result = build_local_retry_fallback(
+            drill.get("original_answer", ""),
+            answer,
+            drill.get("dimension", "objection_handling"),
+            drill.get("dimension_score_before", 30),
+        )
+
+    drill["result"] = comparison_result
+    comp = comparison_result.get("comparison", {})
+    updated_scorecard = apply_retry_to_scorecard(session, drill, comp)
+
+    response: dict[str, Any] = {
+        "session_id": session_id,
+        "retry_id": retry_id,
+        "dimension": drill.get("dimension", ""),
+        "attack_tag": drill.get("attack_tag", ""),
+        "original_question": drill.get("original_question", ""),
+        "retry_question": drill.get("retry_question", ""),
+        "original_answer": drill.get("original_answer", ""),
+        "retry_answer": answer,
+        "comparison": comp,
+        "next_practice_prompt": comparison_result.get("next_practice_prompt", ""),
+    }
+    if updated_scorecard:
+        response["updated_scorecard"] = updated_scorecard
+        try:
+            verdict = build_judge_verdict(session, updated_scorecard, local_only=True)
+            session["judge_verdict"] = verdict
+            response["judge_verdict"] = verdict
+        except Exception as exc:
+            logger.warning("retry_handler: could not refresh judge verdict — %s", exc)
+    return response

core/scoring_engine.py

@@ -1,24 +1,43 @@
-"""Scoring engine for PitchFight AI — Phase 5D: Hybrid Claim-Based Scorecard.
+"""Scoring engine for PitchFight AI — Phase 8: Nemotron Full Scoring as Primary.
 
-Architecture (permanent):
-  - Local deterministic logic scores all 6 dimensions using extracted signals.
-  - Nemotron generates ONLY: improved_answer, improved_pitch, top_3_questions.
-  - No giant fragile Nemotron full-scorecard JSON in the main path.
+Architecture:
+  Primary path  — Nemotron reads the full battle Q&A and scores all 6 dimensions.
+  Fallback path — Local claim-based scoring if Nemotron full scoring fails.
+  Last resort   — Session-aware local fallback for catastrophic errors.
 
 scorecard_source values:
-  "hybrid_claims_nemotron" — local scores + Nemotron coaching succeeded
-  "hybrid_claims_local"    — local scores + local coaching fallback (still useful)
+  "nemotron_full"          — Nemotron judged all 6 dimensions from actual Q&A (primary)
+  "hybrid_claims_nemotron" — Local regex scores + Nemotron coaching (fallback 1)
+  "hybrid_claims_local"    — Local scores + local coaching (fallback 2)
+  "session_fallback"       — Catastrophic crash fallback
 """
 
 from __future__ import annotations
 
 import logging
 import os
+import re
 from typing import Any
 
 from core import model_router
-from core.json_utils import safe_json_parse, _score_label
-from core.claim_extractor import extract_concrete_signals
+from core.json_utils import (
+    safe_json_parse,
+    parse_model_json,
+    parse_json_object,
+    normalize_parsed_root,
+    extract_partial_string_fields,
+    extract_partial_string_list,
+    ends_abruptly,
+    sanitize_for_log,
+    _score_label,
+)
+from core.claim_extractor import extract_concrete_signals, extract_startup_context_signals
+from core.judge_settings import (
+    normalize_difficulty,
+    get_scoring_calibration,
+    get_coaching_style,
+    get_label,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -66,12 +85,251 @@ def _first(lst: list, default: str = "") -> str:
     return lst[0] if lst else default
 
 
+_ROUND_REF_RE = re.compile(r"^(?:round\s*)?r?\s*(\d{1,2})$", re.IGNORECASE)
+
+
+def _user_answers_from_session(session: dict) -> list[str]:
+    """Return founder answer texts in battle order."""
+    history = session.get("history", [])
+    return [
+        str(m.get("content", "")).strip()
+        for m in history
+        if m.get("role") == "user" and str(m.get("content", "")).strip()
+    ]
+
+
+def _parse_round_reference(text: str) -> int | None:
+    """Parse round labels like R4, r2, Round 3 into a 1-based round number."""
+    t = text.strip()
+    if not t:
+        return None
+    m = re.fullmatch(r"[Rr](\d{1,2})", t)
+    if m:
+        return int(m.group(1))
+    m = _ROUND_REF_RE.fullmatch(t)
+    if m:
+        return int(m.group(1))
+    return None
+
+
+def _is_round_reference(text: str) -> bool:
+    """Return True when text is only a round label (e.g. R4), not real answer content."""
+    return _parse_round_reference(text) is not None
+
+
+def _resolve_answer_text(
+    raw: str,
+    session: dict,
+    local_fallback: str,
+) -> tuple[str, int | None]:
+    """Map Nemotron round refs (R2, R4) to actual founder answer text."""
+    text = str(raw or "").strip()
+    user_answers = _user_answers_from_session(session)
+
+    round_num = _parse_round_reference(text)
+    if round_num is not None and 1 <= round_num <= len(user_answers):
+        return user_answers[round_num - 1][:400], round_num
+
+    if _is_prompt_artifact(text):
+        text = ""
+
+    if _is_round_reference(text) or (text and len(text) <= 6 and not text.endswith((".", "!", "?"))):
+        if local_fallback and not _is_prompt_artifact(local_fallback):
+            return local_fallback[:400], None
+        if user_answers:
+            return user_answers[-1][:400], len(user_answers)
+        return "No battle answers were submitted.", None
+
+    if text:
+        # Try to match a quoted excerpt back to a round for UI badges
+        for idx, answer in enumerate(user_answers, start=1):
+            snippet = answer[:80].lower()
+            if snippet and snippet in text.lower():
+                return text[:400], idx
+        return text[:400], None
+
+    if local_fallback:
+        return local_fallback[:400], None
+    if user_answers:
+        return user_answers[0][:400], 1
+    return "No answer recorded.", None
+
+
+def _resolve_best_weakest_answers(
+    session: dict,
+    best_raw: str,
+    weakest_raw: str,
+    local_best: str,
+    local_weakest: str,
+) -> tuple[str, str, int | None, int | None]:
+    """Ensure best/weakest fields contain readable answer text, not round codes."""
+    best_answer, best_round = _resolve_answer_text(best_raw, session, local_best)
+    weakest_answer, weakest_round = _resolve_answer_text(weakest_raw, session, local_weakest)
+    return best_answer, weakest_answer, best_round, weakest_round
+
+
+def _sync_overall_to_dimensions(scorecard: dict[str, Any]) -> dict[str, Any]:
+    """Keep overall aligned with the six dimension scores shown in the UI."""
+    scores = scorecard.get("scores") or {}
+    if len(scores) < 6:
+        return scorecard
+    avg = round(sum(int(v.get("score", 0)) for v in scores.values()) / len(scores))
+    scorecard["overall"] = avg
+    scorecard["overall_label"] = _score_label(avg)
+    return scorecard
+
+
+def _apply_practice_score_nudge(
+    overall: int,
+    signals: dict,
+    difficulty_profile: str,
+) -> int:
+    """Small practice-mode nudge when the founder showed real effort."""
+    if normalize_difficulty(difficulty_profile) != "practice":
+        return overall
+    answers = signals.get("all_user_answers") or []
+    has_substance = signals.get("signal_count", 0) > 0 or any(
+        len(str(a).split()) >= 4 for a in answers if str(a).strip()
+    )
+    if not has_substance:
+        return overall
+    return min(100, overall + 3)
+
+
+def _apply_practice_signal_floor(
+    scores: dict[str, Any],
+    local_reference: dict | None,
+    difficulty_profile: str,
+) -> dict[str, Any]:
+    """In Practice mode, never score a dimension below what real signals already justify.
+
+    The local claim-based scorer (`_compute_local_scores`) uses student-friendly floors and
+    only credits genuinely extracted signals, so it cannot be gamed by fluff. Lifting the
+    Nemotron score up to that deterministic reference protects honest students who gave a
+    short answer with one real proof point from a harsh prose-biased judgement.
+
+    Practice mode only — Judge and Investor keep pure Nemotron scoring.
+    """
+    if normalize_difficulty(difficulty_profile) != "practice":
+        return scores
+    if not local_reference or not isinstance(local_reference.get("scores"), dict):
+        return scores
+    ref = local_reference["scores"]
+    for dim, entry in scores.items():
+        ref_score = ref.get(dim, {}).get("score")
+        if not isinstance(ref_score, (int, float)):
+            continue
+        try:
+            cur = int(entry.get("score", 0))
+        except (TypeError, ValueError):
+            cur = 0
+        if ref_score > cur:
+            lifted = _clamp(int(round(ref_score)), 0, 100)
+            entry["score"] = lifted
+            entry["label"] = _score_label(lifted)
+    return scores
+
+
+_PROMPT_ARTIFACTS = frozenset({
+    "battle q&a", "local ref", "battle q&a:", "local ref (hints only)",
+    "no answer recorded.", "no answers recorded.", "not identified.",
+})
+
+
+def _is_prompt_artifact(text: str) -> bool:
+    """True when text is a scoring-prompt label, not a founder answer."""
+    t = text.strip().lower()
+    if not t:
+        return True
+    if t in _PROMPT_ARTIFACTS:
+        return True
+    if "local ref" in t and len(t) < 40:
+        return True
+    if t.startswith("battle q") and len(t) < 30:
+        return True
+    return False
+
+
+def _merge_signal_dicts(battle: dict, extra: dict) -> dict:
+    """Merge two signal dicts (lists concatenated, deduped where sensible)."""
+    merged = dict(battle)
+    for key in (
+        "numbers", "percentages", "pricing", "user_counts", "validation",
+        "college_mentions", "competitors", "technical_mechanisms",
+        "revenue_signals", "retention_signals", "gtm_signals", "vague_claims",
+        "best_user_quotes",
+    ):
+        a = list(merged.get(key, []) or [])
+        b = list(extra.get(key, []) or [])
+        seen: set[str] = set()
+        out: list[str] = []
+        for item in a + b:
+            k = str(item).strip().lower()
+            if k and k not in seen:
+                seen.add(k)
+                out.append(str(item).strip())
+        merged[key] = out
+    merged["all_user_answers"] = list(merged.get("all_user_answers", []) or [])
+    merged["non_answers"] = list(merged.get("non_answers", []) or [])
+    merged["signal_count"] = (
+        len(merged.get("numbers", [])) + len(merged.get("validation", [])) +
+        len(merged.get("competitors", [])) + len(merged.get("technical_mechanisms", [])) +
+        len(merged.get("pricing", [])) + len(merged.get("user_counts", [])) +
+        len(merged.get("revenue_signals", []))
+    )
+    return merged
+
+
+def _battle_engagement(signals: dict) -> dict[str, int]:
+    """Summarize how much the founder actually answered during the battle."""
+    all_answers = signals.get("all_user_answers", [])
+    non_answers = signals.get("non_answers", [])
+    user_turns = len(all_answers)
+    substantive = max(0, user_turns - len(non_answers))
+    return {
+        "user_turns": user_turns,
+        "substantive_answers": substantive,
+    }
+
+
+def _has_startup_context(startup: dict, startup_signals: dict) -> bool:
+    """Return True if the idea was described upfront (form or voice pitch)."""
+    if startup_signals.get("signal_count", 0) > 0:
+        return True
+    substantive_fields = 0
+    for key in ("problem", "solution", "why_ai", "traction", "target_users"):
+        if len(str(startup.get(key, "")).strip()) > 20:
+            substantive_fields += 1
+    return substantive_fields >= 2
+
+
+def _apply_startup_context_cap(score: int, engagement: int, cal: dict) -> int:
+    """Cap scores when battle had no substantive answers (startup-only credit)."""
+    if engagement > 0:
+        return score
+    cap = cal.get("startup_context_max", 45)
+    return min(score, cap)
+
+
+def _zero_engagement_reason(total: int, has_startup: bool) -> str:
+    if total == 0 and not has_startup:
+        return "No battle answers were submitted."
+    if total == 0 and has_startup:
+        return "Scored from startup description only — no battle answers were given."
+    return "No substantive battle answers were given."
+
+
 # ---------------------------------------------------------------------------
 # Local dimension scoring functions
 # ---------------------------------------------------------------------------
 
-def _score_clarity(signals: dict, engagement: int, total: int) -> tuple[int, str, str, list]:
+def _score_clarity(signals: dict, engagement: int, total: int, cal: dict | None = None) -> tuple[int, str, str, list]:
     """Did the founder communicate what the product does and who it helps?"""
+    cal = cal or {}
+    floor = cal.get("attempted_answer_floor", 33)
+    non_ans_max = cal.get("non_answer_max", 15)
+    concrete_floor = cal.get("concrete_signal_floor", 52)
+
     has_tech = bool(signals.get("technical_mechanisms"))
     has_numbers = bool(signals.get("numbers") or signals.get("user_counts"))
     has_validation = bool(signals.get("validation"))
@@ -80,45 +338,51 @@ def _score_clarity(signals: dict, engagement: int, total: int) -> tuple[int, str
     quote = best_quotes[0][:160] if best_quotes else ""
     used: list[str] = []
 
-    if engagement == 0:
-        return 15, "No substantive answers — product explanation absent.", quote, []
+    if engagement == 0 and signals.get("signal_count", 0) == 0:
+        return 0, _zero_engagement_reason(total, False), quote, []
 
-    # Floor: any on-topic answer = at least 33
-    score = 33
+    score = floor
     parts: list[str] = []
 
     if has_tech and (has_numbers or has_validation):
-        score = max(score, 65)
+        score = max(score, concrete_floor + 13)
         techs = signals.get("technical_mechanisms", [])[:2]
         used += techs
         parts.append(f"Technical mechanism described ({', '.join(techs)}) with supporting evidence.")
     elif has_tech:
-        score = max(score, 58)
+        score = max(score, concrete_floor + 6)
         techs = signals.get("technical_mechanisms", [])[:2]
         used += techs
         parts.append(f"Technical mechanism explained: {', '.join(techs)}.")
     elif has_validation:
-        score = max(score, 55)
+        score = max(score, concrete_floor + 3)
         vals = signals.get("validation", [])[:2]
         used += vals
         parts.append(f"Validation evidence present ({', '.join(vals)}) — product is real.")
     elif has_numbers:
-        score = max(score, 52)
+        score = max(score, concrete_floor)
         nums = signals.get("numbers", [])[:2]
         used += nums
         parts.append(f"Concrete numbers ({', '.join(nums)}) suggest product has been built/used.")
     elif has_vague_only:
-        score = _clamp(score, 33, 40)
+        vague_hi = cal.get("vague_on_topic_range", [floor, floor + 10])[1]
+        score = _clamp(score, floor, vague_hi)
         parts.append("Answer was on-topic but used vague language without concrete specifics.")
     else:
         parts.append("Product described with some substance but limited concrete evidence.")
 
     reason = " ".join(parts)[:280]
-    return _clamp(score), reason, quote, list(dict.fromkeys(used))[:5]
+    score = _apply_startup_context_cap(_clamp(score), engagement, cal)
+    return score, reason, quote, list(dict.fromkeys(used))[:5]
 
 
-def _score_problem_understanding(signals: dict, engagement: int, total: int) -> tuple[int, str, str, list]:
+def _score_problem_understanding(signals: dict, engagement: int, total: int, cal: dict | None = None) -> tuple[int, str, str, list]:
     """Did they name a specific user, pain, and provide evidence of understanding?"""
+    cal = cal or {}
+    floor = cal.get("attempted_answer_floor", 33)
+    non_ans_max = cal.get("non_answer_max", 15)
+    concrete_floor = cal.get("concrete_signal_floor", 52)
+
     has_validation = bool(signals.get("validation"))
     has_colleges = bool(signals.get("college_mentions"))
     has_user_counts = bool(signals.get("user_counts") or signals.get("numbers"))
@@ -129,35 +393,41 @@ def _score_problem_understanding(signals: dict, engagement: int, total: int) ->
     quote = (val_list[0] if val_list else (col_list[0] if col_list else (best_quotes[0][:160] if best_quotes else "")))
     used: list[str] = (val_list[:2] + col_list[:2])[:5]
 
-    if engagement == 0:
-        return 15, "No evidence of problem understanding — no substantive answers.", quote[:160], []
+    if engagement == 0 and signals.get("signal_count", 0) == 0:
+        return 0, _zero_engagement_reason(total, False), quote[:160], []
 
-    score = 33
+    score = floor
     parts: list[str] = []
 
     if has_validation and has_colleges:
-        score = max(score, 72)
+        score = max(score, concrete_floor + 20)
         parts.append(
             f"Validated with real users ({', '.join(val_list[:2])}) "
             f"at named campuses ({', '.join(col_list[:2])})."
         )
     elif has_validation:
-        score = max(score, 62)
+        score = max(score, concrete_floor + 10)
         parts.append(f"Validation evidence: {', '.join(val_list[:2])}.")
     elif has_colleges:
-        score = max(score, 52)
+        score = max(score, concrete_floor)
         parts.append(f"Campus/college context mentioned: {', '.join(col_list[:2])}.")
     elif has_user_counts:
-        score = max(score, 50)
+        score = max(score, concrete_floor - 2)
         parts.append(f"User/number evidence present: {', '.join(num_list)}.")
     else:
         parts.append("Problem described but without user research or validation evidence.")
 
-    return _clamp(score), " ".join(parts)[:280], quote[:160] if isinstance(quote, str) else "", used
+    score = _apply_startup_context_cap(_clamp(score), engagement, cal)
+    return score, " ".join(parts)[:280], quote[:160] if isinstance(quote, str) else "", used
 
 
-def _score_market_awareness(signals: dict, engagement: int, total: int) -> tuple[int, str, str, list]:
+def _score_market_awareness(signals: dict, engagement: int, total: int, cal: dict | None = None) -> tuple[int, str, str, list]:
     """Did they demonstrate knowledge of market size, segment, or competitive landscape?"""
+    cal = cal or {}
+    floor = cal.get("attempted_answer_floor", 33)
+    non_ans_max = cal.get("non_answer_max", 15)
+    concrete_floor = cal.get("concrete_signal_floor", 52)
+
     has_numbers = bool(signals.get("numbers") or signals.get("user_counts"))
     has_competitors = bool(signals.get("competitors"))
     has_colleges = bool(signals.get("college_mentions"))
@@ -167,38 +437,44 @@ def _score_market_awareness(signals: dict, engagement: int, total: int) -> tuple
     quote = (nums[0] if nums else (comps[0] if comps else (best_quotes[0][:160] if best_quotes else "")))
     used: list[str] = (nums[:2] + comps[:2])[:5]
 
-    if engagement == 0:
-        return 15, "No market awareness demonstrated — no substantive answers.", str(quote)[:160], []
+    if engagement == 0 and signals.get("signal_count", 0) == 0:
+        return 0, _zero_engagement_reason(total, False), str(quote)[:160], []
 
-    score = 33
+    score = floor
     parts: list[str] = []
 
     if has_numbers and has_competitors:
-        score = max(score, 67)
+        score = max(score, concrete_floor + 15)
         parts.append(
             f"Market numbers ({', '.join(nums[:2])}) and competitors named ({', '.join(comps[:2])})."
         )
     elif has_numbers and has_colleges:
-        score = max(score, 60)
+        score = max(score, concrete_floor + 8)
         parts.append(
             f"User/market numbers ({', '.join(nums[:2])}) with campus context."
         )
     elif has_numbers:
-        score = max(score, 55)
+        score = max(score, concrete_floor + 3)
         parts.append(f"Market/user numbers: {', '.join(nums[:2])}.")
     elif has_competitors:
-        score = max(score, 48)
+        score = max(score, concrete_floor - 4)
         parts.append(
             f"Competitors identified ({', '.join(comps[:2])}) — indicates market awareness."
         )
     else:
         parts.append("Market described but without user counts, TAM, or competitor landscape.")
 
-    return _clamp(score), " ".join(parts)[:280], str(quote)[:160], used
+    score = _apply_startup_context_cap(_clamp(score), engagement, cal)
+    return score, " ".join(parts)[:280], str(quote)[:160], used
 
 
-def _score_differentiation(signals: dict, engagement: int, total: int) -> tuple[int, str, str, list]:
+def _score_differentiation(signals: dict, engagement: int, total: int, cal: dict | None = None) -> tuple[int, str, str, list]:
     """Did they explain why this beats alternatives (competitor + mechanism/moat)?"""
+    cal = cal or {}
+    floor = cal.get("attempted_answer_floor", 33)
+    non_ans_max = cal.get("non_answer_max", 15)
+    concrete_floor = cal.get("concrete_signal_floor", 52)
+
     has_competitors = bool(signals.get("competitors"))
     has_tech = bool(signals.get("technical_mechanisms"))
     comps = signals.get("competitors", [])[:3]
@@ -207,24 +483,24 @@ def _score_differentiation(signals: dict, engagement: int, total: int) -> tuple[
     quote = (comps[0] if comps else (techs[0] if techs else (best_quotes[0][:160] if best_quotes else "")))
     used: list[str] = (comps[:2] + techs[:2])[:5]
 
-    if engagement == 0:
-        return 15, "No differentiation demonstrated — no substantive answers.", str(quote)[:160], []
+    if engagement == 0 and signals.get("signal_count", 0) == 0:
+        return 0, _zero_engagement_reason(total, False), str(quote)[:160], []
 
-    score = 33
+    score = floor
     parts: list[str] = []
 
     if has_competitors and has_tech:
-        score = max(score, 70)
+        score = max(score, concrete_floor + 18)
         parts.append(
             f"Named competitors ({', '.join(comps[:2])}) with technical moat ({', '.join(techs[:2])})."
         )
     elif has_competitors:
-        score = max(score, 52)
+        score = max(score, concrete_floor)
         parts.append(
             f"Competitors identified ({', '.join(comps[:2])}) but moat/mechanism not fully articulated."
         )
     elif has_tech:
-        score = max(score, 50)
+        score = max(score, concrete_floor - 2)
         parts.append(
             f"Technical approach described ({', '.join(techs[:2])}) but no direct competitor comparison."
         )
@@ -233,11 +509,19 @@ def _score_differentiation(signals: dict, engagement: int, total: int) -> tuple[
             "Differentiation not clearly supported — no competitors named and no technical mechanism stated."
         )
 
-    return _clamp(score), " ".join(parts)[:280], str(quote)[:160], used
+    score = _apply_startup_context_cap(_clamp(score), engagement, cal)
+    return score, " ".join(parts)[:280], str(quote)[:160], used
 
 
-def _score_business_model(signals: dict, engagement: int, total: int) -> tuple[int, str, str, list]:
+def _score_business_model(signals: dict, engagement: int, total: int, cal: dict | None = None) -> tuple[int, str, str, list]:
     """Did they explain who pays, how much, and why?"""
+    cal = cal or {}
+    # Business model floor is intentionally lower — early-stage students often lack revenue
+    partial_floor = cal.get("partial_signal_floor", 38)
+    concrete_floor = cal.get("concrete_signal_floor", 52)
+    non_ans_max = cal.get("non_answer_max", 15)
+    biz_floor = max(partial_floor - 10, 12)  # lower than other dims by design
+
     has_pricing = bool(signals.get("pricing"))
     has_revenue = bool(signals.get("revenue_signals"))
     has_validation = bool(signals.get("validation"))
@@ -247,36 +531,39 @@ def _score_business_model(signals: dict, engagement: int, total: int) -> tuple[i
     quote = (pricing[0] if pricing else (revenue[0] if revenue else (best_quotes[0][:160] if best_quotes else "")))
     used: list[str] = (pricing[:2] + revenue[:2])[:5]
 
-    if engagement == 0:
-        return 12, "No business model addressed — all non-answers.", str(quote)[:160], []
+    if engagement == 0 and signals.get("signal_count", 0) == 0:
+        return 0, _zero_engagement_reason(total, False), str(quote)[:160], []
 
-    # Business model floor is lower — it's OK for early-stage students to not have revenue
-    score = 28
+    score = biz_floor
     parts: list[str] = []
 
     if has_pricing and has_revenue:
-        score = max(score, 68)
+        score = max(score, concrete_floor + 16)
         parts.append(f"Pricing ({', '.join(pricing[:2])}) and revenue logic ({', '.join(revenue[:2])}) present.")
     elif has_pricing:
-        score = max(score, 52)
+        score = max(score, concrete_floor)
         parts.append(f"Pricing mentioned: {', '.join(pricing[:2])}.")
     elif has_revenue:
-        score = max(score, 48)
+        score = max(score, concrete_floor - 4)
         parts.append(f"Revenue/monetization signals: {', '.join(revenue[:2])}.")
     elif has_validation:
-        # Traction is a proxy for business activity, even if no explicit model yet
-        score = max(score, 36)
+        score = max(score, partial_floor - 2)
         parts.append(
             "Traction/validation evidence present but no explicit pricing or revenue model stated."
         )
     else:
         parts.append("Business model not clearly stated — no pricing, revenue, or monetization mentioned.")
 
-    return _clamp(score), " ".join(parts)[:280], str(quote)[:160], used
+    score = _apply_startup_context_cap(_clamp(score), engagement, cal)
+    return score, " ".join(parts)[:280], str(quote)[:160], used
 
 
-def _score_objection_handling(signals: dict, engagement: int, total: int) -> tuple[int, str, str, list]:
+def _score_objection_handling(signals: dict, engagement: int, total: int, cal: dict | None = None) -> tuple[int, str, str, list]:
     """Did they answer hard questions directly with evidence?"""
+    cal = cal or {}
+    floor = cal.get("attempted_answer_floor", 33)
+    non_ans_max = cal.get("non_answer_max", 15)
+
     has_validation = bool(signals.get("validation"))
     has_numbers = bool(signals.get("numbers") or signals.get("user_counts"))
     has_tech = bool(signals.get("technical_mechanisms"))
@@ -285,10 +572,10 @@ def _score_objection_handling(signals: dict, engagement: int, total: int) -> tup
     used: list[str] = (signals.get("validation", [])[:2] + signals.get("numbers", [])[:2])[:4]
 
     if total == 0 or engagement == 0:
-        return 15, "No substantive answers to objections recorded.", quote, []
+        has_ctx = signals.get("signal_count", 0) > 0
+        return 0, _zero_engagement_reason(total, has_ctx), quote, []
 
     engagement_rate = engagement / total
-    # Base score: engagement_rate * 60
     score = int(engagement_rate * 60)
     parts: list[str] = []
 
@@ -302,9 +589,9 @@ def _score_objection_handling(signals: dict, engagement: int, total: int) -> tup
     if has_tech:
         score += 5
 
-    # Floor: at least 30 if majority were substantive
+    # Floor: use profile floor if majority were substantive
     if engagement_rate > 0.5:
-        score = max(score, 30)
+        score = max(score, floor - 3)
 
     if not parts:
         parts.append(
@@ -320,6 +607,15 @@ def _score_objection_handling(signals: dict, engagement: int, total: int) -> tup
 # Local scoring orchestrator
 # ---------------------------------------------------------------------------
 
+def _startup_summary_snippet(startup: dict) -> str:
+    """Short excerpt from startup form when no battle answers exist."""
+    for key in ("solution", "problem", "why_ai", "traction"):
+        val = str(startup.get(key, "")).strip()
+        if len(val) > 20:
+            return val[:400]
+    return ""
+
+
 def _why_weak_reason(weak_answer: str, signals: dict) -> str:
     stripped = weak_answer.strip().lower()
     if not stripped or stripped in ("no answers recorded.", "no answers recorded yet."):
@@ -332,13 +628,14 @@ def _why_weak_reason(weak_answer: str, signals: dict) -> str:
 
 
 def _compute_local_scores(
-    signals: dict, startup: dict
+    signals: dict, startup: dict, cal: dict | None = None
 ) -> tuple[dict[str, Any], str, str, str]:
     """Return (scores_dict, best_answer, weakest_answer, why_weak).
 
     All 6 dimension scores are computed deterministically from extracted signals.
-    No API calls.
+    No API calls. cal = scoring_calibration dict from the active difficulty profile.
     """
+    cal = cal or {}
     all_answers = signals.get("all_user_answers", [])
     non_answers = signals.get("non_answers", [])
     best_quotes = signals.get("best_user_quotes", [])
@@ -347,40 +644,257 @@ def _compute_local_scores(
 
     scores = {
         "clarity": _dimension(
-            *_score_clarity(signals, engagement, total)
+            *_score_clarity(signals, engagement, total, cal)
         ),
         "problem_understanding": _dimension(
-            *_score_problem_understanding(signals, engagement, total)
+            *_score_problem_understanding(signals, engagement, total, cal)
         ),
         "market_awareness": _dimension(
-            *_score_market_awareness(signals, engagement, total)
+            *_score_market_awareness(signals, engagement, total, cal)
         ),
         "differentiation": _dimension(
-            *_score_differentiation(signals, engagement, total)
+            *_score_differentiation(signals, engagement, total, cal)
         ),
         "business_model": _dimension(
-            *_score_business_model(signals, engagement, total)
+            *_score_business_model(signals, engagement, total, cal)
         ),
         "objection_handling": _dimension(
-            *_score_objection_handling(signals, engagement, total)
+            *_score_objection_handling(signals, engagement, total, cal)
         ),
     }
 
-    best_answer = (
-        best_quotes[0]
-        if best_quotes
-        else (all_answers[0] if all_answers else "No answers recorded.")
+    if engagement == 0 and total == 0:
+        snippet = _startup_summary_snippet(startup)
+        if snippet:
+            best_answer = snippet
+            weakest_answer = "No battle answers were submitted."
+            why_weak = "The judge asked questions but no answers were given during the battle."
+        else:
+            best_answer = "No battle answers were submitted."
+            weakest_answer = "No battle answers were submitted."
+            why_weak = "No answers were recorded in this session."
+    else:
+        best_answer = (
+            best_quotes[0]
+            if best_quotes
+            else (all_answers[0] if all_answers else "No battle answers were submitted.")
+        )
+        non_best = [a for a in all_answers if a != best_answer]
+        if non_answers:
+            weakest_answer = non_answers[0]
+        elif non_best:
+            weakest_answer = min(non_best, key=len)
+        else:
+            weakest_answer = all_answers[-1] if len(all_answers) > 1 else best_answer
+        why_weak = _why_weak_reason(weakest_answer, signals)
+    return scores, best_answer, weakest_answer, why_weak
+
+
+# ---------------------------------------------------------------------------
+# "Path to 80+" score explanation builder (fully local — no API call)
+# ---------------------------------------------------------------------------
+
+_DIM_NAMES = {
+    "clarity": "clarity",
+    "problem_understanding": "problem understanding",
+    "market_awareness": "market awareness",
+    "differentiation": "differentiation",
+    "business_model": "business model",
+    "objection_handling": "objection handling",
+}
+
+_DIM_TO_RETRY_ADVICE = {
+    "clarity": (
+        "When answering questions about your product, name the specific thing you built, "
+        "who uses it today, and one number that proves it works."
+    ),
+    "problem_understanding": (
+        "Show you researched the problem — name a real user, a campus, or a specific pain point "
+        "you observed firsthand. One validation data point changes everything."
+    ),
+    "market_awareness": (
+        "Size the market with one real number and name at least two alternatives students use today. "
+        "Judges want to know you understand the competitive landscape."
+    ),
+    "differentiation": (
+        "Name your top two competitors, then explain the one thing they cannot easily copy from you. "
+        "A technical mechanism, a relationship, or a data advantage all count."
+    ),
+    "business_model": (
+        "Say exactly who pays, how much, and when the first payment happens. "
+        "Even a rough plan ('₹499/student/month, collect at onboarding') is far stronger than silence."
+    ),
+    "objection_handling": (
+        "When challenged, do not deflect. Answer the exact question with a number, a fact, or a concrete example. "
+        "Judges remember founders who hold their ground under pressure."
+    ),
+}
+
+_TONE_OPENER = {
+    "practice": "You are closer than the score feels.",
+    "judge": "Here is what the scorecard is actually telling you.",
+    "investor": "Here is exactly what held this pitch back.",
+}
+
+
+def _build_score_explanation(
+    overall: int,
+    scores: dict[str, Any],
+    weakest_answer: str,
+    why_weak: str,
+    signals: dict,
+    session: dict,
+    difficulty_profile: str = "practice",
+) -> dict[str, Any]:
+    """Build the 'Path to 80+' coaching section from local data only — no API call."""
+    dim_items = sorted(scores.items(), key=lambda x: x[1]["score"])
+    strong_dims = [(k, v) for k, v in scores.items() if v["score"] >= 70]
+    weak_dims   = [(k, v) for k, v in dim_items if v["score"] < 55]
+    blocker_dim, blocker_data = dim_items[0]  # lowest scoring
+
+    strong_names  = [_DIM_NAMES.get(k, k) for k, _ in strong_dims]
+    blocker_name  = _DIM_NAMES.get(blocker_dim, blocker_dim)
+    blocker_score = blocker_data["score"]
+    blocker_label = blocker_data["label"]
+
+    tone_opener = _TONE_OPENER.get(difficulty_profile, _TONE_OPENER["practice"])
+
+    # --- why_you_scored_this ---
+    if strong_names:
+        strong_str = " and ".join(strong_names[:2])
+        why_scored = (
+            f"{tone_opener} "
+            f"Your {strong_str} answer{'s were' if len(strong_names) > 1 else ' was'} solid, "
+            f"but your {blocker_name} answer brought the score down. "
+            f"The judge scored {blocker_name} at {blocker_score} ({blocker_label}) "
+            f"because {blocker_data.get('reason', 'it lacked concrete evidence')[:120]}."
+        )
+    else:
+        why_scored = (
+            f"{tone_opener} "
+            f"Your {blocker_name} answer was the main drag on the score — "
+            f"{blocker_score} ({blocker_label}). "
+            f"{blocker_data.get('reason', 'It lacked concrete evidence')[:120]}."
+        )
+
+    # --- what_stopped_80 ---
+    history = session.get("history", [])
+    ai_messages = [m["content"] for m in history if m.get("role") == "assistant"]
+    blocker_question = ai_messages[0][:180] if ai_messages else ""
+
+    if blocker_question:
+        what_stopped = (
+            f"The biggest gap was in {blocker_name}. "
+            f"The judge pressed on this with a question like: \"{blocker_question}\" "
+            f"and the answer did not fully land. {why_weak}"
+        )
+    else:
+        what_stopped = (
+            f"The biggest gap was in {blocker_name} ({blocker_score}/100). "
+            f"{why_weak} "
+            f"A stronger answer here alone could push the overall score into the mid-70s."
+        )
+
+    # --- answer_to_retry ---
+    all_answers = signals.get("all_user_answers", [])
+    non_answers = signals.get("non_answers", [])
+
+    # Pick the answer most associated with the blocker dimension
+    original_answer = weakest_answer
+    attack_tag_for_retry = blocker_name.replace(" ", "_")
+    round_for_retry: int | None = None
+
+    # Try to find the round number from history
+    user_turns = [m for m in history if m.get("role") == "user"]
+    if user_turns:
+        worst_idx = None
+        shortest_len = 9999
+        for idx, m in enumerate(user_turns):
+            content = m.get("content", "")
+            if content in non_answers and (worst_idx is None or len(content) < shortest_len):
+                worst_idx = idx
+                shortest_len = len(content)
+        if worst_idx is not None:
+            round_for_retry = worst_idx + 1
+            original_answer = user_turns[worst_idx].get("content", weakest_answer)
+        else:
+            round_for_retry = len(user_turns)
+
+    retry_advice = _DIM_TO_RETRY_ADVICE.get(blocker_dim, "Give one concrete piece of evidence to back your claim.")
+
+    # Sample stronger answer using signals from session
+    numbers  = signals.get("numbers", []) + signals.get("user_counts", [])
+    valid    = signals.get("validation", [])
+    comps    = signals.get("competitors", [])
+    pricing  = signals.get("pricing", [])
+    startup  = session.get("startup", {})
+    sname    = startup.get("name", "our product")
+
+    sample_parts: list[str] = [f"A stronger answer would say: '{sname} "]
+    if numbers:
+        sample_parts.append(f"has {numbers[0]} ")
+    if valid:
+        sample_parts.append(f"validated through {valid[0]} ")
+    if comps:
+        sample_parts.append(f"— unlike {comps[0]}, we ")
+    if pricing:
+        sample_parts.append(f"charge {pricing[0]}")
+    else:
+        sample_parts.append("and our advantage is the specific data and relationships we have built'")
+    sample_stronger_answer = "".join(sample_parts).strip()
+    if not sample_stronger_answer.endswith("'"):
+        sample_stronger_answer += "'"
+
+    why_it_hurt = (
+        f"This answer scored low on {blocker_name} because it {why_weak.lower()} "
+        f"The judge needs one specific fact, number, or example to move on."
     )
-    non_best = [a for a in all_answers if a != best_answer]
-    if non_answers:
-        weakest_answer = non_answers[0]
-    elif non_best:
-        weakest_answer = min(non_best, key=len)
+
+    answer_to_retry = {
+        "round": round_for_retry,
+        "attack_tag": attack_tag_for_retry,
+        "dimension": blocker_dim,
+        "original_answer": original_answer[:300],
+        "why_it_hurt": why_it_hurt[:300],
+        "retry_advice": retry_advice,
+        "sample_stronger_answer": sample_stronger_answer[:400],
+    }
+
+    # --- estimated_score_if_fixed ---
+    if overall >= 80:
+        # Already strong — advise path to 90
+        gap_to_90 = 90 - overall
+        estimated_new = _clamp(overall + min(gap_to_90, 8))
+        improvement_reason = (
+            f"Your pitch is already strong. To reach 90+, deepen the evidence in "
+            f"{blocker_name} and {_DIM_NAMES.get(dim_items[1][0], 'your second weakest area')} "
+            f"with specific numbers and a sharper competitive contrast."
+        )
     else:
-        weakest_answer = all_answers[-1] if len(all_answers) > 1 else best_answer
+        # Estimate conservative improvement from fixing the main blocker
+        blocker_weight = 1 / len(scores)
+        point_gain = max(8, min(15, int((70 - blocker_score) * blocker_weight * 1.4)))
+        estimated_new = _clamp(overall + point_gain, overall, 82)
+        if len(strong_dims) >= 3:
+            estimated_new = min(estimated_new + 3, 85)
+        improvement_reason = (
+            f"Fixing your {blocker_name} answer alone could add roughly {point_gain} points overall. "
+            f"This would move your pitch from '{_score_label(overall)}' toward "
+            f"'{_score_label(estimated_new)}' territory."
+        )
 
-    why_weak = _why_weak_reason(weakest_answer, signals)
-    return scores, best_answer, weakest_answer, why_weak
+    estimated_score_if_fixed = {
+        "current_overall": overall,
+        "estimated_new_overall": estimated_new,
+        "reason": improvement_reason,
+    }
+
+    return {
+        "why_you_scored_this": why_scored,
+        "what_stopped_80": what_stopped,
+        "answer_to_retry": answer_to_retry,
+        "estimated_score_if_fixed": estimated_score_if_fixed,
+    }
 
 
 # ---------------------------------------------------------------------------
@@ -394,6 +908,7 @@ def _build_coaching_prompt(
     best_answer: str,
     weakest_answer: str,
     why_weak: str,
+    difficulty_profile: str = "practice",
 ) -> list[dict[str, str]]:
     """Build messages for Nemotron coaching-only call.
 
@@ -401,6 +916,8 @@ def _build_coaching_prompt(
     All scoring is already done locally and passed as context.
     """
     startup = session.get("startup", {})
+    coaching_style = get_coaching_style(difficulty_profile)
+    difficulty_label = get_label(difficulty_profile)
 
     startup_block = "\n".join([
         f"Startup: {startup.get('name', 'Unknown')}",
@@ -456,21 +973,41 @@ def _build_coaching_prompt(
         answers_lines.append(f"  {i}. {a[:200]}")
     answers_block = "\n".join(answers_lines)
 
+    coaching_instruction = coaching_style.get(
+        "instruction",
+        "Be encouraging but honest. Show how to make the answer stronger with one specific number or proof point.",
+    )
+    coaching_example = coaching_style.get("example", "")
+
     system_content = (
-        "Return ONLY valid JSON. First character must be {. Last character must be }.\n"
-        "No markdown. No explanation. No analysis. No reasoning. No chain-of-thought.\n\n"
-        "You are a startup pitch coach for a student founder. "
-        "Generate coaching content based on the provided context.\n\n"
-        "RULES:\n"
+        "Return ONLY valid JSON. Return one JSON object only.\n"
+        "First character must be {. Last character must be }.\n"
+        "Do not wrap in an array. No markdown. No explanation. No analysis. No reasoning.\n"
+        "Keep each field short and complete. Do not end mid-sentence.\n\n"
+        f"You are a startup pitch coach for a student founder. Difficulty profile: {difficulty_label}.\n\n"
+        f"COACHING STYLE: {coaching_instruction}\n"
+        + (f"TONE EXAMPLE: {coaching_example}\n\n" if coaching_example else "\n")
+        + "RULES:\n"
         "  - Do NOT hallucinate traction, numbers, or facts not in the provided context.\n"
         "  - Do NOT re-score — scores are already computed.\n"
         "  - Use actual startup context and actual founder answers.\n"
         "  - If concrete signals exist, reference them in improved_answer and improved_pitch.\n"
-        "  - improved_answer: rewrite of the weakest answer using specifics the founder already knows.\n"
-        "  - improved_pitch: one concise 60-second pitch using startup name, problem, solution, evidence.\n"
-        "  - top_3_questions: 3 pointed follow-up questions an investor would ask, focused on weak dimensions.\n\n"
+        "  - Use 'your answer' or 'you said' — never 'you typed' (voice transcripts also arrive here).\n"
+        "  - improved_answer: 3-5 sentences rewriting the weakest answer.\n"
+        "  - improved_pitch: 4-6 sentences — one concise 60-second pitch.\n"
+        "  - top_3_questions: exactly 3 strings.\n"
+        "  - score_explanation: Path to 80+ coaching — keep each field SHORT and COMPLETE.\n"
+        "    why_you_scored_this: max 2 sentences.\n"
+        "    what_stopped_80: max 2 sentences.\n"
+        "    answer_to_retry.retry_advice: ONE complete sentence only.\n"
+        "    answer_to_retry.sample_stronger_answer: 3-4 sentences max.\n\n"
         "Return exactly this JSON schema — nothing else:\n"
-        '{"improved_answer": "string", "improved_pitch": "string", "top_3_questions": ["string", "string", "string"]}'
+        '{"improved_answer":"string","improved_pitch":"string","top_3_questions":["string","string","string"],'
+        '"score_explanation":{"why_you_scored_this":"string","what_stopped_80":"string",'
+        '"answer_to_retry":{"round":null,"attack_tag":"string","dimension":"string",'
+        '"original_answer":"string","why_it_hurt":"string","retry_advice":"string",'
+        '"sample_stronger_answer":"string"},'
+        '"estimated_score_if_fixed":{"current_overall":0,"estimated_new_overall":0,"reason":"string"}}}'
     )
 
     user_content = (
@@ -491,33 +1028,243 @@ def _build_coaching_prompt(
     ]
 
 
-def _parse_coaching_json(raw: str) -> dict[str, Any] | None:
-    """Parse and validate the coaching JSON response."""
-    parsed = safe_json_parse(raw)
-    if not parsed or not isinstance(parsed, dict):
+def _ends_abruptly(text: str) -> bool:
+    """Return True if text looks cut off mid-sentence."""
+    t = text.strip()
+    if not t:
+        return True
+    if t[-1] in ".!?":
+        return False
+    # Short fragment without terminal punctuation is likely truncated
+    if len(t) < 50:
+        return True
+    # Longer text without punctuation may still be valid — only flag if very short last token
+    last_word = t.split()[-1] if t.split() else ""
+    return len(last_word) <= 2 and len(t) < 80
+
+
+def _field_looks_truncated(field: str, text: str) -> bool:
+    """Return True if a score_explanation text field appears incomplete."""
+    t = text.strip()
+    if not t:
+        return True
+    if field == "retry_advice":
+        return len(t) < 20 or _ends_abruptly(t)
+    if field in ("why_you_scored_this", "what_stopped_80"):
+        return _ends_abruptly(t)
+    if field == "sample_stronger_answer":
+        return len(t) < 30 or _ends_abruptly(t)
+    return _ends_abruptly(t)
+
+
+def _parse_coaching_score_explanation(raw: Any) -> dict[str, Any] | None:
+    """Parse score_explanation sub-object from coaching JSON."""
+    if not isinstance(raw, dict):
+        return None
+    atr_raw = raw.get("answer_to_retry", {})
+    esif_raw = raw.get("estimated_score_if_fixed", {})
+    if not isinstance(atr_raw, dict):
+        atr_raw = {}
+    if not isinstance(esif_raw, dict):
+        esif_raw = {}
+    why = str(raw.get("why_you_scored_this", "")).strip()
+    if not why:
         return None
+    return {
+        "why_you_scored_this": why,
+        "what_stopped_80": str(raw.get("what_stopped_80", "")).strip(),
+        "answer_to_retry": {
+            "round": atr_raw.get("round"),
+            "attack_tag": str(atr_raw.get("attack_tag", "")).strip(),
+            "dimension": str(atr_raw.get("dimension", "")).strip(),
+            "original_answer": str(atr_raw.get("original_answer", "")).strip()[:300],
+            "why_it_hurt": str(atr_raw.get("why_it_hurt", "")).strip()[:300],
+            "retry_advice": str(atr_raw.get("retry_advice", "")).strip(),
+            "sample_stronger_answer": str(atr_raw.get("sample_stronger_answer", "")).strip()[:400],
+        },
+        "estimated_score_if_fixed": {
+            "current_overall": esif_raw.get("current_overall"),
+            "estimated_new_overall": esif_raw.get("estimated_new_overall"),
+            "reason": str(esif_raw.get("reason", "")).strip(),
+        },
+    }
+
+
+def _resolve_score_explanation(
+    nemotron_se: dict[str, Any] | None,
+    local_se: dict[str, Any],
+    overall: int,
+) -> dict[str, Any]:
+    """Merge Nemotron score_explanation with local fallback — never keep truncated fields."""
+    if not nemotron_se:
+        return local_se
+
+    result = {
+        "why_you_scored_this": local_se.get("why_you_scored_this", ""),
+        "what_stopped_80": local_se.get("what_stopped_80", ""),
+        "answer_to_retry": dict(local_se.get("answer_to_retry", {})),
+        "estimated_score_if_fixed": dict(local_se.get("estimated_score_if_fixed", {})),
+    }
+
+    for field in ("why_you_scored_this", "what_stopped_80"):
+        n_val = str(nemotron_se.get(field, "")).strip()
+        if n_val and not _field_looks_truncated(field, n_val):
+            result[field] = n_val
+
+    local_atr = local_se.get("answer_to_retry", {})
+    n_atr = nemotron_se.get("answer_to_retry", {})
+    merged_atr = dict(local_atr) if isinstance(local_atr, dict) else {}
+    if isinstance(n_atr, dict):
+        for key in ("round", "attack_tag", "dimension", "original_answer", "why_it_hurt"):
+            n_val = n_atr.get(key)
+            if key in ("original_answer", "why_it_hurt"):
+                n_val = str(n_val or "").strip()
+                if n_val and not _field_looks_truncated(key, n_val):
+                    merged_atr[key] = n_val[:300]
+            elif n_val is not None and str(n_val).strip():
+                merged_atr[key] = n_val
+        retry = str(n_atr.get("retry_advice", "")).strip()
+        if retry and not _field_looks_truncated("retry_advice", retry):
+            merged_atr["retry_advice"] = retry
+        sample = str(n_atr.get("sample_stronger_answer", "")).strip()
+        if sample and not _field_looks_truncated("sample_stronger_answer", sample):
+            merged_atr["sample_stronger_answer"] = sample[:400]
+    result["answer_to_retry"] = merged_atr
+
+    local_esif = local_se.get("estimated_score_if_fixed", {})
+    n_esif = nemotron_se.get("estimated_score_if_fixed", {})
+    merged_esif = dict(local_esif) if isinstance(local_esif, dict) else {}
+    if isinstance(n_esif, dict):
+        est = n_esif.get("estimated_new_overall")
+        reason = str(n_esif.get("reason", "")).strip()
+        if isinstance(est, (int, float)) and not _field_looks_truncated("reason", reason):
+            merged_esif["estimated_new_overall"] = _clamp(int(est), overall, 95)
+        if reason and not _field_looks_truncated("reason", reason):
+            merged_esif["reason"] = reason
+    merged_esif["current_overall"] = overall
+    result["estimated_score_if_fixed"] = merged_esif
+
+    return result
+
+
+def _parse_coaching_json(raw: str) -> dict[str, Any]:
+    """Parse coaching JSON — best effort, may return partial fields."""
+    parsed = parse_json_object(
+        raw,
+        string_fields=["improved_answer", "improved_pitch", "why_you_scored_this", "what_stopped_80"],
+    )
+    if not parsed:
+        partial = extract_partial_string_fields(raw, ["improved_answer", "improved_pitch"])
+        parsed = partial
+
+    if not parsed:
+        return {}
 
     improved_answer = str(parsed.get("improved_answer", "")).strip()
     improved_pitch = str(parsed.get("improved_pitch", "")).strip()
     raw_q = parsed.get("top_3_questions", [])
 
+    if not raw_q:
+        raw_q = extract_partial_string_list(raw, "top_3_questions", min_items=3)
+
     if isinstance(raw_q, list):
         questions = [str(q).strip() for q in raw_q if str(q).strip()][:3]
     else:
         questions = []
 
-    while len(questions) < 3:
-        questions.append("What concrete evidence can you give to support your strongest claim?")
+    result: dict[str, Any] = {}
+    if improved_answer and not ends_abruptly(improved_answer):
+        result["improved_answer"] = improved_answer
+    if improved_pitch and not ends_abruptly(improved_pitch):
+        result["improved_pitch"] = improved_pitch
+    if questions:
+        result["top_3_questions"] = questions
+
+    se = _parse_coaching_score_explanation(parsed.get("score_explanation"))
+    if se:
+        result["score_explanation"] = se
+    elif isinstance(parsed.get("score_explanation"), dict):
+        se_partial = parsed["score_explanation"]
+        if isinstance(se_partial, dict):
+            partial_se: dict[str, Any] = {}
+            for field in ("why_you_scored_this", "what_stopped_80"):
+                val = str(se_partial.get(field, "")).strip()
+                if val and not _field_looks_truncated(field, val):
+                    partial_se[field] = val
+            if partial_se:
+                result["score_explanation"] = partial_se
 
-    # Both coaching fields must be non-empty for the parse to be considered valid
-    if not improved_answer or not improved_pitch:
-        return None
+    return result
 
-    return {
-        "improved_answer": improved_answer,
-        "improved_pitch": improved_pitch,
-        "top_3_questions": questions,
-    }
+
+def _coaching_source_label(nemotron: dict[str, Any], local: dict[str, Any]) -> str:
+    """Classify how much coaching came from Nemotron vs local fallback."""
+    core_keys = ("improved_answer", "improved_pitch", "top_3_questions")
+    n_hits = sum(1 for k in core_keys if nemotron.get(k))
+    if n_hits >= 3:
+        return "nemotron"
+    if n_hits > 0:
+        return "partial_nemotron_local"
+    return "local"
+
+
+def _merge_coaching_with_local(
+    nemotron: dict[str, Any] | None,
+    local: dict[str, Any],
+) -> tuple[dict[str, Any], str]:
+    """Merge Nemotron coaching with local fallback field-by-field."""
+    nemotron = nemotron or {}
+    merged = dict(local)
+    for key in ("improved_answer", "improved_pitch"):
+        val = str(nemotron.get(key, "")).strip()
+        if val and not ends_abruptly(val):
+            merged[key] = val
+    n_q = nemotron.get("top_3_questions")
+    if isinstance(n_q, list) and len(n_q) >= 3:
+        merged["top_3_questions"] = [str(q).strip() for q in n_q[:3]]
+    elif isinstance(n_q, list) and n_q:
+        base = list(local.get("top_3_questions", []))
+        for i, q in enumerate(n_q):
+            if i < 3 and str(q).strip():
+                if i < len(base):
+                    base[i] = str(q).strip()
+                else:
+                    base.append(str(q).strip())
+        while len(base) < 3:
+            base.append("What concrete evidence can you give to support your strongest claim?")
+        merged["top_3_questions"] = base[:3]
+    if nemotron.get("score_explanation"):
+        merged["score_explanation"] = nemotron["score_explanation"]
+    return merged, _coaching_source_label(nemotron, local)
+
+
+def _resolve_coaching_from_raw(
+    coaching_raw: str,
+    local: dict[str, Any],
+    resolved_mode: str,
+) -> tuple[dict[str, Any], str]:
+    """Parse + repair Nemotron coaching, merging with local field-by-field."""
+    nemotron = _parse_coaching_json(coaching_raw) if coaching_raw else {}
+    if not nemotron.get("improved_answer") and not nemotron.get("improved_pitch") and coaching_raw:
+        logger.warning("scoring_engine: coaching parse failed, trying repair")
+        try:
+            repair = model_router.generate_coaching_repair_response(coaching_raw, model_mode=resolved_mode)
+            if repair.get("ok") and repair.get("content"):
+                repaired = _parse_coaching_json(repair["content"])
+                for k, v in repaired.items():
+                    if v and not nemotron.get(k):
+                        nemotron[k] = v
+                if repaired:
+                    logger.info("scoring_engine: repaired coaching JSON OK")
+        except Exception as exc:
+            logger.warning("scoring_engine: coaching repair raised — %s", exc)
+
+    merged, source = _merge_coaching_with_local(nemotron, local)
+    if source == "local":
+        logger.warning("scoring_engine: coaching fallback to local (scoring still nemotron_full)")
+    elif source == "partial_nemotron_local":
+        logger.info("scoring_engine: partial Nemotron coaching merged with local fields")
+    return merged, source
 
 
 # ---------------------------------------------------------------------------
@@ -592,42 +1339,312 @@ def _local_coaching(
 
 
 # ---------------------------------------------------------------------------
-# Main hybrid scorecard generator (Phase 5D — permanent architecture)
+# Nemotron primary scoring path (Phase 8) — split into two smaller calls
+#
+# Call 1: scorecard_scoring — 6 dimension scores + best/weakest/why_weak
+# Call 2: scorecard_coaching — improved_answer, improved_pitch, top_3_questions
+#
+# This split keeps each JSON payload small enough for long battles (9+ rounds).
+# scorecard_source = "nemotron_full" when Call 1 succeeds, regardless of Call 2.
+# ---------------------------------------------------------------------------
+
+_SCORING_SCHEMA = (
+    '{"scores":{'
+    '"clarity":{"score":0,"reason":"","quote":"","signals_used":[]},'
+    '"problem_understanding":{"score":0,"reason":"","quote":"","signals_used":[]},'
+    '"market_awareness":{"score":0,"reason":"","quote":"","signals_used":[]},'
+    '"differentiation":{"score":0,"reason":"","quote":"","signals_used":[]},'
+    '"business_model":{"score":0,"reason":"","quote":"","signals_used":[]},'
+    '"objection_handling":{"score":0,"reason":"","quote":"","signals_used":[]}},'
+    '"best_answer":"","weakest_answer":"","why_weak":""}'
+)
+
+
+def _build_scoring_only_prompt(
+    session: dict,
+    signals: dict,
+    local_reference: dict | None,
+    difficulty_profile: str,
+    difficulty_label: str,
+) -> list[dict[str, str]]:
+    """Build the Nemotron scoring-only prompt (Call 1).
+
+    Returns scores for all 6 dims + best/weakest/why_weak.
+    No coaching text, no score_explanation — keeps the JSON small.
+    """
+    startup = session.get("startup", {})
+    history = session.get("history", [])
+
+    startup_block = "\n".join([
+        f"Startup: {startup.get('name', 'Unknown')}",
+        f"Problem: {startup.get('problem', 'Not stated')}",
+        f"Solution: {startup.get('solution', 'Not stated')}",
+        f"Stage: {startup.get('stage', 'Not stated')}",
+        f"Traction: {startup.get('traction', 'Not stated')}",
+    ])
+
+    # Battle history — truncate each turn to keep prompt lean
+    ai_turns = [m for m in history if m.get("role") == "assistant"]
+    user_turns = [m for m in history if m.get("role") == "user"]
+    history_lines: list[str] = ["BATTLE Q&A:"]
+    for i, (ai_msg, user_msg) in enumerate(zip(ai_turns, user_turns), start=1):
+        history_lines.append(f"R{i} Judge: {ai_msg.get('content','')[:200]}")
+        history_lines.append(f"R{i} Founder: {user_msg.get('content','')[:200]}")
+    battle_block = "\n".join(history_lines)
+
+    # Signals block — brief
+    sig_parts: list[str] = []
+    for key, label in [
+        ("numbers", "Numbers"), ("validation", "Validation"),
+        ("competitors", "Competitors"), ("pricing", "Pricing"),
+        ("technical_mechanisms", "Tech"), ("non_answers", "Non-answers"),
+    ]:
+        items = signals.get(key, [])[:4]
+        if items:
+            sig_parts.append(f"{label}: {', '.join(str(x) for x in items)}")
+    signals_block = "SIGNALS: " + " | ".join(sig_parts) if sig_parts else ""
+
+    local_block = ""
+    if local_reference and isinstance(local_reference.get("scores"), dict):
+        ref_parts = []
+        for dim in _REQUIRED_DIMS:
+            d = local_reference["scores"].get(dim, {})
+            ref_parts.append(f"{dim}={d.get('score','?')}")
+        local_block = "LOCAL REF (hints only): " + ", ".join(ref_parts)
+
+    profile_guidance = {
+        "practice": (
+            "This founder is a STUDENT practising. Judge intent and real signals generously. "
+            "A genuine attempt that includes one concrete detail (a number, a named user, a "
+            "real test result) should land 55+. Never punish casual phrasing, nerves, short "
+            "answers, or imperfect grammar. Reserve low scores for non-answers or honest "
+            "admissions of not knowing."
+        ),
+        "judge": "Balanced hackathon judging. Reward concrete evidence. Penalise deflection.",
+        "investor": "Investor-grade. Vague answers on revenue/moat hurt significantly.",
+    }.get(difficulty_profile, "Be fair and honest.")
+
+    system_content = (
+        "Return ONLY valid JSON. First character {. Last character }. No markdown. No explanation.\n\n"
+        "You are scoring a real founder talking, often a student. Judge whether the answer "
+        "contains the RIGHT KIND OF PROOF for the question — not how polished it sounds.\n\n"
+        "SCORE WHAT MATTERS:\n"
+        "  Score the PRESENCE and RELEVANCE of concrete signals (a real number, a named user, "
+        "a test/pilot result, a named competitor with a reason, a pricing figure).\n"
+        "  Do NOT reward length, fluency, grammar, jargon, or polish. A short, plain, or "
+        "informal answer that carries one real proof point must score the SAME as a long "
+        "polished answer with the same proof. Do not reward verbosity.\n"
+        "  Example: 'we tested with 40 students and the quiz group did better' is REAL "
+        "validation — score it as concrete evidence even though it is short and casual.\n\n"
+        "RELEVANCE GUARD (do not let this be gamed):\n"
+        "  A signal only counts for the dimension it actually addresses. Naming a competitor "
+        "or saying a buzzword does NOT earn differentiation if the founder cannot say why they "
+        "are better. If the founder says 'I don't know' / 'okay' / one word, or admits the "
+        "issue is unsolved, score THAT dimension honestly low (10-25) even if keywords appear.\n\n"
+        "BANDS:\n"
+        "  Non-answer / 'I don't know' / one word = 10-25.\n"
+        "  Relevant attempt but no concrete proof = 35-50.\n"
+        "  At least one real, relevant proof point (even if short/casual) = 55-78.\n"
+        "  Strong answer with specific, well-matched proof = 79-92.\n"
+        "  Recovery rule: score the strongest relevant answer if the founder improved later.\n"
+        "  Do NOT hallucinate facts not in the conversation.\n"
+        "  Each reason: 1 sentence. Quote: short excerpt. signals_used: max 4 items.\n"
+        "  best_answer and weakest_answer: copy the ACTUAL founder answer text verbatim.\n"
+        "  NEVER use round labels like R1, R2, R4 — always paste the real answer sentence(s).\n\n"
+        "The SIGNALS block below was extracted from the founder's answers — credit those real "
+        "signals for the dimensions they fit, even when the wording was brief or informal.\n\n"
+        f"PROFILE: {difficulty_label} — {profile_guidance}\n\n"
+        "SCHEMA:\n" + _SCORING_SCHEMA
+    )
+
+    user_content = (
+        f"{startup_block}\n\n"
+        f"{battle_block}\n\n"
+        f"{signals_block}\n"
+        f"{local_block}\n\n"
+        "Score each dimension based on what was ACTUALLY said. Return JSON only."
+    )
+
+    return [
+        {"role": "system", "content": system_content},
+        {"role": "user", "content": user_content},
+    ]
+
+
+def _normalize_scoring_json(parsed: dict) -> dict:
+    """Fill missing reason fields so structurally valid JSON passes validation."""
+    if not isinstance(parsed, dict):
+        return parsed
+    scores = parsed.get("scores")
+    if not isinstance(scores, dict):
+        return parsed
+    for dim in _REQUIRED_DIMS:
+        d = scores.get(dim)
+        if not isinstance(d, dict):
+            scores[dim] = {"score": 0, "reason": "No reasoning provided.", "quote": "", "signals_used": []}
+            continue
+        if not str(d.get("reason", "")).strip():
+            score = d.get("score", 0)
+            try:
+                score_int = int(round(float(score)))
+            except (TypeError, ValueError):
+                score_int = 0
+            d["reason"] = f"Score: {score_int} based on answer quality."
+    return parsed
+
+
+def _validate_scoring_json(parsed: dict) -> bool:
+    """Return True if the scoring-only JSON has all required dimension fields."""
+    if not isinstance(parsed, dict):
+        return False
+    scores = parsed.get("scores")
+    if not isinstance(scores, dict) or len(scores) < 6:
+        return False
+    for dim in _REQUIRED_DIMS:
+        d = scores.get(dim)
+        if not isinstance(d, dict):
+            return False
+        score = d.get("score")
+        if not isinstance(score, (int, float)):
+            return False
+        if not str(d.get("reason", "")).strip():
+            return False
+    return True
+
+
+def _normalize_scoring_result(parsed: dict) -> tuple[dict[str, Any], str, str, str]:
+    """Extract and normalize dimension scores from scoring-only JSON.
+
+    Returns (scores_dict, best_answer, weakest_answer, why_weak).
+    Backend computes labels from Nemotron scores.
+    """
+    raw_scores = parsed.get("scores", {})
+    scores: dict[str, Any] = {}
+    for dim in _REQUIRED_DIMS:
+        d = raw_scores.get(dim, {})
+        raw_score = d.get("score", 0)
+        score = _clamp(int(round(float(raw_score))), 0, 100)
+        scores[dim] = {
+            "score": score,
+            "label": _score_label(score),
+            "reason": str(d.get("reason", "")).strip()[:280] or f"Score: {score}",
+            "quote": str(d.get("quote", "")).strip()[:160],
+            "signals_used": [str(s) for s in d.get("signals_used", [])][:5],
+        }
+    best_answer = str(parsed.get("best_answer", "")).strip()[:400]
+    weakest_answer = str(parsed.get("weakest_answer", "")).strip()[:400]
+    why_weak = str(parsed.get("why_weak", "")).strip()[:300]
+    return scores, best_answer, weakest_answer, why_weak
+
+
+def _call_nemotron_scoring(
+    session: dict,
+    signals: dict,
+    local_reference: dict | None,
+    difficulty_profile: str,
+    difficulty_label: str,
+    resolved_mode: str,
+) -> tuple[dict[str, Any], str, str, str] | None:
+    """Call Nemotron for dimension scores only (Call 1).
+
+    Returns (scores, best_answer, weakest_answer, why_weak) on success, or None on failure.
+    """
+    messages = _build_scoring_only_prompt(
+        session, signals, local_reference, difficulty_profile, difficulty_label
+    )
+    raw_content = ""
+    try:
+        result = model_router.generate_scoring_response(messages, model_mode=resolved_mode)
+        if result.get("ok") and result.get("content"):
+            raw_content = result["content"]
+        else:
+            logger.warning("scoring_engine: Nemotron scoring call not ok — %s", result.get("error"))
+            return None
+    except Exception as exc:
+        logger.warning("scoring_engine: Nemotron scoring raised — %s", exc)
+        return None
+
+    parsed, extraction_used = parse_model_json(raw_content)
+    if not isinstance(parsed, dict) or not parsed:
+        parsed = safe_json_parse(raw_content)
+        extraction_used = True
+
+    if isinstance(parsed, dict) and parsed:
+        parsed = _normalize_scoring_json(parsed)
+        if _validate_scoring_json(parsed):
+            logger.info(
+                "scoring_engine: Nemotron scoring JSON parsed OK (content_len=%d extraction=%s preview=%r)",
+                len(raw_content),
+                extraction_used,
+                sanitize_for_log(raw_content),
+            )
+            return _normalize_scoring_result(parsed)
+
+    # Repair attempt
+    logger.warning(
+        "scoring_engine: Nemotron scoring parse failed, attempting repair "
+        "(content_len=%d preview=%r)",
+        len(raw_content),
+        sanitize_for_log(raw_content),
+    )
+    try:
+        repair = model_router.generate_scoring_repair_response(raw_content, model_mode=resolved_mode)
+        if repair.get("ok") and repair.get("content"):
+            repaired, _ = parse_model_json(repair["content"])
+            if not isinstance(repaired, dict) or not repaired:
+                repaired = safe_json_parse(repair["content"])
+            if isinstance(repaired, dict) and repaired:
+                repaired = _normalize_scoring_json(repaired)
+            if isinstance(repaired, dict) and repaired and _validate_scoring_json(repaired):
+                logger.info("scoring_engine: repaired scoring JSON OK")
+                return _normalize_scoring_result(repaired)
+    except Exception as exc:
+        logger.warning("scoring_engine: scoring repair raised — %s", exc)
+
+    logger.warning("scoring_engine: Nemotron scoring failed — will fall back to local scores")
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Main scorecard generator — Nemotron full scoring primary (Phase 8)
 # ---------------------------------------------------------------------------
 
 def generate_claim_based_scorecard(
     session: dict, model_mode: str | None = None
 ) -> dict[str, Any]:
-    """Hybrid claim-based scorecard.
+    """Main scorecard generator — split Nemotron calls for reliability.
+
+    Call 1 (scorecard_scoring): Nemotron judges all 6 dims from actual Q&A.
+    Call 2 (scorecard_coaching): Nemotron generates coaching text + score_explanation.
 
-    Local scoring → deterministic, signal-based, always fair to student founders.
-    Nemotron coaching → generates improved_answer, improved_pitch, top_3_questions only.
+    scorecard_source = "nemotron_full"   when Call 1 succeeds (regardless of Call 2).
+    scorecard_source = "hybrid_claims_*" when Call 1 fails (fallback only).
 
     Returns a frontend-safe dict with all required fields on every path.
     """
     resolved_mode = model_mode or session.get("model_mode") or os.getenv(
         "DEFAULT_MODEL_MODE", "premium_nvidia"
     )
+    difficulty_profile = normalize_difficulty(
+        session.get("difficulty_profile") or session.get("difficulty") or "practice"
+    )
+    difficulty_label = get_label(difficulty_profile)
+    cal = get_scoring_calibration(difficulty_profile)
     startup = session.get("startup", {})
 
-    # Step 1: Extract signals (local, no API)
+    # Step 1: Extract signals — always needed for context + fallback
     try:
         signals = extract_concrete_signals(session)
     except Exception as exc:
         logger.warning("scoring_engine: signal extraction failed: %s", exc)
         signals = _empty_signals()
 
-    # Step 2: Compute all 6 dimension scores + best/weakest answers locally
-    try:
-        scores, best_answer, weakest_answer, why_weak = _compute_local_scores(signals, startup)
-    except Exception as exc:
-        logger.warning("scoring_engine: local scoring failed: %s", exc)
-        return build_session_aware_fallback_scorecard(
-            session, signals, f"Local scoring error: {type(exc).__name__}"
-        )
+    engagement_info = _battle_engagement(signals)
+    startup_signals = extract_startup_context_signals(session)
+    has_startup = _has_startup_context(startup, startup_signals)
+    if engagement_info["substantive_answers"] == 0:
+        signals = _merge_signal_dicts(signals, startup_signals)
 
-    # Step 3: Compute overall and concrete_signals_summary locally
-    overall = round(sum(d["score"] for d in scores.values()) / len(scores))
     concrete_signals_summary = {
         "numbers":              signals.get("numbers", [])[:6],
         "validation":           signals.get("validation", [])[:6],
@@ -636,87 +1653,251 @@ def generate_claim_based_scorecard(
         "technical_mechanisms": signals.get("technical_mechanisms", [])[:6],
     }
 
-    # Step 4: Call Nemotron for coaching only
-    coaching: dict[str, Any] | None = None
-    coaching_error: str = ""
-    coaching_raw: str = ""
+    # Step 2: Compute local scores as reference context + fallback
+    local_reference: dict[str, Any] | None = None
+    local_scores: dict[str, Any] | None = None
+    local_best = ""
+    local_weakest = ""
+    local_why_weak = ""
+    try:
+        _ls, local_best, local_weakest, local_why_weak = _compute_local_scores(signals, startup, cal)
+        local_scores = _ls
+        local_reference = {"scores": local_scores, "best_answer": local_best, "weakest_answer": local_weakest}
+    except Exception as exc:
+        logger.warning("scoring_engine: local scoring failed: %s", exc)
 
+    # Step 3: Nemotron scoring call (Call 1) — skip when no substantive battle answers
+    nemotron_scoring_result = None
+    skip_nemotron_scoring = engagement_info["substantive_answers"] == 0
+    if skip_nemotron_scoring:
+        logger.info(
+            "scoring_engine: skipping Nemotron scoring — no substantive battle answers "
+            "(user_turns=%d substantive=%d has_startup=%s)",
+            engagement_info["user_turns"],
+            engagement_info["substantive_answers"],
+            has_startup,
+        )
+    elif resolved_mode == "premium_nvidia":
+        nemotron_scoring_result = _call_nemotron_scoring(
+            session, signals, local_reference,
+            difficulty_profile, difficulty_label, resolved_mode,
+        )
+
+    if nemotron_scoring_result is not None:
+        # Call 1 succeeded — scorecard_source is always "nemotron_full" from here
+        scores, best_answer, weakest_answer, why_weak = nemotron_scoring_result
+
+        # Practice fairness: lift any dimension up to its signal-justified local floor
+        # so a short, genuine student answer is not dragged down by a prose-biased judge.
+        scores = _apply_practice_signal_floor(scores, local_reference, difficulty_profile)
+
+        # Resolve round refs (R2, R4) to actual founder answer text
+        best_answer, weakest_answer, best_round, weakest_round = _resolve_best_weakest_answers(
+            session, best_answer, weakest_answer, local_best, local_weakest,
+        )
+        if not why_weak and local_why_weak:
+            why_weak = local_why_weak
+
+        overall = round(sum(d["score"] for d in scores.values()) / len(scores))
+        overall = _apply_practice_score_nudge(overall, signals, difficulty_profile)
+
+        # Step 4: Nemotron coaching call
+        local_coaching = _local_coaching(weakest_answer, startup, signals, scores)
+        coaching_raw = ""
+        try:
+            coaching_messages = _build_coaching_prompt(
+                session, signals, scores, best_answer, weakest_answer, why_weak,
+                difficulty_profile=difficulty_profile,
+            )
+            coaching_result = model_router.generate_coaching_response(
+                coaching_messages, model_mode=resolved_mode
+            )
+            if coaching_result.get("ok") and coaching_result.get("content"):
+                coaching_raw = coaching_result["content"]
+            else:
+                logger.warning("scoring_engine: coaching call not ok — %s", coaching_result.get("error"))
+        except Exception as exc:
+            logger.warning("scoring_engine: coaching call raised — %s", exc)
+
+        coaching, coaching_source = _resolve_coaching_from_raw(
+            coaching_raw, local_coaching, resolved_mode
+        )
+
+        # Step 5: score_explanation — merge Nemotron coaching with local fallback (no truncated fields)
+        try:
+            local_score_explanation = _build_score_explanation(
+                overall, scores, weakest_answer, why_weak, signals, session, difficulty_profile
+            )
+        except Exception as exc:
+            logger.warning("scoring_engine: score_explanation build failed: %s", exc)
+            local_score_explanation = {
+                "why_you_scored_this": f"Your overall score is {overall}/100.",
+                "what_stopped_80": "Focus on your weakest dimension to improve.",
+                "answer_to_retry": {
+                    "round": None, "attack_tag": "", "dimension": "",
+                    "original_answer": weakest_answer[:200], "why_it_hurt": why_weak,
+                    "retry_advice": "", "sample_stronger_answer": "",
+                },
+                "estimated_score_if_fixed": {
+                    "current_overall": overall,
+                    "estimated_new_overall": min(overall + 10, 82),
+                    "reason": "Fixing your weakest answer could raise your overall score.",
+                },
+            }
+        se_raw = coaching.get("score_explanation") if isinstance(coaching.get("score_explanation"), dict) else None
+        score_explanation = _resolve_score_explanation(se_raw, local_score_explanation, overall)
+
+        q3 = coaching.get("top_3_questions", [])
+        while len(q3) < 3:
+            q3.append("What concrete evidence can you give to support your strongest claim?")
+
+        logger.info(
+            "scoring_engine: nemotron_full complete — overall=%d signals=%d",
+            overall, signals.get("signal_count", 0),
+        )
+        result = {
+            "overall": overall,
+            "overall_label": _score_label(overall),
+            "scores": scores,
+            "best_answer": best_answer,
+            "weakest_answer": weakest_answer,
+            "best_answer_round": best_round,
+            "weakest_answer_round": weakest_round,
+            "why_weak": why_weak,
+            "improved_answer": coaching.get("improved_answer", ""),
+            "improved_pitch": coaching.get("improved_pitch", ""),
+            "top_3_questions": q3[:3],
+            "concrete_signals_summary": concrete_signals_summary,
+            "score_explanation": score_explanation,
+            "model_ok": True,
+            "provider": "nvidia",
+            "model_mode": resolved_mode,
+            "scorecard_source": "nemotron_full",
+            "coaching_source": coaching_source,
+            "difficulty_profile": difficulty_profile,
+            "difficulty_label": difficulty_label,
+        }
+        result = _sync_overall_to_dimensions(result)
+        result["overall"] = _apply_practice_score_nudge(
+            int(result["overall"]), signals, difficulty_profile
+        )
+        result["overall_label"] = _score_label(result["overall"])
+        return result
+
+    # Step 6: Local claim-based path (Nemotron skipped or failed)
+    if skip_nemotron_scoring:
+        logger.info("scoring_engine: building local scorecard for zero-engagement battle")
+    else:
+        logger.warning("scoring_engine: Nemotron scoring failed; using claim-based fallback")
+
+    if local_scores is None:
+        return build_session_aware_fallback_scorecard(
+            session, signals, "All scoring paths failed"
+        )
+
+    scores = local_scores
+    best_answer, weakest_answer, best_round, weakest_round = _resolve_best_weakest_answers(
+        session, local_best, local_weakest, local_best, local_weakest,
+    )
+    why_weak = local_why_weak
+    overall = round(sum(d["score"] for d in scores.values()) / len(scores))
+    overall = _apply_practice_score_nudge(overall, signals, difficulty_profile)
+
+    coaching = None
+    coaching_raw = ""
+    local_coaching = _local_coaching(weakest_answer, startup, signals, scores)
     try:
         coaching_messages = _build_coaching_prompt(
-            session, signals, scores, best_answer, weakest_answer, why_weak
+            session, signals, scores, best_answer, weakest_answer, why_weak,
+            difficulty_profile=difficulty_profile,
         )
         coaching_result = model_router.generate_coaching_response(
             coaching_messages, model_mode=resolved_mode
         )
         if coaching_result.get("ok") and coaching_result.get("content"):
             coaching_raw = coaching_result["content"]
-            coaching = _parse_coaching_json(coaching_raw)
-            if coaching:
-                logger.info("scoring_engine: Nemotron coaching JSON parsed OK")
-            else:
-                logger.warning("scoring_engine: primary coaching parse failed, raw[:200]=%r", coaching_raw[:200])
-        else:
-            coaching_error = coaching_result.get("error") or "Coaching model returned empty response"
-            logger.warning("scoring_engine: coaching call not ok — %s", coaching_error)
     except Exception as exc:
-        coaching_error = f"Coaching error: {type(exc).__name__}"
-        logger.warning("scoring_engine: coaching call raised — %s", exc)
+        logger.warning("scoring_engine: fallback coaching raised — %s", exc)
 
-    # Step 5: Repair retry if JSON parse failed (content was returned but not valid JSON)
-    if coaching is None and coaching_raw:
-        logger.info("scoring_engine: attempting coaching JSON repair")
-        try:
-            repair_result = model_router.generate_coaching_repair_response(
-                coaching_raw, model_mode=resolved_mode
-            )
-            if repair_result.get("ok") and repair_result.get("content"):
-                coaching = _parse_coaching_json(repair_result["content"])
-                if coaching:
-                    logger.info("scoring_engine: repaired coaching JSON OK")
-                else:
-                    logger.warning("scoring_engine: repair coaching parse also failed")
-        except Exception as exc:
-            logger.warning("scoring_engine: coaching repair raised — %s", exc)
+    coaching, coaching_source = _resolve_coaching_from_raw(
+        coaching_raw, local_coaching, resolved_mode
+    )
 
-    # Step 6: Local coaching fallback if Nemotron failed
-    if coaching is None:
-        logger.warning(
-            "scoring_engine: using local coaching fallback. error=%r", coaching_error
-        )
-        coaching = _local_coaching(weakest_answer, startup, signals, scores)
+    if skip_nemotron_scoring:
+        if has_startup or signals.get("signal_count", 0) > 0:
+            source = "startup_context_only"
+        else:
+            source = "no_battle_response"
+        provider = "local+nvidia" if coaching_source != "local" else "local"
+    elif coaching_source == "local":
         source = "hybrid_claims_local"
-        model_ok = False
         provider = "local"
     else:
         source = "hybrid_claims_nemotron"
-        model_ok = True
         provider = "local+nvidia"
 
-    # Step 7: Assemble and return complete scorecard
-    result: dict[str, Any] = {
+    try:
+        score_explanation = _build_score_explanation(
+            overall, scores, weakest_answer, why_weak, signals, session, difficulty_profile
+        )
+    except Exception:
+        score_explanation = {
+            "why_you_scored_this": f"Your overall score is {overall}/100.",
+            "what_stopped_80": "Focus on your weakest dimension to improve.",
+            "answer_to_retry": {
+                "round": None, "attack_tag": "", "dimension": "",
+                "original_answer": weakest_answer[:200], "why_it_hurt": why_weak,
+                "retry_advice": "", "sample_stronger_answer": "",
+            },
+            "estimated_score_if_fixed": {
+                "current_overall": overall,
+                "estimated_new_overall": min(overall + 10, 82),
+                "reason": "Fixing your weakest answer could raise your overall score.",
+            },
+        }
+
+    se_raw = coaching.get("score_explanation") if isinstance(coaching.get("score_explanation"), dict) else None
+    score_explanation = _resolve_score_explanation(se_raw, score_explanation, overall)
+
+    q3 = coaching.get("top_3_questions", [])
+    while len(q3) < 3:
+        q3.append("What concrete evidence can you give to support your strongest claim?")
+
+    logger.info(
+        "scoring_engine: fallback scorecard complete — overall=%d source=%s",
+        overall, source,
+    )
+    return {
         "overall": overall,
         "overall_label": _score_label(overall),
         "scores": scores,
         "best_answer": best_answer,
         "weakest_answer": weakest_answer,
+        "best_answer_round": best_round,
+        "weakest_answer_round": weakest_round,
         "why_weak": why_weak,
-        "improved_answer": coaching["improved_answer"],
-        "improved_pitch": coaching["improved_pitch"],
-        "top_3_questions": coaching["top_3_questions"],
+        "improved_answer": coaching.get("improved_answer", ""),
+        "improved_pitch": coaching.get("improved_pitch", ""),
+        "top_3_questions": q3[:3],
         "concrete_signals_summary": concrete_signals_summary,
-        "model_ok": model_ok,
+        "score_explanation": score_explanation,
+        "model_ok": False,
         "provider": provider,
         "model_mode": resolved_mode,
         "scorecard_source": source,
+        "coaching_source": coaching_source,
+        "difficulty_profile": difficulty_profile,
+        "difficulty_label": difficulty_label,
+        "model_error": (
+            "No battle answers were submitted."
+            if skip_nemotron_scoring and not has_startup and signals.get("signal_count", 0) == 0
+            else (
+                "Scored from startup description only — complete the battle to earn full points."
+                if skip_nemotron_scoring
+                else "Nemotron scoring failed; used local scoring fallback."
+            )
+        ),
     }
-    if coaching_error and not model_ok:
-        result["model_error"] = coaching_error
-
-    logger.info(
-        "scoring_engine: hybrid scorecard complete — overall=%d source=%s signals=%d",
-        overall, source, signals.get("signal_count", 0),
-    )
-    return result
 
 
 # ---------------------------------------------------------------------------
@@ -825,6 +2006,28 @@ def build_session_aware_fallback_scorecard(
 
     overall = round(sum(d["score"] for d in scores.values()) / 6)
     dim_sorted = sorted(scores.items(), key=lambda x: x[1]["score"])
+    fallback_why_weak = "This answer lacked concrete evidence compared to your stronger responses."
+
+    try:
+        fb_explanation = _build_score_explanation(
+            overall, scores, weakest_answer, fallback_why_weak, signals, session, "practice"
+        )
+    except Exception:
+        fb_explanation = {
+            "why_you_scored_this": f"Your overall score is {overall}/100.",
+            "what_stopped_80": "Focus on your weakest dimension to improve.",
+            "answer_to_retry": {
+                "round": None, "attack_tag": "", "dimension": "",
+                "original_answer": weakest_answer[:200],
+                "why_it_hurt": fallback_why_weak, "retry_advice": "",
+                "sample_stronger_answer": "",
+            },
+            "estimated_score_if_fixed": {
+                "current_overall": overall,
+                "estimated_new_overall": min(overall + 10, 82),
+                "reason": "Fixing your weakest answer could raise your overall score.",
+            },
+        }
 
     return {
         "overall": overall,
@@ -832,7 +2035,7 @@ def build_session_aware_fallback_scorecard(
         "scores": scores,
         "best_answer": best_answer,
         "weakest_answer": weakest_answer,
-        "why_weak": "This answer lacked concrete evidence compared to your stronger responses.",
+        "why_weak": fallback_why_weak,
         "improved_answer": _local_improved_answer(weakest_answer, startup, signals),
         "improved_pitch": _local_improved_pitch(startup, signals),
         "top_3_questions": _fallback_questions(dim_sorted, startup),
@@ -843,6 +2046,7 @@ def build_session_aware_fallback_scorecard(
             "revenue_signals":      signals.get("revenue_signals", [])[:6],
             "technical_mechanisms": signals.get("technical_mechanisms", [])[:6],
         },
+        "score_explanation": fb_explanation,
         "model_ok": False,
         "provider": "local",
         "model_mode": "session_fallback",

core/session_manager.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 import uuid
 from typing import Any
 
@@ -24,6 +25,9 @@ def create_session(
         "input_mode": input_mode,
         "round": 1,
         "history": [],
+        "voice_pitch": None,
+        "pending_voice_turns": {},
+        "confirmed_voice_turns": [],
     }
     SESSIONS[session_id] = session
     return session
@@ -75,3 +79,51 @@ def reset_session(session_id: str) -> bool:
         del SESSIONS[session_id]
         return True
     return False
+
+
+def set_voice_pitch(session_id: str, voice_pitch: dict[str, Any]) -> None:
+    """Store opening voice pitch metadata on session."""
+    session = SESSIONS.get(session_id)
+    if session:
+        session["voice_pitch"] = voice_pitch
+
+
+def store_pending_voice_turn(session_id: str, turn_record: dict[str, Any]) -> None:
+    """Store a pending (unconfirmed) voice turn."""
+    session = SESSIONS.get(session_id)
+    if not session:
+        return
+    pending = session.setdefault("pending_voice_turns", {})
+    vid = turn_record.get("voice_turn_id", "")
+    if vid:
+        pending[vid] = turn_record
+
+
+def confirm_voice_turn(
+    session_id: str,
+    voice_turn_id: str,
+    final_transcript: str,
+) -> bool:
+    """Confirm a pending voice turn and move it to confirmed_voice_turns."""
+    session = SESSIONS.get(session_id)
+    if not session:
+        return False
+    pending = session.get("pending_voice_turns") or {}
+    turn = pending.get(voice_turn_id)
+    if not turn:
+        return False
+    turn = dict(turn)
+    turn["transcript"] = str(final_transcript).strip()
+    turn["confirmed"] = True
+    turn["word_count"] = len(re.findall(r"\b\w+\b", turn["transcript"]))
+    session.setdefault("confirmed_voice_turns", []).append(turn)
+    del pending[voice_turn_id]
+    return True
+
+
+def get_pending_voice_turn(session_id: str, voice_turn_id: str) -> dict[str, Any] | None:
+    """Return a pending voice turn by id."""
+    session = SESSIONS.get(session_id)
+    if not session:
+        return None
+    return (session.get("pending_voice_turns") or {}).get(voice_turn_id)

core/session_repository.py

@@ -0,0 +1,678 @@
+"""
+MongoDB session repository for PitchFight AI.
+
+Phase 9.5 rules:
+- MongoDB is optional background persistence only.
+- In-memory session_manager remains the live source of truth.
+- Every repository operation is best-effort.
+- MongoDB failure must never crash API handlers.
+- Never store API keys, raw audio/base64, uploaded files, or model reasoning_content.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Callable, Optional
+
+from pymongo.collection import Collection
+from pymongo.errors import PyMongoError
+
+from core.db import get_sessions_collection, is_mongodb_enabled
+
+
+SENSITIVE_KEYS = {
+    "api_key",
+    "apikey",
+    "nvidia_api_key",
+    "openai_api_key",
+    "secret",
+    "password",
+    "mongodb_uri",
+    "mongo_uri",
+    "uri",
+    "audio",
+    "audio_base64",
+    "raw_audio",
+    "base64_audio",
+    "uploaded_file",
+    "uploaded_files",
+    "file_bytes",
+    "raw_file",
+    "reasoning_content",
+}
+
+MAX_STRING_LENGTH = 12000
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _safe(operation_name: str, fn: Callable[[], Any]) -> Any:
+    """
+    Execute a MongoDB operation safely.
+
+    Never raise persistence errors into app/runtime flow.
+    """
+    if not is_mongodb_enabled():
+        return None
+
+    try:
+        return fn()
+    except (PyMongoError, Exception) as exc:
+        print(
+            "[MongoDB] Non-critical persistence warning "
+            f"in {operation_name}: {type(exc).__name__}"
+        )
+        return None
+
+
+def _get_collection() -> Optional[Collection]:
+    return get_sessions_collection()
+
+
+def _sanitize(value: Any) -> Any:
+    """
+    Recursively sanitize values before MongoDB storage.
+
+    Removes secrets, raw audio/base64 payloads, raw files, and model reasoning traces.
+    Converts unknown objects to strings.
+    """
+    if isinstance(value, dict):
+        cleaned: dict[str, Any] = {}
+
+        for key, item in value.items():
+            key_str = str(key)
+            key_lower = key_str.lower()
+
+            if key_lower in SENSITIVE_KEYS:
+                continue
+
+            cleaned[key_str] = _sanitize(item)
+
+        return cleaned
+
+    if isinstance(value, list):
+        return [_sanitize(item) for item in value]
+
+    if isinstance(value, tuple):
+        return [_sanitize(item) for item in value]
+
+    if isinstance(value, str):
+        if len(value) > MAX_STRING_LENGTH:
+            return value[:MAX_STRING_LENGTH] + "...[truncated]"
+        return value
+
+    if isinstance(value, (int, float, bool)) or value is None:
+        return value
+
+    return str(value)
+
+
+def _startup_context_from_session(session: dict) -> dict:
+    startup = session.get("startup") or {}
+
+    context = {
+        "name": startup.get("name", ""),
+        "problem": startup.get("problem", ""),
+        "target_users": startup.get("target_users", ""),
+        "solution": startup.get("solution", ""),
+        "why_ai": startup.get("why_ai", ""),
+        "traction": startup.get("traction", ""),
+        "competitors": startup.get("competitors", ""),
+        "ask": startup.get("ask", ""),
+        "entry_mode": "voice_pitch" if session.get("voice_pitch") else "form",
+    }
+
+    # Preserve useful extra startup fields without storing secrets/raw payloads.
+    extra = {
+        key: value
+        for key, value in startup.items()
+        if key not in context
+    }
+
+    if extra:
+        context["extra"] = _sanitize(extra)
+
+    return _sanitize(context)
+
+
+def _voice_pitch_entry_from_session(session: dict) -> dict:
+    voice_pitch = session.get("voice_pitch") or {}
+
+    if not voice_pitch:
+        return {
+            "used": False,
+            "transcript": "",
+            "delivery_observations": {
+                "filler_words": [],
+                "filler_word_count": 0,
+                "pace": "",
+                "clarity": "",
+                "confidence_signal": "",
+                "word_count": 0,
+                "delivery_note": "",
+            },
+            "extraction_confidence": "",
+        }
+
+    transcript = voice_pitch.get("transcript", "") or ""
+    observations = voice_pitch.get("delivery_observations") or {}
+
+    filler_words = observations.get("filler_words") or []
+    if not isinstance(filler_words, list):
+        filler_words = [str(filler_words)]
+
+    delivery_observations = {
+        "filler_words": filler_words,
+        "filler_word_count": len(filler_words),
+        "pace": observations.get("pace", ""),
+        "clarity": observations.get("clarity", ""),
+        "confidence_signal": observations.get("confidence_signal", ""),
+        "word_count": len(transcript.split()) if transcript else 0,
+        "delivery_note": observations.get("delivery_note", ""),
+    }
+
+    return _sanitize(
+        {
+            "used": True,
+            "transcript": transcript,
+            "delivery_observations": delivery_observations,
+            "extraction_confidence": voice_pitch.get("extraction_confidence", ""),
+        }
+    )
+
+
+def _rounds_from_history(history: Any) -> list[dict]:
+    if not isinstance(history, list):
+        return []
+
+    rounds: list[dict] = []
+
+    for index, item in enumerate(history):
+        if not isinstance(item, dict):
+            continue
+
+        rounds.append(
+            _sanitize(
+                {
+                    "sequence": index + 1,
+                    "round_number": item.get("round") or item.get("round_number") or None,
+                    "role": item.get("role", ""),
+                    "content": item.get("content", ""),
+                    "attack_tag": item.get("attack_tag", ""),
+                    "answer_quality": item.get("answer_quality", ""),
+                    "timestamp": item.get("timestamp", ""),
+                }
+            )
+        )
+
+    return rounds
+
+
+def _retry_drills_from_session(session: dict) -> list[dict]:
+    retry_drills = session.get("retry_drills") or {}
+
+    if isinstance(retry_drills, dict):
+        drills = list(retry_drills.values())
+    elif isinstance(retry_drills, list):
+        drills = retry_drills
+    else:
+        drills = []
+
+    cleaned_drills = []
+
+    for drill in drills:
+        if not isinstance(drill, dict):
+            continue
+
+        cleaned_drill = dict(drill)
+        cleaned_drill.pop("voice_turn_id", None)
+        cleaned_drills.append(_sanitize(cleaned_drill))
+
+    return cleaned_drills
+
+
+def _scorecard_for_storage(scorecard: dict) -> dict:
+    if not isinstance(scorecard, dict):
+        return {}
+
+    cleaned = dict(scorecard)
+
+    # Store judge verdict separately to avoid duplicated nested state.
+    cleaned.pop("judge_verdict", None)
+
+    return _sanitize(cleaned)
+
+
+def _deal_phase_from_session(session: dict) -> dict:
+    return _sanitize(
+        {
+            "activated": bool(session.get("deal_phase_active", False)),
+            "deal_phase_id": session.get("deal_phase_id", ""),
+            "deal_type": session.get("deal_type", ""),
+            "deal_context": session.get("deal_context", {}) or {},
+            "deal_round": session.get("deal_round", 0) or 0,
+            "deal_history": session.get("deal_history", []) or [],
+            "deal_scorecard": session.get("deal_scorecard", {}) or {},
+            "combined_scorecard": session.get("combined_scorecard", {}) or {},
+        }
+    )
+
+
+def _infer_status(session: dict) -> str:
+    if session.get("combined_scorecard") or session.get("deal_scorecard"):
+        return "completed"
+
+    if session.get("latest_scorecard") and not session.get("deal_phase_active"):
+        return "completed"
+
+    return "active"
+
+
+def _session_document(session: dict) -> dict:
+    session_id = session.get("session_id")
+
+    return _sanitize(
+        {
+            "_id": session_id,
+            "meta": {
+                "created_at": _utc_now(),
+                "updated_at": _utc_now(),
+                "status": _infer_status(session),
+                "mode": session.get("mode", "pitch_battle"),
+                "input_mode": session.get("input_mode", "text"),
+            },
+            "config": {
+                "opponent": session.get("persona", ""),
+                "persona": session.get("persona", ""),
+                "model_mode": session.get("model_mode", ""),
+                "difficulty_profile": session.get("difficulty_profile")
+                or session.get("difficulty")
+                or "",
+                "difficulty_label": session.get("difficulty_label", ""),
+            },
+            "startup_context": _startup_context_from_session(session),
+            "voice_pitch_entry": _voice_pitch_entry_from_session(session),
+            "rounds": _rounds_from_history(session.get("history", [])),
+            "battle_summary": {
+                "total_rounds": session.get("round", 0),
+                "final_round": session.get("round", 0),
+            },
+            "scorecard": _scorecard_for_storage(session.get("latest_scorecard", {}) or {}),
+            "retry_drills": _retry_drills_from_session(session),
+            "judge_verdict": _sanitize(session.get("judge_verdict", {}) or {}),
+            "deal_phase": _deal_phase_from_session(session),
+        }
+    )
+
+
+def _set_with_touch(
+    collection: Collection,
+    session_id: str,
+    fields: dict,
+    *,
+    status: Optional[str] = None,
+) -> None:
+    now = _utc_now()
+
+    set_fields = _sanitize(fields)
+    set_fields["meta.updated_at"] = now
+
+    if status:
+        set_fields["meta.status"] = status
+
+    collection.update_one(
+        {"_id": session_id},
+        {
+            "$setOnInsert": {
+                "_id": session_id,
+                "meta.created_at": now,
+            },
+            "$set": set_fields,
+        },
+        upsert=True,
+    )
+
+
+def save_session(session: dict) -> Any:
+    """
+    Save/initialize one PitchFight session document.
+
+    Called after /api/start-session succeeds.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None:
+            return None
+
+        doc = _session_document(session)
+        session_id = doc.get("_id")
+
+        if not session_id:
+            print("[MongoDB] save_session skipped: missing session_id.")
+            return None
+
+        meta = doc.pop("meta", {}) or {}
+        doc_without_id = {key: value for key, value in doc.items() if key != "_id"}
+
+        set_fields = dict(doc_without_id)
+        set_fields["meta.updated_at"] = _utc_now()
+        set_fields["meta.status"] = meta.get("status", "active")
+        set_fields["meta.mode"] = meta.get("mode", "pitch_battle")
+        set_fields["meta.input_mode"] = meta.get("input_mode", "text")
+
+        return collection.update_one(
+            {"_id": session_id},
+            {
+                "$setOnInsert": {
+                    "_id": session_id,
+                    "meta.created_at": meta.get("created_at", _utc_now()),
+                },
+                "$set": set_fields,
+            },
+            upsert=True,
+        )
+
+    return _safe("save_session", op)
+
+
+def update_round(session_id: str, round_data: Any) -> Any:
+    """
+    Append one or more battle round/history entries.
+
+    Called after /api/chat-round succeeds.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        if isinstance(round_data, list):
+            entries = [_sanitize(item) for item in round_data if isinstance(item, dict)]
+        elif isinstance(round_data, dict):
+            entries = [_sanitize(round_data)]
+        else:
+            entries = []
+
+        if not entries:
+            return None
+
+        now = _utc_now()
+
+        return collection.update_one(
+            {"_id": session_id},
+            {
+                "$setOnInsert": {
+                    "_id": session_id,
+                    "meta.created_at": now,
+                    "meta.status": "active",
+                },
+                "$set": {
+                    "meta.updated_at": now,
+                },
+                "$push": {
+                    "rounds": {
+                        "$each": entries,
+                    }
+                },
+            },
+            upsert=True,
+        )
+
+    return _safe("update_round", op)
+
+
+def update_battle_summary(session_id: str, summary: dict) -> Any:
+    """
+    Save final pitch battle summary.
+
+    Called after /api/end-battle.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        return _set_with_touch(
+            collection,
+            session_id,
+            {
+                "battle_summary": _sanitize(summary or {}),
+            },
+        )
+
+    return _safe("update_battle_summary", op)
+
+
+def save_scorecard(session_id: str, scorecard: dict) -> Any:
+    """
+    Save latest pitch scorecard.
+
+    Called after scorecard generation succeeds.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        return _set_with_touch(
+            collection,
+            session_id,
+            {
+                "scorecard": _scorecard_for_storage(scorecard or {}),
+            },
+        )
+
+    return _safe("save_scorecard", op)
+
+
+def save_retry_drill(session_id: str, drill: dict) -> Any:
+    """
+    Save or replace one retry drill in retry_drills array.
+
+    Called after retry weakest question start/submit succeeds.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id or not isinstance(drill, dict):
+            return None
+
+        cleaned_drill = dict(drill)
+        cleaned_drill.pop("voice_turn_id", None)
+        cleaned_drill = _sanitize(cleaned_drill)
+
+        retry_id = cleaned_drill.get("retry_id")
+        now = _utc_now()
+
+        if retry_id:
+            collection.update_one(
+                {"_id": session_id},
+                {
+                    "$pull": {
+                        "retry_drills": {
+                            "retry_id": retry_id,
+                        }
+                    },
+                    "$set": {
+                        "meta.updated_at": now,
+                    },
+                },
+                upsert=False,
+            )
+
+        return collection.update_one(
+            {"_id": session_id},
+            {
+                "$setOnInsert": {
+                    "_id": session_id,
+                    "meta.created_at": now,
+                    "meta.status": "active",
+                },
+                "$set": {
+                    "meta.updated_at": now,
+                },
+                "$push": {
+                    "retry_drills": cleaned_drill,
+                },
+            },
+            upsert=True,
+        )
+
+    return _safe("save_retry_drill", op)
+
+
+def save_judge_verdict(session_id: str, verdict: dict) -> Any:
+    """
+    Save judge verdict separately from scorecard.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        return _set_with_touch(
+            collection,
+            session_id,
+            {
+                "judge_verdict": _sanitize(verdict or {}),
+            },
+        )
+
+    return _safe("save_judge_verdict", op)
+
+
+def update_deal_round(session_id: str, deal_round: Any) -> Any:
+    """
+    Append one or more deal-phase history entries.
+
+    Called after /api/start-deal-phase and /api/deal-round.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        if isinstance(deal_round, list):
+            entries = [_sanitize(item) for item in deal_round if isinstance(item, dict)]
+        elif isinstance(deal_round, dict):
+            entries = [_sanitize(deal_round)]
+        else:
+            entries = []
+
+        if not entries:
+            return None
+
+        now = _utc_now()
+
+        return collection.update_one(
+            {"_id": session_id},
+            {
+                "$setOnInsert": {
+                    "_id": session_id,
+                    "meta.created_at": now,
+                },
+                "$set": {
+                    "meta.updated_at": now,
+                    "meta.status": "active",
+                    "deal_phase.activated": True,
+                },
+                "$push": {
+                    "deal_phase.deal_history": {
+                        "$each": entries,
+                    }
+                },
+            },
+            upsert=True,
+        )
+
+    return _safe("update_deal_round", op)
+
+
+def save_deal_scorecard(
+    session_id: str,
+    deal_scorecard: dict,
+    combined_scorecard: dict,
+) -> Any:
+    """
+    Save final deal scorecard and combined pitch + deal scorecard.
+
+    Called after /api/end-deal succeeds.
+    """
+    def op() -> Any:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        return _set_with_touch(
+            collection,
+            session_id,
+            {
+                "deal_phase.activated": False,
+                "deal_phase.deal_scorecard": _sanitize(deal_scorecard or {}),
+                "deal_phase.combined_scorecard": _sanitize(combined_scorecard or {}),
+            },
+            status="completed",
+        )
+
+    return _safe("save_deal_scorecard", op)
+
+
+def get_session(session_id: str) -> Optional[dict]:
+    """
+    Optional read helper.
+    """
+    def op() -> Optional[dict]:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        return collection.find_one({"_id": session_id})
+
+    return _safe("get_session", op)
+
+
+def get_recent_sessions(limit: int = 10) -> list[dict]:
+    """
+    Optional read helper for debugging/history screens later.
+    """
+    def op() -> list[dict]:
+        collection = _get_collection()
+        if collection is None:
+            return []
+
+        safe_limit = max(1, min(int(limit), 50))
+
+        return list(
+            collection.find({})
+            .sort("meta.created_at", -1)
+            .limit(safe_limit)
+        )
+
+    result = _safe("get_recent_sessions", op)
+    return result or []
+
+
+def get_session_scorecard(session_id: str) -> Optional[dict]:
+    """
+    Optional read helper.
+    """
+    def op() -> Optional[dict]:
+        collection = _get_collection()
+        if collection is None or not session_id:
+            return None
+
+        doc = collection.find_one(
+            {"_id": session_id},
+            {
+                "_id": 1,
+                "scorecard": 1,
+                "judge_verdict": 1,
+                "deal_phase.deal_scorecard": 1,
+                "deal_phase.combined_scorecard": 1,
+            },
+        )
+
+        return doc
+
+    return _safe("get_session_scorecard", op)

core/voice_handler.py

@@ -0,0 +1,679 @@
+"""Voice input layer for PitchFight AI — Phase 7.
+
+Converts spoken audio to confirmed text + delivery cues via Nemotron Omni API.
+Does not replace the battle engine — only produces transcripts for existing flows.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import logging
+import re
+import shutil
+import subprocess
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Any
+
+from core import nvidia_client
+from core import session_manager
+from core.json_utils import parse_model_json, safe_json_parse
+from core.nvidia_client import OmniAudioError
+
+logger = logging.getLogger(__name__)
+
+_FILLER_PATTERNS = [
+    r"\bum\b", r"\buh\b", r"\buhm\b", r"\ber\b", r"\bah\b",
+    r"\blike\b", r"\byou know\b", r"\bkind of\b", r"\bsort of\b",
+    r"\bbasically\b", r"\bliterally\b", r"\bactually\b", r"\bso+\b",
+    r"\bi mean\b", r"\bwell\b",
+]
+
+_VOICE_PITCH_PROMPT = """The founder just recorded an opening startup pitch.
+
+Listen to the audio carefully and extract only what was actually said.
+
+Return ONLY valid JSON.
+First character must be {.
+Last character must be }.
+No markdown.
+No explanation.
+No reasoning.
+Do not hallucinate.
+Do not invent traction, users, revenue, competitors, or market data.
+If a field was not mentioned, return an empty string.
+
+Do NOT claim emotion, stress, anxiety, or psychological state detection.
+Only report observable delivery cues such as filler words, pauses, pacing, repetition, self-corrections, and clarity.
+
+Required JSON:
+
+{
+"transcript": "exact words spoken",
+"extracted": {
+"name": "startup name or empty string",
+"problem": "problem described or empty string",
+"target_users": "who they are building for or empty string",
+"solution": "what the product does or empty string",
+"why_ai": "why AI is needed or empty string",
+"traction": "any validation/users/pilots mentioned or empty string",
+"competitors": "any competitors named or empty string",
+"ask": "what they are asking for or empty string"
+},
+"delivery_observations": {
+"filler_words": ["list of filler words heard"],
+"pace": "rushed / measured / slow / unclear",
+"clarity": "one sentence observation based only on delivery",
+"confidence_signal": "confident / mixed / hesitant / unclear based only on observable delivery cues",
+"delivery_note": "one concise sentence"
+},
+"extraction_confidence": "high / medium / low"
+}"""
+
+_VOICE_TURN_PROMPT = """Transcribe this spoken battle answer exactly as spoken.
+
+Return ONLY valid JSON.
+First character must be {.
+Last character must be }.
+No markdown.
+No explanation.
+No reasoning.
+Do not interpret or expand the answer.
+Do not add words not spoken.
+
+Do NOT claim emotion, stress, anxiety, or psychological state detection.
+Only report observable delivery cues such as filler words, pauses, pacing, repetition, self-corrections, and clarity.
+
+Required JSON:
+
+{
+"transcript": "exact words spoken",
+"delivery_note": "one concise sentence about observable delivery cues. If clean, say Clean delivery.",
+"word_count": 0,
+"delivery_cues": {
+"filler_words": [],
+"pace": "rushed / measured / slow / unclear",
+"clarity": "clear / mostly clear / unclear",
+"repetition": "low / medium / high",
+"self_corrections": 0,
+"confidence_signal": "confident delivery / mixed delivery / hesitant delivery / unclear"
+}
+}"""
+
+_EXTRACTED_FIELDS = (
+    "name", "problem", "target_users", "solution",
+    "why_ai", "traction", "competitors", "ask",
+)
+
+_WAV_RIFF = b"RIFF"
+_WEBM_MAGIC = b"\x1aE\xdf\xa3"
+_OGG_MAGIC = b"OggS"
+_MP3_ID3 = b"ID3"
+
+# Minimum decoded audio size to treat as a real recording. Anything smaller is an
+# empty/instant tap that NVIDIA Omni rejects with HTTP 400. ~1s of webm/opus is several KB.
+_MIN_AUDIO_BYTES = 1024
+_MP3_SYNC = b"\xff\xfb"
+
+
+def _detect_audio_magic(data: bytes) -> str:
+    if len(data) >= 4 and data[:4] == _WAV_RIFF:
+        return "wav"
+    if len(data) >= 4 and data[:4] == _WEBM_MAGIC:
+        return "webm"
+    if len(data) >= 4 and data[:4] == _OGG_MAGIC:
+        return "ogg"
+    if len(data) >= 3 and data[:3] == _MP3_ID3:
+        return "mp3"
+    if len(data) >= 2 and data[:2] == _MP3_SYNC:
+        return "mp3"
+    return "unknown"
+
+
+def _magic_hex(data: bytes, n: int = 8) -> str:
+    return data[:n].hex() if data else ""
+
+
+def _convert_audio_to_wav_ffmpeg(input_bytes: bytes, input_ext: str) -> bytes | None:
+    ffmpeg = shutil.which("ffmpeg")
+    if not ffmpeg:
+        return None
+    with tempfile.TemporaryDirectory() as tmp:
+        inp = Path(tmp) / f"input.{input_ext or 'webm'}"
+        out = Path(tmp) / "output.wav"
+        inp.write_bytes(input_bytes)
+        cmd = [
+            ffmpeg,
+            "-y",
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-i",
+            str(inp),
+            "-ar",
+            "16000",
+            "-ac",
+            "1",
+            "-c:a",
+            "pcm_s16le",
+            str(out),
+        ]
+        try:
+            result = subprocess.run(cmd, capture_output=True, timeout=45, check=False)
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            logger.warning("voice_handler: ffmpeg conversion failed — %s", exc)
+            return None
+        if result.returncode != 0 or not out.is_file():
+            stderr = (result.stderr or b"").decode("utf-8", errors="replace")[:200]
+            logger.warning("voice_handler: ffmpeg exit=%s stderr=%s", result.returncode, stderr)
+            return None
+        return out.read_bytes()
+
+
+def normalize_audio_for_omni(
+    audio_base64: str,
+    audio_format: str,
+    mode: str = "voice_extraction",
+) -> dict[str, Any]:
+    """Decode browser audio and normalize to WAV for NVIDIA Omni when needed."""
+    fmt = str(audio_format or "webm").strip().lower().lstrip(".")
+    if fmt not in {"webm", "wav", "mp3", "m4a", "ogg"}:
+        return {
+            "error": f"Unsupported audio_format: {fmt}",
+            "audio_format": fmt,
+            "mode": mode,
+        }
+
+    try:
+        raw = base64.b64decode(audio_base64.strip(), validate=True)
+    except (binascii.Error, ValueError) as exc:
+        return {
+            "error": "Invalid base64 audio payload",
+            "detail": str(exc),
+            "audio_format": fmt,
+            "mode": mode,
+        }
+
+    if not raw:
+        return {"error": "Decoded audio is empty", "audio_format": fmt, "mode": mode}
+
+    # Guard against empty/instant taps (e.g. a few-byte payload). These are not real
+    # recordings and NVIDIA Omni rejects them with HTTP 400 ("Invalid audio file").
+    # Catch it here and return a clean, user-facing message instead of an API error.
+    if len(raw) < _MIN_AUDIO_BYTES:
+        logger.info(
+            "voice_handler: rejecting too-small audio mode=%s bytes=%d (min=%d)",
+            mode, len(raw), _MIN_AUDIO_BYTES,
+        )
+        return {
+            "error": "That recording was too short. Tap the mic, speak, then tap again to stop.",
+            "audio_format": fmt,
+            "byte_size": len(raw),
+            "mode": mode,
+        }
+
+    detected = _detect_audio_magic(raw)
+    logger.info(
+        "voice_handler: normalize audio mode=%s declared=%s detected=%s bytes=%d magic=%s",
+        mode,
+        fmt,
+        detected,
+        len(raw),
+        _magic_hex(raw),
+    )
+
+    if detected == "wav" or (fmt == "wav" and raw[:4] == _WAV_RIFF):
+        return {
+            "audio_base64": base64.b64encode(raw).decode("ascii"),
+            "audio_format": "wav",
+            "source_format": fmt,
+            "byte_size": len(raw),
+            "converted": fmt != "wav" and detected == "wav",
+            "mode": mode,
+        }
+
+    source_ext = detected if detected != "unknown" else fmt
+    wav_bytes = _convert_audio_to_wav_ffmpeg(raw, source_ext)
+    if wav_bytes and wav_bytes[:4] == _WAV_RIFF:
+        logger.info(
+            "voice_handler: converted %s → wav (%d → %d bytes)",
+            source_ext,
+            len(raw),
+            len(wav_bytes),
+        )
+        return {
+            "audio_base64": base64.b64encode(wav_bytes).decode("ascii"),
+            "audio_format": "wav",
+            "source_format": fmt,
+            "byte_size": len(wav_bytes),
+            "converted": True,
+            "mode": mode,
+        }
+
+    # ffmpeg unavailable or conversion failed — pass through original browser audio
+    # (restores pre-stability behavior; Omni accepts webm on many setups).
+    send_fmt = source_ext if source_ext != "unknown" else fmt
+    logger.info(
+        "voice_handler: passthrough audio mode=%s format=%s bytes=%d (ffmpeg=%s)",
+        mode,
+        send_fmt,
+        len(raw),
+        bool(shutil.which("ffmpeg")),
+    )
+    return {
+        "audio_base64": base64.b64encode(raw).decode("ascii"),
+        "audio_format": send_fmt,
+        "source_format": fmt,
+        "byte_size": len(raw),
+        "converted": False,
+        "mode": mode,
+    }
+
+
+def _call_omni_with_normalized_audio(
+    prompt: str,
+    audio_base64: str,
+    audio_format: str,
+    mode: str,
+) -> str | dict[str, Any]:
+    normalized = normalize_audio_for_omni(audio_base64, audio_format, mode=mode)
+    if normalized.get("error"):
+        return normalized
+
+    def _invoke(payload: dict[str, Any]) -> str:
+        return nvidia_client.call_omni_audio_json(
+            prompt,
+            payload["audio_base64"],
+            payload["audio_format"],
+            mode=mode,
+            source_format=payload.get("source_format", audio_format),
+            decoded_bytes=payload.get("byte_size"),
+        )
+
+    try:
+        return _invoke(normalized)
+    except OmniAudioError as exc:
+        # If passthrough failed and ffmpeg can convert, retry once as WAV.
+        if not normalized.get("converted"):
+            raw_bytes = base64.b64decode(normalized["audio_base64"])
+            detected = _detect_audio_magic(raw_bytes)
+            source_ext = detected if detected != "unknown" else normalized.get("source_format", audio_format)
+            wav_bytes = _convert_audio_to_wav_ffmpeg(raw_bytes, source_ext)
+            if wav_bytes and wav_bytes[:4] == _WAV_RIFF:
+                logger.info("voice_handler: Omni rejected passthrough; retrying as wav")
+                retry_payload = {
+                    "audio_base64": base64.b64encode(wav_bytes).decode("ascii"),
+                    "audio_format": "wav",
+                    "source_format": normalized.get("source_format", audio_format),
+                    "byte_size": len(wav_bytes),
+                    "converted": True,
+                }
+                try:
+                    return _invoke(retry_payload)
+                except OmniAudioError as retry_exc:
+                    err = retry_exc.to_error_dict()
+                    err["source_format"] = normalized.get("source_format", audio_format)
+                    err["converted"] = True
+                    err["error"] = "Voice transcription failed. Try recording again or type your answer."
+                    return err
+
+        err = exc.to_error_dict()
+        err["source_format"] = normalized.get("source_format", audio_format)
+        err["converted"] = normalized.get("converted", False)
+        err["error"] = "Voice transcription failed. Try recording again or type your answer."
+        return err
+    except ValueError as exc:
+        return {"error": str(exc)}
+    except RuntimeError as exc:
+        return {"error": str(exc)}
+
+
+def count_filler_words(transcript: str) -> list[str]:
+    """Return filler words/phrases found in transcript (case-insensitive)."""
+    if not transcript:
+        return []
+    text = transcript.lower()
+    found: list[str] = []
+    for pattern in _FILLER_PATTERNS:
+        if re.search(pattern, text, re.IGNORECASE):
+            label = pattern.strip(r"\b").replace("\\b", "")
+            if label not in found:
+                found.append(label)
+    return found
+
+
+def estimate_word_count(transcript: str) -> int:
+    """Count words in transcript."""
+    if not transcript:
+        return 0
+    return len(re.findall(r"\b\w+\b", transcript))
+
+
+def detect_self_corrections(transcript: str) -> int:
+    """Count simple self-correction cues in transcript."""
+    if not transcript:
+        return 0
+    patterns = [
+        r"\bi mean\b", r"\bwait\b", r"\bsorry\b", r"\bno,\s", r"\bactually\b",
+        r"\blet me rephrase\b", r"\bwhat i meant\b",
+    ]
+    count = 0
+    lower = transcript.lower()
+    for p in patterns:
+        count += len(re.findall(p, lower))
+    return count
+
+
+def _detect_repeated_phrases(transcript: str) -> int:
+    """Count repeated 3-word phrases (simple repetition signal)."""
+    words = re.findall(r"\b\w+\b", (transcript or "").lower())
+    if len(words) < 6:
+        return 0
+    trigrams: dict[str, int] = {}
+    for i in range(len(words) - 2):
+        tri = " ".join(words[i : i + 3])
+        trigrams[tri] = trigrams.get(tri, 0) + 1
+    return sum(1 for c in trigrams.values() if c > 1)
+
+
+def sanitize_voice_json(data: dict[str, Any]) -> dict[str, Any]:
+    """Normalize voice JSON fields with safe delivery-only wording."""
+    if not isinstance(data, dict):
+        return {}
+    out = dict(data)
+    out["transcript"] = str(out.get("transcript", "")).strip()
+    extracted = out.get("extracted")
+    if isinstance(extracted, dict):
+        out["extracted"] = {
+            k: str(extracted.get(k, "")).strip() for k in _EXTRACTED_FIELDS
+        }
+    delivery = out.get("delivery_observations")
+    if isinstance(delivery, dict):
+        fillers = delivery.get("filler_words", [])
+        out["delivery_observations"] = {
+            "filler_words": [str(f).strip() for f in fillers if str(f).strip()][:20]
+            if isinstance(fillers, list) else [],
+            "pace": str(delivery.get("pace", "")).strip() or "unclear",
+            "clarity": str(delivery.get("clarity", "")).strip(),
+            "confidence_signal": str(delivery.get("confidence_signal", "")).strip() or "unclear",
+            "delivery_note": str(delivery.get("delivery_note", "")).strip(),
+        }
+    conf = str(out.get("extraction_confidence", "")).strip().lower()
+    if conf not in ("high", "medium", "low"):
+        conf = "medium"
+    out["extraction_confidence"] = conf
+    return out
+
+
+def _sanitize_turn_json(data: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(data, dict):
+        return {}
+    transcript = str(data.get("transcript", "")).strip()
+    cues_raw = data.get("delivery_cues", {})
+    cues: dict[str, Any] = {}
+    if isinstance(cues_raw, dict):
+        fillers = cues_raw.get("filler_words", [])
+        cues = {
+            "filler_words": [str(f).strip() for f in fillers if str(f).strip()][:20]
+            if isinstance(fillers, list) else [],
+            "pace": str(cues_raw.get("pace", "")).strip() or "unclear",
+            "clarity": str(cues_raw.get("clarity", "")).strip() or "unclear",
+            "repetition": str(cues_raw.get("repetition", "")).strip() or "low",
+            "self_corrections": int(cues_raw.get("self_corrections", 0) or 0),
+            "confidence_signal": str(cues_raw.get("confidence_signal", "")).strip() or "unclear",
+        }
+    local_fillers = count_filler_words(transcript)
+    if not cues.get("filler_words") and local_fillers:
+        cues["filler_words"] = local_fillers
+    if cues.get("self_corrections", 0) == 0:
+        cues["self_corrections"] = detect_self_corrections(transcript)
+    rep_count = _detect_repeated_phrases(transcript)
+    if cues.get("repetition") == "low" and rep_count >= 2:
+        cues["repetition"] = "medium"
+    return {
+        "transcript": transcript,
+        "delivery_note": str(data.get("delivery_note", "")).strip() or "Clean delivery.",
+        "word_count": estimate_word_count(transcript),
+        "delivery_cues": cues,
+    }
+
+
+def _parse_pitch_json(raw: str) -> dict[str, Any] | None:
+    parsed, _ = parse_model_json(raw)
+    if not isinstance(parsed, dict) or not parsed:
+        parsed = safe_json_parse(raw)
+    if not isinstance(parsed, dict) or not parsed:
+        return None
+    transcript = str(parsed.get("transcript", "")).strip()
+    if not transcript:
+        return None
+    sanitized = sanitize_voice_json(parsed)
+    sanitized["transcript"] = transcript
+    return sanitized
+
+
+def _parse_turn_json(raw: str) -> dict[str, Any] | None:
+    parsed, _ = parse_model_json(raw)
+    if not isinstance(parsed, dict) or not parsed:
+        parsed = safe_json_parse(raw)
+    if not isinstance(parsed, dict) or not parsed:
+        return None
+    transcript = str(parsed.get("transcript", "")).strip()
+    if not transcript:
+        return None
+    return _sanitize_turn_json(parsed)
+
+
+def _repair_pitch_json(raw_bad: str) -> dict[str, Any] | None:
+    repair_prompt = (
+        "Convert the input into valid JSON matching this schema exactly. "
+        "Return ONLY JSON. First char { last char }.\n"
+        '{"transcript":"","extracted":{"name":"","problem":"","target_users":"",'
+        '"solution":"","why_ai":"","traction":"","competitors":"","ask":""},'
+        '"delivery_observations":{"filler_words":[],"pace":"","clarity":"",'
+        '"confidence_signal":"","delivery_note":""},"extraction_confidence":"medium"}\n\n'
+        + raw_bad[:4000]
+    )
+    try:
+        content = nvidia_client.generate_nemotron_response(
+            [{"role": "user", "content": repair_prompt}],
+            mode="voice_extraction_repair",
+        )
+        return _parse_pitch_json(content)
+    except Exception as exc:
+        logger.warning("voice_handler: pitch repair failed — %s", exc)
+        return None
+
+
+def _repair_turn_json(raw_bad: str) -> dict[str, Any] | None:
+    repair_prompt = (
+        "Convert the input into valid JSON matching this schema exactly. "
+        "Return ONLY JSON. First char { last char }.\n"
+        '{"transcript":"","delivery_note":"","word_count":0,'
+        '"delivery_cues":{"filler_words":[],"pace":"","clarity":"",'
+        '"repetition":"low","self_corrections":0,"confidence_signal":""}}\n\n'
+        + raw_bad[:3000]
+    )
+    try:
+        content = nvidia_client.generate_nemotron_response(
+            [{"role": "user", "content": repair_prompt}],
+            mode="voice_turn_repair",
+        )
+        return _parse_turn_json(content)
+    except Exception as exc:
+        logger.warning("voice_handler: turn repair failed — %s", exc)
+        return None
+
+
+def process_voice_pitch(audio_base64: str, audio_format: str) -> dict[str, Any]:
+    """Opening spoken pitch → transcript + extracted startup fields + delivery cues."""
+    if not nvidia_client.is_configured():
+        return {"error": "NVIDIA_API_KEY is not configured on the server."}
+
+    raw = _call_omni_with_normalized_audio(
+        _VOICE_PITCH_PROMPT, audio_base64, audio_format, mode="voice_extraction"
+    )
+    if isinstance(raw, dict):
+        return raw
+
+    parsed = _parse_pitch_json(raw)
+    if parsed is None:
+        logger.warning("voice_handler: pitch parse failed, attempting repair")
+        parsed = _repair_pitch_json(raw)
+
+    if parsed is None:
+        return {"error": "Could not parse voice pitch response from Nemotron Omni."}
+
+    return parsed
+
+
+def process_voice_turn(
+    session_id: str,
+    audio_base64: str,
+    audio_format: str,
+) -> dict[str, Any]:
+    """One battle answer audio → transcript + delivery note (pending confirmation)."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        return {"error": "Session not found", "session_id": session_id}
+
+    if not nvidia_client.is_configured():
+        return {"error": "NVIDIA_API_KEY is not configured on the server.", "session_id": session_id}
+
+    raw = _call_omni_with_normalized_audio(
+        _VOICE_TURN_PROMPT, audio_base64, audio_format, mode="voice_turn"
+    )
+    if isinstance(raw, dict):
+        raw["session_id"] = session_id
+        return raw
+
+    parsed = _parse_turn_json(raw)
+    if parsed is None:
+        logger.warning("voice_handler: turn parse failed, attempting repair")
+        parsed = _repair_turn_json(raw)
+
+    if parsed is None:
+        return {"error": "Could not parse voice turn response from Nemotron Omni.", "session_id": session_id}
+
+    voice_turn_id = str(uuid.uuid4())
+    transcript = parsed["transcript"]
+    fillers = parsed["delivery_cues"].get("filler_words") or count_filler_words(transcript)
+    filler_count = len(fillers)
+
+    turn_record = {
+        "voice_turn_id": voice_turn_id,
+        "transcript": transcript,
+        "delivery_note": parsed.get("delivery_note", ""),
+        "word_count": parsed.get("word_count", estimate_word_count(transcript)),
+        "delivery_cues": parsed.get("delivery_cues", {}),
+        "filler_word_count": filler_count,
+        "confirmed": False,
+    }
+    session_manager.store_pending_voice_turn(session_id, turn_record)
+
+    return {
+        "session_id": session_id,
+        "voice_turn_id": voice_turn_id,
+        "transcript": transcript,
+        "delivery_note": turn_record["delivery_note"],
+        "word_count": turn_record["word_count"],
+        "delivery_cues": turn_record["delivery_cues"],
+    }
+
+
+def confirm_voice_turn(
+    session_id: str,
+    voice_turn_id: str,
+    final_transcript: str,
+) -> bool:
+    """Mark a pending voice turn as confirmed with the user's final transcript."""
+    return session_manager.confirm_voice_turn(session_id, voice_turn_id, final_transcript)
+
+
+def _is_generic_delivery_note(note: str) -> bool:
+    """Skip filler delivery notes that clutter the scorecard UI."""
+    n = (note or "").strip().lower().rstrip(".")
+    return n in ("clean delivery", "clean delivery.", "")
+
+
+def build_voice_delivery_summary(session: dict) -> dict[str, Any] | None:
+    """Aggregate confirmed voice turns into a scorecard delivery summary (local only)."""
+    confirmed = session.get("confirmed_voice_turns") or []
+    voice_pitch = session.get("voice_pitch")
+    if not confirmed and not voice_pitch:
+        return None
+
+    all_fillers: list[str] = []
+    delivery_notes: list[str] = []
+    pace_counts: dict[str, int] = {}
+    clarity_signals: list[str] = []
+    confidence_signals: list[str] = []
+
+    if isinstance(voice_pitch, dict):
+        obs = voice_pitch.get("delivery_observations") or {}
+        if isinstance(obs, dict):
+            note = str(obs.get("delivery_note", "")).strip()
+            if note and not _is_generic_delivery_note(note):
+                delivery_notes.append(f"Opening pitch: {note}")
+            for f in obs.get("filler_words") or []:
+                if str(f).strip():
+                    all_fillers.append(str(f).strip())
+            pace = str(obs.get("pace", "")).strip()
+            if pace:
+                pace_counts[pace] = pace_counts.get(pace, 0) + 1
+            clarity = str(obs.get("clarity", "")).strip()
+            if clarity:
+                clarity_signals.append(clarity)
+            conf = str(obs.get("confidence_signal", "")).strip()
+            if conf:
+                confidence_signals.append(conf)
+
+    for turn in confirmed:
+        if not isinstance(turn, dict):
+            continue
+        note = str(turn.get("delivery_note", "")).strip()
+        if note and not _is_generic_delivery_note(note):
+            delivery_notes.append(note)
+        cues = turn.get("delivery_cues") or {}
+        if isinstance(cues, dict):
+            for f in cues.get("filler_words") or []:
+                if str(f).strip():
+                    all_fillers.append(str(f).strip())
+            pace = str(cues.get("pace", "")).strip()
+            if pace:
+                pace_counts[pace] = pace_counts.get(pace, 0) + 1
+            clarity = str(cues.get("clarity", "")).strip()
+            if clarity:
+                clarity_signals.append(clarity)
+            conf = str(cues.get("confidence_signal", "")).strip()
+            if conf:
+                confidence_signals.append(conf)
+
+    filler_unique = list(dict.fromkeys(all_fillers))
+    total_fillers = len(all_fillers)
+    avg_pace = max(pace_counts, key=pace_counts.get) if pace_counts else "unclear"
+
+    if total_fillers == 0 and len(confirmed) >= 2:
+        overall = "Voice delivery was generally clear across your spoken answers."
+    elif total_fillers > 5:
+        overall = (
+            f"Filler words appeared often ({total_fillers} total). "
+            "Practice pausing briefly instead of using fillers before key claims."
+        )
+    elif delivery_notes:
+        overall = "Review the delivery notes below and practice smoother pacing on your weakest round."
+    else:
+        overall = "Voice turns recorded — delivery was acceptable for a practice session."
+
+    return {
+        "total_voice_turns": len(confirmed),
+        "total_filler_words": total_fillers,
+        "filler_word_list": filler_unique[:12],
+        "delivery_notes": list(dict.fromkeys(delivery_notes))[:4],
+        "average_pace": avg_pace,
+        "clarity_signal": clarity_signals[-1] if clarity_signals else "unclear",
+        "confidence_signal": confidence_signals[-1] if confidence_signals else "unclear",
+        "overall_delivery_feedback": overall,
+    }

frontend/index.html

@@ -6,6 +6,9 @@
   <title>PitchFight AI</title>
   <link rel="icon" href="/frontend/assets/logo.svg" type="image/svg+xml" />
   <link rel="stylesheet" href="/frontend/styles.css" />
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Rajdhani:wght@500;600;700&display=swap" rel="stylesheet" />
 </head>
 <body>
   <div class="bg-glow"></div>
@@ -13,143 +16,1207 @@
   <div id="error-banner" class="error-banner" hidden role="alert"></div>
 
   <main id="app" class="app">
-    <!-- Landing -->
+    <!-- Landing — Founder Pressure Arena (Pass 1) -->
     <section id="screen-landing" class="screen active">
-      <header class="hero">
-        <img src="/frontend/assets/logo.svg" alt="PitchFight AI logo" class="logo" />
-        <h1>PitchFight AI</h1>
-        <p class="tagline">Your first tough pitch should not be in front of a real judge.</p>
-        <p class="subtitle">A small-model pressure simulator for student founders.</p>
-      </header>
-      <div class="hero-actions">
-        <button id="btn-load-sample" class="btn btn-secondary">Load Demo Startup</button>
-        <button id="btn-go-setup" class="btn btn-primary">Start Pitch Battle</button>
+      <div class="arena-landing">
+        <div class="arena-scene" aria-hidden="true">
+          <div class="arena-scene-base"></div>
+          <div class="hero-center-haze"></div>
+          <div class="spotlight-core"></div>
+          <div class="hero-spotlight-particles"></div>
+          <div class="spotlight-beam"></div>
+          <div class="arena-floor"></div>
+          <div class="pressure-line"></div>
+          <div class="arena-glow arena-glow-founder"></div>
+          <div class="arena-glow arena-glow-judge"></div>
+
+          <div class="founder-silhouette">
+            <div class="founder-aura"></div>
+            <svg class="character-svg character-svg-founder" viewBox="0 0 140 230" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+              <defs>
+                <linearGradient id="founder-skin" x1="0%" y1="0%" x2="0%" y2="100%">
+                  <stop offset="0%" stop-color="#c9954a"/>
+                  <stop offset="100%" stop-color="#3d2810"/>
+                </linearGradient>
+                <linearGradient id="founder-suit" x1="0%" y1="0%" x2="0%" y2="100%">
+                  <stop offset="0%" stop-color="#5a4020"/>
+                  <stop offset="100%" stop-color="#120c06"/>
+                </linearGradient>
+                <linearGradient id="gold-glow" x1="0%" y1="0%" x2="100%" y2="100%">
+                  <stop offset="0%" stop-color="#f4d35e" stop-opacity="0.9"/>
+                  <stop offset="100%" stop-color="#a67c1a" stop-opacity="0.4"/>
+                </linearGradient>
+                <filter id="founder-soft-glow" x="-20%" y="-20%" width="140%" height="140%">
+                  <feGaussianBlur stdDeviation="3" result="blur"/>
+                  <feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
+                </filter>
+              </defs>
+              <!-- Podium platform -->
+              <ellipse cx="70" cy="206" rx="58" ry="6" fill="rgba(244,211,94,0.08)"/>
+              <rect x="14" y="198" width="112" height="16" rx="3" fill="#1a1208" stroke="#f4d35e" stroke-opacity="0.45"/>
+              <rect x="20" y="190" width="100" height="10" rx="2" fill="#2a1e0c" stroke="#f4d35e" stroke-opacity="0.28"/>
+              <rect x="26" y="184" width="88" height="8" rx="1" fill="#1f160a" stroke="#f4d35e" stroke-opacity="0.15"/>
+              <!-- Traction glow ring -->
+              <ellipse cx="70" cy="188" rx="48" ry="4" fill="none" stroke="#f4d35e" stroke-opacity="0.2" stroke-width="1"/>
+              <!-- Money bag (the ask) -->
+              <g class="prop-money-bag" filter="url(#founder-soft-glow)">
+                <path d="M8 185 Q8 168 22 162 Q28 158 28 150 L32 150 Q32 158 38 162 Q52 168 52 185 Q52 198 30 198 Q8 198 8 185Z" fill="#2a2210" stroke="#f4d35e" stroke-opacity="0.55"/>
+                <path d="M22 150 Q30 146 38 150" fill="none" stroke="#f4d35e" stroke-opacity="0.45" stroke-width="2"/>
+                <text x="30" y="182" text-anchor="middle" fill="#f4d35e" font-size="14" font-weight="700" opacity="0.85">$</text>
+              </g>
+              <!-- Legs -->
+              <path d="M46 168 L42 192 L56 192 L52 168 Z" fill="#0e0a06"/>
+              <path d="M88 168 L84 192 L98 192 L94 168 Z" fill="#0e0a06"/>
+              <!-- Torso / jacket -->
+              <path d="M40 92 Q70 84 100 92 L106 168 Q70 176 34 168 Z" fill="url(#founder-suit)"/>
+              <path d="M40 92 Q70 84 100 92 L98 108 Q70 112 42 108 Z" fill="#f4d35e" fill-opacity="0.06"/>
+              <path d="M56 92 L84 92 L82 168 L58 168 Z" fill="#f4d35e" fill-opacity="0.1"/>
+              <!-- Lapels -->
+              <path d="M56 92 L62 108 L58 168 L52 108 Z" fill="#2a1e0c" fill-opacity="0.6"/>
+              <path d="M84 92 L78 108 L82 168 L88 108 Z" fill="#2a1e0c" fill-opacity="0.6"/>
+              <!-- Shirt collar -->
+              <path d="M56 92 L70 92 L66 110 L62 110 Z" fill="#1a1510"/>
+              <path d="M70 92 L84 92 L82 110 L74 110 Z" fill="#1a1510"/>
+              <!-- Head -->
+              <ellipse cx="70" cy="70" rx="24" ry="27" fill="url(#founder-skin)"/>
+              <path d="M52 78 Q70 88 88 78" fill="none" stroke="#3d2810" stroke-opacity="0.35" stroke-width="1"/>
+              <!-- Hair -->
+              <path d="M46 66 Q70 44 94 66 Q90 54 70 50 Q50 54 46 66Z" fill="#1a1008"/>
+              <path d="M48 62 Q70 48 92 62" fill="none" stroke="#f4d35e" stroke-opacity="0.12" stroke-width="2"/>
+              <!-- Pitch deck / tablet -->
+              <g class="prop-pitch-deck">
+                <rect x="88" y="108" width="36" height="48" rx="3" fill="#1a1510" stroke="#f4d35e" stroke-opacity="0.6" transform="rotate(8 106 132)"/>
+                <line x1="94" y1="120" x2="118" y2="122" stroke="#f4d35e" stroke-opacity="0.4" stroke-width="2" transform="rotate(8 106 132)"/>
+                <line x1="94" y1="130" x2="114" y2="132" stroke="#f4d35e" stroke-opacity="0.3" stroke-width="2" transform="rotate(8 106 132)"/>
+                <line x1="94" y1="140" x2="116" y2="142" stroke="#f4d35e" stroke-opacity="0.25" stroke-width="2" transform="rotate(8 106 132)"/>
+              </g>
+              <!-- Presenting arm -->
+              <path d="M100 92 Q122 98 128 118 Q130 130 120 134 Q108 128 102 112 Q98 102 100 92Z" fill="url(#founder-skin)"/>
+              <!-- Other arm -->
+              <path d="M40 92 Q24 106 22 128 Q20 140 30 138 Q38 132 42 114 Q44 102 40 92Z" fill="url(#founder-suit)"/>
+            </svg>
+            <div class="arena-artifacts arena-artifacts-founder" aria-hidden="true">
+              <span class="artifact artifact-pitch-card"></span>
+              <span class="artifact artifact-deck-tile"></span>
+              <span class="artifact artifact-traction-graph"></span>
+            </div>
+            <span class="character-shadow character-shadow-founder"></span>
+            <span class="character-label character-label-founder">Founder</span>
+          </div>
+
+          <div class="judge-silhouette">
+            <div class="judge-aura"></div>
+            <svg class="character-svg character-svg-judge" viewBox="0 0 150 240" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+              <defs>
+                <linearGradient id="judge-metal" x1="0%" y1="0%" x2="0%" y2="100%">
+                  <stop offset="0%" stop-color="#1a3040"/>
+                  <stop offset="100%" stop-color="#060a10"/>
+                </linearGradient>
+                <linearGradient id="visor-glow" x1="0%" y1="0%" x2="100%" y2="0%">
+                  <stop offset="0%" stop-color="#4ecdc4" stop-opacity="0.2"/>
+                  <stop offset="50%" stop-color="#7efff0" stop-opacity="1"/>
+                  <stop offset="100%" stop-color="#4ecdc4" stop-opacity="0.2"/>
+                </linearGradient>
+                <linearGradient id="cash-green" x1="0%" y1="0%" x2="0%" y2="100%">
+                  <stop offset="0%" stop-color="#3d8a62"/>
+                  <stop offset="100%" stop-color="#1a4030"/>
+                </linearGradient>
+                <filter id="judge-cyan-glow" x="-30%" y="-30%" width="160%" height="160%">
+                  <feGaussianBlur stdDeviation="2.5" result="blur"/>
+                  <feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
+                </filter>
+              </defs>
+              <!-- Platform -->
+              <ellipse cx="75" cy="216" rx="62" ry="6" fill="rgba(78,205,196,0.1)"/>
+              <rect x="16" y="206" width="118" height="16" rx="3" fill="#0a1420" stroke="#4ecdc4" stroke-opacity="0.45"/>
+              <rect x="22" y="198" width="106" height="10" rx="2" fill="#0e1824" stroke="#4ecdc4" stroke-opacity="0.25"/>
+              <!-- Cash stack -->
+              <g class="prop-cash-stack">
+                <rect x="6" y="186" width="34" height="8" rx="1" fill="url(#cash-green)" stroke="#4ecdc4" stroke-opacity="0.3"/>
+                <rect x="8" y="178" width="30" height="8" rx="1" fill="url(#cash-green)" stroke="#4ecdc4" stroke-opacity="0.35"/>
+                <rect x="10" y="170" width="26" height="8" rx="1" fill="url(#cash-green)" stroke="#4ecdc4" stroke-opacity="0.4"/>
+                <rect x="14" y="162" width="18" height="8" rx="1" fill="#2a6048" stroke="#f4d35e" stroke-opacity="0.35"/>
+              </g>
+              <!-- Briefcase (capital) -->
+              <g class="prop-briefcase">
+                <rect x="108" y="172" width="38" height="28" rx="3" fill="#0c1018" stroke="#4ecdc4" stroke-opacity="0.5"/>
+                <path d="M118 172 L118 166 Q127 160 136 166 L136 172" fill="none" stroke="#4ecdc4" stroke-opacity="0.55" stroke-width="2"/>
+                <rect x="122" y="182" width="10" height="6" rx="1" fill="#4ecdc4" fill-opacity="0.25"/>
+                <text x="127" y="194" text-anchor="middle" fill="#f4d35e" font-size="11" font-weight="700">$</text>
+              </g>
+              <!-- Legs / base -->
+              <rect x="50" y="176" width="16" height="32" rx="3" fill="#060a10" stroke="#4ecdc4" stroke-opacity="0.15"/>
+              <rect x="84" y="176" width="16" height="32" rx="3" fill="#060a10" stroke="#4ecdc4" stroke-opacity="0.15"/>
+              <!-- Body -->
+              <path d="M34 102 Q75 90 116 102 L122 178 Q75 188 28 178 Z" fill="url(#judge-metal)" stroke="#4ecdc4" stroke-opacity="0.3"/>
+              <!-- Shoulder armor -->
+              <path d="M34 102 Q22 108 18 128 L34 118 Z" fill="#122030" stroke="#4ecdc4" stroke-opacity="0.35"/>
+              <path d="M116 102 Q128 108 132 128 L116 118 Z" fill="#122030" stroke="#4ecdc4" stroke-opacity="0.35"/>
+              <!-- Core panel -->
+              <rect x="54" y="124" width="42" height="44" rx="3" fill="#060a10" stroke="#4ecdc4" stroke-opacity="0.4"/>
+              <line x1="54" y1="146" x2="96" y2="146" stroke="#4ecdc4" stroke-opacity="0.25"/>
+              <line x1="75" y1="124" x2="75" y2="168" stroke="#4ecdc4" stroke-opacity="0.25"/>
+              <!-- Score bars on panel -->
+              <rect x="60" y="152" width="8" height="12" rx="1" fill="#4ecdc4" fill-opacity="0.35"/>
+              <rect x="72" y="146" width="8" height="18" rx="1" fill="#4ecdc4" fill-opacity="0.55"/>
+              <rect x="84" y="138" width="8" height="26" rx="1" fill="#7efff0" fill-opacity="0.7"/>
+              <!-- Neck -->
+              <rect x="64" y="94" width="22" height="14" rx="3" fill="#0a1018" stroke="#4ecdc4" stroke-opacity="0.25"/>
+              <!-- Head -->
+              <rect x="44" y="48" width="62" height="52" rx="8" fill="#0a1420" stroke="#4ecdc4" stroke-opacity="0.5"/>
+              <rect x="48" y="52" width="54" height="8" rx="2" fill="#4ecdc4" fill-opacity="0.08"/>
+              <!-- Visor -->
+              <rect class="judge-visor-svg" x="48" y="66" width="54" height="12" rx="2" fill="url(#visor-glow)" filter="url(#judge-cyan-glow)"/>
+              <line x1="52" y1="72" x2="98" y2="72" stroke="#7efff0" stroke-opacity="0.35" stroke-width="1"/>
+              <!-- Antenna array -->
+              <line x1="75" y1="48" x2="75" y2="38" stroke="#4ecdc4" stroke-opacity="0.7" stroke-width="2"/>
+              <circle cx="75" cy="36" r="3.5" fill="#4ecdc4" class="judge-sensor-svg"/>
+              <line x1="58" y1="52" x2="52" y2="44" stroke="#4ecdc4" stroke-opacity="0.45" stroke-width="1.5"/>
+              <line x1="92" y1="52" x2="98" y2="44" stroke="#4ecdc4" stroke-opacity="0.45" stroke-width="1.5"/>
+              <!-- Side sensors -->
+              <circle cx="50" cy="60" r="3" fill="#4ecdc4" fill-opacity="0.75" class="judge-sensor-svg"/>
+              <circle cx="100" cy="60" r="3" fill="#4ecdc4" fill-opacity="0.75" class="judge-sensor-svg"/>
+            </svg>
+            <div class="arena-artifacts arena-artifacts-judge" aria-hidden="true">
+              <span class="artifact artifact-score-tile"><span class="artifact-score-num">72</span></span>
+              <span class="artifact artifact-scanner"></span>
+              <span class="artifact artifact-deal-chip">DEAL</span>
+            </div>
+            <span class="character-shadow character-shadow-judge"></span>
+            <span class="character-label character-label-judge">AI Judge</span>
+          </div>
+
+          <div class="arena-dust"></div>
+          <div class="arena-pressure-scan"></div>
+          <div class="arena-scanline"></div>
+        </div>
+
+        <div class="arena-landing-content">
+          <p class="arena-eyebrow">AI Founder Pressure Arena</p>
+
+          <div class="arena-logo-wrap">
+            <img src="/frontend/assets/logo.svg" alt="PitchFight AI logo" class="logo arena-logo" />
+          </div>
+
+          <h1 class="arena-title">PitchFight AI</h1>
+
+          <div class="arena-hook" id="landing-typewriter" aria-live="polite">
+            <p class="arena-hook-line" id="landing-type-line-1">
+              <span class="arena-type-text" data-text="Your pitch is ready."></span>
+              <span class="arena-cursor" aria-hidden="true"></span>
+            </p>
+            <p class="arena-hook-line arena-hook-line-accent" id="landing-type-line-2">
+              <span class="arena-type-text" data-text="Now survive the questions."></span>
+            </p>
+          </div>
+
+          <p class="arena-support">
+            Train against an AI judge, defend your startup under pressure, and leave with a scorecard that shows exactly what to fix.
+          </p>
+
+          <div class="hero-actions arena-cta-row" id="landing-cta-row">
+            <button id="btn-go-setup" class="btn btn-primary btn-arena-primary" type="button">Enter the Arena</button>
+            <button id="btn-load-sample" class="btn btn-secondary btn-arena-secondary" type="button">Load Demo Founder</button>
+          </div>
+
+          <div class="arena-feature-chips" id="landing-feature-chips" aria-label="Features">
+            <span class="arena-chip">Pitch Battle</span>
+            <span class="arena-chip">Voice Mode</span>
+            <span class="arena-chip">Retry Weakest</span>
+            <span class="arena-chip">Deal Phase</span>
+          </div>
+
+          <footer class="arena-landing-footer">
+            <p class="arena-trust-badge">Powered by NVIDIA Nemotron</p>
+            <p class="arena-footer-line">Built for student founders before the real room.</p>
+          </footer>
+        </div>
       </div>
     </section>
 
-    <!-- Setup -->
-    <section id="screen-setup" class="screen">
+    <!-- Start method -->
+    <section id="screen-start-method" class="screen">
       <div class="panel glass">
         <div class="panel-header">
-          <h2>Startup Context</h2>
-          <button id="btn-back-landing" class="btn btn-ghost">Back</button>
+          <h2>How do you want to start?</h2>
+          <button id="btn-start-back-landing" class="btn btn-ghost">Back</button>
         </div>
-        <form id="startup-form" class="startup-form">
-          <label>Name<input name="name" type="text" placeholder="EventRadar AI" required /></label>
-          <label>Problem<textarea name="problem" rows="2" required></textarea></label>
-          <label>Target Users<input name="target_users" type="text" required /></label>
-          <label>Solution<textarea name="solution" rows="2" required></textarea></label>
-          <label>Why AI<textarea name="why_ai" rows="2" required></textarea></label>
-          <label>Competitors<input name="competitors" type="text" required /></label>
-          <label>Traction<input name="traction" type="text" required /></label>
-          <label>Ask<input name="ask" type="text" required /></label>
-        </form>
-      </div>
-
-      <div class="panel glass">
-        <h2>Choose Your Opponent</h2>
-        <div class="persona-grid">
-          <button class="persona-card" data-persona="skeptical_vc">
-            <span class="persona-icon">💼</span>
-            <h3>Skeptical VC</h3>
-            <p>Market, moat, revenue, defensibility</p>
+        <div class="start-method-grid">
+          <button id="btn-start-text" class="start-method-card selected" type="button">
+            <span class="start-method-icon">✎</span>
+            <h3>Fill Details</h3>
+            <p>Type your startup context manually.</p>
           </button>
-          <button class="persona-card" data-persona="technical_judge">
-            <span class="persona-icon">🛠️</span>
-            <h3>Technical Judge</h3>
-            <p>AI necessity, architecture, feasibility</p>
+          <button id="btn-start-voice" class="start-method-card" type="button">
+            <span class="start-method-icon voice-icon">🎙</span>
+            <h3>Pitch First</h3>
+            <p>Speak a 60–90 second pitch and let AI extract the details.</p>
           </button>
-          <button class="persona-card selected" data-persona="hackathon_judge">
-            <span class="persona-icon">🏆</span>
-            <h3>Hackathon Judge</h3>
-            <p>Novelty, demo clarity, MVP strength</p>
+        </div>
+        <button id="btn-continue-start" class="btn btn-primary btn-wide">Continue</button>
+      </div>
+    </section>
+
+    <!-- Voice pitch recording -->
+    <section id="screen-voice-pitch" class="screen">
+      <div class="panel glass voice-panel">
+        <div class="panel-header">
+          <h2>Record Your Opening Pitch</h2>
+          <button id="btn-voice-pitch-back" class="btn btn-ghost">Back</button>
+        </div>
+        <div class="voice-guidance glass-inner">
+          <p>Try to mention: <strong>startup name</strong>, problem, users, solution, why AI, traction, competitors, ask.</p>
+          <p class="voice-hint">Aim for 60–90 seconds. Tap the mic to start, tap again to stop.</p>
+        </div>
+        <div class="voice-recorder">
+          <button id="btn-voice-pitch-record" class="voice-mic-btn" type="button" aria-label="Record pitch">
+            <span class="mic-ring"></span>
+            <span class="mic-icon">🎙</span>
           </button>
+          <p id="voice-pitch-timer" class="voice-timer">0:00</p>
+          <p id="voice-pitch-status" class="voice-status"></p>
+          <button id="btn-voice-pitch-cancel" class="btn btn-ghost btn-sm" type="button">Cancel</button>
+        </div>
+      </div>
+    </section>
+
+    <!-- Voice pitch confirmation -->
+    <section id="screen-voice-confirm" class="screen">
+      <div class="panel glass voice-panel">
+        <div class="panel-header">
+          <h2>Here's what we understood</h2>
+        </div>
+        <p id="voice-confidence-warning" class="voice-low-confidence" hidden>Low extraction confidence — please review and edit fields carefully.</p>
+        <div class="voice-transcript-card glass-inner">
+          <h3>Transcript</h3>
+          <p id="voice-confirm-transcript" class="voice-transcript-text"></p>
+          <p id="voice-confirm-delivery" class="voice-delivery-note"></p>
+          <span id="voice-confirm-confidence" class="delivery-chip"></span>
+        </div>
+        <form id="voice-extract-form" class="startup-form voice-extract-form">
+          <label>Name<input name="name" type="text" /></label>
+          <label>Problem<textarea name="problem" rows="2"></textarea></label>
+          <label>Target Users<input name="target_users" type="text" /></label>
+          <label>Solution<textarea name="solution" rows="2"></textarea></label>
+          <label>Why AI<textarea name="why_ai" rows="2"></textarea></label>
+          <label>Competitors<input name="competitors" type="text" /></label>
+          <label>Traction<input name="traction" type="text" /></label>
+          <label>Ask<input name="ask" type="text" /></label>
+        </form>
+        <div class="voice-confirm-actions">
+          <button id="btn-voice-edit-manual" class="btn btn-secondary" type="button">Edit manually</button>
+          <button id="btn-voice-looks-right" class="btn btn-primary" type="button">Looks right → Continue</button>
+        </div>
+      </div>
+    </section>
+
+    <!-- Setup -->
+    <section id="screen-setup" class="screen">
+      <div class="briefing-shell">
+        <header class="briefing-header">
+          <div>
+            <p class="results-eyebrow">Pre-Fight Briefing</p>
+            <h2 class="briefing-title">Founder Briefing</h2>
+            <p class="briefing-subtitle">Give the AI judge enough context to attack your pitch properly.</p>
+            <p class="briefing-helper">Sharper inputs create tougher questions.</p>
+          </div>
+          <button id="btn-back-landing" class="btn btn-ghost">Back</button>
+        </header>
+
+        <div class="briefing-grid">
+          <div class="panel glass briefing-panel">
+            <h3 class="briefing-section-title">Startup Identity</h3>
+            <form id="startup-form" class="startup-form briefing-form">
+              <div class="briefing-group">
+                <label>Name<input name="name" type="text" placeholder="EventRadar AI" required /></label>
+              </div>
+              <div class="briefing-group briefing-group-problem">
+                <h4 class="briefing-group-label">Problem + Users</h4>
+                <label>Problem<textarea name="problem" rows="2" required placeholder="What pain are you solving?"></textarea></label>
+                <label>Target Users<input name="target_users" type="text" required placeholder="Who feels this pain most?" /></label>
+              </div>
+              <div class="briefing-group briefing-group-solution">
+                <h4 class="briefing-group-label">Solution + Why AI</h4>
+                <label>Solution<textarea name="solution" rows="2" required placeholder="What do you build?"></textarea></label>
+                <label>Why AI<textarea name="why_ai" rows="2" required placeholder="Why AI instead of rules or manual work?"></textarea></label>
+              </div>
+              <div class="briefing-group briefing-group-traction">
+                <h4 class="briefing-group-label">Traction + Competitors</h4>
+                <label>Competitors<input name="competitors" type="text" required placeholder="Who else solves this?" /></label>
+                <label>Traction<input name="traction" type="text" required placeholder="Users, pilots, revenue, demos…" /></label>
+              </div>
+              <div class="briefing-group briefing-group-ask">
+                <h4 class="briefing-group-label">Ask / Desired Outcome</h4>
+                <label>Ask<input name="ask" type="text" required placeholder="Funding, pilot, mentorship, sponsorship…" /></label>
+              </div>
+            </form>
+          </div>
+
+          <div class="panel glass briefing-panel briefing-opponent-panel">
+            <h3 class="briefing-section-title">Choose Your Opponent</h3>
+            <div class="persona-grid">
+              <button class="persona-card" type="button" data-persona="skeptical_vc">
+                <span class="persona-icon">💼</span>
+                <h3>Skeptical VC</h3>
+                <p>Market, moat, revenue, defensibility</p>
+              </button>
+              <button class="persona-card" type="button" data-persona="technical_judge">
+                <span class="persona-icon">🛠️</span>
+                <h3>Technical Judge</h3>
+                <p>AI necessity, architecture, feasibility</p>
+              </button>
+              <button class="persona-card selected" type="button" data-persona="hackathon_judge">
+                <span class="persona-icon">🏆</span>
+                <h3>Hackathon Judge</h3>
+                <p>Novelty, demo clarity, MVP strength</p>
+              </button>
+            </div>
+            <div class="difficulty-selector">
+              <h3>Difficulty Mode</h3>
+              <div class="difficulty-grid">
+                <button class="difficulty-card selected" type="button" data-difficulty="practice">
+                  <span class="difficulty-icon">🎓</span>
+                  <h4>Practice Mode</h4>
+                  <p>Student-friendly, clear questions, confidence-building</p>
+                </button>
+                <button class="difficulty-card" type="button" data-difficulty="judge">
+                  <span class="difficulty-icon">⚖️</span>
+                  <h4>Judge Mode</h4>
+                  <p>Balanced hackathon judge, sharper, demo-focused</p>
+                </button>
+                <button class="difficulty-card" type="button" data-difficulty="investor">
+                  <span class="difficulty-icon">💰</span>
+                  <h4>Investor Mode</h4>
+                  <p>Skeptical VC pressure — market, moat, and traction</p>
+                </button>
+              </div>
+            </div>
+            <button id="btn-start-battle" class="btn btn-primary btn-wide btn-arena-start" type="button">Start Pitch Battle</button>
+          </div>
         </div>
-        <button id="btn-start-battle" class="btn btn-primary btn-wide">Enter the Arena</button>
       </div>
     </section>
 
-    <!-- Battle -->
-    <section id="screen-battle" class="screen">
-      <div class="battle-layout">
-        <aside class="battle-meta glass">
-          <h2>Battle Arena</h2>
-          <div class="meta-item"><span>Round</span><strong id="round-counter">1</strong></div>
-          <div class="meta-item"><span>Pressure</span><strong id="pressure-level" class="pressure-high">High</strong></div>
-          <div class="meta-item"><span>Phase</span><strong id="battle-phase" hidden>explore</strong></div>
-          <div class="meta-item"><span>Attack Tag</span><strong id="attack-tag">—</strong></div>
-          <button id="btn-end-battle" class="btn btn-danger btn-wide">End Battle</button>
-          <button id="btn-back-scorecard" class="btn btn-ghost btn-wide" hidden>Back to Scorecard</button>
-        </aside>
-
-        <div class="battle-chat glass">
-          <div id="chat-window" class="chat-window" aria-live="polite"></div>
-          <form id="chat-form" class="chat-input-row">
-            <textarea id="user-input" rows="2" placeholder="Defend your startup under pressure..."></textarea>
-            <button id="btn-send" type="submit" class="btn btn-primary">Send</button>
-          </form>
-          <p id="battle-status" class="status-text" hidden></p>
+    <!-- Battle — Pass 3B Duel Stage -->
+    <section id="screen-battle" class="screen screen-arena">
+      <div class="battle-arena-wrap">
+        <div class="battle-arena-scene" aria-hidden="true">
+          <div class="battle-arena-glow battle-arena-glow-left"></div>
+          <div class="battle-arena-glow battle-arena-glow-right"></div>
+          <div class="battle-arena-spotlight"></div>
+          <div class="battle-arena-floor"></div>
+          <div class="arena-energy-lines"></div>
+          <div class="arena-particles"></div>
+        </div>
+
+        <div class="battle-stage-shell arcade-shell">
+          <div class="arcade-grid-bg" aria-hidden="true"></div>
+          <div class="arcade-scanlines" aria-hidden="true"></div>
+
+          <header class="arcade-hud" aria-label="Battle status">
+            <div class="hud-cell hud-cell-round">
+              <span class="hud-cell-label">Round</span>
+              <span class="hud-cell-value hud-font" id="round-display">01</span>
+            </div>
+            <div class="hud-cell">
+              <span class="hud-cell-label">Opponent</span>
+              <span class="hud-cell-value hud-font-sm" id="sidebar-persona-name">AI Judge</span>
+            </div>
+            <div class="hud-cell">
+              <span class="hud-cell-label">Attack</span>
+              <span class="hud-cell-value hud-accent-cyan" id="attack-tag">—</span>
+            </div>
+            <div class="hud-cell">
+              <span class="hud-cell-label">Mode</span>
+              <span class="hud-cell-value" id="mode-chip">Practice</span>
+            </div>
+            <div class="hud-cell hud-cell-meter">
+              <span class="hud-cell-label">Confidence</span>
+              <div class="arcade-meter" aria-label="Confidence meter">
+                <div id="confidence-meter-fill" class="arcade-meter-fill confidence-fill"></div>
+              </div>
+            </div>
+            <div class="hud-cell hud-cell-combo">
+              <span class="hud-cell-label">Combo</span>
+              <div class="combo-meter" id="combo-meter" aria-label="Answer momentum">
+                <span class="combo-pip" data-pip="1"></span>
+                <span class="combo-pip" data-pip="2"></span>
+                <span class="combo-pip" data-pip="3"></span>
+                <span class="combo-pip" data-pip="4"></span>
+                <span class="combo-pip" data-pip="5"></span>
+              </div>
+            </div>
+            <div class="hud-cell hud-cell-actions">
+              <button id="btn-end-battle" class="btn btn-arcade-end btn-arcade-end-lg" type="button">End Battle</button>
+              <button id="btn-back-scorecard" class="btn btn-arcade-back" type="button" hidden>Back to Scorecard</button>
+            </div>
+            <span id="round-counter" hidden></span>
+            <span id="attack-tag-chip" hidden></span>
+            <span id="pressure-chip" hidden></span>
+            <span id="battle-phase" hidden></span>
+            <span id="difficulty-label" hidden></span>
+            <span id="sidebar-persona-mode" hidden></span>
+            <span id="pressure-level" hidden></span>
+            <span class="pressure-meter pressure-meter-hud" hidden aria-hidden="true">
+              <span class="pressure-meter-track"><span id="pressure-meter-fill" class="pressure-meter-fill pressure-warmup"></span></span>
+            </span>
+            <span id="battle-progress-fill" class="battle-progress-fill pressure-warmup" hidden aria-hidden="true"></span>
+          </header>
+
+          <nav class="battle-progress-strip arcade-progress" aria-label="Battle progression">
+            <div class="progress-strip-rounds" id="battle-progress-rounds">
+              <span class="progress-node" data-round="1"><span class="progress-node-dot"></span>R1</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="2"><span class="progress-node-dot"></span>R2</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="3"><span class="progress-node-dot"></span>R3</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="4"><span class="progress-node-dot"></span>R4</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="5"><span class="progress-node-dot"></span>R5</span>
+            </div>
+            <div class="progress-strip-attacks" id="battle-progress-attacks" aria-label="Attack progression">
+              <span class="progress-attack-tag" data-attack="User Pain">User Pain</span>
+              <span class="progress-attack-tag" data-attack="Novelty">Novelty</span>
+              <span class="progress-attack-tag" data-attack="MVP Strength">MVP</span>
+              <span class="progress-attack-tag" data-attack="Business Model">Model</span>
+              <span class="progress-attack-tag" data-attack="Objection Handling">Objections</span>
+            </div>
+          </nav>
+
+          <div class="arcade-duel-frame">
+            <div class="fighter-row">
+              <div class="fighter-panel fighter-founder">
+                <div class="fighter-avatar-wrap">
+                  <svg class="holo-avatar holo-founder" viewBox="0 0 64 88" aria-hidden="true">
+                    <defs>
+                      <linearGradient id="holo-f-gold" x1="0" y1="0" x2="0" y2="1"><stop offset="0%" stop-color="#f4d35e"/><stop offset="100%" stop-color="#8a6520"/></linearGradient>
+                    </defs>
+                    <ellipse cx="32" cy="80" rx="22" ry="3" fill="rgba(244,211,94,0.2)"/>
+                    <path d="M18 38 Q32 30 46 38 L48 62 Q32 68 16 62 Z" fill="#1a1208" stroke="url(#holo-f-gold)" stroke-width="1.2"/>
+                    <circle cx="32" cy="24" r="11" fill="#3d2810" stroke="#f4d35e" stroke-width="1"/>
+                    <rect x="38" y="42" width="12" height="16" rx="1.5" fill="#0e0c08" stroke="#f4d35e" stroke-opacity="0.6" transform="rotate(8 44 50)"/>
+                    <path d="M14 38 L8 48 M50 38 L56 46" stroke="#f4d35e" stroke-opacity="0.35" stroke-width="1"/>
+                  </svg>
+                  <span class="fighter-avatar-glow founder-glow"></span>
+                </div>
+                <div class="fighter-label-box">
+                  <span class="fighter-tag">You</span>
+                  <span class="fighter-name">Founder</span>
+                </div>
+                <ul class="signal-stats founder-signals" id="founder-signal-chips">
+                  <li><span>Traction</span><strong>—</strong></li>
+                  <li><span>Market</span><strong>Live</strong></li>
+                  <li><span>Moat</span><strong>Building</strong></li>
+                </ul>
+              </div>
+
+              <div class="duel-node">
+                <div class="duel-node-badge hud-font">
+                  <span id="round-counter-duel">01</span>
+                </div>
+                <span class="duel-node-vs hud-font">VS</span>
+                <span id="duel-pressure-label" class="duel-node-pressure">Warm-up</span>
+                <div class="duel-node-ring" aria-hidden="true"></div>
+              </div>
+
+              <div class="fighter-panel fighter-judge">
+                <div class="fighter-avatar-wrap">
+                  <svg class="holo-avatar holo-judge" viewBox="0 0 64 88" aria-hidden="true">
+                    <defs>
+                      <linearGradient id="holo-j-cyan" x1="0" y1="0" x2="1" y2="0"><stop offset="0%" stop-color="#4ecdc4"/><stop offset="100%" stop-color="#7efff0"/></linearGradient>
+                    </defs>
+                    <ellipse cx="32" cy="80" rx="22" ry="3" fill="rgba(78,205,196,0.15)"/>
+                    <path d="M16 40 Q32 32 48 40 L50 64 Q32 70 14 64 Z" fill="#0a1420" stroke="#4ecdc4" stroke-width="1.2"/>
+                    <rect x="20" y="18" width="24" height="20" rx="4" fill="#060a10" stroke="#4ecdc4" stroke-width="1"/>
+                    <rect x="24" y="26" width="16" height="4" rx="1" fill="url(#holo-j-cyan)"/>
+                    <rect x="24" y="44" width="16" height="14" rx="1" fill="#060a10" stroke="#4ecdc4" stroke-opacity="0.5"/>
+                    <rect x="26" y="50" width="3" height="6" fill="#4ecdc4" fill-opacity="0.5"/>
+                    <rect x="30.5" y="47" width="3" height="9" fill="#7efff0" fill-opacity="0.65"/>
+                    <rect x="35" y="45" width="3" height="11" fill="#4ecdc4"/>
+                  </svg>
+                  <span class="fighter-avatar-glow judge-glow"></span>
+                </div>
+                <div class="fighter-label-box judge-label-box">
+                  <span class="fighter-tag">Judge</span>
+                  <span class="fighter-name" id="judge-fighter-name">AI Judge</span>
+                </div>
+                <ul class="signal-stats judge-signals" id="judge-signal-chips">
+                  <li><span>Style</span><strong id="judge-stat-style">Socratic</strong></li>
+                  <li><span>Focus</span><strong id="judge-stat-focus">—</strong></li>
+                  <li><span>Pressure</span><strong id="judge-stat-pressure">Warm-up</strong></li>
+                </ul>
+              </div>
+            </div>
+
+            <article id="judge-live-card" class="attack-card-arena">
+              <div class="attack-card-banner hud-font">&gt;&gt; ATTACK &lt;&lt;</div>
+              <div class="attack-card-inner">
+                <span id="judge-attack-pill" class="judge-attack-pill attack-card-tag">—</span>
+                <span id="judge-question-meta" class="judge-attack-meta" hidden></span>
+                <blockquote id="judge-question-text" class="judge-question-text attack-card-question">AI judge is preparing the next attack…</blockquote>
+              </div>
+              <div class="attack-card-glow" aria-hidden="true"></div>
+              <div class="judge-card-scan" aria-hidden="true"></div>
+            </article>
+          </div>
+
+          <p id="founder-coach-hint" hidden aria-hidden="true"></p>
+          <p id="micro-coach" class="micro-coach" hidden aria-hidden="true"></p>
+          <p id="answer-hint" class="answer-hint" hidden aria-hidden="true"></p>
+
+          <div class="battle-log-ribbon arcade-log-bar" id="battle-log-ribbon" hidden aria-hidden="true">
+            <span class="battle-log-label hud-font">Battle Log</span>
+            <div class="battle-log-tabs" id="battle-log-tabs" role="tablist"></div>
+            <div class="battle-log-detail" id="battle-log-detail" hidden></div>
+          </div>
+
+          <div id="battle-readiness-prompt" class="battle-readiness-prompt arena-readiness-prompt" hidden>
+            <p id="battle-readiness-text">Enough signal collected. Ready for your scorecard?</p>
+            <div class="battle-readiness-actions">
+              <button id="btn-battle-readiness-end" class="btn btn-primary btn-sm" type="button">End Battle Now</button>
+              <button id="btn-battle-readiness-continue" class="btn btn-ghost btn-sm" type="button">Continue One More Round</button>
+            </div>
+          </div>
+
+          <details id="battle-history" hidden aria-hidden="true"></details>
+
+          <footer class="response-dock arcade-dock unified-dock">
+            <div class="dock-unified-header">
+              <div class="dock-header-main">
+                <p class="response-dock-label hud-font">Your Move</p>
+                <p id="dock-assist-hint" class="dock-assist-hint">Tip: use numbers</p>
+              </div>
+              <button id="btn-open-battle-rounds" class="btn btn-arcade-log-inline previous-rounds-toggle" type="button" hidden>
+                View Battle Log <span id="timeline-count" class="timeline-count"></span>
+              </button>
+            </div>
+
+            <div id="voice-turn-preview" class="voice-turn-preview voice-console-preview" hidden>
+              <h4>Voice transcript</h4>
+              <div class="voice-wave-decor voice-wave-active" aria-hidden="true"></div>
+              <textarea id="voice-turn-transcript" rows="3" placeholder="Edit transcript before sending…"></textarea>
+              <p id="voice-turn-delivery" class="voice-delivery-note"></p>
+              <div class="voice-turn-actions">
+                <button id="btn-voice-turn-send" class="btn btn-primary btn-sm" type="button">Send Voice Answer</button>
+                <button id="btn-voice-turn-cancel" class="btn btn-ghost btn-sm" type="button">Discard</button>
+              </div>
+            </div>
+
+            <form id="chat-form" class="response-dock-form arcade-dock-form">
+              <textarea id="user-input" rows="3" placeholder="Type your defense here…"></textarea>
+              <div class="response-action-row arcade-action-row">
+                <div class="response-action-left">
+                  <button id="btn-voice-turn-record" class="btn btn-arcade-voice" type="button" aria-label="Voice mode — record answer">
+                    <span class="arcade-voice-ring" aria-hidden="true"></span>
+                    <svg class="arcade-voice-icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false">
+                      <path fill="currentColor" d="M12 14a3 3 0 0 0 3-3V6a3 3 0 1 0-6 0v5a3 3 0 0 0 3 3zm5-3a5 5 0 0 1-10 0H5a7 7 0 0 0 6 6.92V21h2v-3.08A7 7 0 0 0 19 11h-2z"/>
+                    </svg>
+                    <span class="arcade-voice-label">Voice Mode</span>
+                  </button>
+                  <span id="voice-turn-timer" class="voice-timer voice-timer-inline hud-font">0:00</span>
+                  <span id="voice-turn-status" class="voice-status"></span>
+                  <div class="dock-hint-chips hint-chips" aria-label="Answer hints">
+                    <button type="button" class="hint-chip" data-hint="We measured ">Proof</button>
+                    <button type="button" class="hint-chip" data-hint="Our users ">User</button>
+                    <button type="button" class="hint-chip" data-hint="Traction: ">Traction</button>
+                  </div>
+                </div>
+                <button id="btn-send" type="submit" class="btn btn-arcade-send">Send &gt;&gt;</button>
+              </div>
+            </form>
+            <p id="battle-status" class="status-text battle-status-msg" hidden></p>
+          </footer>
         </div>
       </div>
     </section>
 
     <!-- Scorecard -->
     <section id="screen-scorecard" class="screen">
-      <div class="panel glass scorecard-panel">
-        <header class="scorecard-header">
-          <div class="scorecard-header-left">
-            <h2>Battle Scorecard</h2>
-            <button id="btn-view-conversation" class="btn btn-ghost btn-sm">View Conversation</button>
-          </div>
-          <div class="overall-score">
-            <span>Overall</span>
-            <strong id="overall-score">0</strong>
-            <span id="overall-label" hidden style="font-size:0.85rem;color:var(--gold);display:block;margin-top:0.2rem"></span>
-          </div>
-          <p id="scorecard-source-badge" hidden style="font-size:0.8rem;opacity:0.7;margin:0"></p>
-        </header>
+      <div class="results-shell results-compact">
+        <article class="results-hero-card glass">
+          <header class="results-hero-header">
+            <div class="results-hero-header-left">
+              <p class="results-eyebrow">Pitch Battle Result</p>
+              <button id="btn-view-conversation" class="btn btn-conversation-review" type="button">View Conversation</button>
+            </div>
+            <p id="scorecard-source-badge" class="source-chip" hidden></p>
+          </header>
+          <p id="scorecard-fallback-warning" class="results-fallback-warn" hidden></p>
+
+          <div class="results-hero-grid">
+            <div class="score-orb-wrap">
+              <div class="score-orb" aria-label="Overall pitch score">
+                <strong id="overall-score" class="score-orb-value">0</strong>
+                <span id="overall-label" class="score-orb-label"></span>
+              </div>
+            </div>
+            <div class="results-hero-center">
+              <p id="pitch-readout" class="result-verdict-text">Your pitch battle is complete.</p>
+              <div class="insight-grid score-triad" id="pitch-stat-chips">
+                <span class="source-chip chip-strong" id="chip-strongest-dim">Strongest: —</span>
+                <span class="source-chip chip-weak" id="chip-weakest-dim">Weakest: —</span>
+                <span class="source-chip chip-source" id="chip-score-source" hidden>Nemotron Judge</span>
+              </div>
+            </div>
+          </div>
+
+          <div class="result-next-action result-next-action-compact" id="pitch-next-action" hidden>
+            <span class="result-next-action-label">Next</span>
+            <p id="pitch-next-action-text" class="result-next-action-text"></p>
+          </div>
+
+          <div class="scorecard-actions results-hero-actions results-hero-actions-compact">
+            <button id="btn-path-to-80" class="btn btn-path80" type="button">View Path to 80+</button>
+            <button id="btn-reset" class="btn btn-primary" type="button">New Battle</button>
+            <button id="btn-back-setup" class="btn btn-secondary" type="button">Edit Startup</button>
+          </div>
+        </article>
+
+        <article id="judge-verdict-hero" class="judge-verdict-hero glass" hidden>
+          <p class="results-eyebrow">Judge Verdict</p>
+          <div id="judge-verdict-section" class="judge-verdict-panel">
+            <article id="judge-verdict-card" class="judge-verdict-card glass-inner">
+              <div class="judge-verdict-head">
+                <span id="verdict-persona-badge" class="verdict-persona-badge result-verdict-badge"></span>
+                <span id="verdict-interest-badge" class="verdict-interest-badge"></span>
+              </div>
+              <blockquote id="verdict-reaction" class="verdict-reaction verdict-reaction-compact"></blockquote>
+              <div class="verdict-meta-grid verdict-meta-compact">
+                <div><span>Deal Type</span><strong id="verdict-deal-type"></strong></div>
+                <div><span>Why</span><strong id="verdict-why" class="clamp-text clamp-short"></strong></div>
+              </div>
+              <p id="verdict-opening-offer" class="verdict-opening-offer" hidden></p>
+              <div id="verdict-actions" class="verdict-actions"></div>
+            </article>
+          </div>
+        </article>
+
+        <nav class="result-tabs" id="pitch-result-tabs" role="tablist" aria-label="Pitch scorecard sections">
+          <button type="button" class="result-tab active" role="tab" aria-selected="true" data-tab="overview">Overview</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="dimensions">Dimensions</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="coaching">Coaching</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="voice" id="tab-voice-delivery" hidden>Voice Delivery</button>
+        </nav>
+
+        <div class="result-panels" id="pitch-result-panels">
+          <section class="result-panel active" data-panel="overview" role="tabpanel">
+            <div class="answer-compare overview-answers overview-answers-compact">
+              <article class="feedback-card answer-card answer-best coaching-card">
+                <div class="feedback-card-head">
+                  <span class="answer-badge answer-badge-best">Strongest Answer</span>
+                  <span id="best-answer-round" class="round-badge" hidden></span>
+                </div>
+                <blockquote id="best-answer" class="answer-quote clamp-text clamp-short"></blockquote>
+              </article>
+              <article class="feedback-card answer-card answer-weak coaching-card">
+                <div class="feedback-card-head">
+                  <span class="answer-badge answer-badge-weak">Weakest Answer</span>
+                  <span id="weakest-answer-round" class="round-badge" hidden></span>
+                </div>
+                <blockquote id="weakest-answer" class="answer-quote answer-quote-weak clamp-text clamp-short"></blockquote>
+                <p id="why-weak" class="why-weak-note clamp-text clamp-short" hidden></p>
+              </article>
+            </div>
+            <div id="signals-summary" class="insight-grid signals-chips signals-chips-compact" hidden></div>
+          </section>
+
+          <section class="result-panel" data-panel="dimensions" role="tabpanel" hidden>
+            <div id="score-bars" class="dimension-list"></div>
+          </section>
+
+          <section class="result-panel" data-panel="coaching" role="tabpanel" hidden>
+            <div class="feedback-grid coaching-grid">
+              <article class="feedback-card highlight coaching-card">
+                <div class="feedback-card-head">
+                  <span class="feedback-icon" aria-hidden="true">✦</span>
+                  <h3>Improved Answer</h3>
+                </div>
+                <p id="improved-answer" class="feedback-body clamp-text"></p>
+              </article>
+              <article class="feedback-card highlight coaching-card">
+                <div class="feedback-card-head">
+                  <span class="feedback-icon" aria-hidden="true">◎</span>
+                  <h3>Improved Pitch</h3>
+                </div>
+                <p id="improved-pitch" class="feedback-body clamp-text"></p>
+              </article>
+            </div>
+            <div class="coaching-card prep-questions">
+              <h3 class="scorecard-section-title">Top 3 Prep Questions</h3>
+              <ol id="top-questions" class="prep-list prep-checklist"></ol>
+            </div>
+          </section>
 
-        <div id="score-bars" class="score-bars"></div>
+          <section class="result-panel" data-panel="voice" role="tabpanel" hidden>
+            <div id="voice-delivery-section" class="voice-delivery-panel">
+              <p class="scorecard-section-desc">Observable delivery cues from your spoken answers.</p>
+              <div id="voice-delivery-content" class="voice-delivery-grid"></div>
+            </div>
+          </section>
+        </div>
+      </div>
+    </section>
+
+    <!-- Deal Arena — Pass 3B Duel Stage -->
+    <section id="screen-deal" class="screen screen-arena">
+      <div class="battle-arena-wrap deal-arena-wrap">
+        <div class="battle-arena-scene deal-arena-scene" aria-hidden="true">
+          <div class="battle-arena-glow battle-arena-glow-left"></div>
+          <div class="battle-arena-glow battle-arena-glow-right deal-glow-right"></div>
+          <div class="battle-arena-spotlight deal-spotlight"></div>
+          <div class="battle-arena-floor"></div>
+          <div class="arena-energy-lines deal-energy-lines"></div>
+        </div>
+
+        <div class="battle-stage-shell deal-stage-shell arcade-shell deal-arcade-shell">
+          <div class="arcade-grid-bg" aria-hidden="true"></div>
+          <div class="arcade-scanlines" aria-hidden="true"></div>
+          <header class="battle-hud deal-hud glass" aria-label="Deal status">
+            <div class="battle-hud-main">
+              <span class="hud-round">DEAL <span id="deal-round-display">01</span></span>
+              <span class="hud-sep" aria-hidden="true"></span>
+              <span class="hud-opponent" id="deal-persona-name">—</span>
+              <span class="hud-meta">Type: <strong id="deal-type-label">—</strong></span>
+              <span class="hud-meta">Focus: <strong id="deal-negotiation-tag">—</strong></span>
+              <span class="hud-mode deal-hud-chip" id="deal-type-chip">—</span>
+            </div>
+            <div class="battle-hud-actions">
+              <button id="btn-open-deal-rounds" class="btn btn-ghost btn-sm previous-rounds-toggle" type="button" hidden>
+                Full Log <span id="deal-timeline-count" class="timeline-count"></span>
+              </button>
+              <button id="btn-end-deal" class="btn btn-danger btn-sm" type="button">End Deal</button>
+              <button id="btn-deal-back-scorecard" class="btn btn-ghost btn-sm" type="button">Back to Pitch Scorecard</button>
+            </div>
+            <span id="deal-round-counter" hidden></span>
+            <span id="deal-focus-chip" hidden></span>
+          </header>
+
+          <nav class="battle-progress-strip deal-progress-strip glass" aria-label="Deal progression">
+            <div class="progress-strip-rounds" id="deal-progress-rounds">
+              <span class="progress-node" data-round="1"><span class="progress-node-dot"></span>R1</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="2"><span class="progress-node-dot"></span>R2</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="3"><span class="progress-node-dot"></span>R3</span>
+              <span class="progress-connector" aria-hidden="true"></span>
+              <span class="progress-node" data-round="4"><span class="progress-node-dot"></span>R4</span>
+            </div>
+          </nav>
+
+          <div class="battle-log-ribbon glass deal-log-ribbon" id="deal-log-ribbon" hidden>
+            <span class="battle-log-label">Negotiation Log</span>
+            <div class="battle-log-tabs" id="deal-log-tabs" role="tablist"></div>
+            <div class="battle-log-detail" id="deal-log-detail" hidden></div>
+          </div>
+
+          <div class="duel-stage duel-stage-arena deal-duel-stage">
+            <div class="duel-stage-beam duel-beam-founder" aria-hidden="true"></div>
+            <div class="duel-stage-beam duel-beam-judge deal-beam" aria-hidden="true"></div>
+
+            <aside class="duel-founder-card glass deal-founder-card">
+              <div class="duel-card-inner">
+                <div class="duel-character duel-character-founder deal-character" aria-hidden="true">
+                  <svg class="duel-svg duel-svg-founder" viewBox="0 0 80 120" xmlns="http://www.w3.org/2000/svg">
+                    <ellipse cx="40" cy="112" rx="28" ry="4" fill="rgba(74,222,128,0.12)"/>
+                    <path d="M24 52 Q40 44 56 52 L60 88 Q40 94 20 88 Z" fill="#1a3028" stroke="#4ade80" stroke-opacity="0.3"/>
+                    <ellipse cx="40" cy="36" rx="14" ry="16" fill="#c9954a"/>
+                    <rect x="48" y="58" width="18" height="24" rx="2" fill="#1a1510" stroke="#4ade80" stroke-opacity="0.45" transform="rotate(6 57 70)"/>
+                  </svg>
+                  <span class="duel-char-glow duel-char-glow-deal"></span>
+                </div>
+                <div class="duel-founder-body">
+                  <p class="duel-side-label">Your Terms</p>
+                  <dl class="deal-terms-mini">
+                    <div><dt>Opening Offer</dt><dd id="deal-opening-offer">—</dd></div>
+                    <div><dt>Your Ask</dt><dd id="deal-your-ask">—</dd></div>
+                  </dl>
+                  <p class="founder-coach-single">Counter with evidence, leverage, and clarity.</p>
+                </div>
+              </div>
+            </aside>
+
+            <div class="duel-core deal-core">
+              <div class="duel-pressure-ring deal-pressure-ring pressure-core-live">
+                <span class="duel-core-pulse" aria-hidden="true"></span>
+                <span class="duel-vs">VS</span>
+                <span class="duel-core-round">D<span id="deal-round-counter-duel">1</span></span>
+              </div>
+            </div>
+
+            <article id="deal-judge-card" class="duel-judge-card judge-attack-card deal-judge-card glass">
+              <div class="judge-attack-glow deal-attack-glow" aria-hidden="true"></div>
+              <div class="duel-card-inner judge-card-inner">
+                <div class="duel-character duel-character-judge" aria-hidden="true">
+                  <svg class="duel-svg duel-svg-judge" viewBox="0 0 80 120" xmlns="http://www.w3.org/2000/svg">
+                    <ellipse cx="40" cy="112" rx="28" ry="4" fill="rgba(74,222,128,0.1)"/>
+                    <path d="M22 54 Q40 46 58 54 L62 90 Q40 96 18 90 Z" fill="#0a2018" stroke="#4ade80" stroke-opacity="0.35"/>
+                    <rect x="26" y="28" width="28" height="26" rx="5" fill="#0a1420" stroke="#4ade80" stroke-opacity="0.5"/>
+                    <rect x="30" y="38" width="20" height="6" rx="1" fill="#4ade80" fill-opacity="0.6"/>
+                    <rect x="28" y="58" width="24" height="28" rx="2" fill="#060a10" stroke="#4ade80" stroke-opacity="0.35"/>
+                  </svg>
+                  <span class="duel-char-glow duel-char-glow-judge deal-glow"></span>
+                </div>
+                <div class="judge-attack-body">
+                  <div class="judge-card-head">
+                    <span class="judge-badge">AI Judge</span>
+                    <span id="deal-judge-attack-pill" class="judge-attack-pill deal-pill">—</span>
+                  </div>
+                  <span id="deal-judge-meta" class="judge-attack-meta" hidden></span>
+                  <blockquote id="deal-judge-text" class="judge-question-text judge-question-quote">Preparing deal terms…</blockquote>
+                </div>
+              </div>
+              <div class="judge-card-scan deal-scan" aria-hidden="true"></div>
+            </article>
+          </div>
+
+          <div id="deal-readiness-prompt" class="deal-readiness-prompt arena-readiness-prompt" hidden>
+            <p id="deal-readiness-text">You have enough negotiation signal for a scorecard.</p>
+            <div class="deal-readiness-actions">
+              <button id="btn-deal-readiness-end" class="btn btn-primary btn-sm" type="button">End Deal Now</button>
+              <button id="btn-deal-readiness-continue" class="btn btn-ghost btn-sm" type="button">Continue One More Round</button>
+            </div>
+          </div>
+
+          <div id="deal-rounds-drawer" class="previous-rounds-drawer" hidden>
+            <button type="button" class="previous-rounds-backdrop" id="btn-close-deal-rounds" aria-label="Close previous rounds"></button>
+            <div class="previous-rounds-panel glass" role="dialog" aria-labelledby="deal-rounds-title">
+              <header class="previous-rounds-header">
+                <h3 id="deal-rounds-title">Previous Rounds</h3>
+                <button type="button" class="btn btn-ghost btn-sm" id="btn-close-deal-rounds-x">Close</button>
+              </header>
+              <div id="deal-chat-window" class="chat-window battle-timeline deal-timeline previous-rounds-timeline" aria-live="polite"></div>
+            </div>
+          </div>
+          <details id="deal-history" hidden aria-hidden="true"></details>
+
+          <footer class="response-dock glass deal-response-dock response-dock-move">
+            <div class="response-dock-header">
+              <p class="response-dock-label">Your Counter</p>
+              <p class="dock-assist-hint">Anchor on evidence. Concede with leverage.</p>
+            </div>
+
+            <div id="deal-voice-preview" class="voice-turn-preview voice-console-preview" hidden>
+              <h4>Voice transcript</h4>
+              <div class="voice-wave-decor voice-wave-active" aria-hidden="true"></div>
+              <textarea id="deal-voice-transcript" rows="3" placeholder="Edit transcript before sending…"></textarea>
+              <div class="voice-turn-actions">
+                <button id="btn-deal-voice-send" class="btn btn-primary btn-sm" type="button">Send Counter</button>
+                <button id="btn-deal-voice-cancel" class="btn btn-ghost btn-sm" type="button">Discard</button>
+              </div>
+            </div>
+
+            <form id="deal-form" class="response-dock-form">
+              <textarea id="deal-input" rows="4" placeholder="Defend your terms with evidence and leverage…"></textarea>
+              <div class="response-action-row">
+                <div class="response-action-left">
+                  <button id="btn-deal-voice-record" class="voice-mic-btn voice-mic-btn-sm voice-pill" type="button" aria-label="Record counter">
+                    <span class="mic-ring"></span>
+                    <span class="mic-icon">🎙</span>
+                  </button>
+                  <span class="input-tab-label">Voice</span>
+                  <span id="deal-voice-timer" class="voice-timer voice-timer-inline">0:00</span>
+                  <span id="deal-voice-status" class="voice-status"></span>
+                </div>
+                <button id="btn-deal-send" type="submit" class="btn btn-deal-send btn-send-answer">Send Counter</button>
+              </div>
+            </form>
+            <p id="deal-status" class="status-text battle-status-msg" hidden></p>
+          </footer>
+        </div>
+      </div>
+    </section>
+
+    <!-- Deal + Combined Scorecard -->
+    <section id="screen-deal-scorecard" class="screen">
+      <div class="results-shell">
+        <article class="results-hero-card glass">
+          <header class="results-hero-header">
+            <p class="results-eyebrow">Combined Founder Readout</p>
+            <p id="deal-scorecard-meta" class="source-chip" hidden></p>
+          </header>
+
+          <div class="score-triad combined-score-triad">
+            <div class="combined-score-item">
+              <span>Pitch</span>
+              <strong id="combined-pitch">0</strong>
+            </div>
+            <div class="combined-score-item">
+              <span>Deal</span>
+              <strong id="combined-deal">0</strong>
+            </div>
+            <div class="combined-score-item combined-highlight">
+              <span>Combined</span>
+              <strong id="combined-overall">0</strong>
+            </div>
+          </div>
+
+          <p id="combined-profile" class="result-verdict-text combined-profile"></p>
+          <p id="combined-summary" class="combined-summary clamp-text"></p>
+
+          <div class="result-next-action">
+            <span class="result-next-action-label">Next Best Action</span>
+            <p id="combined-next-action" class="result-next-action-text"></p>
+          </div>
+
+          <div class="deal-outcome-row results-hero-meta">
+            <span id="deal-outcome-badge" class="deal-outcome-badge result-verdict-badge"></span>
+            <span id="deal-overall-label" class="deal-overall-label"></span>
+          </div>
+
+          <div class="scorecard-actions results-hero-actions">
+            <button id="btn-deal-view-pitch-scorecard" class="btn btn-secondary" type="button">View Pitch Breakdown</button>
+            <button id="btn-deal-view-negotiation" class="btn btn-secondary" type="button">View Negotiation Conversation</button>
+            <button id="btn-deal-new-battle" class="btn btn-primary" type="button">New Battle</button>
+          </div>
+        </article>
+
+        <nav class="result-tabs" id="deal-result-tabs" role="tablist" aria-label="Deal scorecard sections">
+          <button type="button" class="result-tab active" role="tab" aria-selected="true" data-tab="deal-summary">Combined Summary</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="pitch-vs-deal">Pitch vs Deal</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="deal-dimensions">Deal Dimensions</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="deal-highlights">Highlights</button>
+          <button type="button" class="result-tab" role="tab" aria-selected="false" data-tab="deal-coaching">Coaching</button>
+        </nav>
+
+        <div class="result-panels" id="deal-result-panels">
+          <section class="result-panel active" data-panel="deal-summary" role="tabpanel">
+            <div class="coaching-card">
+              <h3 class="scorecard-section-title">Session Snapshot</h3>
+              <p class="scorecard-section-desc">Your final founder profile after pitch + deal.</p>
+              <p id="deal-summary-weakest" class="deal-weakest-line"></p>
+            </div>
+          </section>
+
+          <section class="result-panel" data-panel="pitch-vs-deal" role="tabpanel" hidden>
+            <div class="score-triad combined-score-triad compact-triad">
+              <div class="combined-score-item"><span>Pitch</span><strong id="combined-pitch-tab">0</strong></div>
+              <div class="combined-score-item"><span>Deal</span><strong id="combined-deal-tab">0</strong></div>
+              <div class="combined-score-item combined-highlight"><span>Combined</span><strong id="combined-overall-tab">0</strong></div>
+            </div>
+            <p id="combined-profile-tab" class="combined-profile"></p>
+          </section>
+
+          <section class="result-panel" data-panel="deal-dimensions" role="tabpanel" hidden>
+            <div id="deal-score-bars" class="dimension-list"></div>
+          </section>
+
+          <section class="result-panel" data-panel="deal-highlights" role="tabpanel" hidden>
+            <div class="feedback-grid coaching-grid">
+              <article class="feedback-card coaching-card"><h3>Best Move</h3><p id="deal-best-move" class="clamp-text"></p></article>
+              <article class="feedback-card coaching-card answer-weak"><h3>Weakest Move</h3><p id="deal-weakest-move" class="clamp-text"></p></article>
+            </div>
+          </section>
+
+          <section class="result-panel" data-panel="deal-coaching" role="tabpanel" hidden>
+            <article class="feedback-card highlight coaching-card">
+              <h3>Improved Response</h3>
+              <p id="deal-improved-response" class="clamp-text"></p>
+            </article>
+            <div class="coaching-card">
+              <h3 class="scorecard-section-title">Top 3 Prep Points</h3>
+              <ol id="deal-prep-points" class="prep-list prep-checklist"></ol>
+            </div>
+          </section>
+        </div>
+      </div>
+    </section>
+  </main>
+
+  <!-- Battle log — body-level so arena overflow does not clip the modal -->
+  <div id="battle-rounds-drawer" class="previous-rounds-drawer conversation-split-drawer" hidden>
+    <button type="button" class="previous-rounds-backdrop" id="btn-close-battle-rounds" aria-label="Close battle log"></button>
+    <div class="conversation-split-panel glass" role="dialog" aria-labelledby="battle-rounds-title">
+      <header class="conversation-split-header">
+        <h3 id="battle-rounds-title">Battle Log</h3>
+        <button type="button" class="btn btn-ghost btn-sm" id="btn-close-battle-rounds-x">Close</button>
+      </header>
+      <div class="conversation-split-body">
+        <aside id="conversation-sidebar" class="conversation-sidebar" aria-label="Battle details"></aside>
+        <div class="conversation-thread-wrap">
+          <p class="conversation-thread-hint" aria-hidden="true">Scroll for full history ↓</p>
+          <div id="chat-window" class="chat-window conversation-thread" aria-live="polite"></div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Negotiation Conversation Overlay -->
+  <div id="negotiation-overlay" class="negotiation-overlay conversation-modal" hidden aria-modal="true" role="dialog" aria-label="Negotiation Conversation">
+    <div class="negotiation-panel glass results-modal-panel">
+      <div class="negotiation-header">
+        <div>
+          <p class="results-eyebrow">Deal Phase</p>
+          <h2>Negotiation Conversation</h2>
+        </div>
+        <button id="btn-close-negotiation" class="btn btn-ghost btn-sm" type="button">✕ Close</button>
+      </div>
+      <div id="negotiation-transcript" class="negotiation-transcript conversation-timeline"></div>
+      <div class="negotiation-footer">
+        <button id="btn-negotiation-back" class="btn btn-secondary btn-sm" type="button">Back to Deal Scorecard</button>
+      </div>
+    </div>
+  </div>
 
-        <p id="signals-summary" class="signals-summary" hidden></p>
+  <!-- Coaching Roadmap Overlay -->
+  <div id="path80-overlay" class="path80-overlay conversation-modal" hidden aria-modal="true" role="dialog" aria-label="Path to 80+">
+    <div class="path80-panel glass results-modal-panel">
+      <div class="path80-header">
+        <div>
+          <p class="results-eyebrow path80-eyebrow">Coaching Roadmap</p>
+          <h2 class="path80-title">Path to 80+</h2>
+          <p class="path80-subtitle">What stopped this pitch from becoming investor-ready.</p>
+        </div>
+        <button id="btn-close-path80" class="btn btn-ghost btn-sm" aria-label="Close">✕ Close</button>
+      </div>
+
+      <div class="path80-score-bar results-score-lift">
+        <div class="path80-score-item">
+          <span class="path80-score-label">Current Score</span>
+          <strong id="p80-current-score" class="path80-score-num">—</strong>
+        </div>
+        <div class="path80-arrow">→</div>
+        <div class="path80-score-item">
+          <span class="path80-score-label">Potential Score</span>
+          <strong id="p80-estimated-score" class="path80-score-num path80-score-green">—</strong>
+        </div>
+        <p id="p80-estimate-reason" class="path80-estimate-reason clamp-text"></p>
+      </div>
 
-        <div class="feedback-grid">
-          <article class="feedback-card highlight">
-            <h3>Improved Answer</h3>
-            <p id="improved-answer"></p>
+      <div class="path80-sections insight-grid path80-sections-compact">
+        <div class="path80-card coaching-card path80-card-compact">
+          <h3 class="path80-card-title">Why You Scored This</h3>
+          <p id="p80-why-scored" class="path80-card-body clamp-text clamp-short"></p>
+        </div>
+
+        <div class="path80-card path80-card-alert coaching-card path80-card-compact">
+          <h3 class="path80-card-title">What Stopped 80+</h3>
+          <p id="p80-what-stopped" class="path80-card-body clamp-text clamp-short"></p>
+        </div>
+
+        <div class="path80-card path80-card-retry coaching-card path80-card-retry-compact">
+          <h3 class="path80-card-title">One Answer to Retry</h3>
+          <div class="path80-retry-meta">
+            <span id="p80-retry-dim" class="path80-dim-badge source-chip"></span>
+            <span id="p80-retry-round" class="path80-round-tag source-chip"></span>
+          </div>
+          <div class="path80-retry-grid">
+            <div>
+              <p class="path80-answer-label">Original Answer</p>
+              <blockquote id="p80-original-answer" class="path80-quote path80-quote-weak quote-chip clamp-text clamp-short"></blockquote>
+            </div>
+            <div>
+              <p class="path80-answer-label">How to Fix It</p>
+              <p id="p80-retry-advice" class="path80-card-body clamp-text clamp-short"></p>
+            </div>
+          </div>
+          <details class="path80-sample-details">
+            <summary>Sample stronger answer</summary>
+            <blockquote id="p80-sample-answer" class="path80-quote path80-quote-strong quote-chip"></blockquote>
+          </details>
+          <p id="p80-why-it-hurt" class="path80-card-body path80-muted clamp-text clamp-short path80-why-hurt"></p>
+        </div>
+      </div>
+
+      <div class="path80-footer">
+        <button id="btn-retry-question" class="btn btn-retry-start" type="button">Retry This Question</button>
+        <button id="btn-close-path80-bottom" class="btn btn-secondary" type="button">Close</button>
+      </div>
+    </div>
+  </div>
+
+  <!-- Retry Weakest Question Drill -->
+  <div id="retry-overlay" class="retry-overlay conversation-modal" hidden aria-modal="true" role="dialog" aria-label="Retry Weakest Question">
+    <div class="retry-panel glass results-modal-panel retry-drill-panel">
+      <div class="retry-header">
+        <div>
+          <p class="results-eyebrow">Training Drill</p>
+          <h2 class="retry-title">Rematch Drill</h2>
+          <p class="retry-subtitle">Practice the answer that held your score back.</p>
+        </div>
+        <button id="btn-close-retry" class="btn btn-ghost btn-sm" aria-label="Close">✕ Close</button>
+      </div>
+
+      <div id="retry-drill-view" class="retry-drill-view">
+        <div class="retry-cards insight-grid">
+          <article class="retry-card coaching-card">
+            <h3>Original Question</h3>
+            <p id="retry-original-question" class="retry-card-body clamp-text"></p>
           </article>
-          <article class="feedback-card highlight">
-            <h3>Improved Pitch</h3>
-            <p id="improved-pitch"></p>
+          <article class="retry-card retry-card-weak coaching-card">
+            <h3>Your Previous Answer</h3>
+            <blockquote id="retry-original-answer" class="retry-quote quote-chip clamp-text"></blockquote>
           </article>
-          <article class="feedback-card">
-            <h3>Best Answer</h3>
-            <p id="best-answer"></p>
+          <article class="retry-card coaching-card">
+            <h3>Why It Hurt</h3>
+            <p id="retry-why-hurt" class="retry-card-body clamp-text"></p>
           </article>
-          <article class="feedback-card">
-            <h3>Weakest Answer</h3>
-            <p id="weakest-answer"></p>
+          <article class="retry-card retry-card-tip coaching-card">
+            <h3>Sample Stronger Direction</h3>
+            <blockquote id="retry-sample" class="retry-quote retry-quote-strong quote-chip clamp-text"></blockquote>
           </article>
         </div>
 
-        <div class="prep-questions">
-          <h3>Top 3 Prep Questions</h3>
-          <ol id="top-questions"></ol>
+        <div class="retry-answer-area coaching-card">
+          <label class="retry-input-label" for="retry-answer-input">Your retry answer</label>
+          <div class="retry-input-row">
+            <button id="btn-retry-voice-record" class="voice-mic-btn voice-mic-btn-sm" type="button" aria-label="Record retry answer">
+              <span class="mic-ring"></span>
+              <span class="mic-icon">🎙</span>
+            </button>
+            <span id="retry-voice-timer" class="voice-timer voice-timer-inline">0:00</span>
+            <span id="retry-voice-status" class="voice-status"></span>
+          </div>
+          <textarea id="retry-answer-input" rows="3" placeholder="Give a stronger answer with a specific fact, number, or example…"></textarea>
+          <div id="retry-voice-preview" class="retry-voice-preview" hidden>
+            <p class="retry-input-label">Voice transcript — edit before submitting</p>
+            <textarea id="retry-voice-transcript" rows="2"></textarea>
+          </div>
+          <button id="btn-submit-retry" class="btn btn-retry-submit" type="button">Submit Retry Answer</button>
         </div>
+      </div>
 
-        <div class="scorecard-actions">
-          <button id="btn-reset" class="btn btn-secondary">New Battle</button>
-          <button id="btn-back-setup" class="btn btn-primary">Edit Startup</button>
+      <div id="retry-result-view" class="retry-result-view" hidden>
+        <h3 class="retry-result-title">Rematch Drill Result</h3>
+        <div class="retry-vs-grid">
+          <article class="retry-card retry-card-weak coaching-card">
+            <h4>Old Answer</h4>
+            <p id="retry-result-old" class="retry-card-body clamp-text"></p>
+          </article>
+          <article class="retry-card retry-card-strong coaching-card">
+            <h4>New Answer</h4>
+            <p id="retry-result-new" class="retry-card-body clamp-text"></p>
+          </article>
+        </div>
+        <div class="retry-feedback-grid insight-grid">
+          <article class="retry-card coaching-card"><h4>What improved</h4><p id="retry-what-improved" class="clamp-text"></p></article>
+          <article class="retry-card coaching-card"><h4>Still missing</h4><p id="retry-still-missing" class="clamp-text"></p></article>
+          <article class="retry-card coaching-card"><h4>Specific tip</h4><p id="retry-specific-tip" class="clamp-text"></p></article>
+        </div>
+        <div class="retry-estimate-bar results-score-lift">
+          <span id="retry-dim-estimate" class="retry-dim-estimate"></span>
+          <span id="retry-overall-lift" class="retry-overall-lift"></span>
+          <span id="retry-verdict-badge" class="retry-verdict-badge result-verdict-badge"></span>
+        </div>
+        <p id="retry-next-prompt" class="retry-next-prompt clamp-text"></p>
+        <div class="retry-result-actions scorecard-actions">
+          <button id="btn-retry-again" class="btn btn-retry-start" type="button">Retry Again</button>
+          <button id="btn-retry-back-scorecard" class="btn btn-secondary" type="button">Back to Scorecard</button>
+          <button id="btn-retry-new-battle" class="btn btn-primary" type="button">New Battle</button>
         </div>
       </div>
-    </section>
-  </main>
+    </div>
+  </div>
 
-  <div id="loading-overlay" class="loading-overlay" hidden>
-    <div class="spinner"></div>
-    <p>Loading...</p>
+  <div id="loading-overlay" class="loading-overlay arena-loading" hidden>
+    <div class="arena-loading-panel">
+      <div class="spinner"></div>
+      <div class="arena-loading-scan" aria-hidden="true"></div>
+      <p id="loading-message">Loading…</p>
+    </div>
   </div>
 
   <script type="module" src="/frontend/script.js"></script>
+  <!-- voice.js imported by script.js -->
 </body>
 </html>

frontend/script.js

@@ -1,21 +1,56 @@
+import { initVoiceUI } from "./voice.js";
+
 const state = {
   sessionId: null,
   persona: "hackathon_judge",
+  difficultyProfile: "practice",
   round: 1,
+  scoreExplanation: null,
+  startMode: "text",
+  pendingVoicePitch: null,
+  pendingVoiceTurn: null,
+  retryDrill: null,
+  pendingRetryVoiceTurn: null,
+  judgeVerdict: null,
+  dealContext: null,
+  dealRound: 1,
+  uiMode: "pitch",
+  pendingDealVoiceTurn: null,
+  negotiationTranscript: [],
+  conversationLog: [],
+  dealConversationLog: [],
+  battleLog: [],
+  dealBattleLog: [],
+  battleMetaSnapshot: null,
+  scorecardSnapshot: null,
 };
 
+let liveJudgeTurn = { text: "", meta: "" };
+let liveFounderReply = "";
+let liveDealJudgeTurn = { text: "", meta: "" };
+let liveDealFounderReply = "";
+
 const screens = {
   landing: document.getElementById("screen-landing"),
+  startMethod: document.getElementById("screen-start-method"),
+  voicePitch: document.getElementById("screen-voice-pitch"),
+  voiceConfirm: document.getElementById("screen-voice-confirm"),
   setup: document.getElementById("screen-setup"),
   battle: document.getElementById("screen-battle"),
   scorecard: document.getElementById("screen-scorecard"),
+  deal: document.getElementById("screen-deal"),
+  dealScorecard: document.getElementById("screen-deal-scorecard"),
 };
 
+const dealChatWindow = document.getElementById("deal-chat-window");
+const dealInput = document.getElementById("deal-input");
+const dealStatus = document.getElementById("deal-status");
+
 const startupForm = document.getElementById("startup-form");
 const chatWindow = document.getElementById("chat-window");
 const userInput = document.getElementById("user-input");
 const loadingOverlay = document.getElementById("loading-overlay");
-const loadingText = loadingOverlay?.querySelector("p");
+const loadingText = document.getElementById("loading-message");
 const battleStatus = document.getElementById("battle-status");
 const errorBanner = document.getElementById("error-banner");
 
@@ -23,6 +58,93 @@ function showScreen(name) {
   Object.entries(screens).forEach(([key, el]) => {
     el.classList.toggle("active", key === name);
   });
+  if (name === "landing" && landingIntroComplete) {
+    finalizeLandingIntroStatic();
+  }
+}
+
+/* ---- Landing typewriter intro (Pass 1 — isolated, no API impact) ---- */
+
+let landingIntroComplete = false;
+let landingIntroRunning = false;
+
+function prefersReducedMotion() {
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
+function finalizeLandingIntroStatic() {
+  const line1Text = document.querySelector("#landing-type-line-1 .arena-type-text");
+  const line2Text = document.querySelector("#landing-type-line-2 .arena-type-text");
+  const line1 = document.getElementById("landing-type-line-1");
+  const line2 = document.getElementById("landing-type-line-2");
+  const landing = document.querySelector(".arena-landing");
+
+  if (line1Text?.dataset.text) line1Text.textContent = line1Text.dataset.text;
+  if (line2Text?.dataset.text) line2Text.textContent = line2Text.dataset.text;
+  line1?.classList.add("done");
+  line2?.classList.add("done");
+  document.getElementById("landing-typewriter")?.classList.add("intro-complete");
+  landing?.classList.add("intro-complete");
+  document.getElementById("landing-cta-row")?.classList.add("visible");
+  document.getElementById("landing-feature-chips")?.classList.add("visible");
+  landingIntroComplete = true;
+}
+
+function typeText(el, text, speedMs, onDone) {
+  if (!el || !text) {
+    onDone?.();
+    return;
+  }
+  el.textContent = "";
+  let i = 0;
+  const step = () => {
+    if (i < text.length) {
+      el.textContent += text.charAt(i);
+      i += 1;
+      setTimeout(step, speedMs);
+    } else {
+      onDone?.();
+    }
+  };
+  step();
+}
+
+function initLandingIntro() {
+  if (landingIntroRunning || landingIntroComplete) return;
+  landingIntroRunning = true;
+
+  const line1Text = document.querySelector("#landing-type-line-1 .arena-type-text");
+  const line2Text = document.querySelector("#landing-type-line-2 .arena-type-text");
+  const line1 = document.getElementById("landing-type-line-1");
+  const line2 = document.getElementById("landing-type-line-2");
+
+  if (!line1Text || !line2Text) {
+    landingIntroRunning = false;
+    return;
+  }
+
+  if (prefersReducedMotion()) {
+    finalizeLandingIntroStatic();
+    landingIntroRunning = false;
+    return;
+  }
+
+  const text1 = line1Text.dataset.text || "";
+  const text2 = line2Text.dataset.text || "";
+
+  typeText(line1Text, text1, 32, () => {
+    line1?.classList.add("done");
+    line2?.classList.add("active");
+    setTimeout(() => {
+      typeText(line2Text, text2, 28, () => {
+        line2?.classList.add("done");
+        setTimeout(() => {
+          finalizeLandingIntroStatic();
+          landingIntroRunning = false;
+        }, 180);
+      });
+    }, 220);
+  });
 }
 
 function setGlobalLoading(isLoading, message = "Loading...") {
@@ -30,7 +152,36 @@ function setGlobalLoading(isLoading, message = "Loading...") {
   loadingOverlay.hidden = !isLoading;
 }
 
+const NEMOTRON_SCORECARD_SOURCES = new Set(["nemotron_full", "nemotron", "nemotron_repaired"]);
+
+function isNemotronScorecardSource(src) {
+  return NEMOTRON_SCORECARD_SOURCES.has(String(src ?? "").trim());
+}
+
+const INTERNAL_ERROR_PATTERNS = [
+  /nvidia/i,
+  /max_tokens/i,
+  /reasoning model/i,
+  /empty response/i,
+  /mock fallback/i,
+  /model scoring fallback/i,
+  /local fallback/i,
+  /server logs/i,
+  /nemotron omni/i,
+  /api_key/i,
+];
+
+function isInternalErrorMessage(message) {
+  const text = String(message ?? "").trim();
+  if (!text) return true;
+  return INTERNAL_ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
+
 function showErrorBanner(message) {
+  if (isInternalErrorMessage(message)) {
+    console.warn("[PitchFight] suppressed internal error from UI:", message);
+    return;
+  }
   errorBanner.textContent = message;
   errorBanner.hidden = false;
 }
@@ -52,14 +203,402 @@ function fillStartupForm(startup) {
   });
 }
 
-function appendMessage(role, text, meta = "") {
+const PERSONA_LABELS = {
+  skeptical_vc: "Skeptical VC",
+  technical_judge: "Technical Judge",
+  hackathon_judge: "Hackathon Judge",
+};
+
+function pressureMeterLevel(data) {
+  const label = String(data.pressure_label ?? data.pressure_level ?? "").toLowerCase();
+  if (label.includes("extreme")) return { pct: 100, tier: "extreme" };
+  if (label.includes("high")) return { pct: 78, tier: "high" };
+  if (label.includes("focused") || label.includes("medium")) return { pct: 52, tier: "focused" };
+  if (label.includes("warm")) return { pct: 28, tier: "warmup" };
+  const phase = String(data.battle_phase ?? "").toLowerCase();
+  if (phase.includes("extreme") || phase.includes("pressure")) return { pct: 78, tier: "high" };
+  if (phase.includes("challenge")) return { pct: 52, tier: "focused" };
+  const round = Number(data.round ?? state.round ?? 1);
+  if (round >= 4) return { pct: 100, tier: "extreme" };
+  if (round === 3) return { pct: 78, tier: "high" };
+  if (round === 2) return { pct: 52, tier: "focused" };
+  return { pct: 28, tier: "warmup" };
+}
+
+const ATTACK_PROGRESSION = [
+  "User Pain",
+  "Novelty",
+  "MVP Strength",
+  "Business Model",
+  "Objection Handling",
+];
+
+function normalizeAttackKey(tag) {
+  return String(tag || "").trim().toLowerCase();
+}
+
+function updateProgressStrip(round, attack, mode = "battle") {
+  const roundStrip = document.getElementById(
+    mode === "deal" ? "deal-progress-rounds" : "battle-progress-rounds",
+  );
+  if (roundStrip) {
+    roundStrip.querySelectorAll(".progress-node").forEach((node) => {
+      const n = Number(node.dataset.round);
+      node.classList.remove("progress-node-active", "progress-node-done");
+      if (n < round) node.classList.add("progress-node-done");
+      else if (n === round) node.classList.add("progress-node-active");
+    });
+  }
+
+  if (mode !== "battle") return;
+  const attackStrip = document.getElementById("battle-progress-attacks");
+  if (!attackStrip) return;
+  const key = normalizeAttackKey(attack);
+  let activeIdx = ATTACK_PROGRESSION.findIndex((a) => {
+    const ak = normalizeAttackKey(a);
+    return key === ak || key.includes(ak.split(" ")[0]) || ak.includes(key);
+  });
+  if (activeIdx < 0 && key) activeIdx = Math.min(round - 1, ATTACK_PROGRESSION.length - 1);
+
+  attackStrip.querySelectorAll(".progress-attack-tag").forEach((tag, idx) => {
+    tag.classList.remove("progress-attack-active", "progress-attack-done");
+    if (activeIdx >= 0 && idx < activeIdx) tag.classList.add("progress-attack-done");
+    if (activeIdx >= 0 && idx === activeIdx) tag.classList.add("progress-attack-active");
+  });
+}
+
+function addBattleLogEntry(roundNum, judge, founderReply, mode = "battle") {
+  const log = mode === "deal" ? state.dealBattleLog : state.battleLog;
+  const entry = { roundNum, judge: { ...judge }, founderReply };
+  log.push(entry);
+
+  const ribbonId = mode === "deal" ? "deal-log-ribbon" : "battle-log-ribbon";
+  const tabsId = mode === "deal" ? "deal-log-tabs" : "battle-log-tabs";
+  const detailId = mode === "deal" ? "deal-log-detail" : "battle-log-detail";
+  const ribbon = document.getElementById(ribbonId);
+  const tabs = document.getElementById(tabsId);
+  if (!ribbon || !tabs) return;
+  /* Ribbon stays hidden — log only opens via drawer */
+
+  const btn = document.createElement("button");
+  btn.type = "button";
+  btn.className = "battle-log-tab";
+  btn.textContent = mode === "deal" ? `D${roundNum}` : `R${roundNum}`;
+  btn.dataset.round = roundNum;
+  btn.addEventListener("click", () => {
+    tabs.querySelectorAll(".battle-log-tab").forEach((t) => t.classList.remove("active"));
+    btn.classList.add("active");
+    const detail = document.getElementById(detailId);
+    if (!detail) return;
+    detail.hidden = false;
+    detail.innerHTML = `
+      <p class="log-detail-attack">${escapeHtml(simplifyJudgeMeta(judge.meta) || "—")}</p>
+      <p class="log-detail-label">Judge</p>
+      <p class="log-detail-text">${escapeHtml(judge.text)}</p>
+      ${founderReply ? `<p class="log-detail-label">You</p><p class="log-detail-text">${escapeHtml(founderReply)}</p>` : ""}`;
+  });
+  tabs.appendChild(btn);
+}
+
+function updateJudgeAttackPill(attack, mode = "battle") {
+  const pill = document.getElementById(mode === "deal" ? "deal-judge-attack-pill" : "judge-attack-pill");
+  if (pill) pill.textContent = attack && attack !== "—" ? attack : "Pressing";
+}
+
+function simplifyJudgeMeta(meta) {
+  if (!meta) return "";
+  const attack = String(meta).split("·")[0]?.trim();
+  return attack || meta;
+}
+
+function updatePressureCore(tier, label) {
+  const ring = document.querySelector(".duel-node-ring");
+  if (ring) {
+    ring.className = `duel-node-ring pressure-core-${tier}`;
+  }
+  const lbl = document.getElementById("duel-pressure-label");
+  if (lbl && label) lbl.textContent = label;
+  const judgePressure = document.getElementById("judge-stat-pressure");
+  if (judgePressure && label) judgePressure.textContent = label;
+}
+
+function updateConfidenceMeter(pressurePct) {
+  const fill = document.getElementById("confidence-meter-fill");
+  if (!fill) return;
+  const confidence = Math.max(8, Math.min(100, 100 - pressurePct));
+  fill.style.width = `${confidence}%`;
+  fill.classList.toggle("confidence-low", confidence < 35);
+  fill.classList.toggle("confidence-mid", confidence >= 35 && confidence < 65);
+  fill.classList.toggle("confidence-high", confidence >= 65);
+}
+
+function updateComboMeter(round) {
+  const meter = document.getElementById("combo-meter");
+  if (!meter) return;
+  const streak = Math.max(0, Math.min(5, Number(round) - 1));
+  meter.querySelectorAll(".combo-pip").forEach((pip) => {
+    const n = Number(pip.dataset.pip);
+    pip.classList.toggle("combo-pip-lit", n <= streak);
+  });
+}
+
+function updateJudgeSignalChips(attack, pressureLabel) {
+  const focus = document.getElementById("judge-stat-focus");
+  if (focus) focus.textContent = attack && attack !== "—" ? attack : "Scanning";
+  const pressure = document.getElementById("judge-stat-pressure");
+  if (pressure && pressureLabel) pressure.textContent = pressureLabel;
+  const judgeName = document.getElementById("judge-fighter-name");
+  const sidebarName = document.getElementById("sidebar-persona-name");
+  const persona = PERSONA_LABELS[state.persona] ?? "AI Judge";
+  if (judgeName) judgeName.textContent = persona;
+  if (sidebarName) sidebarName.textContent = persona;
+}
+
+function updateJudgeLiveCard(text, meta) {
+  const q = document.getElementById("judge-question-text");
+  const metaEl = document.getElementById("judge-question-meta");
+  const card = document.getElementById("judge-live-card");
+  const attack = simplifyJudgeMeta(meta);
+  if (q) q.textContent = text || "AI judge is preparing the next attack…";
+  if (metaEl) metaEl.textContent = attack;
+  updateJudgeAttackPill(attack, "battle");
+  const pressureLbl = document.getElementById("judge-stat-pressure")?.textContent;
+  updateJudgeSignalChips(attack !== "—" ? attack : simplifyJudgeMeta(meta), pressureLbl);
+  if (card) {
+    card.classList.remove("judge-attack-enter");
+    void card.offsetWidth;
+    card.classList.add("judge-attack-enter");
+  }
+}
+
+function updateDealJudgeCard(text, meta) {
+  const q = document.getElementById("deal-judge-text");
+  const metaEl = document.getElementById("deal-judge-meta");
+  const card = document.getElementById("deal-judge-card");
+  if (q) q.textContent = text || "Preparing deal terms…";
+  if (metaEl) metaEl.textContent = simplifyJudgeMeta(meta);
+  const attack = simplifyJudgeMeta(meta);
+  updateJudgeAttackPill(attack !== "—" ? attack : "Terms", "deal");
+  if (card) {
+    card.classList.remove("judge-attack-enter");
+    void card.offsetWidth;
+    card.classList.add("judge-attack-enter");
+  }
+}
+
+function refreshCoachBar() {
+  const dockHint = document.getElementById("dock-assist-hint");
+  const coach = (document.getElementById("micro-coach")?.textContent || "").trim();
+  const hintRaw = (document.getElementById("answer-hint")?.textContent || "").trim();
+
+  if (dockHint) {
+    if (coach) {
+      dockHint.textContent = coach;
+    } else if (hintRaw) {
+      dockHint.textContent = `Tip: ${hintRaw}`;
+    } else {
+      dockHint.textContent = "Tip: use numbers";
+    }
+  }
+
+  const bar = document.getElementById("battle-coach-bar");
+  if (bar) {
+    bar.hidden = true;
+    bar.textContent = "";
+  }
+}
+
+function extractRoundFromMeta(meta) {
+  const match = String(meta || "").match(/Round\s+(\d+)/i);
+  return match ? match[1] : null;
+}
+
+function archiveBattleRound(_container, judge, founderReply, mode = "battle") {
+  if (!judge.text) return;
+  const roundNum = extractRoundFromMeta(judge.meta) ?? Math.max(1, (state.round || 1) - 1);
+  addBattleLogEntry(roundNum, judge, founderReply, mode);
+  updateTimelineVisibility(mode, mode === "deal" ? "deal-timeline-count" : "timeline-count");
+}
+
+function updateTimelineVisibility(mode = "battle", countId) {
+  const count = mode === "deal"
+    ? (state.dealBattleLog?.length ?? 0)
+    : (state.battleLog?.length ?? 0);
+  const countEl = document.getElementById(countId);
+  if (countEl) countEl.textContent = count ? `(${count})` : "";
+  const toggleId = mode === "deal" ? "btn-open-deal-rounds" : "btn-open-battle-rounds";
+  const toggle = document.getElementById(toggleId);
+  if (toggle) toggle.hidden = count === 0;
+}
+
+const CONV_FOUNDER_AVATAR = `<svg class="conv-avatar-svg conv-avatar-founder" viewBox="0 0 64 88" aria-hidden="true"><circle cx="32" cy="24" r="11" fill="#3d2810" stroke="#c084fc" stroke-width="1"/><path d="M18 38 Q32 30 46 38 L48 62 Q32 68 16 62 Z" fill="#1a1208" stroke="#c084fc" stroke-width="1"/></svg>`;
+const CONV_JUDGE_AVATAR = `<svg class="conv-avatar-svg conv-avatar-judge" viewBox="0 0 64 88" aria-hidden="true"><rect x="20" y="18" width="24" height="20" rx="4" fill="#060a10" stroke="#22d3ee" stroke-width="1"/><path d="M16 40 Q32 32 48 40 L50 64 Q32 70 14 64 Z" fill="#0a1420" stroke="#22d3ee" stroke-width="1"/></svg>`;
+
+function renderConversationMessage(role, text, meta = "") {
+  const isJudge = role === "ai";
+  const speaker = isJudge ? (PERSONA_LABELS[state.persona] ?? "AI Judge") : "You · Founder";
+  const row = document.createElement("div");
+  row.className = `conv-message ${isJudge ? "conv-message-judge" : "conv-message-founder"}`;
+  row.innerHTML = `
+    <div class="conv-avatar ${isJudge ? "conv-avatar-judge-wrap" : "conv-avatar-founder-wrap"}">
+      ${isJudge ? CONV_JUDGE_AVATAR : CONV_FOUNDER_AVATAR}
+    </div>
+    <div class="conv-bubble">
+      <div class="conv-bubble-head">
+        <span class="conv-speaker">${escapeHtml(speaker)}</span>
+        ${meta ? `<span class="conv-meta">${escapeHtml(meta)}</span>` : ""}
+      </div>
+      <p class="conv-text">${escapeHtml(text)}</p>
+    </div>`;
+  return row;
+}
+
+function renderConversationThread(log, container) {
+  if (!container) return;
+  container.innerHTML = "";
+  (log || []).forEach(({ role, text, meta }) => {
+    container.appendChild(renderConversationMessage(role, text, meta));
+  });
+  container.scrollTop = container.scrollHeight;
+}
+
+function renderConversationSidebar(context = "battle") {
+  const sidebar = document.getElementById("conversation-sidebar");
+  if (!sidebar) return;
+
+  const meta = state.battleMetaSnapshot ?? {};
+  const score = state.scorecardSnapshot;
+  const persona = PERSONA_LABELS[meta.persona ?? state.persona] ?? "AI Judge";
+  const rounds = state.battleLog?.length ?? Math.max(0, Math.floor((state.conversationLog?.length ?? 0) / 2));
+  const attacks = ATTACK_PROGRESSION.map((label) => {
+    const done = state.battleLog?.some((e) => simplifyJudgeMeta(e.judge?.meta) === label);
+    const active = meta.attack === label;
+    return `<li class="${done ? "sidebar-attack-done" : ""} ${active ? "sidebar-attack-active" : ""}">${escapeHtml(label)}</li>`;
+  }).join("");
+
+  sidebar.innerHTML = `
+    <p class="sidebar-eyebrow hud-font">Battle Details</p>
+    <dl class="sidebar-stats">
+      <div><dt>Rounds</dt><dd>${rounds || meta.round || "—"}</dd></div>
+      <div><dt>Opponent</dt><dd>${escapeHtml(persona)}</dd></div>
+      <div><dt>Mode</dt><dd>${escapeHtml(meta.mode ?? "Practice")}</dd></div>
+      <div><dt>Last Attack</dt><dd>${escapeHtml(meta.attack ?? "—")}</dd></div>
+      <div><dt>Pressure</dt><dd>${escapeHtml(meta.pressure ?? "—")}</dd></div>
+    </dl>
+    ${context === "scorecard" && score ? `
+      <p class="sidebar-eyebrow hud-font sidebar-eyebrow-score">Scorecard</p>
+      <dl class="sidebar-stats sidebar-score-block">
+        <div><dt>Score</dt><dd class="sidebar-score-val">${score.overall ?? "—"}</dd></div>
+        <div><dt>Label</dt><dd>${escapeHtml(score.overallLabel ?? "—")}</dd></div>
+        <div><dt>Strongest</dt><dd class="sidebar-strong">${escapeHtml(score.strongest ?? "—")}</dd></div>
+        <div><dt>Weakest</dt><dd class="sidebar-weak">${escapeHtml(score.weakest ?? "—")}</dd></div>
+      </dl>` : ""}
+    <p class="sidebar-eyebrow hud-font">Attack Progression</p>
+    <ul class="sidebar-attack-list">${attacks}</ul>`;
+}
+
+function openBattleConversationLog(fromScorecard = false) {
+  renderConversationSidebar(fromScorecard ? "scorecard" : "battle");
+  renderConversationThread(state.conversationLog, chatWindow);
+  openRoundsDrawer("battle-rounds-drawer");
+  document.getElementById("conversation-sidebar")?.scrollTo(0, 0);
+  chatWindow?.scrollTo(0, chatWindow.scrollHeight);
+}
+
+function openRoundsDrawer(drawerId) {
+  const drawer = document.getElementById(drawerId);
+  if (!drawer) return;
+  drawer.hidden = false;
+  document.body.classList.add("rounds-drawer-open");
+}
+
+function closeRoundsDrawer(drawerId) {
+  const drawer = document.getElementById(drawerId);
+  if (!drawer) return;
+  drawer.hidden = true;
+  if (!document.querySelector(".previous-rounds-drawer:not([hidden])")) {
+    document.body.classList.remove("rounds-drawer-open");
+  }
+}
+
+function appendFounderBubble(container, text, meta = "", extraClass = "") {
   const bubble = document.createElement("div");
-  bubble.className = `message ${role}`;
+  bubble.className = `message message-founder user${extraClass ? ` ${extraClass}` : ""}`;
+  const preview = text.length > 160 ? `${text.slice(0, 157)}…` : text;
   bubble.innerHTML = meta
-    ? `<span class="message-meta">${meta}</span><p>${escapeHtml(text)}</p>`
-    : `<p>${escapeHtml(text)}</p>`;
-  chatWindow.appendChild(bubble);
-  chatWindow.scrollTop = chatWindow.scrollHeight;
+    ? `<span class="message-meta">${escapeHtml(meta)}</span><p class="message-preview">${escapeHtml(preview)}</p>`
+    : `<p class="message-preview">${escapeHtml(preview)}</p>`;
+  bubble.title = text;
+  container.appendChild(bubble);
+  container.scrollTop = container.scrollHeight;
+}
+
+function rebuildConversationView() {
+  openBattleConversationLog(true);
+}
+
+function resetLiveTurnTracking() {
+  liveJudgeTurn = { text: "", meta: "" };
+  liveFounderReply = "";
+  liveDealJudgeTurn = { text: "", meta: "" };
+  liveDealFounderReply = "";
+}
+
+function appendMessage(role, text, meta = "") {
+  state.conversationLog.push({ role, text, meta });
+
+  if (role === "ai") {
+    if (liveJudgeTurn.text) {
+      archiveBattleRound(null, liveJudgeTurn, liveFounderReply, "battle");
+      liveFounderReply = "";
+    }
+    liveJudgeTurn = { text, meta };
+    updateJudgeLiveCard(text, meta);
+    updateTimelineVisibility("battle", "timeline-count");
+    return;
+  }
+
+  liveFounderReply = text;
+  updateTimelineVisibility("battle", "timeline-count");
+}
+
+function appendDealMessage(role, text, meta = "") {
+  if (!dealChatWindow) return;
+  state.dealConversationLog.push({ role, text, meta });
+
+  if (role === "ai") {
+    dealChatWindow?.querySelector(".live-pending")?.remove();
+    if (liveDealJudgeTurn.text) {
+      archiveBattleRound(null, liveDealJudgeTurn, liveDealFounderReply, "deal");
+      liveDealFounderReply = "";
+    }
+    liveDealJudgeTurn = { text, meta };
+    updateDealJudgeCard(text, meta);
+    updateTimelineVisibility("deal", "deal-timeline-count");
+    return;
+  }
+
+  liveDealFounderReply = text;
+  dealChatWindow?.querySelector(".live-pending")?.remove();
+  updateTimelineVisibility("deal", "deal-timeline-count");
+}
+
+// "Minimum viable answer" recipe shown above the input for the current question.
+function setAnswerHint(hint) {
+  const el = document.getElementById("answer-hint");
+  if (!el) return;
+  el.textContent = (hint || "").trim();
+  el.hidden = true;
+  refreshCoachBar();
+}
+
+// Gentle after-round nudge — shown only in the response dock hint line.
+function setMicroCoach(tip) {
+  const el = document.getElementById("micro-coach");
+  if (!el) return;
+  el.textContent = (tip || "").trim();
+  el.hidden = true;
+  refreshCoachBar();
 }
 
 function escapeHtml(text) {
@@ -70,18 +609,95 @@ function escapeHtml(text) {
 }
 
 function updateBattleMeta(data) {
-  document.getElementById("round-counter").textContent = data.round ?? state.round;
+  const round = data.round ?? state.round ?? 1;
+  document.getElementById("round-counter").textContent = round;
+  const roundDisplay = document.getElementById("round-display");
+  if (roundDisplay) roundDisplay.textContent = String(round).padStart(2, "0");
+  const roundDuel = document.getElementById("round-counter-duel");
+  if (roundDuel) roundDuel.textContent = String(round).padStart(2, "0");
+  state.round = round;
+
+  const pressureDisplay = data.pressure_label ?? data.pressure_level ?? "Warm-up";
   const pressureEl = document.getElementById("pressure-level");
-  pressureEl.textContent = data.pressure_level ?? "High";
-  pressureEl.className = `pressure-${(data.pressure_level ?? "high").toLowerCase()}`;
-  document.getElementById("attack-tag").textContent = data.attack_tag ?? "—";
-  state.round = data.round ?? state.round;
+  if (pressureEl) {
+    pressureEl.textContent = pressureDisplay;
+    const { tier } = pressureMeterLevel(data);
+    pressureEl.className = `pressure-${tier}`;
+  }
+
+  const { pct, tier } = pressureMeterLevel(data);
+  const fill = document.getElementById("pressure-meter-fill");
+  if (fill) {
+    fill.style.width = `${pct}%`;
+    fill.className = `pressure-meter-fill pressure-${tier}`;
+  }
+  updateConfidenceMeter(pct);
+  updateComboMeter(round);
+  const progressFill = document.getElementById("battle-progress-fill");
+  if (progressFill) {
+    progressFill.style.width = `${pct}%`;
+    progressFill.className = `battle-progress-fill pressure-${tier}`;
+  }
+
+  const attack = data.attack_tag ?? "—";
+  document.getElementById("attack-tag").textContent = attack;
+  const attackChip = document.getElementById("attack-tag-chip");
+  if (attackChip) attackChip.textContent = attack;
+
+  const pressureChip = document.getElementById("pressure-chip");
+  if (pressureChip) pressureChip.textContent = pressureDisplay;
+
+  const diffLabel = data.difficulty_label ?? "Practice Mode";
+  const diffLabelEl = document.getElementById("difficulty-label");
+  if (diffLabelEl) diffLabelEl.textContent = diffLabel;
+
+  const modeChip = document.getElementById("mode-chip");
+  if (modeChip) modeChip.textContent = diffLabel.replace(" Mode", "");
 
   const phaseEl = document.getElementById("battle-phase");
-  if (phaseEl && data.battle_phase) {
-    phaseEl.textContent = data.battle_phase;
-    phaseEl.hidden = false;
+  if (phaseEl && data.battle_phase) phaseEl.textContent = data.battle_phase;
+
+  const sidebarMode = document.getElementById("sidebar-persona-mode");
+  if (sidebarMode) sidebarMode.textContent = diffLabel;
+
+  const sidebarPersona = document.getElementById("sidebar-persona-name");
+  if (sidebarPersona) {
+    sidebarPersona.textContent = PERSONA_LABELS[state.persona] ?? "AI Judge";
+  }
+
+  updateProgressStrip(round, attack, "battle");
+  updateJudgeAttackPill(attack, "battle");
+  updatePressureCore(tier, pressureDisplay);
+  updateJudgeSignalChips(attack, pressureDisplay);
+
+  state.battleMetaSnapshot = {
+    round,
+    attack,
+    pressure: pressureDisplay,
+    mode: diffLabel.replace(" Mode", ""),
+    persona: state.persona,
+  };
+}
+
+function updateBattleReadiness(data) {
+  const prompt = document.getElementById("battle-readiness-prompt");
+  const text = document.getElementById("battle-readiness-text");
+  if (!prompt) return;
+  const show = data.soft_round_limit_reached || data.recommended_action === "end_battle";
+  if (!show) {
+    prompt.hidden = true;
+    return;
   }
+  if (text) {
+    text.textContent = data.completion_message
+      ?? data.readiness?.reason
+      ?? "Enough signal collected. Ready for your scorecard?";
+  }
+  prompt.hidden = false;
+}
+
+function hideBattleReadiness() {
+  document.getElementById("battle-readiness-prompt")?.setAttribute("hidden", "");
 }
 
 async function apiPost(path, body = undefined) {
@@ -107,7 +723,7 @@ async function apiPost(path, body = undefined) {
 
 export async function loadSample() {
   try {
-    setGlobalLoading(true, "Loading demo startup...");
+    setGlobalLoading(true, "Loading demo founder…");
     const data = await apiPost("/api/load-sample");
     fillStartupForm(data.startup);
     showScreen("setup");
@@ -122,19 +738,39 @@ export async function loadSample() {
 
 export async function startSession() {
   try {
-    setGlobalLoading(true, "Starting pitch battle...");
+    setGlobalLoading(true, "AI judge is preparing the first attack…");
     battleStatus.hidden = true;
+    hideBattleReadiness();
     chatWindow.innerHTML = "";
+    state.conversationLog = [];
+    state.battleLog = [];
+    resetLiveTurnTracking();
+    document.getElementById("battle-log-tabs") && (document.getElementById("battle-log-tabs").innerHTML = "");
+    document.getElementById("battle-log-detail")?.setAttribute("hidden", "");
+    document.getElementById("battle-log-ribbon")?.setAttribute("hidden", "");
+    document.getElementById("btn-open-battle-rounds")?.setAttribute("hidden", "");
+    document.getElementById("battle-rounds-drawer")?.setAttribute("hidden", "");
+    document.getElementById("battle-coach-bar")?.setAttribute("hidden", "");
+    document.getElementById("voice-turn-preview")?.setAttribute("hidden", "");
 
     const payload = {
       mode: "pitch_battle",
       startup: getStartupPayload(),
       persona: state.persona,
-      difficulty: "high",
-      input_mode: "text",
+      difficulty_profile: state.difficultyProfile,
+      difficulty: state.difficultyProfile,  // keep for backward compat
+      input_mode: state.startMode === "voice" ? "voice" : "text",
       model_mode: "premium_nvidia",
     };
 
+    if (state.startMode === "voice" && state.pendingVoicePitch) {
+      payload.voice_pitch = {
+        transcript: state.pendingVoicePitch.transcript,
+        delivery_observations: state.pendingVoicePitch.delivery_observations,
+        extraction_confidence: state.pendingVoicePitch.extraction_confidence,
+      };
+    }
+
     const data = await apiPost("/api/start-session", payload);
 
     if (data.error) {
@@ -144,12 +780,20 @@ export async function startSession() {
 
     state.sessionId = data.session_id;
     state.round = data.round ?? 1;
+    state.uiMode = "pitch";
     userInput.disabled = false;
     const submitBtn = document.getElementById("chat-form").querySelector("button[type=submit]");
     if (submitBtn) submitBtn.disabled = false;
     updateBattleMeta(data);
-    const startBadge = data.model_ok ? "⚡ Premium Nemotron" : "Mock";
-    appendMessage("ai", data.ai_message, `${data.attack_tag} · Round ${data.round} · ${startBadge}`);
+    const startMeta = data.model_ok
+      ? `${data.attack_tag} · Round ${data.round} · ⚡ Premium Nemotron`
+      : `${data.attack_tag} · Round ${data.round}`;
+    if (data.model_error) {
+      console.warn("Opponent model fallback (not shown to user):", data.model_error);
+    }
+    appendMessage("ai", data.ai_message, startMeta);
+    setMicroCoach("");
+    setAnswerHint(data.answer_hint);
     showScreen("battle");
     hideErrorBanner();
   } catch (error) {
@@ -160,19 +804,28 @@ export async function startSession() {
   }
 }
 
-export async function sendMessage() {
-  const message = userInput.value.trim();
+export async function sendMessage(messageOverride, voiceMeta = null) {
+  const message = (messageOverride ?? userInput.value).trim();
   if (!message || !state.sessionId) return;
 
   try {
-    setGlobalLoading(true, "Sending answer...");
+    setGlobalLoading(true, "Scoring your answer…");
     userInput.value = "";
     appendMessage("user", message);
 
-    const data = await apiPost("/api/chat-round", {
+    const chatPayload = {
       session_id: state.sessionId,
       user_message: message,
-    });
+    };
+    if (voiceMeta?.voice_turn_id) {
+      chatPayload.input_mode = "voice";
+      chatPayload.voice_turn_id = voiceMeta.voice_turn_id;
+      if (voiceMeta.delivery_metadata) {
+        chatPayload.delivery_metadata = voiceMeta.delivery_metadata;
+      }
+    }
+
+    const data = await apiPost("/api/chat-round", chatPayload);
 
     if (data.error) {
       battleStatus.hidden = false;
@@ -181,15 +834,24 @@ export async function sendMessage() {
     }
 
     updateBattleMeta(data);
-    const chatBadge = data.model_ok ? "⚡ Premium Nemotron" : "Mock";
-    appendMessage("ai", data.ai_message, `${data.attack_tag} · Round ${data.round} · ${chatBadge}`);
+    const chatMeta = data.model_ok
+      ? `${data.attack_tag} · Round ${data.round} · ⚡ Premium Nemotron`
+      : `${data.attack_tag} · Round ${data.round}`;
+    if (data.model_error) {
+      console.warn("Opponent model fallback (not shown to user):", data.model_error);
+    }
+    appendMessage("ai", data.ai_message, chatMeta);
+    setMicroCoach(data.micro_coach);
+    setAnswerHint(data.answer_hint);
 
     if (data.soft_round_limit_reached) {
-      battleStatus.hidden = false;
-      battleStatus.textContent = data.completion_message
-        ?? "You have enough material for a scorecard. End Battle when ready.";
-      battleStatus.style.color = "var(--gold)";
+      updateBattleReadiness(data);
+    } else {
+      hideBattleReadiness();
     }
+
+    state.pendingVoiceTurn = null;
+    document.getElementById("voice-turn-preview")?.setAttribute("hidden", "");
   } catch (error) {
     console.error(error);
     battleStatus.hidden = false;
@@ -203,7 +865,7 @@ export async function endBattle() {
   if (!state.sessionId) return;
 
   try {
-    setGlobalLoading(true, "Generating scorecard...");
+    setGlobalLoading(true, "Building scorecard…");
     const data = await apiPost("/api/end-battle", {
       session_id: state.sessionId,
     });
@@ -235,14 +897,142 @@ export async function resetBattle() {
 
   state.sessionId = null;
   state.round = 1;
+  state.pendingVoicePitch = null;
+  state.pendingVoiceTurn = null;
+  state.retryDrill = null;
+  state.pendingRetryVoiceTurn = null;
+  state.judgeVerdict = null;
+  state.dealContext = null;
+  state.dealRound = 1;
+  state.uiMode = "pitch";
+  state.pendingDealVoiceTurn = null;
+  state.startMode = "text";
+  state.conversationLog = [];
+  state.dealConversationLog = [];
+  state.battleLog = [];
+  state.dealBattleLog = [];
+  resetLiveTurnTracking();
   chatWindow.innerHTML = "";
+  if (dealChatWindow) dealChatWindow.innerHTML = "";
+  ["battle-log-tabs", "deal-log-tabs"].forEach((id) => {
+    const el = document.getElementById(id);
+    if (el) el.innerHTML = "";
+  });
+  document.getElementById("battle-log-ribbon")?.setAttribute("hidden", "");
+  document.getElementById("deal-log-ribbon")?.setAttribute("hidden", "");
+  document.getElementById("btn-open-battle-rounds")?.setAttribute("hidden", "");
+  document.getElementById("battle-rounds-drawer")?.setAttribute("hidden", "");
+  document.getElementById("btn-open-deal-rounds")?.setAttribute("hidden", "");
+  document.getElementById("deal-rounds-drawer")?.setAttribute("hidden", "");
+  document.getElementById("battle-coach-bar")?.setAttribute("hidden", "");
+  hideBattleReadiness();
+  updateJudgeLiveCard("", "");
+  updateDealJudgeCard("", "");
   userInput.value = "";
   showScreen("landing");
 }
 
+function formatDimLabel(dim) {
+  return String(dim ?? "").replaceAll("_", " ");
+}
+
+function scoreBand(score) {
+  const s = Number(score) || 0;
+  if (s >= 70) return "score-high";
+  if (s >= 50) return "score-mid";
+  return "score-low";
+}
+
+function getStrongestWeakest(scores) {
+  const entries = Object.entries(scores || {}).filter(([, v]) => v && typeof v.score === "number");
+  if (!entries.length) return { strongest: null, weakest: null };
+  const sorted = [...entries].sort((a, b) => (b[1].score ?? 0) - (a[1].score ?? 0));
+  return { strongest: sorted[0], weakest: sorted[sorted.length - 1] };
+}
+
+function attachShowMore(el) {
+  if (!el || !el.textContent?.trim()) return;
+  el.classList.add("clamp-text");
+  if (el.nextElementSibling?.classList?.contains("show-more-btn")) return;
+  requestAnimationFrame(() => {
+    if (el.scrollHeight <= el.clientHeight + 2) return;
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "show-more-btn";
+    btn.textContent = "Show more";
+    btn.addEventListener("click", () => {
+      const expanded = el.classList.toggle("expanded");
+      btn.textContent = expanded ? "Show less" : "Show more";
+    });
+    el.insertAdjacentElement("afterend", btn);
+  });
+}
+
+function buildDimensionRow(key, value, opts = {}) {
+  const s = value?.score ?? 0;
+  const band = scoreBand(s);
+  const row = document.createElement("div");
+  row.className = `dimension-row score-row ${band}`;
+  const dimLabel = formatDimLabel(key);
+  const labelHtml = value?.label
+    ? `<span class="score-label">${escapeHtml(value.label)}</span>`
+    : "";
+  const quote = value?.quote && opts.showQuote
+    ? `<span class="quote-chip">"${escapeHtml(value.quote)}"</span>`
+    : "";
+  const reason = value?.reason ?? "";
+  row.innerHTML = `
+    <div class="dimension-row-head score-row-head">
+      <span class="dimension-name">${dimLabel}${labelHtml}</span>
+      <strong class="dimension-score">${s}</strong>
+    </div>
+    <div class="dimension-bar bar-track"><div class="dimension-bar-fill bar-fill" style="width:0%" data-width="${s}%"></div></div>
+    <p class="dimension-reason score-reason clamp-text">${escapeHtml(reason)}</p>
+    ${quote}
+  `;
+  requestAnimationFrame(() => {
+    const fill = row.querySelector(".dimension-bar-fill");
+    if (fill) fill.style.width = fill.dataset.width || `${s}%`;
+  });
+  return row;
+}
+
+function initResultTabs(tabsRootId, panelsRootId) {
+  const tabsRoot = document.getElementById(tabsRootId);
+  const panelsRoot = document.getElementById(panelsRootId);
+  if (!tabsRoot || !panelsRoot || tabsRoot.dataset.tabsInit === "1") return;
+  tabsRoot.dataset.tabsInit = "1";
+
+  const activate = (tabName) => {
+    tabsRoot.querySelectorAll(".result-tab").forEach((tab) => {
+      const active = tab.dataset.tab === tabName;
+      tab.classList.toggle("active", active);
+      tab.setAttribute("aria-selected", active ? "true" : "false");
+    });
+    panelsRoot.querySelectorAll(".result-panel").forEach((panel) => {
+      const active = panel.dataset.panel === tabName;
+      panel.classList.toggle("active", active);
+      panel.hidden = !active;
+    });
+  };
+
+  tabsRoot.addEventListener("click", (e) => {
+    const tab = e.target.closest(".result-tab");
+    if (!tab || tab.hidden) return;
+    activate(tab.dataset.tab);
+  });
+}
+
+function switchResultTab(tabsRootId, tabName) {
+  const tabsRoot = document.getElementById(tabsRootId);
+  const tab = tabsRoot?.querySelector(`.result-tab[data-tab="${tabName}"]`);
+  tab?.click();
+}
+
 function renderScorecard(data) {
   const overall = data.overall ?? 0;
-  document.getElementById("overall-score").textContent = overall;
+  const overallEl = document.getElementById("overall-score");
+  if (overallEl) overallEl.textContent = overall;
 
   const overallLabelEl = document.getElementById("overall-label");
   if (overallLabelEl) {
@@ -250,40 +1040,77 @@ function renderScorecard(data) {
     overallLabelEl.hidden = !data.overall_label;
   }
 
+  const scores = data.scores ?? {};
+  const { strongest, weakest } = getStrongestWeakest(scores);
+
+  const readoutEl = document.getElementById("pitch-readout");
+  if (readoutEl) {
+    const se = data.score_explanation ?? {};
+    readoutEl.textContent =
+      data.improved_pitch?.split(/[.!?]/)[0]?.trim()
+      || se.why_you_scored_this?.split(/[.!?]/)[0]?.trim()
+      || (data.overall_label ? `${data.overall_label} pitch — review dimensions below.` : "Your pitch battle is complete.");
+  }
+
+  const strongChip = document.getElementById("chip-strongest-dim");
+  const weakChip = document.getElementById("chip-weakest-dim");
+  if (strongChip) {
+    strongChip.textContent = strongest
+      ? `Strongest: ${formatDimLabel(strongest[0])}`
+      : "Strongest: —";
+  }
+  if (weakChip) {
+    weakChip.textContent = weakest
+      ? `Weakest: ${formatDimLabel(weakest[0])}`
+      : "Weakest: —";
+  }
+
   const sourceBadgeEl = document.getElementById("scorecard-source-badge");
+  const chipSource = document.getElementById("chip-score-source");
+  const fallbackWarnEl = document.getElementById("scorecard-fallback-warning");
+  const nemotronScored = isNemotronScorecardSource(data.scorecard_source);
   if (sourceBadgeEl) {
-    const src = data.scorecard_source ?? "";
-    sourceBadgeEl.textContent =
-      src === "hybrid_claims_nemotron" ? "⚡ Claim-based score + Premium Nemotron coaching" :
-      src === "hybrid_claims_local" ? "Claim-based local scorecard" :
-      src === "nemotron" ? "⚡ Scored by Premium Nemotron" :
-      src === "nemotron_repaired" ? "⚡ Scored by Premium Nemotron (repaired)" :
-      src === "session_fallback" ? "Session-based scorecard (model unavailable)" :
-      "Mock fallback scorecard";
-    sourceBadgeEl.hidden = false;
+    sourceBadgeEl.textContent = nemotronScored ? "Powered by NVIDIA Nemotron" : "";
+    sourceBadgeEl.hidden = !nemotronScored;
+  }
+  if (chipSource) {
+    chipSource.textContent = nemotronScored ? "Nemotron Judge" : "";
+    chipSource.hidden = !nemotronScored;
+    chipSource.classList.toggle("chip-source", nemotronScored);
+  }
+  if (fallbackWarnEl) {
+    fallbackWarnEl.textContent = "";
+    fallbackWarnEl.hidden = true;
+  }
+  if (data.model_error) {
+    console.warn("Scorecard model note (not shown to user):", data.model_error);
   }
 
-  const bars = document.getElementById("score-bars");
-  bars.innerHTML = "";
-  const scores = data.scores ?? {};
+  const nextWrap = document.getElementById("pitch-next-action");
+  const nextText = document.getElementById("pitch-next-action-text");
+  const se = data.score_explanation ?? {};
+  const atr = se.answer_to_retry ?? {};
+  const nextLine =
+    atr.retry_advice
+    || se.what_stopped_80?.split(/[.!?]/)[0]?.trim()
+    || (weakest ? `Retry your ${formatDimLabel(weakest[0])} answer with one concrete proof point.` : "");
+  if (nextWrap && nextText) {
+    if (nextLine) {
+      nextText.textContent = nextLine.endsWith(".") ? nextLine : `${nextLine}.`;
+      nextWrap.hidden = false;
+    } else {
+      nextWrap.hidden = true;
+    }
+  }
 
-  Object.entries(scores).forEach(([key, value]) => {
-    const row = document.createElement("div");
-    row.className = "score-row";
-    const dimLabel = key.replaceAll("_", " ");
-    const scoreLabel = value.label ? `<span class="score-label">${escapeHtml(value.label)}</span>` : "";
-    row.innerHTML = `
-      <div class="score-row-head">
-        <span>${dimLabel}${scoreLabel}</span>
-        <strong>${value.score}</strong>
-      </div>
-      <div class="bar-track"><div class="bar-fill" style="width:${value.score}%"></div></div>
-      <p class="score-reason">${escapeHtml(value.reason ?? "")}</p>
-    `;
-    bars.appendChild(row);
-  });
+  const bars = document.getElementById("score-bars");
+  if (bars) {
+    bars.innerHTML = "";
+    Object.entries(scores).forEach(([key, value]) => {
+      bars.appendChild(buildDimensionRow(key, value, { showQuote: true }));
+    });
+  }
 
-  // Concrete signals summary
   const sigEl = document.getElementById("signals-summary");
   if (sigEl) {
     const css = data.concrete_signals_summary ?? {};
@@ -294,52 +1121,919 @@ function renderScorecard(data) {
       ...(css.revenue_signals ?? []),
       ...(css.technical_mechanisms ?? []),
     ].slice(0, 8);
+    sigEl.innerHTML = "";
     if (allSigs.length > 0) {
-      sigEl.textContent = "Signals detected: " + allSigs.join(" · ");
+      allSigs.forEach((sig) => {
+        const chip = document.createElement("span");
+        chip.className = "source-chip signal-chip";
+        chip.textContent = sig;
+        sigEl.appendChild(chip);
+      });
       sigEl.hidden = false;
     } else {
       sigEl.hidden = true;
     }
   }
 
-  // Reordered: improved content first, then answers
-  document.getElementById("improved-answer").textContent = data.improved_answer ?? "";
-  document.getElementById("improved-pitch").textContent = data.improved_pitch ?? "";
-  document.getElementById("best-answer").textContent = data.best_answer ?? "";
-  document.getElementById("weakest-answer").textContent = data.weakest_answer ?? "";
+  const setText = (id, text) => {
+    const el = document.getElementById(id);
+    if (!el) return;
+    el.textContent = text ?? "";
+    el.classList.remove("expanded");
+    const next = el.nextElementSibling;
+    if (next?.classList?.contains("show-more-btn")) next.remove();
+  };
+
+  setText("improved-answer", data.improved_answer);
+  setText("improved-pitch", data.improved_pitch);
+  setText("best-answer", data.best_answer);
+  setText("weakest-answer", data.weakest_answer);
+
+  ["improved-answer", "improved-pitch", "best-answer", "weakest-answer"].forEach((id) => {
+    attachShowMore(document.getElementById(id));
+  });
+
+  const setRoundBadge = (id, round) => {
+    const el = document.getElementById(id);
+    if (!el) return;
+    if (round) {
+      el.textContent = `Round ${round}`;
+      el.hidden = false;
+    } else {
+      el.textContent = "";
+      el.hidden = true;
+    }
+  };
+  setRoundBadge("best-answer-round", data.best_answer_round);
+  setRoundBadge("weakest-answer-round", data.weakest_answer_round);
+
+  const whyWeakEl = document.getElementById("why-weak");
+  if (whyWeakEl) {
+    const why = data.why_weak ?? "";
+    whyWeakEl.textContent = why ? `Why it hurt: ${why}` : "";
+    whyWeakEl.hidden = !why;
+    attachShowMore(whyWeakEl);
+  }
 
   const list = document.getElementById("top-questions");
-  list.innerHTML = "";
-  (data.top_3_questions ?? []).forEach((q) => {
-    const li = document.createElement("li");
-    li.textContent = q;
-    list.appendChild(li);
+  if (list) {
+    list.innerHTML = "";
+    (data.top_3_questions ?? []).forEach((q) => {
+      const li = document.createElement("li");
+      li.textContent = q;
+      list.appendChild(li);
+    });
+  }
+
+  state.scoreExplanation = data.score_explanation ?? null;
+
+  const pathBtn = document.getElementById("btn-path-to-80");
+  const hasExplanation = Boolean(state.scoreExplanation);
+  if (pathBtn) pathBtn.hidden = !hasExplanation;
+
+  renderVoiceDelivery(data.voice_delivery);
+  renderJudgeVerdict(data.judge_verdict);
+  state.judgeVerdict = data.judge_verdict ?? null;
+
+  initResultTabs("pitch-result-tabs", "pitch-result-panels");
+  switchResultTab("pitch-result-tabs", "overview");
+
+  const orb = document.querySelector(".score-orb");
+  if (orb) {
+    orb.classList.remove("score-high", "score-mid", "score-low");
+    orb.classList.add(scoreBand(overall));
+  }
+
+  state.scorecardSnapshot = {
+    overall,
+    overallLabel: data.overall_label ?? "",
+    strongest: strongest ? formatDimLabel(strongest[0]) : null,
+    weakest: weakest ? formatDimLabel(weakest[0]) : null,
+    roundsCompleted: state.battleLog?.length ?? 0,
+  };
+}
+
+const DEAL_TYPE_LABELS = {
+  equity: "Equity Negotiation",
+  mentorship: "Mentorship Terms",
+  pilot: "Pilot Agreement",
+  sponsorship: "Sponsorship Terms",
+  verdict_only: "Hackathon Verdict",
+  none: "General Discussion",
+};
+
+function verdictNegotiationCta(label, fallback = "Start Negotiation →") {
+  const text = String(label || "").trim();
+  if (!text || /pitch practice/i.test(text)) return fallback;
+  return text
+    .replace(/Continue to Deal Practice/i, "Start Negotiation")
+    .replace(/Continue to Deal Round/i, "Start Negotiation")
+    .replace(/Deal Practice/i, "Negotiation")
+    .replace(/Deal Round/i, "Negotiation");
+}
+
+function renderJudgeVerdict(verdict) {
+  const heroWrap = document.getElementById("judge-verdict-hero");
+  if (!verdict) {
+    if (heroWrap) heroWrap.hidden = true;
+    return;
+  }
+  if (heroWrap) heroWrap.hidden = false;
+
+  const interest = verdict.interest_level || "no_interest";
+  const personaLine = `${verdict.persona_name || "Judge"} — ${verdict.persona_type || ""}`.trim();
+
+  document.getElementById("verdict-persona-badge").textContent = personaLine;
+  const badge = document.getElementById("verdict-interest-badge");
+  badge.textContent = verdict.interest_label || interest.replaceAll("_", " ");
+  badge.className = `verdict-interest-badge result-verdict-badge interest-${interest}`;
+
+  const reactionEl = document.getElementById("verdict-reaction");
+  if (reactionEl) {
+    reactionEl.textContent = verdict.judge_reaction || "";
+  }
+  document.getElementById("verdict-deal-type").textContent =
+    DEAL_TYPE_LABELS[verdict.deal_type] || verdict.deal_type || "—";
+  const whyEl = document.getElementById("verdict-why");
+  if (whyEl) whyEl.textContent = verdict.why_this_verdict || "";
+
+  const offerEl = document.getElementById("verdict-opening-offer");
+  if (offerEl) {
+    if (verdict.deal_opening_offer) {
+      offerEl.textContent = `Opening offer: ${verdict.deal_opening_offer}`;
+      offerEl.hidden = false;
+    } else {
+      offerEl.hidden = true;
+    }
+  }
+
+  const actions = document.getElementById("verdict-actions");
+  if (!actions) return;
+  actions.innerHTML = "";
+
+  if (verdict.can_continue_to_deal) {
+    const btn = document.createElement("button");
+    btn.className = "btn btn-deal-continue";
+    btn.textContent = verdictNegotiationCta(verdict.next_step_label);
+    btn.type = "button";
+    btn.addEventListener("click", startDealPhase);
+    actions.appendChild(btn);
+  } else if (interest === "too_early") {
+    const btn = document.createElement("button");
+    btn.className = "btn btn-secondary";
+    btn.type = "button";
+    btn.textContent = verdictNegotiationCta(verdict.next_step_label, "Practice More — Negotiate Later");
+    btn.addEventListener("click", () => showScreen("setup"));
+    actions.appendChild(btn);
+  } else if (interest === "no_interest") {
+    const retryBtn = document.createElement("button");
+    retryBtn.className = "btn btn-path80";
+    retryBtn.type = "button";
+    retryBtn.textContent = "View Path to 80+";
+    retryBtn.addEventListener("click", openPath80);
+    actions.appendChild(retryBtn);
+    const newBtn = document.createElement("button");
+    newBtn.className = "btn btn-ghost";
+    newBtn.type = "button";
+    newBtn.textContent = "New Battle";
+    newBtn.addEventListener("click", resetBattle);
+    actions.appendChild(newBtn);
+  } else if (interest === "mild_interest" || interest === "strong_interest") {
+    if (!verdict.can_continue_to_deal) {
+      const btn = document.createElement("button");
+      btn.className = "btn btn-deal-continue";
+      btn.textContent = verdictNegotiationCta(verdict.next_step_label);
+      btn.type = "button";
+      btn.addEventListener("click", startDealPhase);
+      actions.appendChild(btn);
+    }
+  } else if (verdict.deal_type === "verdict_only") {
+    const gapBtn = document.createElement("button");
+    gapBtn.className = "btn btn-path80";
+    gapBtn.type = "button";
+    gapBtn.textContent = verdict.next_step_label || "View Path to 80+";
+    gapBtn.addEventListener("click", openPath80);
+    actions.appendChild(gapBtn);
+  }
+}
+
+function renderDealArena(data) {
+  state.uiMode = "deal";
+  state.dealContext = data.deal_context || {};
+  state.dealRound = data.round ?? 1;
+
+  document.getElementById("deal-round-counter").textContent = state.dealRound;
+  const dealRoundDisplay = document.getElementById("deal-round-display");
+  if (dealRoundDisplay) dealRoundDisplay.textContent = String(state.dealRound).padStart(2, "0");
+  const dealRoundDuel = document.getElementById("deal-round-counter-duel");
+  if (dealRoundDuel) dealRoundDuel.textContent = state.dealRound;
+
+  const dealType = DEAL_TYPE_LABELS[data.deal_type] || data.deal_type || "—";
+  document.getElementById("deal-type-label").textContent = dealType;
+  const typeChip = document.getElementById("deal-type-chip");
+  if (typeChip) typeChip.textContent = dealType;
+
+  const focus = data.negotiation_tag || "—";
+  document.getElementById("deal-negotiation-tag").textContent = focus;
+  const focusChip = document.getElementById("deal-focus-chip");
+  if (focusChip) focusChip.textContent = focus;
+
+  document.getElementById("deal-persona-name").textContent =
+    `${data.persona_name || ""} — ${data.persona_role || ""}`.trim();
+  document.getElementById("deal-opening-offer").textContent =
+    data.deal_context?.opening_offer || data.deal_context?.judge_position || "—";
+  document.getElementById("deal-your-ask").textContent = data.deal_context?.ask || "—";
+
+  updateProgressStrip(state.dealRound, focus, "deal");
+  updateJudgeAttackPill(focus, "deal");
+}
+
+export async function startDealPhase() {
+  if (!state.sessionId) return;
+  try {
+    setGlobalLoading(true, "Preparing deal terms…");
+    const data = await apiPost("/api/start-deal-phase", { session_id: state.sessionId });
+    if (data.error) {
+      showErrorBanner(data.error);
+      return;
+    }
+    if (dealChatWindow) dealChatWindow.innerHTML = "";
+    state.dealConversationLog = [];
+    state.dealBattleLog = [];
+    liveDealJudgeTurn = { text: "", meta: "" };
+    liveDealFounderReply = "";
+    document.getElementById("deal-log-tabs") && (document.getElementById("deal-log-tabs").innerHTML = "");
+    document.getElementById("deal-log-ribbon")?.setAttribute("hidden", "");
+    document.getElementById("btn-open-deal-rounds")?.setAttribute("hidden", "");
+    document.getElementById("deal-rounds-drawer")?.setAttribute("hidden", "");
+    if (dealInput) dealInput.value = "";
+    dealStatus.hidden = true;
+    document.getElementById("deal-readiness-prompt")?.setAttribute("hidden", "");
+    renderDealArena(data);
+    appendDealMessage(
+      "ai",
+      data.ai_message,
+      `${data.negotiation_tag} · Round ${data.round}`,
+    );
+    showScreen("deal");
+    hideErrorBanner();
+  } catch (error) {
+    console.error(error);
+    showErrorBanner("Could not start deal phase.");
+  } finally {
+    setGlobalLoading(false);
+  }
+}
+
+export async function sendDealRound(messageOverride, voiceMeta = null) {
+  const message = (messageOverride ?? dealInput?.value ?? "").trim();
+  if (!message || !state.sessionId) return;
+
+  try {
+    setGlobalLoading(true, "Scoring your counter…");
+    if (dealInput) dealInput.value = "";
+    appendDealMessage("user", message);
+
+    const payload = {
+      session_id: state.sessionId,
+      user_message: message,
+      input_mode: voiceMeta?.voice_turn_id ? "voice" : "text",
+    };
+    if (voiceMeta?.voice_turn_id) payload.voice_turn_id = voiceMeta.voice_turn_id;
+
+    const data = await apiPost("/api/deal-round", payload);
+    if (data.error) {
+      if (dealStatus) {
+        dealStatus.hidden = false;
+        dealStatus.textContent = data.error;
+      }
+      return;
+    }
+
+    state.dealRound = data.round ?? state.dealRound;
+    document.getElementById("deal-round-counter").textContent = state.dealRound;
+    const dealRoundDisplay = document.getElementById("deal-round-display");
+    if (dealRoundDisplay) dealRoundDisplay.textContent = String(state.dealRound).padStart(2, "0");
+    const dealRoundDuel = document.getElementById("deal-round-counter-duel");
+    if (dealRoundDuel) dealRoundDuel.textContent = state.dealRound;
+    document.getElementById("deal-negotiation-tag").textContent = data.negotiation_tag || "—";
+    updateProgressStrip(state.dealRound, data.negotiation_tag, "deal");
+
+    appendDealMessage(
+      "ai",
+      data.ai_message,
+      `${data.negotiation_tag} · Round ${data.round}`,
+    );
+
+    updateDealReadiness(data.readiness, data.soft_limit_reached, data.completion_message);
+
+    state.pendingDealVoiceTurn = null;
+    document.getElementById("deal-voice-preview")?.setAttribute("hidden", "");
+  } catch (error) {
+    console.error(error);
+    dealStatus.hidden = false;
+    dealStatus.textContent = "Deal round failed. Try again.";
+  } finally {
+    setGlobalLoading(false);
+  }
+}
+
+function updateDealReadiness(readiness, softLimit, completionMessage) {
+  const prompt = document.getElementById("deal-readiness-prompt");
+  const text = document.getElementById("deal-readiness-text");
+  const action = readiness?.recommended_action;
+  const shouldShow = action === "recommend_end" || action === "force_end" || softLimit;
+  if (!prompt) return;
+  if (!shouldShow) {
+    prompt.hidden = true;
+    return;
+  }
+  if (text) {
+    text.textContent = readiness?.reason
+      || completionMessage
+      || "You have enough negotiation signal for a scorecard. You can end now or continue one more round.";
+  }
+  // At the hard cap, hide the "continue" option.
+  const continueBtn = document.getElementById("btn-deal-readiness-continue");
+  if (continueBtn) continueBtn.style.display = action === "force_end" ? "none" : "";
+  prompt.hidden = false;
+}
+
+function showDealVoicePreview(data) {
+  state.pendingDealVoiceTurn = data;
+  const preview = document.getElementById("deal-voice-preview");
+  const transcriptEl = document.getElementById("deal-voice-transcript");
+  if (preview) preview.hidden = false;
+  if (transcriptEl) transcriptEl.value = data.transcript ?? "";
+  if (dealInput) dealInput.value = data.transcript ?? "";
+}
+
+export async function endDeal() {
+  if (!state.sessionId) return;
+  try {
+    setGlobalLoading(true, "Building deal scorecard…");
+    const data = await apiPost("/api/end-deal", { session_id: state.sessionId });
+    if (data.error) {
+      showErrorBanner(data.error);
+      return;
+    }
+    state.negotiationTranscript = data.negotiation_transcript || [];
+    renderDealScorecard(data);
+    showScreen("dealScorecard");
+    hideErrorBanner();
+  } catch (error) {
+    console.error(error);
+    showErrorBanner("Failed to generate deal scorecard.");
+  } finally {
+    setGlobalLoading(false);
+  }
+}
+
+function renderDealScorecard(data) {
+  const combined = data.combined_scorecard || {};
+  const deal = data.deal_scorecard || {};
+
+  const pitch = combined.pitch_overall ?? 0;
+  const dealScore = combined.deal_overall ?? 0;
+  const overall = combined.combined_overall ?? 0;
+
+  document.getElementById("combined-pitch").textContent = pitch;
+  document.getElementById("combined-deal").textContent = dealScore;
+  document.getElementById("combined-overall").textContent = overall;
+
+  ["combined-pitch-tab", "combined-deal-tab", "combined-overall-tab"].forEach((id, i) => {
+    const el = document.getElementById(id);
+    if (el) el.textContent = [pitch, dealScore, overall][i];
+  });
+
+  const profile = combined.founder_profile ?? "";
+  document.getElementById("combined-profile").textContent = profile;
+  const profileTab = document.getElementById("combined-profile-tab");
+  if (profileTab) profileTab.textContent = profile;
+
+  const summaryEl = document.getElementById("combined-summary");
+  if (summaryEl) {
+    summaryEl.textContent = combined.summary ?? "";
+    attachShowMore(summaryEl);
+  }
+
+  const nextEl = document.getElementById("combined-next-action");
+  if (nextEl) {
+    nextEl.textContent = combined.next_best_action ?? "Review deal dimensions and prep points below.";
+  }
+
+  const outcomeEl = document.getElementById("deal-outcome-badge");
+  if (outcomeEl) {
+    outcomeEl.textContent = (deal.deal_outcome || "balanced").replaceAll("_", " ");
+    outcomeEl.className = `deal-outcome-badge result-verdict-badge outcome-${deal.deal_outcome || "balanced"}`;
+  }
+  document.getElementById("deal-overall-label").textContent =
+    `${deal.overall ?? 0} — ${deal.overall_label ?? ""}`;
+
+  const dealWeakest = getStrongestWeakest(deal.scores || {}).weakest;
+  const weakestLine = document.getElementById("deal-summary-weakest");
+  if (weakestLine) {
+    weakestLine.textContent = dealWeakest
+      ? `Weakest negotiation skill: ${formatDimLabel(dealWeakest[0])} (${dealWeakest[1].score ?? 0})`
+      : "";
+  }
+
+  const bars = document.getElementById("deal-score-bars");
+  if (bars) {
+    bars.innerHTML = "";
+    Object.entries(deal.scores || {}).forEach(([key, value]) => {
+      bars.appendChild(buildDimensionRow(key, value, { showQuote: true }));
+    });
+  }
+
+  const WEAK_FALLBACK =
+    "No major single weak move detected; the main weakness was lack of alternatives/leverage.";
+  const bestEl = document.getElementById("deal-best-move");
+  const weakEl = document.getElementById("deal-weakest-move");
+  const improvedEl = document.getElementById("deal-improved-response");
+  if (bestEl) {
+    bestEl.textContent = cleanMoveText(deal.best_move) || "No standout negotiation move was recorded.";
+    attachShowMore(bestEl);
+  }
+  if (weakEl) {
+    weakEl.textContent = cleanMoveText(deal.weakest_move) || WEAK_FALLBACK;
+    attachShowMore(weakEl);
+  }
+  if (improvedEl) {
+    improvedEl.textContent = deal.improved_response ?? "";
+    attachShowMore(improvedEl);
+  }
+
+  const prep = document.getElementById("deal-prep-points");
+  if (prep) {
+    prep.innerHTML = "";
+    (deal.top_3_prep_points || []).forEach((p) => {
+      const li = document.createElement("li");
+      li.textContent = p;
+      prep.appendChild(li);
+    });
+  }
+
+  const metaEl = document.getElementById("deal-scorecard-meta");
+  if (metaEl) {
+    const nemotronScored = isNemotronScorecardSource(deal.scorecard_source);
+    metaEl.textContent = nemotronScored ? "Powered by NVIDIA Nemotron" : "";
+    metaEl.hidden = !nemotronScored;
+  }
+
+  initResultTabs("deal-result-tabs", "deal-result-panels");
+  switchResultTab("deal-result-tabs", "deal-summary");
+}
+
+// Reject empty / single-word / obviously truncated move text so the UI never
+// shows a lone "sure" or a half-sentence.
+function cleanMoveText(text) {
+  const t = (text || "").trim();
+  if (!t) return "";
+  const bareWords = ["sure", "ok", "okay", "yes", "fine", "yeah"];
+  if (bareWords.includes(t.toLowerCase().replace(/[.!?]$/, ""))) return "";
+  if (t.length < 12) return "";
+  return t;
+}
+
+function renderNegotiationTranscript() {
+  const container = document.getElementById("negotiation-transcript");
+  if (!container) return;
+  container.innerHTML = "";
+  const transcript = state.negotiationTranscript || [];
+  if (!transcript.length) {
+    container.innerHTML = `<p class="negotiation-empty">No negotiation messages were recorded.</p>`;
+    return;
+  }
+  transcript.forEach((turn) => {
+    const row = document.createElement("div");
+    const role = turn.role === "judge" ? "judge" : "founder";
+    row.className = `negotiation-turn negotiation-${role}`;
+    const speaker = role === "judge" ? "Judge" : "Founder";
+    const badges = [];
+    if (turn.negotiation_tag) {
+      badges.push(`<span class="neg-badge neg-tag source-chip">${escapeHtml(turn.negotiation_tag)}</span>`);
+    }
+    if (turn.answer_quality) {
+      badges.push(`<span class="neg-badge neg-quality neg-q-${escapeHtml(turn.answer_quality)} source-chip">${escapeHtml(turn.answer_quality)}</span>`);
+    }
+    if ((turn.input_mode || "") === "voice") {
+      badges.push(`<span class="neg-badge neg-voice source-chip">Voice</span>`);
+    }
+    if (turn.action_taken) {
+      badges.push(`<span class="neg-badge source-chip">${escapeHtml(turn.action_taken)}</span>`);
+    }
+    row.innerHTML = `
+      <div class="negotiation-turn-head">
+        <span class="negotiation-speaker">${turn.round ? `Round ${turn.round} · ` : ""}${speaker}</span>
+        <span class="negotiation-badges">${badges.join("")}</span>
+      </div>
+      <p class="negotiation-message">${escapeHtml(turn.message || "")}</p>
+    `;
+    container.appendChild(row);
+  });
+  container.scrollTop = container.scrollHeight;
+}
+
+function openNegotiationModal() {
+  renderNegotiationTranscript();
+  const overlay = document.getElementById("negotiation-overlay");
+  if (overlay) overlay.hidden = false;
+}
+
+function closeNegotiationModal() {
+  const overlay = document.getElementById("negotiation-overlay");
+  if (overlay) overlay.hidden = true;
+}
+
+function renderVoiceDelivery(vd) {
+  const content = document.getElementById("voice-delivery-content");
+  const tab = document.getElementById("tab-voice-delivery");
+  if (!content) return;
+  if (!vd || typeof vd !== "object") {
+    if (tab) tab.hidden = true;
+    content.innerHTML = "";
+    return;
+  }
+  if (tab) tab.hidden = false;
+
+  const fillers = (vd.filler_word_list ?? []).slice(0, 6).join(", ") || "None detected";
+  const overallNote = vd.overall_delivery_feedback
+    || (vd.delivery_notes ?? []).find((n) => String(n).trim()) || "";
+
+  content.innerHTML = `
+    <div class="voice-wave-decor" aria-hidden="true"></div>
+    <div class="voice-delivery-summary voice-delivery-grid">
+      <div class="voice-delivery-stat"><span>Voice turns</span><strong>${vd.total_voice_turns ?? 0}</strong></div>
+      <div class="voice-delivery-stat"><span>Filler words</span><strong>${vd.total_filler_words ?? 0}</strong></div>
+      <div class="voice-delivery-stat"><span>Common fillers</span><strong>${escapeHtml(fillers)}</strong></div>
+      <div class="voice-delivery-stat"><span>Pace</span><strong>${escapeHtml(vd.average_pace ?? "—")}</strong></div>
+      <div class="voice-delivery-stat"><span>Clarity signal</span><strong>${escapeHtml(vd.clarity_signal ?? "—")}</strong></div>
+      <div class="voice-delivery-stat"><span>Confidence signal</span><strong>${escapeHtml(vd.confidence_signal ?? "—")}</strong></div>
+    </div>
+    ${overallNote ? `<p class="voice-delivery-overall">${escapeHtml(overallNote)}</p>` : ""}
+  `;
+
+  const notes = (vd.delivery_notes ?? []).filter((n) => {
+    const t = String(n || "").trim().toLowerCase();
+    const overallLower = String(overallNote).trim().toLowerCase();
+    return t && t !== "clean delivery." && t !== "clean delivery" && t !== overallLower;
+  });
+  const uniqueNotes = [...new Set(notes.map((n) => String(n).trim()))].slice(0, 3);
+  if (uniqueNotes.length) {
+    const ul = document.createElement("ul");
+    ul.className = "voice-delivery-notes";
+    uniqueNotes.forEach((n) => {
+      const li = document.createElement("li");
+      li.textContent = n;
+      ul.appendChild(li);
+    });
+    content.appendChild(ul);
+  }
+}
+
+function fillVoiceExtractForm(data) {
+  const form = document.getElementById("voice-extract-form");
+  if (!form || !data) return;
+  const extracted = data.extracted ?? {};
+  Object.entries(extracted).forEach(([key, value]) => {
+    const field = form.elements.namedItem(key);
+    if (field) field.value = value ?? "";
+  });
+  const transcriptEl = document.getElementById("voice-confirm-transcript");
+  if (transcriptEl) transcriptEl.textContent = data.transcript ?? "";
+  const deliveryEl = document.getElementById("voice-confirm-delivery");
+  const obs = data.delivery_observations ?? {};
+  if (deliveryEl) {
+    deliveryEl.textContent = obs.delivery_note
+      ? `Delivery: ${obs.delivery_note}`
+      : "";
+  }
+  const confEl = document.getElementById("voice-confirm-confidence");
+  if (confEl) {
+    const conf = data.extraction_confidence ?? "medium";
+    confEl.textContent = `Confidence: ${conf}`;
+    confEl.className = `delivery-chip confidence-${conf}`;
+  }
+  const warn = document.getElementById("voice-confidence-warning");
+  if (warn) warn.hidden = (data.extraction_confidence ?? "medium") !== "low";
+}
+
+function showVoiceTurnPreview(data) {
+  state.pendingVoiceTurn = data;
+  const preview = document.getElementById("voice-turn-preview");
+  const transcriptEl = document.getElementById("voice-turn-transcript");
+  const deliveryEl = document.getElementById("voice-turn-delivery");
+  if (preview) preview.hidden = false;
+  if (transcriptEl) transcriptEl.value = data.transcript ?? "";
+  if (deliveryEl) {
+    deliveryEl.textContent = data.delivery_note
+      ? `Delivery: ${data.delivery_note}`
+      : "";
+  }
+}
+
+function openPath80() {
+  const ex = state.scoreExplanation;
+  if (!ex) return;
+
+  const esif = ex.estimated_score_if_fixed ?? {};
+  const atr  = ex.answer_to_retry ?? {};
+
+  const setEl = (id, text) => {
+    const el = document.getElementById(id);
+    if (el) el.textContent = text ?? "";
+  };
+
+  setEl("p80-current-score", esif.current_overall ?? "—");
+  setEl("p80-estimated-score", esif.estimated_new_overall ?? "—");
+  setEl("p80-estimate-reason", esif.reason ?? "");
+  setEl("p80-why-scored", ex.why_you_scored_this ?? "");
+  setEl("p80-what-stopped", ex.what_stopped_80 ?? "");
+
+  const dimBadge = document.getElementById("p80-retry-dim");
+  if (dimBadge) dimBadge.textContent = (atr.dimension ?? "").replaceAll("_", " ");
+
+  const roundTag = document.getElementById("p80-retry-round");
+  if (roundTag) roundTag.textContent = atr.round ? `Round ${atr.round}` : "";
+
+  setEl("p80-original-answer", atr.original_answer ?? "");
+  setEl("p80-why-it-hurt", atr.why_it_hurt ?? "");
+  setEl("p80-retry-advice", atr.retry_advice ?? "");
+  setEl("p80-sample-answer", atr.sample_stronger_answer ?? "");
+
+  ["p80-why-scored", "p80-what-stopped", "p80-original-answer", "p80-why-it-hurt", "p80-retry-advice"].forEach((id) => {
+    attachShowMore(document.getElementById(id));
   });
+
+  document.getElementById("path80-overlay").hidden = false;
+  document.body.style.overflow = "hidden";
+}
+
+function closePath80() {
+  document.getElementById("path80-overlay").hidden = true;
+  document.body.style.overflow = "";
+}
+
+function showRetryDrillView() {
+  document.getElementById("retry-drill-view").hidden = false;
+  document.getElementById("retry-result-view").hidden = true;
+}
+
+function showRetryResultView() {
+  document.getElementById("retry-drill-view").hidden = true;
+  document.getElementById("retry-result-view").hidden = false;
+}
+
+function populateRetryDrill(data) {
+  const q = data.retry_question || data.original_question || "";
+  document.getElementById("retry-original-question").textContent = q;
+  document.getElementById("retry-original-answer").textContent = data.original_answer ?? "";
+  document.getElementById("retry-why-hurt").textContent = data.why_it_hurt ?? "";
+  document.getElementById("retry-sample").textContent = data.sample_stronger_answer ?? "";
+  const input = document.getElementById("retry-answer-input");
+  if (input) input.value = "";
+  document.getElementById("retry-voice-preview")?.setAttribute("hidden", "");
+  state.pendingRetryVoiceTurn = null;
+  showRetryDrillView();
+}
+
+async function startRetryDrill() {
+  if (!state.sessionId) return;
+  try {
+    setGlobalLoading(true, "Preparing retry drill...");
+    const data = await apiPost("/api/retry-weakest-question/start", {
+      session_id: state.sessionId,
+    });
+    if (data.error) {
+      showErrorBanner(data.error);
+      return;
+    }
+    state.retryDrill = data;
+    closePath80();
+    populateRetryDrill(data);
+    document.getElementById("retry-overlay").hidden = false;
+    document.body.style.overflow = "hidden";
+    hideErrorBanner();
+  } catch (error) {
+    console.error(error);
+    showErrorBanner("Could not start retry drill. Try again.");
+  } finally {
+    setGlobalLoading(false);
+  }
+}
+
+function showRetryVoicePreview(data) {
+  state.pendingRetryVoiceTurn = data;
+  const preview = document.getElementById("retry-voice-preview");
+  const transcriptEl = document.getElementById("retry-voice-transcript");
+  const input = document.getElementById("retry-answer-input");
+  if (preview) preview.hidden = false;
+  if (transcriptEl) transcriptEl.value = data.transcript ?? "";
+  if (input) input.value = data.transcript ?? "";
+}
+
+function renderRetryResult(data) {
+  const comp = data.comparison ?? {};
+  document.getElementById("retry-result-old").textContent = comp.old_answer_summary ?? data.original_answer ?? "";
+  document.getElementById("retry-result-new").textContent = comp.new_answer_summary ?? data.retry_answer ?? "";
+  document.getElementById("retry-what-improved").textContent = comp.what_improved ?? "";
+  document.getElementById("retry-still-missing").textContent = comp.still_missing ?? "";
+  document.getElementById("retry-specific-tip").textContent = comp.specific_tip ?? "";
+
+  const dim = formatDimLabel(data.dimension);
+  const before = comp.estimated_dimension_before ?? 0;
+  const after = comp.estimated_dimension_after ?? before;
+  document.getElementById("retry-dim-estimate").textContent =
+    `${formatDimLabel(data.dimension)}: ${before} → ${after}`;
+  const lift = data.updated_scorecard?.retry_overall_lift ?? comp.estimated_overall_lift ?? 0;
+  document.getElementById("retry-overall-lift").textContent =
+    data.updated_scorecard
+      ? `Overall score: ${data.updated_scorecard.overall} (+${lift})`
+      : `Overall lift: +${lift}`;
+
+  const verdictEl = document.getElementById("retry-verdict-badge");
+  const verdict = comp.verdict ?? "needs_more_work";
+  const verdictLabels = {
+    improved: "Improved",
+    slightly_improved: "Slightly improved",
+    needs_more_work: "Needs more work",
+  };
+  if (verdictEl) {
+    verdictEl.textContent = verdictLabels[verdict] ?? verdict;
+    verdictEl.className = `retry-verdict-badge verdict-${verdict}`;
+  }
+
+  const nextPrompt = document.getElementById("retry-next-prompt");
+  if (nextPrompt) {
+    nextPrompt.textContent = data.next_practice_prompt
+      ? `Next practice: ${data.next_practice_prompt}`
+      : "";
+  }
+  showRetryResultView();
+}
+
+async function submitRetryAnswer() {
+  if (!state.sessionId || !state.retryDrill?.retry_id) return;
+
+  const voiceTranscript = document.getElementById("retry-voice-transcript")?.value?.trim();
+  const typed = document.getElementById("retry-answer-input")?.value?.trim();
+  const answer = voiceTranscript || typed;
+  if (!answer) return;
+
+  const payload = {
+    session_id: state.sessionId,
+    retry_id: state.retryDrill.retry_id,
+    retry_answer: answer,
+    input_mode: state.pendingRetryVoiceTurn ? "voice" : "text",
+  };
+  if (state.pendingRetryVoiceTurn?.voice_turn_id) {
+    payload.voice_turn_id = state.pendingRetryVoiceTurn.voice_turn_id;
+  }
+
+  try {
+    setGlobalLoading(true, "Comparing your retry answer...");
+    const data = await apiPost("/api/retry-weakest-question/submit", payload);
+    if (data.error) {
+      showErrorBanner(data.error);
+      return;
+    }
+    renderRetryResult(data);
+    if (data.updated_scorecard) {
+      renderScorecard(data.updated_scorecard);
+      state.scoreExplanation = data.updated_scorecard.score_explanation ?? state.scoreExplanation;
+      if (data.judge_verdict) {
+        renderJudgeVerdict(data.judge_verdict);
+        state.judgeVerdict = data.judge_verdict;
+      }
+    }
+    hideErrorBanner();
+  } catch (error) {
+    console.error(error);
+    showErrorBanner("Retry submission failed. Try again.");
+  } finally {
+    setGlobalLoading(false);
+  }
+}
+
+function closeRetryOverlay() {
+  document.getElementById("retry-overlay").hidden = true;
+  document.body.style.overflow = "";
+  state.pendingRetryVoiceTurn = null;
+}
+
+function openRetryFromPath80() {
+  startRetryDrill();
 }
 
 document.getElementById("btn-load-sample").addEventListener("click", loadSample);
-document.getElementById("btn-go-setup").addEventListener("click", () => showScreen("setup"));
+document.getElementById("btn-go-setup").addEventListener("click", () => showScreen("startMethod"));
 document.getElementById("btn-back-landing").addEventListener("click", () => showScreen("landing"));
+document.getElementById("btn-start-back-landing").addEventListener("click", () => showScreen("landing"));
+
+document.getElementById("btn-start-text").addEventListener("click", () => {
+  state.startMode = "text";
+  document.querySelectorAll(".start-method-card").forEach((c) => c.classList.remove("selected"));
+  document.getElementById("btn-start-text").classList.add("selected");
+});
+document.getElementById("btn-start-voice").addEventListener("click", () => {
+  state.startMode = "voice";
+  document.querySelectorAll(".start-method-card").forEach((c) => c.classList.remove("selected"));
+  document.getElementById("btn-start-voice").classList.add("selected");
+});
+document.getElementById("btn-continue-start").addEventListener("click", () => {
+  if (state.startMode === "voice") showScreen("voicePitch");
+  else showScreen("setup");
+});
+document.getElementById("btn-voice-pitch-back").addEventListener("click", () => showScreen("startMethod"));
+document.getElementById("btn-voice-edit-manual").addEventListener("click", () => {
+  const form = document.getElementById("voice-extract-form");
+  const data = new FormData(form);
+  fillStartupForm(Object.fromEntries(data.entries()));
+  showScreen("setup");
+});
+document.getElementById("btn-voice-looks-right").addEventListener("click", () => {
+  const form = document.getElementById("voice-extract-form");
+  const data = new FormData(form);
+  fillStartupForm(Object.fromEntries(data.entries()));
+  showScreen("setup");
+});
+document.getElementById("btn-voice-turn-send").addEventListener("click", () => {
+  const transcript = document.getElementById("voice-turn-transcript")?.value?.trim();
+  if (!transcript || !state.pendingVoiceTurn) return;
+  sendMessage(transcript, {
+    voice_turn_id: state.pendingVoiceTurn.voice_turn_id,
+    delivery_metadata: {
+      delivery_note: state.pendingVoiceTurn.delivery_note,
+      delivery_cues: state.pendingVoiceTurn.delivery_cues,
+      word_count: state.pendingVoiceTurn.word_count,
+    },
+  });
+});
 document.getElementById("btn-start-battle").addEventListener("click", startSession);
 document.getElementById("btn-end-battle").addEventListener("click", endBattle);
 document.getElementById("btn-reset").addEventListener("click", resetBattle);
 document.getElementById("btn-back-setup").addEventListener("click", () => showScreen("setup"));
+document.getElementById("btn-path-to-80").addEventListener("click", openPath80);
+document.getElementById("btn-close-path80").addEventListener("click", closePath80);
+document.getElementById("btn-close-path80-bottom").addEventListener("click", closePath80);
+document.getElementById("btn-retry-question")?.addEventListener("click", openRetryFromPath80);
+document.getElementById("path80-overlay").addEventListener("click", (e) => {
+  if (e.target === e.currentTarget) closePath80();
+});
+
+document.getElementById("btn-close-retry")?.addEventListener("click", closeRetryOverlay);
+document.getElementById("btn-submit-retry")?.addEventListener("click", submitRetryAnswer);
+document.getElementById("btn-retry-again")?.addEventListener("click", () => {
+  if (state.retryDrill) populateRetryDrill(state.retryDrill);
+});
+document.getElementById("btn-retry-back-scorecard")?.addEventListener("click", () => {
+  closeRetryOverlay();
+  showScreen("scorecard");
+});
+document.getElementById("btn-retry-new-battle")?.addEventListener("click", () => {
+  closeRetryOverlay();
+  resetBattle();
+});
+document.getElementById("retry-overlay")?.addEventListener("click", (e) => {
+  if (e.target === e.currentTarget) closeRetryOverlay();
+});
 
 document.getElementById("btn-view-conversation").addEventListener("click", () => {
   document.getElementById("btn-end-battle").hidden = true;
   document.getElementById("btn-back-scorecard").hidden = false;
   document.getElementById("chat-form").hidden = true;
   showScreen("battle");
-  chatWindow.scrollTop = chatWindow.scrollHeight;
+  openBattleConversationLog(true);
 });
 
 document.getElementById("btn-back-scorecard").addEventListener("click", () => {
+  closeRoundsDrawer("battle-rounds-drawer");
   document.getElementById("btn-end-battle").hidden = false;
   document.getElementById("btn-back-scorecard").hidden = true;
   document.getElementById("chat-form").hidden = false;
   showScreen("scorecard");
 });
 
+document.getElementById("btn-open-battle-rounds")?.addEventListener("click", () => {
+  openBattleConversationLog(false);
+});
+document.getElementById("btn-close-battle-rounds")?.addEventListener("click", () => {
+  closeRoundsDrawer("battle-rounds-drawer");
+});
+document.getElementById("btn-close-battle-rounds-x")?.addEventListener("click", () => {
+  closeRoundsDrawer("battle-rounds-drawer");
+});
+document.getElementById("btn-open-deal-rounds")?.addEventListener("click", () => {
+  openRoundsDrawer("deal-rounds-drawer");
+});
+document.getElementById("btn-close-deal-rounds")?.addEventListener("click", () => {
+  closeRoundsDrawer("deal-rounds-drawer");
+});
+document.getElementById("btn-close-deal-rounds-x")?.addEventListener("click", () => {
+  closeRoundsDrawer("deal-rounds-drawer");
+});
+
 document.querySelectorAll(".persona-card").forEach((card) => {
   card.addEventListener("click", () => {
     document.querySelectorAll(".persona-card").forEach((c) => c.classList.remove("selected"));
@@ -348,15 +2042,106 @@ document.querySelectorAll(".persona-card").forEach((card) => {
   });
 });
 
+document.querySelectorAll(".difficulty-card").forEach((card) => {
+  card.addEventListener("click", () => {
+    document.querySelectorAll(".difficulty-card").forEach((c) => c.classList.remove("selected"));
+    card.classList.add("selected");
+    state.difficultyProfile = card.dataset.difficulty;
+  });
+});
+
 document.getElementById("chat-form").addEventListener("submit", (event) => {
   event.preventDefault();
   sendMessage();
 });
 
+function bindEnterToSubmit(textarea, onSubmit) {
+  textarea?.addEventListener("keydown", (event) => {
+    if (event.key !== "Enter" || event.shiftKey || event.isComposing) return;
+    event.preventDefault();
+    onSubmit();
+  });
+}
+
+bindEnterToSubmit(userInput, () => sendMessage());
+bindEnterToSubmit(document.getElementById("deal-input"), () => sendDealRound());
+
+document.getElementById("deal-form")?.addEventListener("submit", (event) => {
+  event.preventDefault();
+  sendDealRound();
+});
+
+document.getElementById("btn-end-deal")?.addEventListener("click", endDeal);
+document.getElementById("btn-deal-back-scorecard")?.addEventListener("click", () => showScreen("scorecard"));
+document.getElementById("btn-deal-new-battle")?.addEventListener("click", resetBattle);
+document.getElementById("btn-deal-view-pitch-scorecard")?.addEventListener("click", () => showScreen("scorecard"));
+
+document.getElementById("btn-deal-readiness-end")?.addEventListener("click", () => {
+  document.getElementById("deal-readiness-prompt")?.setAttribute("hidden", "");
+  endDeal();
+});
+document.getElementById("btn-deal-readiness-continue")?.addEventListener("click", () => {
+  document.getElementById("deal-readiness-prompt")?.setAttribute("hidden", "");
+  document.getElementById("deal-input")?.focus();
+});
+
+document.getElementById("btn-battle-readiness-end")?.addEventListener("click", () => {
+  hideBattleReadiness();
+  endBattle();
+});
+document.getElementById("btn-battle-readiness-continue")?.addEventListener("click", () => {
+  hideBattleReadiness();
+  userInput?.focus();
+});
+
+document.querySelectorAll(".hint-chip").forEach((chip) => {
+  chip.addEventListener("click", () => {
+    const hint = chip.dataset.hint;
+    if (!hint || !userInput) return;
+    const val = userInput.value.trim();
+    userInput.value = val ? `${val} ${hint}`.trim() : hint.trim();
+    userInput.focus();
+  });
+});
+
+document.getElementById("btn-deal-view-negotiation")?.addEventListener("click", openNegotiationModal);
+document.getElementById("btn-close-negotiation")?.addEventListener("click", closeNegotiationModal);
+document.getElementById("btn-negotiation-back")?.addEventListener("click", closeNegotiationModal);
+document.getElementById("negotiation-overlay")?.addEventListener("click", (event) => {
+  if (event.target?.id === "negotiation-overlay") closeNegotiationModal();
+});
+
+document.getElementById("btn-deal-voice-send")?.addEventListener("click", () => {
+  const transcript = document.getElementById("deal-voice-transcript")?.value?.trim();
+  if (!transcript || !state.pendingDealVoiceTurn) return;
+  sendDealRound(transcript, { voice_turn_id: state.pendingDealVoiceTurn.voice_turn_id });
+});
+
+document.getElementById("btn-deal-voice-cancel")?.addEventListener("click", () => {
+  document.getElementById("deal-voice-preview")?.setAttribute("hidden", "");
+  state.pendingDealVoiceTurn = null;
+});
+
 function boot() {
   console.log("PitchFight frontend booting...");
   setGlobalLoading(false);
   hideErrorBanner();
+  initLandingIntro();
+
+  initVoiceUI({
+    getSessionId: () => state.sessionId,
+    getUiMode: () => state.uiMode,
+    onPitchComplete: (data) => {
+      state.pendingVoicePitch = data;
+      fillVoiceExtractForm(data);
+      showScreen("voiceConfirm");
+      hideErrorBanner();
+    },
+    onTurnComplete: (data) => showVoiceTurnPreview(data),
+    onRetryTurnComplete: (data) => showRetryVoicePreview(data),
+    onDealTurnComplete: (data) => showDealVoicePreview(data),
+    onError: (msg) => showErrorBanner(msg),
+  });
 
   fetch("/health")
     .then((response) => response.json())

frontend/voice.js

@@ -0,0 +1,295 @@
+/** Voice recording + API helpers for PitchFight AI Phase 7. */
+
+let mediaRecorder = null;
+let audioChunks = [];
+let recordTimerInterval = null;
+let recordStartMs = 0;
+let currentRecordMode = null; // "pitch" | "turn"
+
+const MIME_CANDIDATES = [
+  "audio/webm;codecs=opus",
+  "audio/webm",
+  "audio/ogg;codecs=opus",
+  "audio/mp4",
+];
+
+function pickMimeType() {
+  if (!window.MediaRecorder) return "";
+  for (const m of MIME_CANDIDATES) {
+    if (MediaRecorder.isTypeSupported(m)) return m;
+  }
+  return "";
+}
+
+function mimeToFormat(mime) {
+  if (!mime) return "webm";
+  if (mime.includes("ogg")) return "ogg";
+  if (mime.includes("mp4")) return "m4a";
+  return "webm";
+}
+
+export function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const dataUrl = reader.result || "";
+      const base64 = String(dataUrl).split(",")[1] || "";
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+
+async function apiPost(path, body) {
+  const response = await fetch(path, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(data.error || data.detail || response.statusText);
+  }
+  return data;
+}
+
+export async function sendVoicePitch(base64, format) {
+  return apiPost("/api/voice-pitch", { audio: base64, audio_format: format });
+}
+
+export async function sendVoiceTurn(sessionId, base64, format) {
+  return apiPost("/api/voice-turn", {
+    session_id: sessionId,
+    audio: base64,
+    audio_format: format,
+  });
+}
+
+function formatTimer(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+
+function _retryModeActive() {
+  const overlay = document.getElementById("retry-overlay");
+  return overlay && !overlay.hidden;
+}
+
+function _dealModeActive() {
+  const dealScreen = document.getElementById("screen-deal");
+  return dealScreen?.classList.contains("active");
+}
+
+function _voiceContext() {
+  if (_dealModeActive()) return "deal";
+  if (_retryModeActive()) return "retry";
+  return "battle";
+}
+
+function setRecordingUI(active, mode) {
+  const pitchBtn = document.getElementById("btn-voice-pitch-record");
+  const turnBtn = document.getElementById("btn-voice-turn-record");
+  const retryBtn = document.getElementById("btn-retry-voice-record");
+  const dealBtn = document.getElementById("btn-deal-voice-record");
+  const pitchStatus = document.getElementById("voice-pitch-status");
+  const turnStatus = document.getElementById("voice-turn-status");
+  const retryStatus = document.getElementById("retry-voice-status");
+  const dealStatus = document.getElementById("deal-voice-status");
+  const pitchTimer = document.getElementById("voice-pitch-timer");
+  const turnTimer = document.getElementById("voice-turn-timer");
+  const retryTimer = document.getElementById("retry-voice-timer");
+  const dealTimer = document.getElementById("deal-voice-timer");
+  const ctx = _voiceContext();
+  const retryRecording = active && mode === "turn" && ctx === "retry";
+  const dealRecording = active && mode === "turn" && ctx === "deal";
+
+  [pitchBtn, turnBtn, retryBtn, dealBtn].forEach((btn) => btn?.classList.remove("recording"));
+  if (active && mode === "pitch" && pitchBtn) pitchBtn.classList.add("recording");
+  if (active && mode === "turn" && ctx === "battle" && turnBtn) turnBtn.classList.add("recording");
+  if (retryRecording && retryBtn) retryBtn.classList.add("recording");
+  if (dealRecording && dealBtn) dealBtn.classList.add("recording");
+
+  if (pitchStatus) pitchStatus.textContent = active && mode === "pitch" ? "Recording…" : "";
+  if (turnStatus) turnStatus.textContent = active && mode === "turn" && ctx === "battle" ? "Recording…" : "";
+  if (retryStatus) retryStatus.textContent = retryRecording ? "Recording…" : "";
+  if (dealStatus) dealStatus.textContent = dealRecording ? "Recording…" : "";
+  if (!active) {
+    if (pitchTimer) pitchTimer.textContent = "0:00";
+    if (turnTimer) turnTimer.textContent = "0:00";
+    if (retryTimer) retryTimer.textContent = "0:00";
+    if (dealTimer) dealTimer.textContent = "0:00";
+  }
+}
+
+function startTimer(el) {
+  recordStartMs = Date.now();
+  clearInterval(recordTimerInterval);
+  recordTimerInterval = setInterval(() => {
+    const sec = Math.floor((Date.now() - recordStartMs) / 1000);
+    if (el) el.textContent = formatTimer(sec);
+  }, 250);
+}
+
+function stopTimer() {
+  clearInterval(recordTimerInterval);
+  recordTimerInterval = null;
+}
+
+async function startRecording(mode) {
+  if (mediaRecorder?.state === "recording") return;
+  currentRecordMode = mode;
+  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+  const mime = pickMimeType();
+  mediaRecorder = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
+  audioChunks = [];
+  mediaRecorder.ondataavailable = (e) => {
+    if (e.data.size > 0) audioChunks.push(e.data);
+  };
+  mediaRecorder.start(200);
+  let timerEl = document.getElementById("voice-pitch-timer");
+  if (mode === "turn") {
+    const ctx = _voiceContext();
+    timerEl = ctx === "deal"
+      ? document.getElementById("deal-voice-timer")
+      : ctx === "retry"
+        ? document.getElementById("retry-voice-timer")
+        : document.getElementById("voice-turn-timer");
+  }
+  startTimer(timerEl);
+  setRecordingUI(true, mode);
+}
+
+async function stopRecording() {
+  if (!mediaRecorder || mediaRecorder.state !== "recording") {
+    return { blob: null, format: "webm", mode: currentRecordMode };
+  }
+  const mode = currentRecordMode;
+  const mime = mediaRecorder.mimeType || "audio/webm";
+  const format = mimeToFormat(mime);
+
+  return new Promise((resolve) => {
+    mediaRecorder.onstop = () => {
+      stopTimer();
+      setRecordingUI(false, mode);
+      mediaRecorder.stream.getTracks().forEach((t) => t.stop());
+      const blob = new Blob(audioChunks, { type: mime });
+      audioChunks = [];
+      resolve({ blob, format, mode });
+    };
+    mediaRecorder.stop();
+  });
+}
+
+async function _handleTurnRecording(handlers, onComplete) {
+  if (mediaRecorder?.state === "recording" && currentRecordMode === "turn") {
+    const { blob, format } = await stopRecording();
+    if (!blob?.size) throw new Error("No audio captured.");
+    const base64 = await blobToBase64(blob);
+    const sessionId = handlers.getSessionId?.();
+    if (!sessionId) throw new Error("No active session.");
+    const data = await sendVoiceTurn(sessionId, base64, format);
+    if (data.error) throw new Error(data.error);
+    onComplete?.(data);
+  } else {
+    await startRecording("turn");
+  }
+}
+
+export function initVoiceUI(handlers = {}) {
+  const {
+    onPitchComplete,
+    onTurnComplete,
+    onRetryTurnComplete,
+    onDealTurnComplete,
+    onError,
+  } = handlers;
+
+  const resolveTurnComplete = (data) => {
+    const ctx = handlers.getUiMode?.() || _voiceContext();
+    if (ctx === "deal") onDealTurnComplete?.(data);
+    else if (ctx === "retry") (onRetryTurnComplete ?? onTurnComplete)?.(data);
+    else onTurnComplete?.(data);
+  };
+
+  document.getElementById("btn-voice-pitch-record")?.addEventListener("click", async () => {
+    try {
+      if (mediaRecorder?.state === "recording" && currentRecordMode === "pitch") {
+        const { blob, format } = await stopRecording();
+        if (!blob?.size) throw new Error("No audio captured.");
+        const base64 = await blobToBase64(blob);
+        const data = await sendVoicePitch(base64, format);
+        if (data.error) throw new Error(data.error);
+        onPitchComplete?.(data);
+      } else {
+        await startRecording("pitch");
+      }
+    } catch (err) {
+      onError?.(err.message || String(err));
+    }
+  });
+
+  document.getElementById("btn-voice-pitch-cancel")?.addEventListener("click", async () => {
+    if (mediaRecorder?.state === "recording") {
+      mediaRecorder.onstop = () => {
+        stopTimer();
+        setRecordingUI(false, "pitch");
+        mediaRecorder?.stream?.getTracks().forEach((t) => t.stop());
+      };
+      mediaRecorder.stop();
+    }
+  });
+
+  document.getElementById("btn-voice-turn-record")?.addEventListener("click", async () => {
+    try {
+      await _handleTurnRecording(handlers, resolveTurnComplete);
+    } catch (err) {
+      onError?.(err.message || String(err));
+    }
+  });
+
+  document.getElementById("btn-retry-voice-record")?.addEventListener("click", async () => {
+    try {
+      await _handleTurnRecording(handlers, resolveTurnComplete);
+    } catch (err) {
+      onError?.(err.message || String(err));
+    }
+  });
+
+  document.getElementById("btn-deal-voice-record")?.addEventListener("click", async () => {
+    try {
+      await _handleTurnRecording(handlers, resolveTurnComplete);
+    } catch (err) {
+      onError?.(err.message || String(err));
+    }
+  });
+
+  document.getElementById("btn-voice-turn-cancel")?.addEventListener("click", async () => {
+    if (mediaRecorder?.state === "recording") {
+      mediaRecorder.onstop = () => {
+        stopTimer();
+        setRecordingUI(false, "turn");
+        mediaRecorder?.stream?.getTracks().forEach((t) => t.stop());
+      };
+      mediaRecorder.stop();
+    }
+    document.getElementById("voice-turn-preview")?.setAttribute("hidden", "");
+  });
+}
+
+export function startVoicePitchRecording() {
+  return startRecording("pitch");
+}
+
+export function stopVoicePitchRecording() {
+  return stopRecording();
+}
+
+export function startVoiceTurnRecording() {
+  return startRecording("turn");
+}
+
+export function stopVoiceTurnRecording() {
+  return stopRecording();
+}

requirements.txt

@@ -7,3 +7,4 @@ numpy
 openai>=1.0.0
 httpx
 requests
+pymongo[srv]==4.7.2