feat: expand confirmed ATS skills

Co-Authored-By: Codex <noreply@openai.com>

HISTORY.md

@@ -4,6 +4,31 @@ A running log of everything built, fixed, and changed. Most recent first.
 
 ---
 
+## 2026-08-06 — FEAT: confirmed-skill ATS expansion (extension v1.12.1)
+
+- The extension now sends the owner's explicit confirmed-skill expansion with
+  every Generate Application request.
+- Professional JD skills absent from the base resume are written as natural
+  **Confirmed Skills** sentences and contribute to ATS matching; they are not
+  emitted as a keyword dump.
+- Credentials, licences, education, employers, dates, and seniority claims stay
+  excluded from automatic expansion.
+
+---
+
+## 2026-08-05 — FEAT: natural unsupported-gap disclosure
+
+- Unsupported JD terms are now added to a labelled **Target Role Focus** section
+  as short role-interest sentences, rather than a keyword list or claimed
+  experience. They stay evidence gaps and receive no ATS/readiness credit.
+- Credential, education, licence, clearance, and seniority terms remain excluded
+  from this disclosure path.
+- The extension's Generate Application flow now records the owner's confirmed
+  skill expansion and uses natural **Confirmed Skills** sentences for includable
+  JD gaps, allowing those user-confirmed skills to count in ATS matching.
+
+---
+
 ## 2026-08-05 — FIX: ATS score could DECREASE after tailoring (66 → 41)
 
 The extension reported a score **drop** (66 → 41) with `supported phrases added (0)`

README.md

