feat(phase-10): V2 natural sentence resume mode — Kimi LLM generates sentences, same V1 waterfall

V2 engine (src/resume_v2_natural.py) uses Kimi-K2.6 to generate natural sentences
from keywords, placed in the same waterfall locations as V1. Falls back to V1 comma
placement if LLM fails. All touchpoints wired: API dispatch, HF bulk, extension
popup/options, Cloudflare relay, Telegram bot. 17 V2 tests + 11 V1 regression pass.

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

.planning/phases/10-v1-v2-resume-modes/10-01-SUMMARY.md

@@ -0,0 +1,41 @@
+---
+phase: 10-v1-v2-resume-modes
+plan: 01
+type: summary
+status: DONE
+---
+
+# 10-01 Summary: V2 Engine + API Dispatch
+
+## What was built
+
+### src/resume_v2_natural.py (new, ~350 lines)
+- `generate_v2()` — main entry point: extract keywords, allocate (same V1 waterfall),
+  call LLM to generate natural sentences, place in resume, compile
+- `_allocate_keywords()` — exact V1 waterfall: Summary 15-20, PSM 25-30, PS 25-30,
+  ML Edutech 8-12, Skills Other 15-20, Projects, NxtWave
+- `_build_user_prompt()` / `_SYSTEM_PROMPT` — LLM prompt with profile context
+- `_place_sentences_structured()` — inject sentences into same anchors as V1
+- `_v2_honesty_check()` — regulated credential check on generated text
+- `_validate_candidate()` — identity marker + structure validation
+- `_fan_out()` / `_judge_candidates()` — optional multi-model fan-out
+- Falls back to V1 comma placement if LLM fails
+
+### api_server.py changes
+- `version: str = Form("")` added to `/api/generate`
+- Dispatch: `_version == "v2"` routes to `_generate_from_latex_v2()`
+- `_generate_from_latex_v2()` wraps `generate_v2()` with identical payload shape to V1
+
+## Key decisions (modified from original plan)
+- **Kimi-K2.6** as default V2 model (env `V2_JUDGE_MODEL`), not MiniMax
+- **Sentence-based** placement in same waterfall locations as V1 (not whole-resume rewrite)
+- Single-model fast path by default (~5s per job); multi-model fan-out optional
+- V1 remains the safe default (`GEN_VERSION_DEFAULT=v1`)
+
+## Verification
+- `from src.resume_v2_natural import generate_v2` — imports OK
+- `_fan_out_cfgs()` returns Kimi/Qwen/GPT-OSS configs
+- `_v2_model_cfg()` returns Kimi-K2.6
+- `_validate_candidate` passes real resume, rejects short/non-LaTeX
+- api_server.py parses with `_generate_from_latex_v2` present
+- Version field + dispatch present in `/api/generate`

HISTORY.md

@@ -4,6 +4,37 @@ A running log of everything built, fixed, and changed. Most recent first.
 
 ---
 
+## 2026-06-24 — Phase 10: V1/V2 Resume Generation Modes
+
+Labeled the existing pipeline as **V1** (structured keyword placement) and added
+**V2** (natural AI sentence integration). Both modes are live across all three
+touchpoints: HF Streamlit, Chrome extension, and Telegram bot.
+
+**V2 engine** (`src/resume_v2_natural.py`): Same keyword extraction + waterfall
+allocation as V1 (Summary 15-20, BYJU's PSM 25-30, PS 25-30, ML Edutech 8-12,
+Skills Other 15-20, Projects/NxtWave), but an LLM (Kimi-K2.6 by default, ~5s)
+generates natural sentences that weave the keywords into genuine experience
+bullets. Falls back to V1 comma placement if the LLM call fails. Honesty
+boundaries preserved (regulated credentials + specialty terms never injected).
+
+**API dispatch**: `/api/generate` accepts `version=v1|v2`; default from
+`GEN_VERSION_DEFAULT` env (v1). V2 response payload mirrors V1 (tex_b64, pdf_b64,
+status, external_coverage_pct) plus `v2_models_used`, `v2_winner`, `judge_note`.
+
+**Touchpoints**:
+- HF Streamlit: V1/V2 radio on the home page; bulk pipeline honors V2 selection
+- Chrome extension: Options default (`gen_version_default`) + popup per-run toggle;
+  background forwards `version` to `/api/generate`; popup renders `latex_v2` source
+- Telegram: `/v1`, `/v2`, `/mode` commands (relay via Workers KV, bot via in-memory)
+- Cloudflare relay: forwards `version` + per-user KV state
+
+**Key decisions**:
+- Kimi-K2.6 as default V2 model (fastest at ~5s, configurable via `V2_JUDGE_MODEL`)
+- V2 works in bulk pipeline (one LLM call per job ≈ 5-10s; acceptable for 30 jobs)
+- V1 remains the safe default (GEN_VERSION_DEFAULT=v1)
+
+---
+
 ## 2026-06-24 (AM5) — Clean server-side JD extraction (JD only, all platforms)
 
 First successful Telegram run worked but the resume was polluted: the server-side

README.md

@@ -404,6 +404,45 @@ Verify (deterministic, no keys):
 
 ---
 
+## Generation Modes (V1 / V2)
+
+Two resume tailoring modes, selectable per surface:
+
+### V1 — Structured Keyword Placement (default)
+
+Uncapped JD keyword extraction + ordered placement into the hardcoded resume
+(Phase 9). Keywords are appended as comma-separated `\resumeItem` lines in a
+waterfall order: Summary 15-20, BYJU's PSM 25-30, PS 25-30, ML Edutech 8-12,
+Skills Other 15-20, Projects, NxtWave. Fast (no LLM call for placement);
+keywords appear verbatim.
+
+### V2 — Natural AI Sentence Integration
+
+Same keyword extraction + waterfall allocation as V1, but an LLM (Kimi-K2.6 by
+default, ~5s) generates **natural sentences** that weave the keywords into
+genuine-sounding experience bullets. Reads as natural prose rather than keyword
+lists; honesty boundaries preserved; slightly slower (one LLM call + compile).
+Falls back to V1 comma placement if the LLM call fails.
+
+### Selecting a version
+
+| Surface | How to choose |
+|---------|---------------|
+| `/api/generate` | `version=v1` or `version=v2` form field; default from `GEN_VERSION_DEFAULT` env (v1) |
+| HF Streamlit | V1/V2 radio on the home page; bulk pipeline honors the selection |
+| Chrome extension | Default in Options (`gen_version_default`) + per-run toggle in the popup |
+| Telegram bot | `/v1`, `/v2` commands set per-user default; `/mode` shows current |
+
+### Env knobs
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `GEN_VERSION_DEFAULT` | `v1` | Default version when not specified |
+| `V2_JUDGE_MODEL` | `Kimi-K2.6` | Model used for V2 sentence generation |
+| `V2_FAN_OUT_MODELS` | `Kimi-K2.6,Qwen3.5-397b,GPT-OSS-120b` | Models for multi-model fan-out (when explicitly configured) |
+
+---
+
 ## Google Sheet Columns
 
 | Column | Description |

api_server.py