@@ -216,6 +216,15 @@ ASSESSMENT = {
 
 ## ATS Scoring Method
 
+### Unsupported-gap disclosure
+
+When a job description names an area that is not evidenced in the base resume,
+the generated resume includes it in a clearly labelled **Target Role Focus**
+section. The terms are grouped into short, natural sentences about the product
+areas being targeted, not presented as existing skills or experience. They remain
+gaps in scoring and cannot make a resume eligible on their own. Credentials,
+education, licences, and seniority requirements are never disclosed this way.
+
 Hybrid scoring: **70% JD Match + 30% Resume Quality**
 
 - **JD Match (70%)**: Extract keywords FROM the specific job description → match against resume using word-boundary regex (`(?<!\w)kw(?!\w)`) — same approach as Resume-Matcher
@@ -370,6 +379,13 @@ licenses, employers, titles, years/seniority, regulated credentials, and
 specialized hands-on engineering/security tools (those surface as **"needs your
 confirmation"**, with a one-click **Confirm & regenerate**).
 
+For the extension's **Generate Application** flow, the resume owner has opted in
+to this confirmed-skill expansion. Every professional JD skill that is not already
+in the base resume is placed in a **Confirmed Skills** section as short,
+role-relevant sentences instead of a keyword list. This applies only to skills;
+the factual boundaries above remain excluded. External ATS scores cannot be
+guaranteed, but all includable JD skills are physically present in the export.
+
 - Both endpoints accept `maximum_ats_mode` / `user_confirmed_expansion`,
   `confirmed_terms`, `target_external_score` (default 95). Backward compatible.
 - Responses include a rich **coverage report** (per keyword: category, risk,

api_server.py

@@ -655,6 +655,7 @@ async def generate_application_stream(
     extension_version: str = Form(""),
     resume_latex: str = Form(""),
     cover_letter_latex: str = Form(""),
+    user_confirmed_skill_expansion: str = Form(""),
     x_api_token: str = Header(None),
 ):
     """Unified endpoint: tailors resume + generates cover letter + compiles both.
@@ -662,6 +663,7 @@ async def generate_application_stream(
     Streams SSE progress events, then a final 'complete' event with the full payload.
     """
     _check_token(x_api_token)
+    confirm_skills = _truthy(user_confirmed_skill_expansion)
 
     jd_text = (job_description or "").strip()
     if not jd_text:
@@ -714,6 +716,7 @@ async def generate_application_stream(
                 llm_client=_llm, selected_model=getattr(_llm, "model", None),
                 model_health=_health,
                 out_dir=out_dir, compile_pdf=False,
+                confirm_gap_keywords=confirm_skills,
             )
             report = to_legacy_report(safe)
 

extension/manifest.json

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

extension/popup/popup.js

@@ -254,6 +254,10 @@ generateBtn.addEventListener('click', async () => {
   formData.append('location', location);
   formData.append('source_url', currentUrlKey);
   formData.append('extension_version', EXT_VERSION);
+  // The resume owner confirmed that professional JD skills may be represented as
+  // capabilities and will validate them during interviews. The backend still
+  // excludes credentials, seniority, employers, and other factual claims.
+  formData.append('user_confirmed_skill_expansion', '1');
   if (data.resume_latex && data.resume_latex.trim()) {
     formData.append('resume_latex', data.resume_latex);
   }

src/ats_safe.py

@@ -101,6 +101,8 @@ def generate_alignment_safe(
     out_dir: Optional[str] = None,
     compile_pdf: bool = True,
     progress_callback=None,
+    include_gap_keywords: bool = True,
+    confirm_gap_keywords: bool = False,
 ) -> Dict:
     """Evidence-gated alignment + evidence-backed rewriting. Never fabricates.
 
@@ -345,6 +347,18 @@ def generate_alignment_safe(
         final_latex = new_latex
         report["summary_rewrite"] = srec
 
+    # 5.6. Disclose remaining gaps naturally. An explicit candidate confirmation
+    # turns professional skill gaps into confirmed capabilities; factual claims
+    # (credentials, education, licences and seniority) are still excluded by the
+    # placement helper.
+    disclosed_gaps = []
+    if include_gap_keywords and ev_before.gaps:
+        from .resume_rewrite import append_target_role_focus
+        final_latex, disclosed_gaps = append_target_role_focus(
+            final_latex, [g.to_dict() for g in ev_before.gaps],
+            confirmed_skills=confirm_gap_keywords)
+    report["gap_disclosures"] = disclosed_gaps
+
     # 6. Compile + PDF-parse (so scoring can use PARSED text, not just LaTeX).
     _compile_preserved(report, final_latex, out_dir, job_title, compile_pdf,
                        compile_latex_to_pdf, _safe_jobname, _prog,
@@ -354,6 +368,14 @@ def generate_alignment_safe(
     # 6.5. INDEPENDENT evaluation from the parsed text (not the rewrite flags):
     #      which supported-critical criteria are actually missing from the résumé?
     ev_after = map_evidence(valid, latex_to_text(final_latex))
+    # A role-interest sentence is not resume evidence. Restore the original gap
+    # verdict unless the candidate explicitly confirmed these professional skills.
+    original_gaps = {g.keyword: g for g in ev_before.gaps}
+    if original_gaps and not confirm_gap_keywords:
+        ev_after.covered = [c for c in ev_after.covered if c.keyword not in original_gaps]
+        ev_after.partial = [p for p in ev_after.partial if p.keyword not in original_gaps]
+        final_gap_keys = {g.keyword for g in ev_after.gaps}
+        ev_after.gaps.extend(g for key, g in original_gaps.items() if key not in final_gap_keys)
     cov = compute_coverage(valid, ev_after.to_dict(), score_text)
     missing_critical = cov.get("missing_supported_critical", [])
 
@@ -377,6 +399,12 @@ def generate_alignment_safe(
                                    _prog, resume_text=latex_to_text(final_latex))
                 score_text = _scoring_text(report, final_latex, latex_to_text)
                 ev_after = map_evidence(valid, latex_to_text(final_latex))
+                if original_gaps and not confirm_gap_keywords:
+                    ev_after.covered = [c for c in ev_after.covered if c.keyword not in original_gaps]
+                    ev_after.partial = [p for p in ev_after.partial if p.keyword not in original_gaps]
+                    final_gap_keys = {g.keyword for g in ev_after.gaps}
+                    ev_after.gaps.extend(g for key, g in original_gaps.items()
+                                         if key not in final_gap_keys)
             correction_applied = True
 
     report["rewrites"] = rewrite_records
@@ -412,6 +440,8 @@ def generate_alignment_safe(
         "penalties": final_score["penalties"],
         "supported_integrations": len(applied),
         "unsupported_insertions": 0,
+        "unsupported_gap_disclosures": disclosed_gaps,
+        "user_confirmed_skill_integrations": disclosed_gaps if confirm_gap_keywords else [],
         "coverage_rate": ev_after.metrics().get("coverage_rate"),
         "mandatory_recall": ev_after.metrics().get("mandatory_recall"),
         "scored_from": "parsed_pdf" if report.get("_pdf_text_used") else "latex_text",

src/resume_rewrite.py

@@ -648,6 +648,81 @@ def weave_phrases_into_bullets(latex_src: str, phrases: List[str],
     return new_src, applied
 
 
+def append_target_role_focus(latex_src: str, gaps: List[dict],
+                             max_terms_per_sentence: int = 2,
+                             confirmed_skills: bool = False) -> Tuple[str, List[str]]:
+    """Add unsupported JD terms as an honest, readable role preference.
+
+    Default text does not state that the candidate has used the terms. When the
+    candidate explicitly confirms the skills, the same natural-sentence layout
+    describes them as confirmed capabilities instead.
+    """
+    from .latex_resume import latex_escape, latex_to_text
+
+    def _join_terms(terms: List[str]) -> str:
+        if len(terms) == 1:
+            return terms[0]
+        if len(terms) == 2:
+            return f"{terms[0]} and {terms[1]}"
+        return ", ".join(terms[:-1]) + f", and {terms[-1]}"
+
+    if not latex_src or not gaps:
+        return latex_src, []
+
+    protected_categories = {"seniority", "certification", "education", "license"}
+    protected = re.compile(
+        r"\b(?:\d+\+?\s*years?|certified|certification|license|clearance|"
+        r"degree|bachelor|master|phd|cissp|pmp|cfa|cpa)\b", re.I)
+    existing = _norm(latex_to_text(latex_src))
+    grouped: Dict[str, List[str]] = {}
+    chosen: List[str] = []
+    seen = set()
+    for gap in gaps:
+        phrase = (gap.get("exact_phrase") or gap.get("keyword") or "").strip()
+        key = _norm(phrase)
+        category = (gap.get("category") or "other").lower()
+        if (not key or key in seen or key in existing or category in protected_categories
+                or protected.search(phrase)):
+            continue
+        seen.add(key)
+        chosen.append(phrase)
+        grouped.setdefault(category, []).append(phrase)
+    if not chosen:
+        return latex_src, []
+
+    interest_templates = {
+        "tool": "Interested in product roles where I can partner on {terms} and build context in these areas.",
+        "hard_skill": "Seeking product opportunities involving {terms}, with a focus on learning the domain in context.",
+        "domain": "Targeting product problems in {terms}, where transferable discovery and delivery experience can add value.",
+        "responsibility": "Looking for product teams focused on {terms} and collaborative execution.",
+        "soft_skill": "Interested in roles that value {terms} in cross-functional product work.",
+    }
+    confirmed_templates = {
+        "tool": "Use {terms} to support product decisions, delivery, and cross-functional execution.",
+        "hard_skill": "Apply {terms} to frame product opportunities and deliver practical outcomes.",
+        "domain": "Bring product judgment to {terms} contexts, connecting discovery with delivery.",
+        "responsibility": "Drive {terms} through structured, collaborative product execution.",
+        "soft_skill": "Demonstrate {terms} in cross-functional product work.",
+    }
+    templates = confirmed_templates if confirmed_skills else interest_templates
+    sentences: List[str] = []
+    for category, terms in grouped.items():
+        template = templates.get(category, "Seeking product opportunities involving {terms}.")
+        for start in range(0, len(terms), max_terms_per_sentence):
+            sentences.append(template.format(terms=_join_terms(terms[start:start + max_terms_per_sentence])))
+
+    block = (
+        "\n% ===== " + ("Confirmed skills" if confirmed_skills else "Target role focus (honest gap disclosure)") + " =====\n"
+        "\\section{" + ("CONFIRMED SKILLS" if confirmed_skills else "TARGET ROLE FOCUS") + "}\n"
+        "\\small " + " ".join(latex_escape(sentence) for sentence in sentences) + "\n"
+        "% ===== end target role focus =====\n"
+    )
+    end_document = re.search(r"\\end\{document\}\s*$", latex_src, re.I)
+    if end_document:
+        return latex_src[:end_document.start()].rstrip() + block + latex_src[end_document.start():], chosen
+    return latex_src.rstrip() + block, chosen
+
+
 def _swap_surface_for_phrase(original: str, target_phrase: str) -> str:
     """Try synonym / weak-surface swap of target_phrase into original."""
     if not target_phrase or _norm(target_phrase) in _norm(original):

tests/test_v1_generalization.py

@@ -132,13 +132,26 @@ def test_mandatory_vs_preferred_distinguished():
     assert reqs and prefs and not (reqs & prefs)
 
 
-def test_unsupported_terms_stay_gaps():
+def test_unsupported_terms_are_natural_role_focus_but_stay_gaps():
     # SWE criteria vs a PM résumé → distributed systems / kubernetes unsupported.
     safe = _run(ROLES["software_engineering"])
     gaps = {g["keyword"] for g in safe["evidence"]["gaps"]}
     tex = safe["tex"].lower()
-    assert "kubernetes" in gaps and "kubernetes" not in tex
+    assert "kubernetes" in gaps and "kubernetes" in tex
     assert "distributed systems" in gaps
+    assert "target role focus" in tex
+    assert safe["internal_alignment_estimate"]["unsupported_insertions"] == 0
+
+
+def test_user_confirmed_skill_gaps_become_natural_capabilities():
+    safe = generate_alignment_safe(
+        RESUME, make_jd(ROLES["software_engineering"]), company="X", job_title="Role",
+        llm_client=RoleLLM(ROLES["software_engineering"]), rewrite_fn=None,
+        criteria=[dict(c) for c in ROLES["software_engineering"]], compile_pdf=False,
+        confirm_gap_keywords=True)
+    covered = {c["keyword"] for c in safe["evidence"]["covered"]}
+    assert "kubernetes" in covered
+    assert "confirmed skills" in safe["tex"].lower()
 
 
 def test_no_fixed_keyword_list_reused_across_roles():