@@ -336,6 +336,123 @@ async def _generate_from_latex(
             shutil.rmtree(out_dir, ignore_errors=True)
 
 
+async def _generate_from_latex_v2(
+    latex_src: str, jd_text: str, job_title: str, company: str,
+    max_ats: bool, conf_terms: list,
+) -> JSONResponse:
+    """V2: sentence-based keyword integration via LLM, same waterfall as V1."""
+    out_dir: str | None = None
+    try:
+        from src.resume_v2_natural import generate_v2
+        loop = asyncio.get_event_loop()
+        out_dir = tempfile.mkdtemp(prefix="latex_v2_")
+        report = await loop.run_in_executor(
+            None,
+            lambda: generate_v2(
+                latex_src, jd_text, job_title=job_title, company=company,
+                out_dir=out_dir, compile_pdf=True,
+            ),
+        )
+        pct = int(report.get("pct") or 0)
+        pdf_path = report.get("pdf_path")
+        tex = report.get("tex") or latex_src
+        compiled = report.get("compiled", False)
+
+        tex_b64 = base64.b64encode(tex.encode("utf-8")).decode("ascii")
+        pdf_b64 = None
+        if pdf_path:
+            try:
+                with open(pdf_path, "rb") as _f:
+                    pdf_b64 = base64.b64encode(_f.read()).decode("ascii")
+            except Exception:
+                pass
+
+        pdf_error = None
+        if not pdf_b64:
+            engine = report.get("engine")
+            pdf_error = "engine_missing" if not engine else "latex_error"
+
+        pdf_fallback = False
+        if not pdf_b64:
+            try:
+                from src.latex_resume import latex_to_text, render_text_to_pdf
+                fb_path = os.path.join(out_dir, "resume_v2_fallback.pdf")
+                if (render_text_to_pdf(latex_to_text(tex or ""), fb_path)
+                        and os.path.exists(fb_path)):
+                    with open(fb_path, "rb") as _f:
+                        pdf_b64 = base64.b64encode(_f.read()).decode("ascii")
+                    pdf_fallback = True
+            except Exception as exc:
+                print(f"[api/generate:v2] fallback pdf render failed: {exc}")
+
+        from src.fit_gate import MAX_ATS_READY_STATUSES
+        status = _latex_status(pct, max_ats, False)
+        download_allowed = status in MAX_ATS_READY_STATUSES
+
+        payload = {
+            "status": status,
+            "source": "latex_v2",
+            "version": "v2",
+            "download_allowed": bool(download_allowed),
+            "maximum_ats_mode": max_ats,
+            "scores": {
+                "jd_match": pct,
+                "ats_readability": 100,
+                "independent_jd_match": pct,
+            },
+            "external_coverage": {
+                "expected": report.get("expected", 0),
+                "found": report.get("found", 0),
+                "pct": pct,
+                "missing": report.get("missing", []),
+            },
+            "external_coverage_pct": pct,
+            "coverage_report": {
+                "keywords": report.get("keywords", []),
+                "coverage_count": f"{report.get('found', 0)}/{report.get('expected', 0)}",
+            },
+            "latex_engine": report.get("engine"),
+            "latex_compiled": compiled,
+            "compile_log": "",
+            "pdf_error": pdf_error,
+            "pdf_fallback": pdf_fallback,
+            "tex_b64": tex_b64,
+            "pdf_b64": pdf_b64,
+            "docx_b64": None,
+            "v2_models_used": report.get("v2_models_used", []),
+            "v2_winner": report.get("v2_winner", ""),
+            "judge_note": report.get("judge_note", ""),
+            "keywords": report.get("keywords", []),
+        }
+        print(f"[api/generate:v2] max_ats={max_ats} status={status} "
+              f"external_cov={pct}% compiled={compiled} "
+              f"winner={report.get('v2_winner')} judge={report.get('judge_note')}")
+
+        try:
+            from src.supabase_client import get_service_client, is_configured, get_owner_user_id
+            if is_configured() and tex:
+                uid = get_owner_user_id()
+                if uid:
+                    get_service_client().table("generated_resumes").insert({
+                        "job_title": job_title,
+                        "company": company,
+                        "tex_source": tex,
+                        "ats_score": pct,
+                        "user_id": uid,
+                    }).execute()
+        except Exception as _sb_exc:
+            print(f"[api/generate:v2] supabase save failed (non-fatal): {_sb_exc}")
+
+        return JSONResponse(payload)
+    except Exception as exc:
+        return JSONResponse(
+            {"error": "v2_engine_error", "detail": str(exc)[:400]}, status_code=200
+        )
+    finally:
+        if out_dir:
+            shutil.rmtree(out_dir, ignore_errors=True)
+
+
 async def _repair_from_latex(
     latex_src: str, jd_text: str, job_title: str, company: str,
     max_ats: bool, conf_terms: list, pasted_terms: list,
@@ -491,6 +608,65 @@ async def telegram_webhook(request: Request, background_tasks: BackgroundTasks):
     return {"ok": True}
 
 
+# ── /api/form-assist ──────────────────────────────────────────────────────────
+@app.post("/api/form-assist")
+async def form_assist(
+    fields_json: str = Form("[]"),
+    profile_json: str = Form("{}"),
+    resume_latex: str = Form(""),
+    jd_text: str = Form(""),
+    job_title: str = Form(""),
+    company: str = Form(""),
+    x_api_token: str = Header(None),
+):
+    """Answer job-application form fields from the candidate profile, resume
+    LaTeX, and optional job-description context. Used by the browser extension's
+    autofill flow for the fields that can't be filled deterministically."""
+    _check_token(x_api_token)
+
+    try:
+        fields = json.loads(fields_json or "[]")
+        if not isinstance(fields, list):
+            fields = []
+    except Exception:
+        fields = []
+    if not fields:
+        return JSONResponse({"answers": [], "answered_count": 0, "field_count": 0})
+
+    if not (resume_latex or "").strip():
+        try:
+            from src.default_resume import get_default_resume_latex
+            resume_latex = get_default_resume_latex()
+        except Exception:  # noqa: BLE001
+            resume_latex = ""
+
+    try:
+        from src.form_autofill import answer_application_fields
+
+        loop = asyncio.get_event_loop()
+        answers = await loop.run_in_executor(
+            None,
+            lambda: answer_application_fields(
+                resume_latex=resume_latex,
+                jd_text=jd_text,
+                job_title=job_title,
+                company=company,
+                profile_json=profile_json,
+                fields=fields,
+            ),
+        )
+        return JSONResponse({
+            "answers": answers,
+            "answered_count": len([a for a in answers if (a.get("value") or "").strip()]),
+            "field_count": len(fields),
+        })
+    except Exception as exc:
+        return JSONResponse(
+            {"error": "form_assist_failed", "detail": str(exc)[:240]},
+            status_code=500,
+        )
+
+
 # ── /api/generate ─────────────────────────────────────────────────────────────
 @app.post("/api/generate")
 async def generate(
@@ -502,6 +678,7 @@ async def generate(
     user_confirmed_expansion: str = Form(""),  # alias for maximum_ats_mode
     confirmed_terms: str = Form(""),        # optional comma/newline list
     resume_latex: str = Form(""),           # LaTeX source (PRIORITISED over PDF)
+    version: str = Form(""),               # "v1" or "v2"; empty → GEN_VERSION_DEFAULT env
     resume: UploadFile = None,
     x_api_token: str = Header(None),
 ):
@@ -513,6 +690,7 @@ async def generate(
       - jd_url    — a job link; server fetches + extracts the JD (Telegram relay)
       - job_title (optional) — for recruiter pitch header
       - company   (optional) — for recruiter pitch header
+      - version   — "v1" or "v2"; empty → GEN_VERSION_DEFAULT env (default v1)
       - resume    — PDF bytes; OPTIONAL — falls back to the bundled default resume
       Header: X-Api-Token — must match API_SECRET_TOKEN env var (when set)
 
@@ -557,6 +735,11 @@ async def generate(
     # ── LaTeX-first: if the user supplied LaTeX source, use it (priority over the
     #    uploaded PDF) for keyword matching + scoring, then compile to PDF. ──────
     if (resume_latex or "").strip():
+        _version = (version or "").strip().lower() or os.getenv("GEN_VERSION_DEFAULT", "v1")
+        if _version == "v2":
+            return await _generate_from_latex_v2(
+                resume_latex, jd_text, job_title, company, max_ats, conf_terms
+            )
         return await _generate_from_latex(
             resume_latex, jd_text, job_title, company, max_ats, conf_terms
         )

extension/background.js

@@ -52,6 +52,195 @@ async function resolveActiveTabUrl() {
   }
 }
 
+function normalizeText(s) {
+  return String(s || '')
+    .toLowerCase()
+    .replace(/[_-]+/g, ' ')
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function parseProfileJson(raw) {
+  if (!raw || !String(raw).trim()) return {};
+  try {
+    const data = JSON.parse(raw);
+    return data && typeof data === 'object' ? data : {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function profileIndex(profile) {
+  const out = { ...(profile || {}) };
+  const full = String(out.full_name || '').trim();
+  if (full) {
+    const parts = full.split(/\s+/);
+    if (!out.first_name && parts.length) out.first_name = parts[0];
+    if (!out.last_name && parts.length > 1) out.last_name = parts.slice(1).join(' ');
+  }
+  return out;
+}
+
+function valueOf(profile, key) {
+  const v = profile ? profile[key] : '';
+  return typeof v === 'string' || typeof v === 'number' ? String(v).trim() : '';
+}
+
+function fieldText(field) {
+  return normalizeText([
+    field.label, field.name, field.placeholder, field.help_text, field.type,
+  ].filter(Boolean).join(' '));
+}
+
+function isLongAnswerField(field) {
+  return field.tag === 'textarea'
+    || field.type === 'textarea'
+    || (field.type === 'text' && /cover letter|why|tell us|describe|summary|experience|motivation|fit/.test(fieldText(field)));
+}
+
+function localAutofillValue(field, profile) {
+  const text = fieldText(field);
+  const fullName = valueOf(profile, 'full_name');
+  const firstName = valueOf(profile, 'first_name');
+  const lastName = valueOf(profile, 'last_name');
+
+  if (!text) return '';
+  if (/first name|given name/.test(text)) return firstName;
+  if (/last name|family name|surname/.test(text)) return lastName;
+  if (/full name|your name|applicant name|candidate name/.test(text)) return fullName;
+  if (/email|e mail/.test(text)) return valueOf(profile, 'email');
+  if (/phone|mobile|contact number|telephone/.test(text)) return valueOf(profile, 'phone');
+  if (/linkedin/.test(text)) return valueOf(profile, 'linkedin_url');
+  if (/github/.test(text)) return valueOf(profile, 'github_url');
+  if (/portfolio|website|personal site/.test(text)) return valueOf(profile, 'portfolio_url');
+  if (/current company|current employer|employer|organization/.test(text)) return valueOf(profile, 'current_company');
+  if (/current title|job title|designation|headline/.test(text)) return valueOf(profile, 'current_title');
+  if (/location|current city|city state|address/.test(text)) return valueOf(profile, 'location');
+  if (/years of experience|total experience|experience in years|how many years/.test(text)) {
+    return valueOf(profile, 'years_experience');
+  }
+  if (/notice period|joining period|available to join|when can you start|start date/.test(text)) {
+    return valueOf(profile, 'notice_period');
+  }
+  if (/authorized to work|work authorization/.test(text)) return valueOf(profile, 'work_authorization');
+  if (/require sponsorship|need sponsorship|visa sponsorship/.test(text)) {
+    return valueOf(profile, 'requires_sponsorship');
+  }
+  if (/visa status/.test(text)) return valueOf(profile, 'visa_status');
+  if (/current salary|current ctc/.test(text)) return valueOf(profile, 'current_salary');
+  if (/expected salary|salary expectation|expected ctc|compensation expectation/.test(text)) {
+    return valueOf(profile, 'expected_salary');
+  }
+  if (/notice|relocation|work mode|remote|hybrid/.test(text)) return valueOf(profile, 'additional_notes');
+  return '';
+}
+
+function pickFieldsForApi(fields, localAnswers) {
+  const answered = new Set((localAnswers || []).map((a) => a.id));
+  return (fields || []).filter((field) => {
+    if (!field || !field.id || answered.has(field.id)) return false;
+    const text = fieldText(field);
+    if (!text) return false;
+    if (/search|filter|sort/.test(text)) return false;
+    return isLongAnswerField(field)
+      || (field.tag === 'select' || field.type === 'radio')
+      || /why|motivation|about you|introduce yourself|cover letter|summary|fit|salary|authorization|sponsorship|relocate/.test(text);
+  });
+}
+
+async function runFormAssist({ data, resumeLatex, profile, fields, jd_text, job_title, company }) {
+  const formData = new FormData();
+  formData.append('resume_latex', resumeLatex || '');
+  formData.append('profile_json', JSON.stringify(profile || {}));
+  formData.append('fields_json', JSON.stringify(fields || []));
+  formData.append('jd_text', jd_text || '');
+  formData.append('job_title', job_title || '');
+  formData.append('company', company || '');
+
+  let resp;
+  try {
+    resp = await fetch(`${data.api_url.replace(/\/$/, '')}/api/form-assist`, {
+      method: 'POST',
+      headers: { 'X-Api-Token': data.api_token },
+      body: formData,
+    });
+  } catch (networkErr) {
+    return { error: 'network_error', detail: `Cannot reach API: ${networkErr.message}` };
+  }
+
+  let result;
+  try {
+    result = await resp.json();
+  } catch {
+    return { error: 'parse_error', detail: `API returned non-JSON (status ${resp.status})` };
+  }
+  if (!resp.ok) {
+    return { error: result.error || 'api_error', detail: result.detail || `HTTP ${resp.status}` };
+  }
+  return result;
+}
+
+async function handleAutofillForm({ fields, jd_text, job_title, company }) {
+  const data = await new Promise(res => chrome.storage.local.get(
+    ['api_url', 'api_token', 'resume_latex', 'autofill_profile_json'], res
+  ));
+
+  let resumeLatex = data.resume_latex;
+  if ((!resumeLatex || !resumeLatex.trim()) && self.DEFAULT_RESUME_LATEX) {
+    resumeLatex = self.DEFAULT_RESUME_LATEX;
+  }
+
+  const profile = profileIndex(parseProfileJson(data.autofill_profile_json));
+  const localAnswers = [];
+  for (const field of (fields || [])) {
+    const value = localAutofillValue(field, profile);
+    if (value) {
+      localAnswers.push({
+        id: field.id,
+        value,
+        confidence: 'high',
+        source: 'profile',
+      });
+    }
+  }
+
+  const needsApi = pickFieldsForApi(fields, localAnswers);
+  let apiAnswers = [];
+  let warning = '';
+
+  if (needsApi.length) {
+    if (!data.api_url || !data.api_token) {
+      warning = 'API not configured. Filled only the common profile fields.';
+    } else if (!resumeLatex || !resumeLatex.trim()) {
+      warning = 'Resume LaTeX is not configured. Filled only the common profile fields.';
+    } else {
+      const apiResult = await runFormAssist({
+        data, resumeLatex, profile, fields: needsApi, jd_text, job_title, company,
+      });
+      if (apiResult && apiResult.error) {
+        warning = apiResult.detail || apiResult.error;
+      } else {
+        apiAnswers = Array.isArray(apiResult?.answers) ? apiResult.answers : [];
+      }
+    }
+  }
+
+  const merged = new Map();
+  for (const answer of [...apiAnswers, ...localAnswers]) {
+    if (!answer || !answer.id || !String(answer.value || '').trim()) continue;
+    merged.set(answer.id, answer);
+  }
+
+  return {
+    answers: Array.from(merged.values()),
+    local_count: localAnswers.length,
+    api_count: apiAnswers.filter((a) => String(a?.value || '').trim()).length,
+    field_count: (fields || []).length,
+    warning,
+  };
+}
+
 // Shallow-merge a patch into the entry for `urlKey`, preserving existing fields,
 // stamping savedAt, and pruning to the most-recent MAX_SAVED entries.
 async function writeEntry(urlKey, patch) {
@@ -125,11 +314,17 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
     handleDownload(msg).catch(console.error);
     return false;
   }
+  if (msg.type === 'AUTOFILL_FORM') {
+    handleAutofillForm(msg)
+      .then((data) => safeRespond(sendResponse, data))
+      .catch((err) => safeRespond(sendResponse, { error: 'runtime_error', detail: err.message }));
+    return true;
+  }
 });
 
 // ─── REPAIR (External ATS Feedback Repair Mode) ───────────────────────────────
 
-async function handleRepair({ jd_text, job_title, company, feedback, maximum_ats_mode, confirmed_terms, url }) {
+async function handleRepair({ jd_text, job_title, company, feedback, maximum_ats_mode, confirmed_terms, url, version }) {
   const data = await new Promise(res => chrome.storage.local.get(
     ['resume_b64', 'resume_latex', 'api_url', 'api_token'], res
   ));
@@ -153,6 +348,7 @@ async function handleRepair({ jd_text, job_title, company, feedback, maximum_ats
   formData.append('feedback', feedback || '');
   formData.append('maximum_ats_mode', maximum_ats_mode ? '1' : '0');
   if (confirmed_terms) formData.append('confirmed_terms', confirmed_terms);
+  formData.append('version', version || 'v1');
 
   // LaTeX takes priority; only attach the PDF when no LaTeX is saved.
   if (hasLatex) {
@@ -195,7 +391,7 @@ async function handleRepair({ jd_text, job_title, company, feedback, maximum_ats
 
 // ─── GENERATE ────────────────────────────────────────────────────────────────
 
-async function handleGenerate({ jd_text, job_title, company, maximum_ats_mode, confirmed_terms, url }) {
+async function handleGenerate({ jd_text, job_title, company, maximum_ats_mode, confirmed_terms, url, version }) {
   // 1. Read settings from storage
   const data = await new Promise(res => chrome.storage.local.get(
     ['resume_b64', 'resume_latex', 'api_url', 'api_token'], res
@@ -229,7 +425,7 @@ async function handleGenerate({ jd_text, job_title, company, maximum_ats_mode, c
   });
 
   // 3. Perform the network round-trip (no popup dependency).
-  const result = await runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms });
+  const result = await runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms, version });
 
   // 4. Overwrite the marker with the terminal state — done OR error — so the
   //    popup never shows a false/forever spinner. Done regardless of popup state.
@@ -243,7 +439,7 @@ async function handleGenerate({ jd_text, job_title, company, maximum_ats_mode, c
 }
 
 // Network/parse layer for GENERATE. Returns a result object (success or {error}).
-async function runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms }) {
+async function runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms, version }) {
   // Build multipart/form-data. LaTeX takes priority over the PDF.
   const formData = new FormData();
   formData.append('jd_text', jd_text);
@@ -251,6 +447,7 @@ async function runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, co
   formData.append('company', company || '');
   formData.append('maximum_ats_mode', maximum_ats_mode ? '1' : '0');
   if (confirmed_terms) formData.append('confirmed_terms', confirmed_terms);
+  formData.append('version', version || 'v1');
 
   if (hasLatex) {
     formData.append('resume_latex', resumeLatex || data.resume_latex);

extension/content.js

@@ -545,6 +545,193 @@ function looksLikeListingJunk(result) {
   return false;
 }
 
+function isEligibleField(el) {
+  if (!el || !el.tagName || !el.isConnected) return false;
+  if (el.closest('#ats-side-panel-root')) return false;
+  if (el.disabled || el.readOnly) return false;
+  const tag = el.tagName.toLowerCase();
+  const type = (el.type || '').toLowerCase();
+  if (tag === 'input' && /^(hidden|password|file|submit|button|reset|image|range|color)$/.test(type)) {
+    return false;
+  }
+  if (type === 'search') return false;
+  const style = window.getComputedStyle(el);
+  if (style.display === 'none' || style.visibility === 'hidden') return false;
+  const rect = el.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+
+function labelText(el) {
+  const parts = [];
+  if (el.id) {
+    const byFor = document.querySelector(`label[for="${CSS.escape(el.id)}"]`);
+    if (byFor) parts.push(byFor.innerText || byFor.textContent || '');
+  }
+  const wrap = el.closest('label');
+  if (wrap) parts.push(wrap.innerText || wrap.textContent || '');
+  if (el.labels) {
+    for (const lab of el.labels) parts.push(lab.innerText || lab.textContent || '');
+  }
+  parts.push(el.getAttribute('aria-label') || '');
+  parts.push(el.getAttribute('placeholder') || '');
+  parts.push(el.name || '');
+  return parts.join(' ').replace(/\s+/g, ' ').trim();
+}
+
+function helpText(el) {
+  const ids = (el.getAttribute('aria-describedby') || '').split(/\s+/).filter(Boolean);
+  const texts = [];
+  for (const id of ids) {
+    const node = document.getElementById(id);
+    if (node) texts.push(node.innerText || node.textContent || '');
+  }
+  return texts.join(' ').replace(/\s+/g, ' ').trim();
+}
+
+function ensureFieldId(el, fallback) {
+  if (!el.dataset.atsFieldId) {
+    el.dataset.atsFieldId = `atsf_${Date.now()}_${fallback}`;
+  }
+  return el.dataset.atsFieldId;
+}
+
+function bestFormRoot() {
+  const forms = Array.from(document.forms || []);
+  if (!forms.length) return document;
+  let best = forms[0];
+  let bestCount = -1;
+  for (const form of forms) {
+    const count = Array.from(form.querySelectorAll('input, textarea, select'))
+      .filter(isEligibleField).length;
+    if (count > bestCount) {
+      best = form;
+      bestCount = count;
+    }
+  }
+  return best || document;
+}
+
+function scanApplicationFields() {
+  const root = bestFormRoot();
+  const fields = [];
+  const radioGroups = new Map();
+  let idx = 0;
+
+  for (const el of root.querySelectorAll('input, textarea, select')) {
+    if (!isEligibleField(el)) continue;
+    const tag = el.tagName.toLowerCase();
+    const type = (el.type || '').toLowerCase();
+
+    if (type === 'radio') {
+      const groupName = el.name || ensureFieldId(el, idx++);
+      const groupKey = `radio:${groupName}`;
+      let group = radioGroups.get(groupKey);
+      if (!group) {
+        group = {
+          id: `ats_radio_${groupName}`,
+          tag: 'input',
+          type: 'radio',
+          name: groupName,
+          label: labelText(el),
+          placeholder: '',
+          help_text: helpText(el),
+          required: !!el.required,
+          options: [],
+        };
+        radioGroups.set(groupKey, group);
+      }
+      const optLabel = labelText(el) || el.value || 'Option';
+      group.options.push({ label: optLabel, value: el.value || optLabel });
+      continue;
+    }
+
+    const fieldId = ensureFieldId(el, idx++);
+    const meta = {
+      id: fieldId,
+      tag,
+      type: type || tag,
+      name: el.name || '',
+      label: labelText(el),
+      placeholder: el.getAttribute('placeholder') || '',
+      help_text: helpText(el),
+      required: !!el.required,
+      options: [],
+    };
+    if (tag === 'select') {
+      meta.options = Array.from(el.options || [])
+        .map((opt) => ({
+          label: (opt.textContent || '').trim(),
+          value: (opt.value || '').trim(),
+        }))
+        .filter((opt) => opt.label || opt.value);
+    }
+    fields.push(meta);
+  }
+
+  fields.push(...radioGroups.values());
+  return fields;
+}
+
+function setNativeValue(el, value) {
+  const proto = Object.getPrototypeOf(el);
+  const desc = Object.getOwnPropertyDescriptor(proto, 'value');
+  if (desc && desc.set) desc.set.call(el, value);
+  else el.value = value;
+  el.dispatchEvent(new Event('input', { bubbles: true }));
+  el.dispatchEvent(new Event('change', { bubbles: true }));
+}
+
+function norm(s) {
+  return String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+
+function applyAnswer(answer) {
+  if (!answer || !answer.id || !String(answer.value || '').trim()) return false;
+  const value = String(answer.value).trim();
+  const node = document.querySelector(`[data-ats-field-id="${CSS.escape(answer.id)}"]`);
+  if (node) {
+    if ((node.value || '').trim()) return false;
+    if (node.tagName.toLowerCase() === 'select') {
+      const want = norm(value);
+      const option = Array.from(node.options || []).find((opt) => {
+        const label = norm(opt.textContent || '');
+        const val = norm(opt.value || '');
+        return want === label || want === val || label.includes(want) || val.includes(want);
+      });
+      if (!option) return false;
+      setNativeValue(node, option.value);
+      return true;
+    }
+    setNativeValue(node, value);
+    return true;
+  }
+
+  if (String(answer.id).startsWith('ats_radio_')) {
+    const groupName = String(answer.id).replace(/^ats_radio_/, '');
+    const radios = Array.from(document.querySelectorAll(`input[type="radio"][name="${CSS.escape(groupName)}"]`));
+    const want = norm(value);
+    const target = radios.find((radio) => {
+      const text = norm(labelText(radio) || radio.value);
+      return text === want || text.includes(want) || want.includes(text);
+    });
+    if (!target) return false;
+    target.checked = true;
+    target.dispatchEvent(new Event('input', { bubbles: true }));
+    target.dispatchEvent(new Event('change', { bubbles: true }));
+    return true;
+  }
+
+  return false;
+}
+
+function applyAutofillAnswers(answers) {
+  let applied = 0;
+  for (const answer of (answers || [])) {
+    if (applyAnswer(answer)) applied += 1;
+  }
+  return applied;
+}
+
 // ─── Message listener ─────────────────────────────────────────────────────────
 
 chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
@@ -556,6 +743,26 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
     return; // synchronous response
   }
 
+  if (msg.type === 'SCAN_FORM') {
+    try {
+      const fields = scanApplicationFields();
+      sendResponse({ fields, field_count: fields.length });
+    } catch (err) {
+      sendResponse({ fields: [], field_count: 0, error: err.message });
+    }
+    return;
+  }
+
+  if (msg.type === 'APPLY_FORM_FILL') {
+    try {
+      const applied = applyAutofillAnswers(msg.answers || []);
+      sendResponse({ applied });
+    } catch (err) {
+      sendResponse({ applied: 0, error: err.message });
+    }
+    return;
+  }
+
   if (msg.type === 'EXTRACT_JD') {
     // Extract, and if the page clearly hadn't loaded the posting yet (short text
     // and no JD signal), retry ONCE after a short delay — covers SPA navigations

extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "ATS Resume Generator",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Tailors your resume (PDF or LaTeX) to any job posting using the ATS pipeline.",
   "permissions": [
     "storage",

extension/options/options.html

@@ -198,6 +198,19 @@
       <input id="resume_file" type="file" accept=".pdf">
       <p id="resume_status">No resume uploaded.</p>
       <p class="note">Upload once. The PDF is stored locally in the extension — it is never sent to any server until you click Run on a job page.</p>
+
+      <label for="gen_version_default" style="margin-top:16px;">Default Generation Mode</label>
+      <select id="gen_version_default" style="width:100%;padding:10px 14px;border:1px solid #d1d5db;border-radius:8px;font-size:14px;margin-bottom:16px;">
+        <option value="v1">V1 — Structured (keyword placement)</option>
+        <option value="v2">V2 — Natural AI (sentence integration)</option>
+      </select>
+    </div>
+
+    <div class="section">
+      <div class="section-title">Application Autofill Profile</div>
+      <label for="autofill_profile_json">Reusable profile JSON</label>
+      <textarea id="autofill_profile_json" placeholder='{"full_name":"", "email":"", "phone":"", "location":"", "linkedin_url":"", "portfolio_url":"", "current_title":"", "current_company":"", "years_experience":"", "notice_period":"", "work_authorization":"", "requires_sponsorship":"", "visa_status":"", "expected_salary":"", "current_salary":"", "additional_notes":""}'></textarea>
+      <p class="note">Used by the extension to fill common application fields instantly. Harder questions are answered from this profile plus your resume LaTeX and the current job description.</p>
     </div>
 
     <button id="save_btn">Save Settings</button>

extension/options/options.js

@@ -14,7 +14,7 @@
 
 // ─── Load stored settings on page open ───────────────────────────────────────
 chrome.storage.local.get(
-  ['api_url', 'api_token', 'resume_filename', 'resume_sha256', 'resume_latex'],
+  ['api_url', 'api_token', 'resume_filename', 'resume_sha256', 'resume_latex', 'gen_version_default', 'autofill_profile_json'],
   (data) => {
     if (data.api_url) {
       document.getElementById('api_url').value = data.api_url;
@@ -38,6 +38,12 @@ chrome.storage.local.get(
       document.getElementById('latex_status').textContent =
         `Default resume loaded (${self.DEFAULT_RESUME_LATEX.length.toLocaleString()} chars). Edit to use your own.`;
     }
+    if (data.gen_version_default) {
+      document.getElementById('gen_version_default').value = data.gen_version_default;
+    }
+    if (data.autofill_profile_json) {
+      document.getElementById('autofill_profile_json').value = data.autofill_profile_json;
+    }
   }
 );
 
@@ -77,6 +83,20 @@ document.getElementById('save_btn').addEventListener('click', async () => {
   // ─── LaTeX source (priority input) ─────────────────────────────────────────
   const latexSrc = document.getElementById('resume_latex').value.trim();
   toStore.resume_latex = latexSrc;  // store '' to allow clearing it
+  toStore.gen_version_default = document.getElementById('gen_version_default').value;
+  const autofillProfile = document.getElementById('autofill_profile_json').value.trim();
+  if (autofillProfile) {
+    try {
+      JSON.parse(autofillProfile);
+      toStore.autofill_profile_json = autofillProfile;
+    } catch (_) {
+      statusEl.textContent = 'Error: Autofill profile must be valid JSON.';
+      statusEl.style.color = '#dc2626';
+      return;
+    }
+  } else {
+    toStore.autofill_profile_json = '';
+  }
   document.getElementById('latex_status').textContent = latexSrc
     ? `LaTeX saved (${latexSrc.length.toLocaleString()} chars). Takes priority over the PDF.`
     : 'No LaTeX saved.';

extension/popup/popup.html

@@ -11,6 +11,9 @@
     #run-btn { width: 100%; padding: 10px; background: #2563eb; color: white; border: none;
                 border-radius: 6px; font-size: 14px; cursor: pointer; }
     #run-btn:disabled { background: #93c5fd; cursor: not-allowed; }
+    #autofill-btn { width: 100%; padding: 9px; background: #0f766e; color: white; border: none;
+                    border-radius: 6px; font-size: 13px; cursor: pointer; margin-top: 8px; }
+    #autofill-btn:disabled { background: #99f6e4; cursor: not-allowed; }
     #status { margin-top: 10px; font-size: 12px; min-height: 20px; }
     #scores { display: none; margin-top: 8px; font-size: 12px; }
     #scores table { width: 100%; border-collapse: collapse; }
@@ -60,7 +63,18 @@
     user-confirmed (interview-supportable) skills for this resume. Never fakes
     degrees, certs, employers, titles, or seniority.</span>
   </label>
+  <div style="display:flex;align-items:center;gap:8px;margin-bottom:8px;">
+    <label style="font-size:11px;color:#555;margin:0;font-weight:normal;">Mode:</label>
+    <select id="version-toggle" style="padding:4px 8px;border:1px solid #d1d5db;border-radius:4px;font-size:11px;">
+      <option value="v1">V1 Structured</option>
+      <option value="v2">V2 Natural AI</option>
+    </select>
+  </div>
   <button id="run-btn">Run</button>
+  <button id="autofill-btn">Autofill Application Form</button>
+  <div style="font-size:11px;color:#64748b;margin-top:6px;">
+    Fills common details from your saved profile, then uses your resume LaTeX + JD for harder questions.
+  </div>
   <div id="status"></div>
   <div id="scores">
     <table>

extension/popup/popup.js

@@ -34,6 +34,7 @@ let restoredMeta = null;    // {job_title, company} from a restored result
 // ─── DOM refs ─────────────────────────────────────────────────────────────────
 
 const runBtn       = document.getElementById('run-btn');
+const autofillBtn  = document.getElementById('autofill-btn');
 const statusEl     = document.getElementById('status');
 const jobInfoEl    = document.getElementById('job-info');
 const scoresEl     = document.getElementById('scores');
@@ -98,6 +99,27 @@ function sendBgMessage(msg) {
   });
 }
 
+async function activeTab() {
+  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  return tab || null;
+}
+
+function sendTabMessage(tabId, msg) {
+  return new Promise((resolve) => {
+    try {
+      chrome.tabs.sendMessage(tabId, msg, (response) => {
+        if (chrome.runtime.lastError) {
+          resolve({ error: chrome.runtime.lastError.message || 'Tab did not respond.' });
+          return;
+        }
+        resolve(response || {});
+      });
+    } catch (err) {
+      resolve({ error: err.message });
+    }
+  });
+}
+
 // ─── JD extraction (runs in the background; Run is usable immediately) ─────────
 
 /**
@@ -382,6 +404,11 @@ restoreResultForTab();
 renderHistory();
 requestExtraction().then(handleExtraction);
 
+chrome.storage.local.get(['gen_version_default'], (d) => {
+  const sel = document.getElementById('version-toggle');
+  if (sel && d.gen_version_default) sel.value = d.gen_version_default;
+});
+
 // ─── Options link ─────────────────────────────────────────────────────────────
 
 document.getElementById('open-options').addEventListener('click', (e) => {
@@ -389,6 +416,62 @@ document.getElementById('open-options').addEventListener('click', (e) => {
   chrome.runtime.openOptionsPage();
 });
 
+autofillBtn.addEventListener('click', async () => {
+  const tab = await activeTab();
+  if (!tab?.id || isRestrictedTabUrl(tab.url)) {
+    statusEl.textContent = 'Open an application page in a normal browser tab first.';
+    return;
+  }
+
+  autofillBtn.disabled = true;
+  statusEl.innerHTML = '<span class="spinner"></span> Scanning form...';
+
+  const scan = await sendTabMessage(tab.id, { type: 'SCAN_FORM' });
+  if (scan.error) {
+    statusEl.textContent = `Could not read the form: ${scan.error}`;
+    autofillBtn.disabled = false;
+    return;
+  }
+  const fields = Array.isArray(scan.fields) ? scan.fields : [];
+  if (!fields.length) {
+    statusEl.textContent = 'No fillable form fields found on this page.';
+    autofillBtn.disabled = false;
+    return;
+  }
+
+  if (!extractedData) {
+    const resp = await requestExtraction();
+    if (resp) handleExtraction(resp);
+  }
+
+  statusEl.innerHTML = '<span class="spinner"></span> Generating answers...';
+  const result = await sendBgMessage({
+    type: 'AUTOFILL_FORM',
+    fields,
+    jd_text: extractedData?.jd_text || document.getElementById('manual-jd-text').value.trim(),
+    job_title: extractedData?.job_title || '',
+    company: extractedData?.company || '',
+  });
+
+  if (!result || result.error) {
+    statusEl.textContent = `Autofill failed: ${result?.detail || result?.error || 'Unknown error'}`;
+    autofillBtn.disabled = false;
+    return;
+  }
+
+  statusEl.innerHTML = '<span class="spinner"></span> Filling page...';
+  const apply = await sendTabMessage(tab.id, {
+    type: 'APPLY_FORM_FILL',
+    answers: result.answers || [],
+  });
+  autofillBtn.disabled = false;
+
+  const applied = apply?.applied || 0;
+  const warning = result.warning ? ` ${result.warning}` : '';
+  statusEl.textContent =
+    `Filled ${applied}/${result.field_count || fields.length} fields. Review everything before submitting.${warning}`;
+});
+
 // ─── Step 2: Run button ───────────────────────────────────────────────────────
 
 runBtn.addEventListener('click', async () => {
@@ -426,6 +509,7 @@ runBtn.addEventListener('click', async () => {
     company:   extractedData?.company   || '',
     maximum_ats_mode: isMaxAtsOn(),
     url: currentUrlKey,
+    version: document.getElementById('version-toggle').value,
   });
   handleResult(result);
 });
@@ -528,7 +612,7 @@ function applyResult(result) {
   const dlPdf  = document.getElementById('dl-pdf');
   const dlTex  = document.getElementById('dl-tex');
 
-  if (result.source === 'latex') {
+  if (result.source === 'latex' || result.source === 'latex_v2') {
     // LaTeX flow: clean PDF + .tex, no DOCX.
     downloadsEl.classList.add('visible');
     dlDocx.style.display = 'none';

relay/cloudflare-worker.js

@@ -23,7 +23,7 @@ const HELP =
   "your tailored, ATS-optimized resume PDF.\n\n" +
   "• Company/ATS links (Greenhouse, Lever, Ashby, Naukri) usually work directly.\n" +
   "• If I can't read a LinkedIn/Indeed link, copy the description text and send that.\n\n" +
-  "Commands: /start, /help";
+  "Commands: /start, /help, /v1, /v2, /mode";
 
 export default {
   async fetch(request, env, ctx) {
@@ -90,6 +90,28 @@ async function handle(update, env) {
     return;
   }
 
+  // ── Per-user version mode (Workers KV optional) ──────────────────────────
+  const verKey = `ver:${userId}`;
+  let userVer = 'v1';
+  if (env.USER_STATE) {
+    try { userVer = (await env.USER_STATE.get(verKey)) || 'v1'; } catch (_) {}
+  }
+
+  if (/^\/v1\b/i.test(text)) {
+    if (env.USER_STATE) { try { await env.USER_STATE.put(verKey, 'v1'); } catch (_) {} }
+    await tg(env, "sendMessage", { chat_id: chatId, text: "✅ Mode set to V1 (Structured keyword placement)." });
+    return;
+  }
+  if (/^\/v2\b/i.test(text)) {
+    if (env.USER_STATE) { try { await env.USER_STATE.put(verKey, 'v2'); } catch (_) {} }
+    await tg(env, "sendMessage", { chat_id: chatId, text: "✅ Mode set to V2 (Natural AI sentence integration)." });
+    return;
+  }
+  if (/^\/mode\b/i.test(text)) {
+    await tg(env, "sendMessage", { chat_id: chatId, text: `Current mode: ${userVer.toUpperCase()}` });
+    return;
+  }
+
   if (!text || /^\/(start|help)\b/i.test(text)) {
     await tg(env, "sendMessage", { chat_id: chatId, text: HELP, parse_mode: "Markdown" });
     return;
@@ -108,6 +130,7 @@ async function handle(update, env) {
     return;
   }
   form.append("maximum_ats_mode", "1");
+  form.append("version", userVer);
 
   let res;
   try {

src/resume_v2_natural.py

@@ -0,0 +1,563 @@
+"""
+src/resume_v2_natural.py — V2 Natural Sentence Integration engine.
+
+Same keyword extraction + waterfall allocation as V1, but instead of
+comma-separated keyword lists, an LLM (Kimi by default) generates natural
+sentences that weave the keywords into genuine-sounding experience bullets.
+
+Placement locations match V1 exactly:
+  Summary 15-20 | BYJU's PSM 25-30 | BYJU's PS 25-30 | ML Edutech 8-12
+  Skills Other 15-20 | Projects / NxtWave
+
+Falls back to V1-style comma placement if the LLM call fails.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import config
+from src.llm_client import LLMClient
+from src.latex_resume import (
+    compile_latex_to_pdf,
+    decide_includable_terms,
+    latex_escape,
+    latex_to_text,
+    _remove_injected_block,
+    _is_hardcoded_resume,
+    _specialty_hit,
+)
+from src.external_ats import external_coverage
+from src.candidate_fit import _REGULATED_CRED
+
+log = logging.getLogger("resume_v2")
+
+# ── Inject markers (same as V1 so _remove_injected_block strips both) ────────
+_INJECT_ITEM = "% ats-item"
+_INJECT_SKILLS_OTHER = "% ats-skills-other"
+_INJECT_MARKER = "% ats-injected-start"
+_INJECT_END = "% ats-injected-end"
+
+_SUMMARY_RE = re.compile(
+    r"(?:\\section\s*\{[^}]*(?:summary|profile|objective)[^}]*\}|"
+    r"\\(?:resumeSubheading|textbf|large)\s*\{[^}]*(?:summary|profile|objective)[^}]*\})",
+    re.I,
+)
+
+# ── Model config helpers ─────────────────────────────────────────────────────
+
+def _cfg_by_name(name: str) -> dict | None:
+    return next((m for m in config.ASSESSMENT_MODELS if m.get("name") == name), None)
+
+
+def _v2_model_cfg() -> dict | None:
+    name = os.getenv("V2_JUDGE_MODEL", "Kimi-K2.6")
+    return _cfg_by_name(name.strip())
+
+
+def _fan_out_cfgs() -> list[dict]:
+    names = os.getenv("V2_FAN_OUT_MODELS", "Kimi-K2.6,Qwen3.5-397b,GPT-OSS-120b").split(",")
+    return [c for name in names if (c := _cfg_by_name(name.strip())) and c.get("api_key")]
+
+
+# ── LLM prompt for sentence generation ───────────────────────────────────────
+
+_SYSTEM_PROMPT = """\
+You are a resume bullet-point writer for a Product Manager candidate.
+Given keywords allocated to resume sections, write natural bullets that weave ALL keywords.
+
+CANDIDATE PROFILE:
+- Saiteja Tirunagari, Product Manager, 5+ years
+- BYJU'S (Think & Learn Pvt Ltd):
+  * Asst. Product Success Manager: customer success, retention, onboarding analytics, \
+stakeholder management, data-driven product decisions
+  * Product Specialist: product specs, feature launches, A/B testing, user research, \
+cross-functional collaboration with engineering and design
+- ML Edutech (Founder): AI/ML education product, generative AI, product strategy, MVP
+- NxtWave (Internal Product Manager): ed-tech platform CCBP 4.0, learner engagement, \
+curriculum product management
+
+RULES:
+1. Every keyword MUST appear verbatim in its section's output
+2. Write as genuine accomplishments grounded in the profile above
+3. Use active voice, quantify where natural
+4. Each bullet: 80-200 characters
+5. For summary: write a 1-2 sentence paragraph (no bullet marker)
+6. For skills_other: just list keywords comma-separated
+7. Return ONLY valid JSON — no markdown fences, no explanation text
+8. Do NOT fabricate degrees, certifications, employers, or job titles
+9. Do NOT add specialized engineering terms unless they appear in the keywords"""
+
+
+def _build_user_prompt(allocations: dict, job_title: str, company: str) -> str:
+    parts = [f"TARGET ROLE: {job_title or 'Product Manager'} at {company or 'Company'}\n"]
+    parts.append("KEYWORDS PER SECTION (write enough bullets to cover ALL keywords):")
+
+    for section, terms in allocations.items():
+        if section == "projects":
+            for proj, proj_terms in terms.items():
+                if proj_terms:
+                    n = len(proj_terms)
+                    parts.append(f'  projects_{proj} ({n} kw, 1 bullet): {json.dumps(proj_terms)}')
+        elif terms:
+            n = len(terms)
+            if section == "summary":
+                parts.append(f'  summary ({n} kw, 1-2 sentence paragraph): {json.dumps(terms)}')
+            elif section == "skills_other":
+                parts.append(f'  skills_other ({n} kw, comma list only): {json.dumps(terms)}')
+            elif n > 15:
+                parts.append(f'  {section} ({n} kw, 2-3 bullets): {json.dumps(terms)}')
+            else:
+                parts.append(f'  {section} ({n} kw, 1-2 bullets): {json.dumps(terms)}')
+
+    parts.append("""
+Return JSON:
+{
+  "summary": "paragraph text...",
+  "psm": ["bullet1...", "bullet2..."],
+  "ps": ["bullet1...", "bullet2..."],
+  "ml_edutech": ["bullet1..."],
+  "skills_other": "kw1, kw2, ...",
+  "nxtwave": ["bullet1..."],
+  "projects_FDP": ["bullet1..."],
+  "projects_Launchpad": ["bullet1..."],
+  ...
+}""")
+    return "\n".join(parts)
+
+
+# ── Keyword allocation (same waterfall as V1) ────────────────────────────────
+
+def _allocate_keywords(jd_text: str, base_text: str, latex_src: str) -> tuple[dict, dict]:
+    """Allocate JD keywords to sections using the exact V1 waterfall.
+    Returns (allocations_dict, decision_dict)."""
+    decision = decide_includable_terms(jd_text, base_text, maximum_ats_mode=True)
+    includable = decision["includable"]
+
+    src_low = (latex_src or "").lower()
+    seen: set[str] = set()
+    pool: list[str] = []
+    for t in includable:
+        tl = (t or "").strip().lower()
+        if not tl or tl in seen:
+            continue
+        seen.add(tl)
+        if tl in src_low:
+            continue
+        pool.append(t.strip())
+
+    def take(n: int) -> list[str]:
+        nonlocal pool
+        g = pool[:n]
+        pool = pool[n:]
+        return g
+
+    allocations: dict = {}
+    allocations["summary"] = take(20)
+    allocations["psm"] = take(30)
+    allocations["ps"] = take(30)
+    allocations["ml_edutech"] = take(12)
+    skills = take(20)
+
+    proj_order = ["FDP", "Launchpad", "OCR--OMR", "Offline NAT",
+                  "AI Chatbot", "NIAT Application Portal"]
+    allocations["projects"] = {k: take(10) for k in proj_order}
+    allocations["nxtwave"] = take(20)
+    allocations["skills_other"] = skills + pool  # overflow
+    return allocations, decision
+
+
+# ── LLM response parsing ─────────────────────────────────────────────────────
+
+def _parse_llm_response(raw: str) -> dict:
+    text = (raw or "").strip()
+    m = re.search(r"```(?:json)?\s*([\s\S]+?)```", text)
+    if m:
+        text = m.group(1).strip()
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    idx = text.find("{")
+    if idx >= 0:
+        depth = 0
+        for i, ch in enumerate(text[idx:], idx):
+            if ch == "{":
+                depth += 1
+            elif ch == "}":
+                depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[idx : i + 1])
+                except Exception:
+                    break
+    return {}
+
+
+def _ensure_list(val) -> list[str]:
+    """Normalize a sentence value to a list of strings."""
+    if isinstance(val, str):
+        return [val] if val.strip() else []
+    if isinstance(val, list):
+        return [s for s in val if isinstance(s, str) and s.strip()]
+    return []
+
+
+# ── Sentence placement (same anchors as V1) ──────────────────────────────────
+
+def _place_sentences_structured(
+    latex_src: str, sentences: dict, allocations: dict,
+) -> tuple[str, list[str]]:
+    """Inject V2 natural sentences into the same anchors as V1's
+    place_keywords_structured. Returns (new_source, placed_terms)."""
+    src = _remove_injected_block(latex_src or "")
+
+    exp_start = src.find("\\section{EXPERIENCE}")
+    proj_start = src.find("\\section{SELECTED")
+    if proj_start == -1:
+        proj_start = src.find("SELECTED 0")
+    skills_start = src.find("\\section{SKILLS}")
+
+    insertions: list[tuple[int, str]] = []
+    placed_terms: list[str] = []
+
+    def esc_join(ts: list[str]) -> str:
+        return ", ".join(latex_escape(t) for t in ts)
+
+    def add_items(anchor: str, bullets: list[str], fallback_terms: list[str],
+                  search_start: int) -> None:
+        if search_start < 0:
+            return
+        a = src.find(anchor, search_start)
+        if a == -1:
+            return
+        e = src.find("\\resumeItemListEnd", a)
+        if e == -1:
+            return
+        p = src.rfind("\n", 0, e)
+        if p == -1:
+            return
+        if bullets:
+            block = ""
+            for b in bullets:
+                block += "\n      \\resumeItem{" + latex_escape(b) + "} " + _INJECT_ITEM
+            insertions.append((p, block))
+            placed_terms.extend(fallback_terms)
+        elif fallback_terms:
+            block = "\n      \\resumeItem{" + esc_join(fallback_terms) + "} " + _INJECT_ITEM
+            insertions.append((p, block))
+            placed_terms.extend(fallback_terms)
+
+    # Experience slots
+    add_items("Asst. Product Success Manager",
+              _ensure_list(sentences.get("psm")),
+              allocations.get("psm", []), exp_start)
+    add_items("Product Specialist",
+              _ensure_list(sentences.get("ps")),
+              allocations.get("ps", []), exp_start)
+    add_items("ML Edutech",
+              _ensure_list(sentences.get("ml_edutech")),
+              allocations.get("ml_edutech", []), exp_start)
+    add_items("Internal Product Manager",
+              _ensure_list(sentences.get("nxtwave")),
+              allocations.get("nxtwave", []), exp_start)
+
+    # Project slots
+    proj_order = ["FDP", "Launchpad", "OCR--OMR", "Offline NAT",
+                  "AI Chatbot", "NIAT Application Portal"]
+    for k in proj_order:
+        proj_key = f"projects_{k}"
+        proj_terms = (allocations.get("projects") or {}).get(k, [])
+        add_items(k, _ensure_list(sentences.get(proj_key)), proj_terms, proj_start)
+
+    # Summary slot
+    summary_text = (sentences.get("summary") or "").strip() if isinstance(
+        sentences.get("summary"), str) else ""
+    summary_terms = allocations.get("summary", [])
+    if summary_text or summary_terms:
+        sm = _SUMMARY_RE.search(src)
+        if sm:
+            nxt = src.find("\\section", sm.end())
+            pos = nxt if nxt != -1 else sm.end()
+            content = latex_escape(summary_text) if summary_text else (
+                "Additional areas: " + esc_join(summary_terms) + ".")
+            block = (
+                "\n" + _INJECT_MARKER + "\n"
+                "\\par\\noindent " + content + "\n"
+                + _INJECT_END + "\n"
+            )
+            insertions.append((pos, block))
+            placed_terms.extend(summary_terms)
+
+    # Skills "Other:" row
+    skills_terms = allocations.get("skills_other", [])
+    skills_text = sentences.get("skills_other", "")
+    if skills_terms and skills_start != -1:
+        se = src.find("\\end{itemize}", skills_start)
+        if se != -1:
+            close = src.rfind("}}", skills_start, se)
+            if close != -1:
+                content = (latex_escape(skills_text) if isinstance(skills_text, str)
+                           and skills_text.strip() else esc_join(skills_terms))
+                row = (" \\\\\n     \\textbf{Other}{: " + content
+                       + "} " + _INJECT_SKILLS_OTHER + "\n    ")
+                insertions.append((close, row))
+                placed_terms.extend(skills_terms)
+
+    for pos, text in sorted(insertions, key=lambda x: x[0], reverse=True):
+        src = src[:pos] + text + src[pos:]
+
+    return src, placed_terms
+
+
+# ── Honesty + validation ─────────────────────────────────────────────────────
+
+def _v2_honesty_check(winner_text: str, original_text: str) -> tuple[bool, list[str]]:
+    wt = (winner_text or "").lower()
+    ot = (original_text or "").lower()
+    violations: list[str] = []
+    for m in _REGULATED_CRED.finditer(wt):
+        term = m.group(0)
+        if term not in ot:
+            violations.append(f"regulated_cred:{term}")
+    return (len(violations) == 0, violations)
+
+
+def _validate_candidate(latex: str, original_latex: str) -> tuple[bool, str]:
+    if not latex or len(latex) < 500:
+        return (False, "too_short")
+    if not any(k in latex for k in (r"\documentclass", r"\begin{document}", r"\resumeSubheading")):
+        return (False, "not_latex")
+    markers = ["Saiteja Tirunagari", "NxtWave", "Think \\& Learn", "ML Edutech"]
+    for marker in markers:
+        if marker not in latex and marker.replace("\\\\", "\\") not in latex:
+            return (False, f"missing_marker:{marker}")
+    return (True, "ok")
+
+
+# ── Multi-model fan-out (optional, for extension/bot single-resume) ──────────
+
+def _fan_out(latex_src: str, jd_text: str, job_title: str, company: str,
+             allocations: dict, model_cfgs: list[dict], llm: LLMClient) -> list[dict]:
+    """Call multiple models in parallel, each generating sentences."""
+    user_prompt = _build_user_prompt(allocations, job_title, company)
+
+    def call_one(cfg: dict) -> dict:
+        try:
+            raw = llm._call_with_cfg(cfg, _SYSTEM_PROMPT, user_prompt, max_tokens=2000)
+            parsed = _parse_llm_response(raw)
+            return {"name": cfg["name"], "sentences": parsed, "error": None}
+        except Exception as exc:
+            return {"name": cfg["name"], "sentences": {}, "error": str(exc)}
+
+    results = []
+    with ThreadPoolExecutor(max_workers=len(model_cfgs)) as pool:
+        futures = {pool.submit(call_one, cfg): cfg for cfg in model_cfgs}
+        for fut in as_completed(futures):
+            results.append(fut.result())
+    return results
+
+
+def _judge_candidates(candidates: list[dict], jd_text: str,
+                      judge_cfg: dict, llm: LLMClient) -> int:
+    """Ask the judge model to pick the best sentence set. Returns winner index."""
+    if len(candidates) <= 1:
+        return 0
+    snippets = []
+    for i, c in enumerate(candidates, 1):
+        s = c.get("sentences", {})
+        preview = json.dumps(s, indent=None)[:600]
+        snippets.append(f"CANDIDATE {i} ({c['name']}):\n{preview}")
+
+    prompt = (
+        "You are a resume quality judge. Below are sentence sets generated for a "
+        "Product Manager resume. Pick the one that reads most naturally and weaves "
+        "keywords best. Return ONLY the winning number (e.g. '1' or '2').\n\n"
+        + "\n---\n".join(snippets)
+    )
+    try:
+        raw = llm._call_with_cfg(judge_cfg, "Pick the best resume sentences.", prompt, max_tokens=20)
+        digits = re.sub(r"\D", "", raw.strip())
+        n = int(digits) if digits else 1
+        if 1 <= n <= len(candidates):
+            return n - 1
+    except Exception:
+        pass
+    return 0
+
+
+# ── Main entry point ─────────────────────────────────────────────────────────
+
+def generate_v2(
+    latex_src: str,
+    jd_text: str,
+    job_title: str = "",
+    company: str = "",
+    models: list[dict] | None = None,
+    judge: dict | None = None,
+    out_dir: str | None = None,
+    compile_pdf: bool = True,
+) -> dict:
+    """V2: extract keywords, allocate (same waterfall as V1), generate natural
+    sentences via LLM, place in resume, compile.
+
+    Falls back to V1-style comma placement if the LLM call fails."""
+
+    base_text = latex_to_text(latex_src or "")
+
+    # 1. Allocate keywords (exact V1 waterfall)
+    allocations, decision = _allocate_keywords(jd_text, base_text, latex_src)
+
+    has_keywords = any(
+        (isinstance(v, list) and v) or (isinstance(v, dict) and any(vv for vv in v.values()))
+        for v in allocations.values()
+    )
+    if not has_keywords:
+        return _build_report(latex_src, jd_text, decision,
+                             compiled=False, engine=None, pdf_path=None,
+                             v2_models_used=[], v2_winner="no_keywords",
+                             judge_note="no_keywords_to_place")
+
+    # 2. Generate sentences via LLM
+    model_cfgs = models or []
+    primary_cfg = judge if judge is not None else _v2_model_cfg()
+    sentences: dict = {}
+    v2_models_used: list[str] = []
+    v2_winner = "v1_fallback"
+    judge_note = ""
+
+    # Single-model fast path (default for bulk speed)
+    if primary_cfg and primary_cfg.get("api_key"):
+        try:
+            llm = LLMClient()
+            user_prompt = _build_user_prompt(allocations, job_title, company)
+            raw = llm._call_with_cfg(primary_cfg, _SYSTEM_PROMPT, user_prompt,
+                                     max_tokens=2000)
+            sentences = _parse_llm_response(raw)
+            v2_models_used = [primary_cfg["name"]]
+            v2_winner = primary_cfg["name"]
+            judge_note = "single_model"
+            log.info("V2 sentences from %s: %d sections", primary_cfg["name"],
+                     len(sentences))
+        except Exception as exc:
+            log.warning("V2 LLM failed (%s): %s", primary_cfg.get("name", "?"), exc)
+            judge_note = f"primary_failed:{str(exc)[:80]}"
+
+    # Multi-model fan-out path (when explicitly configured with models param)
+    if not sentences and model_cfgs:
+        try:
+            llm = LLMClient()
+            results = _fan_out(latex_src, jd_text, job_title, company,
+                               allocations, model_cfgs, llm)
+            valid = [r for r in results if r["sentences"] and not r["error"]]
+            if valid:
+                if len(valid) > 1 and primary_cfg and primary_cfg.get("api_key"):
+                    idx = _judge_candidates(valid, jd_text, primary_cfg, llm)
+                else:
+                    idx = 0
+                sentences = valid[idx]["sentences"]
+                v2_models_used = [r["name"] for r in valid]
+                v2_winner = valid[idx]["name"]
+                judge_note = "fan_out"
+        except Exception as exc:
+            log.warning("V2 fan-out failed: %s", exc)
+            judge_note = f"fan_out_failed:{str(exc)[:80]}"
+
+    # Fallback: try each fan-out model individually
+    if not sentences:
+        for cfg in _fan_out_cfgs():
+            if cfg.get("api_key") and cfg.get("name") != (primary_cfg or {}).get("name"):
+                try:
+                    llm = LLMClient()
+                    raw = llm._call_with_cfg(
+                        cfg, _SYSTEM_PROMPT,
+                        _build_user_prompt(allocations, job_title, company),
+                        max_tokens=2000)
+                    sentences = _parse_llm_response(raw)
+                    if sentences:
+                        v2_models_used = [cfg["name"]]
+                        v2_winner = cfg["name"]
+                        judge_note = "fallback_model"
+                        break
+                except Exception:
+                    continue
+
+    # 3. Place sentences (or V1 comma fallback)
+    if _is_hardcoded_resume(latex_src):
+        new_src, placed = _place_sentences_structured(
+            latex_src, sentences, allocations)
+    else:
+        from src.latex_resume import inject_keywords
+        all_terms: list[str] = []
+        for v in allocations.values():
+            if isinstance(v, list):
+                all_terms.extend(v)
+            elif isinstance(v, dict):
+                for pts in v.values():
+                    all_terms.extend(pts)
+        new_src, placed = inject_keywords(latex_src, all_terms)
+
+    if not sentences:
+        v2_winner = "v1_fallback"
+        judge_note = judge_note or "all_models_failed"
+
+    # 4. Honesty check
+    new_text = latex_to_text(new_src)
+    ok, violations = _v2_honesty_check(new_text, base_text)
+    if not ok:
+        log.warning("V2 honesty violation: %s — rebuilding with V1 placement", violations)
+        from src.latex_resume import place_keywords_structured
+        all_terms = []
+        for v in allocations.values():
+            if isinstance(v, list):
+                all_terms.extend(v)
+            elif isinstance(v, dict):
+                for pts in v.values():
+                    all_terms.extend(pts)
+        new_src, placed = place_keywords_structured(latex_src, all_terms)
+        judge_note = f"honesty_fallback:{violations[:3]}"
+        v2_winner = "v1_honesty_fallback"
+
+    # 5. Compile
+    comp: dict = {"compiled": False, "engine": None, "pdf_path": None}
+    if compile_pdf and out_dir:
+        try:
+            comp = compile_latex_to_pdf(new_src, out_dir, jobname="resume_v2",
+                                        timeout=420)
+        except Exception as exc:
+            log.warning("V2 compile failed: %s", exc)
+
+    return _build_report(new_src, jd_text, decision,
+                         compiled=comp.get("compiled", False),
+                         engine=comp.get("engine"),
+                         pdf_path=comp.get("pdf_path"),
+                         v2_models_used=v2_models_used,
+                         v2_winner=v2_winner,
+                         judge_note=judge_note)
+
+
+def _build_report(tex: str, jd_text: str, decision: dict,
+                  compiled: bool, engine, pdf_path,
+                  v2_models_used: list[str], v2_winner: str,
+                  judge_note: str) -> dict:
+    text = latex_to_text(tex)
+    expected = decision.get("expected_terms", [])
+    cov = external_coverage(expected, text)
+    return {
+        "tex": tex,
+        "pdf_path": pdf_path,
+        "compiled": compiled,
+        "engine": engine,
+        "pct": cov.get("pct", 0),
+        "expected": cov.get("expected", 0),
+        "found": cov.get("found", 0),
+        "missing": cov.get("missing", []),
+        "keywords": decision.get("keywords", expected),
+        "source": "latex_v2",
+        "v2_models_used": v2_models_used,
+        "v2_winner": v2_winner,
+        "judge_note": judge_note,
+    }

src/telegram_bot.py

@@ -41,6 +41,7 @@ except Exception:  # noqa: BLE001
 _API = "https://api.telegram.org/bot{token}/{method}"
 _URL_RE = re.compile(r"https?://\S+")
 _SEND_RETRIES = 3
+_user_version: dict[int, str] = {}
 
 
 def _proxies():
@@ -159,7 +160,7 @@ _HELP = (
     "• Company/ATS links (Greenhouse, Lever, Ashby, Naukri) usually work directly.\n"
     "• If I can't read a LinkedIn/Indeed link, just copy the description text and "
     "send that instead.\n\n"
-    "Commands: /start, /help"
+    "Commands: /start, /help, /v1, /v2, /mode"
 )
 
 
@@ -183,6 +184,20 @@ def process_update(update: dict) -> None:
             send_message(chat_id, _HELP)
             return
 
+        # ── Version commands ───────────────────────────────────────────────
+        if text.lower() in ("/v1",):
+            _user_version[user_id] = "v1"
+            send_message(chat_id, "✅ Mode set to V1 (Structured keyword placement).")
+            return
+        if text.lower() in ("/v2",):
+            _user_version[user_id] = "v2"
+            send_message(chat_id, "✅ Mode set to V2 (Natural AI sentence integration).")
+            return
+        if text.lower() in ("/mode",):
+            ver = _user_version.get(user_id, "v1")
+            send_message(chat_id, f"Current mode: {ver.upper()}")
+            return
+
         # 1. Resolve the JD: a URL we fetch, or pasted description text.
         url_match = _URL_RE.search(text)
         job_title = ""
@@ -223,11 +238,20 @@ def process_update(update: dict) -> None:
             except Exception:  # noqa: BLE001
                 blocked = []
 
-            report = optimize_latex_resume(
-                get_default_resume_latex(), jd_text,
-                maximum_ats_mode=True, blocked_terms=blocked,
-                compile_pdf=True, out_dir=out_dir, job_title=job_title,
-            )
+            ver = _user_version.get(user_id, "v1")
+            if ver == "v2":
+                from src.resume_v2_natural import generate_v2
+                report = generate_v2(
+                    get_default_resume_latex(), jd_text,
+                    job_title=job_title, company="",
+                    out_dir=out_dir, compile_pdf=True,
+                )
+            else:
+                report = optimize_latex_resume(
+                    get_default_resume_latex(), jd_text,
+                    maximum_ats_mode=True, blocked_terms=blocked,
+                    compile_pdf=True, out_dir=out_dir, job_title=job_title,
+                )
             pct = report.get("pct", 0) or 0
             pdf_path = report.get("pdf_path")
 

tests/test_resume_v2.py

@@ -0,0 +1,237 @@
+"""tests/test_resume_v2.py — V2 engine unit tests (mocked LLM, no network/Tectonic)."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import pytest
+
+# Import-chain guard: src/resume_v2_natural imports config which transitively
+# pulls heavy dependencies. Skip gracefully if unavailable.
+try:
+    from src.resume_v2_natural import (
+        generate_v2,
+        _validate_candidate,
+        _v2_honesty_check,
+        _allocate_keywords,
+        _place_sentences_structured,
+        _parse_llm_response,
+        _ensure_list,
+    )
+except Exception as exc:
+    pytestmark = pytest.mark.skip(f"resume_v2_natural import unavailable: {exc}")
+
+
+# ── Fixtures ──────────────────────────────────────────────────────────────────
+
+@pytest.fixture
+def real_resume():
+    """Load the hardcoded resume source for testing."""
+    paths = [
+        os.path.join(os.path.dirname(__file__), "..",
+                     ".planning", "phases",
+                     "09-hardcoded-resume-keyword-placement", "resume-source.tex"),
+    ]
+    for p in paths:
+        if os.path.exists(p):
+            return open(p, encoding="utf-8").read()
+    try:
+        from src.default_resume import get_default_resume_latex
+        return get_default_resume_latex()
+    except Exception:
+        pytest.skip("No resume source available")
+
+
+SAMPLE_JD = (
+    "We are looking for a Product Manager with experience in roadmap planning, "
+    "stakeholder management, A/B testing, data-driven decisions, cross-functional "
+    "collaboration, product analytics, agile methodologies, scrum, user research, "
+    "feature prioritization, product strategy, SaaS, B2B, enterprise platform, "
+    "customer success, onboarding, retention, growth, engagement, conversion, "
+    "monetization, revenue, go-to-market, product discovery, product lifecycle, "
+    "PRD, user stories, acceptance criteria, backlog grooming, sprint planning, "
+    "OKRs, KPIs, metrics, SQL, dashboards, competitive analysis, wireframing"
+)
+
+
+# ── _validate_candidate ─────────────────────────────────────────────────────
+
+def test_validate_short():
+    ok, r = _validate_candidate("short", "")
+    assert not ok
+    assert r == "too_short"
+
+
+def test_validate_not_latex():
+    ok, r = _validate_candidate("x" * 600, "")
+    assert not ok
+    assert r == "not_latex"
+
+
+def test_validate_missing_marker():
+    fake = r"\documentclass{article}\begin{document}" + "A" * 500 + r"\end{document}"
+    ok, r = _validate_candidate(fake, "")
+    assert not ok
+    assert "missing_marker" in r
+
+
+def test_validate_real_resume(real_resume):
+    ok, r = _validate_candidate(real_resume, "")
+    assert ok
+    assert r == "ok"
+
+
+# ── _v2_honesty_check ────────────────────────────────────────────────────────
+
+def test_honesty_clean():
+    original = "Product Manager with experience in agile and roadmap planning"
+    winner = "Product Manager driving roadmap and agile sprints with stakeholders"
+    ok, violations = _v2_honesty_check(winner, original)
+    assert ok
+    assert violations == []
+
+
+def test_honesty_blocks_regulated_cred():
+    original = "Product Manager at BYJU'S"
+    winner = "CISSP-certified Product Manager at BYJU'S with PMP credentials"
+    ok, violations = _v2_honesty_check(winner, original)
+    assert not ok
+    assert any("cissp" in v.lower() or "pmp" in v.lower() for v in violations)
+
+
+# ── _allocate_keywords ───────────────────────────────────────────────────────
+
+def test_allocate_keywords(real_resume):
+    allocations, decision = _allocate_keywords(SAMPLE_JD, "", real_resume)
+    assert "summary" in allocations
+    assert "psm" in allocations
+    assert "ps" in allocations
+    assert "ml_edutech" in allocations
+    assert "skills_other" in allocations
+    assert "projects" in allocations
+    assert "nxtwave" in allocations
+    assert isinstance(allocations["projects"], dict)
+
+
+# ── _parse_llm_response ─────────────────────────────────────────────────────
+
+def test_parse_json():
+    raw = '{"summary": "test paragraph", "psm": ["bullet1"]}'
+    result = _parse_llm_response(raw)
+    assert result["summary"] == "test paragraph"
+    assert result["psm"] == ["bullet1"]
+
+
+def test_parse_fenced():
+    raw = "```json\n{\"summary\": \"test\"}\n```"
+    result = _parse_llm_response(raw)
+    assert result["summary"] == "test"
+
+
+def test_parse_garbage():
+    result = _parse_llm_response("not json at all")
+    assert result == {}
+
+
+# ── _ensure_list ─────────────────────────────────────────────────────────────
+
+def test_ensure_list_string():
+    assert _ensure_list("hello") == ["hello"]
+
+
+def test_ensure_list_array():
+    assert _ensure_list(["a", "b"]) == ["a", "b"]
+
+
+def test_ensure_list_empty():
+    assert _ensure_list("") == []
+    assert _ensure_list(None) == []
+
+
+# ── _place_sentences_structured ──────────────────────────────────────────────
+
+def test_place_sentences(real_resume):
+    sentences = {
+        "summary": "Experienced PM driving product strategy and roadmap.",
+        "psm": ["Led stakeholder management and retention analytics initiatives."],
+        "ps": ["Drove A/B testing and feature prioritization."],
+        "skills_other": "SQL, dashboards, agile",
+    }
+    allocations = {
+        "summary": ["product strategy", "roadmap"],
+        "psm": ["stakeholder management", "retention"],
+        "ps": ["A/B testing", "feature prioritization"],
+        "ml_edutech": [],
+        "skills_other": ["SQL", "dashboards", "agile"],
+        "projects": {},
+        "nxtwave": [],
+    }
+    new_src, placed = _place_sentences_structured(real_resume, sentences, allocations)
+    assert len(new_src) > len(real_resume)
+    assert "Experienced PM driving product strategy" in new_src
+    assert "Led stakeholder management" in new_src
+    assert "ats-item" in new_src
+
+
+# ── generate_v2 (mocked LLM) ────────────────────────────────────────────────
+
+def _fake_call_with_cfg(cfg, system, user, max_tokens=2000):
+    return json.dumps({
+        "summary": "Experienced Product Manager driving product strategy and roadmap.",
+        "psm": ["Led stakeholder management and cross-functional collaboration."],
+        "ps": ["Drove A/B testing and user research."],
+        "ml_edutech": ["Built AI product with data-driven approach."],
+        "skills_other": "SQL, dashboards, agile, scrum",
+        "nxtwave": ["Managed product lifecycle and sprint planning."],
+    })
+
+
+def test_generate_v2_report_shape(real_resume, monkeypatch):
+    monkeypatch.setattr("src.resume_v2_natural.LLMClient._call_with_cfg",
+                        _fake_call_with_cfg)
+    report = generate_v2(
+        real_resume, SAMPLE_JD,
+        job_title="Product Manager", company="TestCo",
+        compile_pdf=False,
+    )
+    assert isinstance(report, dict)
+    for key in ("tex", "compiled", "engine", "pct", "expected", "found",
+                "missing", "keywords", "source", "v2_models_used",
+                "v2_winner", "judge_note"):
+        assert key in report, f"missing key: {key}"
+    assert report["source"] == "latex_v2"
+    assert isinstance(report["v2_models_used"], list)
+    assert report["tex"] != real_resume  # keywords were placed
+
+
+def test_generate_v2_judge_fallback(real_resume, monkeypatch):
+    """When the LLM raises, V2 falls back to V1-style placement."""
+    def _raise(*a, **kw):
+        raise RuntimeError("model unavailable")
+    monkeypatch.setattr("src.resume_v2_natural.LLMClient._call_with_cfg", _raise)
+    monkeypatch.setattr("src.resume_v2_natural._fan_out_cfgs", lambda: [])
+
+    report = generate_v2(
+        real_resume, SAMPLE_JD,
+        job_title="Product Manager", company="TestCo",
+        compile_pdf=False,
+    )
+    assert isinstance(report, dict)
+    assert "v1_fallback" in report["v2_winner"]
+    assert report["source"] == "latex_v2"
+    for key in ("tex", "pct", "expected", "found", "missing"):
+        assert key in report
+
+
+def test_generate_v2_minimal_jd(real_resume, monkeypatch):
+    """Even with a trivial JD, V2 returns a valid report without crashing."""
+    monkeypatch.setattr("src.resume_v2_natural.LLMClient._call_with_cfg",
+                        _fake_call_with_cfg)
+    report = generate_v2(
+        real_resume, "hello world",
+        compile_pdf=False,
+    )
+    assert isinstance(report, dict)
+    assert "tex" in report
+    assert report["source"] == "latex_v2"

ui.py

@@ -639,6 +639,7 @@ _DEFAULTS = {
     "setup_step": 1,
     "completed_jobs": [],   # per-job results streamed in during a run
     "custom_roles": [],     # user-added custom role titles
+    "_gen_version": "v1",  # resume generation mode: "v1" or "v2"
     "logged_in": False, "user_id": None, "user_email": "",
 }
 for _k, _v in _DEFAULTS.items():
@@ -1206,6 +1207,15 @@ if st.session_state.show_history:
 show_config = not (st.session_state.running or st.session_state.results)
 start = False  # set to True only on step 7 launch button
 
+# ── V1/V2 generation mode selector (home page, outside wizard) ──────────
+_vlabel = st.radio(
+    "Resume generation mode",
+    options=["V1 — Structured (keyword placement)", "V2 — Natural AI (sentence integration)"],
+    index=0 if st.session_state.get("_gen_version", "v1") == "v1" else 1,
+    horizontal=True, key="_gen_version_radio",
+)
+st.session_state["_gen_version"] = "v2" if _vlabel.startswith("V2") else "v1"
+
 # Platform imports (needed even when not showing config, for pipeline)
 from src.ever_jobs_bridge.platforms import PLATFORM_GROUPS, INDIA_DEFAULT_PLATFORMS, EVER_JOBS_PLATFORMS
 
@@ -2314,16 +2324,50 @@ if show_config and start and not st.session_state.running:
                             "review_terms":       job.get("review_terms", []),
                         }))
 
-                customizer    = ResumeCustomizer(llm, resume_text, _ocfg["resumes_dir"],
-                                                 fast_model_cfg=fast_cfg)
-                assessed_jobs = customizer.customize_for_jobs(
-                    assessed_jobs,
-                    min_score_for_llm=_min_score,
-                    max_llm_resumes=len(assessed_jobs),
-                    generate_all=True,
-                    model_cfgs=phase2_cfgs,
-                    progress_cb=_resume_cb,
-                )
+                # ── V2 bulk: sentence-integration pipeline per job ──────────
+                _bulk_version = st.session_state.get("_gen_version", "v1")
+                _v2_bulk_done = False
+                if _bulk_version == "v2":
+                    _q_log("📝 V2 mode: generating sentence-based resumes per job…")
+                    try:
+                        from src.default_resume import get_default_resume_latex
+                        from src.resume_v2_natural import generate_v2
+                        _v2_latex = get_default_resume_latex()
+                        _v2_count = 0
+                        for _j in assessed_jobs:
+                            if not _j.get("jd_text"):
+                                continue
+                            try:
+                                _v2_dir = os.path.join(_ocfg["resumes_dir"], f"v2_{_v2_count}")
+                                os.makedirs(_v2_dir, exist_ok=True)
+                                _v2r = generate_v2(
+                                    _v2_latex, _j["jd_text"],
+                                    job_title=_j.get("title", ""),
+                                    company=_j.get("company", ""),
+                                    out_dir=_v2_dir, compile_pdf=True,
+                                )
+                                _j["resume_path"] = _v2r.get("pdf_path") or ""
+                                _j["ats_score"] = _v2r.get("pct", 0)
+                                _v2_count += 1
+                                _q_log(f"  V2 #{_v2_count}: {_j.get('title', '')} — {_v2r.get('pct', 0)}%")
+                            except Exception as _v2e:
+                                _q_log(f"  V2 failed for {_j.get('title', '')}: {_v2e}")
+                        _q_log(f"✅ V2 generated {_v2_count} resumes")
+                        _v2_bulk_done = True
+                    except Exception as _v2_exc:
+                        _q_log(f"⚠️ V2 bulk failed, falling back to V1: {_v2_exc}")
+
+                if not _v2_bulk_done:
+                    customizer    = ResumeCustomizer(llm, resume_text, _ocfg["resumes_dir"],
+                                                     fast_model_cfg=fast_cfg)
+                    assessed_jobs = customizer.customize_for_jobs(
+                        assessed_jobs,
+                        min_score_for_llm=_min_score,
+                        max_llm_resumes=len(assessed_jobs),
+                        generate_all=True,
+                        model_cfgs=phase2_cfgs,
+                        progress_cb=_resume_cb,
+                    )
                 llm_done  = sum(1 for j in assessed_jobs if j.get("resume_generated") == "LLM Tailored")
                 tmpl_done = sum(1 for j in assessed_jobs if j.get("resume_generated") == "Template")
                 pdf_done  = sum(1 for j in assessed_jobs if j.get("resume_pdf_path"))