Tune JD parse: generic compressed prompt, best-of-N recall, JD phases in explorer

JD prompts:
- Restructure objective/subjective prompts to Role-Task-Context-Constraints-Output;
pin the persona + Mode constraint so Qwen3 skips its thinking loop.
- Make the objective prompt GENERIC (no leaked JD-specific skill/title examples) after
experiments showed listed examples don't drive recall and can anchor/echo.
- Compress the schema 12->7 keys: merge nice_to_have into must_have_skills, merge the
two location fields, drop certifications/target_industries/exclude_companies from the
prompt (they default to [] in _coerce_objective, so the funnel is unaffected). The
leaner prompt freed model capacity -> ~30 skills recall.
- job_titles: keep the verbatim posted title first, add the role family, and always
include the JD's core-activity roles (Search/Ranking/IR Engineer). Generic framing.
- acceptable_countries inferred from cities/"outside <country>"; capture every city.

Recall controls (config):
- Best-of-N objective extraction: parse_temperature (0.5), parse_attempts, min_skills,
parse_max_tokens (1536). Sample at temperature, keep the richest, early-stop at
min_skills; temperature 0 = single greedy pass.

Explorer:
- Run JD objective_extract / summary_extract as timed phases (their time counts in the
total; non-funnel so they don't skew the candidate funnel); persist & replay the
original parse time via a _timing block so cached runs show real timing.

Tooling/tests:
- scripts/jd_prompt_experiment.py: greedy A/B harness for skills + titles recall.
- tests for best-of-N keep-richest, early-stop, greedy-single-pass.

config/settings.yaml

@@ -100,3 +100,7 @@ hard_filter:                         # funnel entry — candidate-only cuts (ind
 jd:                                  # JD-parse inputs/outputs
   path: problem/job_description.md
   extraction_path: data/artifacts/jd_extraction.json   # ONE combined artifact (objective + subjective + summary)
+  parse_temperature: 0.5             # objective-parse sampling temperature; >0 = best-of-N keep-richest
+  parse_attempts: 3                  # samples to draw when temperature>0; keep the richest
+  min_skills: 14                     # early-stop target for the best-of-N path
+  parse_max_tokens: 1536             # objective-parse generation budget (raise if the JSON truncates)

scripts/jd_prompt_experiment.py

@@ -0,0 +1,242 @@
+"""Experiment: which GENERIC objective-extraction wording best recovers the JD's skills / job_titles?
+
+The committed prompt must NOT name the target JD's own answers as examples (that leaks the key and overfits to
+one JD). This harness pits generic prompt variants against the real JD and measures:
+  * skills  — recall against a hand-built ground-truth skill set (independent of any prompt's examples).
+  * titles  — recall of RELEVANT adjacent roles, while flagging IRRELEVANT title leakage (precision).
+Only the field-under-test's wording varies; the other fields stay at the winning generic wording.
+
+Run:  uv run python scripts/jd_prompt_experiment.py [skills|titles]   (default: skills)
+Greedy (temperature=0) so the comparison isolates the PROMPT effect, not sampling noise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from common.runtime import configure_compute  # noqa: E402
+
+configure_compute()
+
+from config import load_settings  # noqa: E402
+from jd.parse import _SYSTEM, _coerce_objective, _extract_json_object  # noqa: E402
+from jd.spec import resolve  # noqa: E402
+from models.llm import index_gen_client  # noqa: E402
+
+# ---- Ground truth (built by READING the JD, never from a prompt) -------------------------------------------
+# Skills genuinely present in the JD; each with match aliases. Short acronyms match by exact token; others by
+# substring.
+SKILLS_TRUTH: dict[str, list[str]] = {
+    "embeddings": ["embedding"], "retrieval": ["retrieval"], "ranking": ["ranking"],
+    "sentence-transformers": ["sentence-transformer", "sentence transformers"], "BGE": ["bge"], "E5": ["e5"],
+    "vector databases": ["vector database", "vector db"], "hybrid search": ["hybrid search"],
+    "Pinecone": ["pinecone"], "Weaviate": ["weaviate"], "Qdrant": ["qdrant"], "Milvus": ["milvus"],
+    "OpenSearch": ["opensearch"], "Elasticsearch": ["elasticsearch", "elastic search"], "FAISS": ["faiss"],
+    "Python": ["python"], "evaluation": ["evaluation", "eval framework"], "NDCG": ["ndcg"], "MRR": ["mrr"],
+    "MAP": ["map"], "A/B testing": ["a/b test", "ab test"], "fine-tuning": ["fine-tun", "finetun"],
+    "LoRA": ["lora"], "QLoRA": ["qlora"], "PEFT": ["peft"],
+    "learning-to-rank": ["learning-to-rank", "learning to rank"], "XGBoost": ["xgboost"],
+    "distributed systems": ["distributed system"], "inference optimization": ["inference optim"],
+    "open-source": ["open-source", "open source"],
+}
+_ACRONYMS = {"bge", "e5", "ndcg", "mrr", "map", "lora", "qlora", "peft", "faiss"}
+
+# Job titles the ideal candidate for THIS JD (ranking / retrieval / search / applied-ML) might plausibly hold.
+TITLES_GOOD: dict[str, list[str]] = {
+    "AI Engineer": ["ai engineer"], "ML Engineer": ["machine learning engineer", "ml engineer"],
+    "Search Engineer": ["search engineer"], "Ranking Engineer": ["ranking engineer", "rank engineer"],
+    "Applied Scientist": ["applied scientist"], "Research Engineer": ["research engineer"],
+    "Research Scientist": ["research scientist"], "Recommendation Engineer": ["recommendation"],
+    "NLP Engineer": ["nlp engineer", "natural language"],
+    "Information Retrieval Engineer": ["information retrieval", "retrieval engineer", "ir engineer"],
+    "Relevance Engineer": ["relevance engineer", "search relevance"], "MLOps Engineer": ["mlops"],
+    "Data Scientist": ["data scientist"],
+}
+# Roles that should NOT show up — they would mis-match candidates in the BM25 title field.
+TITLES_BAD: dict[str, list[str]] = {
+    "Marketing": ["marketing"], "Product Manager": ["product manager"], "Sales": ["sales"],
+    "Frontend": ["frontend", "front-end", "front end"], "QA": ["qa engineer", "quality assurance"],
+    "Designer": ["designer"], "Accountant": ["accountant"], "HR": ["hr ", "human resources"],
+}
+
+# ---- Generic prompt skeleton; one field's hint varies per experiment ---------------------------------------
+_KEYS = """- must_have_skills: {skills_hint}
+- nice_to_have: {nice_hint}
+- job_titles: {titles_hint}
+- target_industries: industry keywords the ideal candidate should come from
+- education_fields: field-of-study keywords
+- certifications: required/preferred certification keywords; [] if none
+- years_min: minimum years of experience (number)
+- years_max: maximum years of experience (number)
+- locations_preferred: the JD's PRIMARY work cities
+- locations_acceptable: ALL OTHER cities the JD explicitly welcomes; [] if none beyond the preferred
+- acceptable_countries: countries candidates are accepted from; [] if remote/worldwide with no restriction
+- exclude_companies: companies the JD rules out; [] if none"""
+
+_BODY = """# Role Definition
+You are an expert technical recruiter and structured-data extractor.
+
+# Context
+The text under "Job Description" is a hiring JD. Downstream code feeds your JSON into keyword search and hard
+filters, and every key maps to a candidate-database field — so list values must be SHORT search keywords.
+
+# Task
+Extract the facts into ONE JSON object with EXACTLY these keys:
+{keys}
+
+# Constraints & Guidelines
+- Output SHORT keywords for the list fields — not phrases or sentences.
+- Extract / infer EVERY relevant value; missing a relevant one is the worst error, but do not invent values
+  unrelated to this JD.
+- Output EVERY key above; use [] for an empty list and a bare number for the years fields.
+- Mode: output your immediate final answer with no reasoning, planning, or explanation.
+- Return ONLY the JSON object — no markdown fences and no text before or after it.
+
+# Job Description
+{jd_text}
+
+# JSON
+"""
+
+# The winning generic hints from the skills experiment — held fixed while testing the OTHER field.
+_WIN_SKILLS = ("EVERY required hard skill, programming language, framework, library, tool, platform, database, "
+               "algorithm, technique, and evaluation metric — include BOTH the broad concept AND each "
+               "specifically-named product/library/metric")
+_WIN_NICE = ("EVERY preferred / bonus skill mentioned (e.g. under a 'nice to have', 'bonus', or 'would like' "
+             "heading); never empty if the JD lists any")
+_WIN_TITLES = "MANY related job titles the ideal candidate may hold — several variants and adjacent roles, not just the posted role"
+
+
+def _build(skills_hint: str, nice_hint: str, titles_hint: str) -> str:
+    return _BODY.replace("{keys}", _KEYS.format(skills_hint=skills_hint, nice_hint=nice_hint, titles_hint=titles_hint))
+
+
+# Skills variants (titles fixed at the baseline) ------------------------------------------------------------
+SKILLS_VARIANTS: dict[str, str] = {
+    "category_only": _build(_WIN_SKILLS, _WIN_NICE, _WIN_TITLES),
+    "neutral_examples": _build(
+        'every required hard skill, tool, library, metric, platform (the KIND of token wanted, from an '
+        'UNRELATED domain: "Java","Kubernetes","PostgreSQL","Spark","unit testing")',
+        'every preferred / bonus skill (unrelated-domain examples: "GraphQL","Terraform","gRPC")', _WIN_TITLES),
+    "minimal": _build("a comprehensive keyword list of ALL required technical skills, tools, libraries, metrics "
+                      "and platforms named in the JD", "ALL preferred / bonus skills named in the JD; [] if none",
+                      _WIN_TITLES),
+}
+
+# Title variants (skills fixed at the winner) ---------------------------------------------------------------
+TITLES_VARIANTS: dict[str, str] = {
+    "baseline": _build(_WIN_SKILLS, _WIN_NICE, _WIN_TITLES),
+    "role_family": _build(_WIN_SKILLS, _WIN_NICE,
+        "ALL job titles in the candidate's role family — the posted role, its seniority variants "
+        "(junior/mid/senior/staff/principal/lead), AND adjacent roles that do the SAME core work the JD "
+        "describes; aim for 10-15 distinct titles, do not invent unrelated roles"),
+    "work_grounded": _build(_WIN_SKILLS, _WIN_NICE,
+        "infer job titles from the WORK the JD describes (the systems they would build and own), not only the "
+        "posted title — list every engineering and scientific role that builds such systems, including "
+        "seniority variants; be exhaustive but stay on-topic"),
+    "count_target": _build(_WIN_SKILLS, _WIN_NICE,
+        "8-15 distinct related job titles the ideal candidate may currently or previously hold, covering "
+        "seniority levels and adjacent specializations relevant to this JD"),
+    # Construction recipe: domain × suffix + the generic ML/AI role family + seniority (no JD-specific titles).
+    "recipe_family": _build(_WIN_SKILLS, _WIN_NICE,
+        "a BROAD, ON-TOPIC set (12-20) of job titles the ideal candidate may hold now or previously. Build it "
+        "THREE ways: (1) combine EACH core technical domain/area this JD centers on with the suffixes "
+        "'Engineer' and 'Scientist'; (2) add the general ML/AI role family — AI Engineer, Machine Learning "
+        "Engineer, Applied Scientist, Research Scientist, Research Engineer, Data Scientist, MLOps Engineer, "
+        "Software Engineer; (3) add seniority variants (Senior/Staff/Principal/Lead) of the main role. Prefer "
+        "'Engineer'/'Scientist' forms over 'Architect'. Do NOT invent unrelated roles (no marketing/sales/PM)."),
+    # Pure recipe: domain × suffix + seniority, WITHOUT enumerating the role family (tests if the recipe alone works).
+    "recipe_pure": _build(_WIN_SKILLS, _WIN_NICE,
+        "a BROAD, ON-TOPIC set (12-20) of job titles. For EACH core technical domain/area this JD is about, "
+        "emit '<domain> Engineer' and '<domain> Scientist'; also emit the broad role family for this field and "
+        "seniority variants (Senior/Staff/Principal/Lead). Prefer 'Engineer'/'Scientist' forms. Stay on-topic — "
+        "no unrelated roles."),
+    # Winner-so-far (family enumeration) PLUS a generic ML problem-area checklist to capture the domain roles.
+    "recipe_full": _build(_WIN_SKILLS, _WIN_NICE,
+        "a BROAD, ON-TOPIC set (15-20) of distinct job titles the ideal candidate may hold now or previously. "
+        "Combine THREE sources: (1) the general ML/AI role family — AI Engineer, Machine Learning Engineer, "
+        "Applied Scientist, Research Scientist, Research Engineer, Data Scientist, MLOps Engineer, Software "
+        "Engineer; (2) for EACH ML problem-area this JD involves (e.g. search, ranking, retrieval, "
+        "recommendation, relevance, personalization, NLP, information retrieval), emit '<area> Engineer' and "
+        "where natural '<area> Scientist'; (3) seniority variants (Senior/Staff/Principal/Lead) of the primary "
+        "role. Prefer 'Engineer'/'Scientist' over 'Architect'. Do NOT invent unrelated roles (no "
+        "marketing/sales/PM/design)."),
+}
+
+
+def _skill_hits(extracted: list[str]) -> set[str]:
+    low = [s.lower() for s in extracted]
+    tokens = {tok for s in low for tok in s.replace("/", " ").replace(",", " ").split()}
+    hits: set[str] = set()
+    for canon, aliases in SKILLS_TRUTH.items():
+        for alias in aliases:
+            if (alias in tokens) if alias in _ACRONYMS else any(alias in s for s in low):
+                hits.add(canon)
+    return hits
+
+
+def _title_good_hits(titles: list[str]) -> set[str]:
+    low = [t.lower() for t in titles]
+    return {canon for canon, aliases in TITLES_GOOD.items() if any(a in t for a in aliases for t in low)}
+
+
+def _title_bad_hits(titles: list[str]) -> list[str]:
+    low = [t.lower() for t in titles]
+    return [t for t in low if any(a in t for aliases in TITLES_BAD.values() for a in aliases)]
+
+
+def _extract(prompt: str, jd_text: str, client) -> dict | None:
+    raw = client.generate(prompt.replace("{jd_text}", jd_text), system=_SYSTEM, temperature=0.0, max_tokens=1024)
+    parsed = _extract_json_object(raw)
+    return _coerce_objective(parsed) if parsed else None
+
+
+def _run_skills(jd_text: str, client) -> None:
+    total = len(SKILLS_TRUTH)
+    rows = []
+    for name, prompt in SKILLS_VARIANTS.items():
+        obj = _extract(prompt, jd_text, client) or {}
+        skills = obj.get("must_have_skills", []) + obj.get("nice_to_have", [])
+        hits = _skill_hits(skills)
+        rows.append((name, len(skills), len(hits)))
+        print(f"\n=== {name} ===  skills={len(skills)}  recall={len(hits)}/{total} ({100*len(hits)/total:.0f}%)")
+        print("extracted:", skills)
+        print("MISSED:", sorted(set(SKILLS_TRUTH) - hits))
+    print("\n=========== SKILLS SUMMARY (greedy) ===========")
+    print(f"{'variant':<18}{'skills':>8}{'recall':>10}")
+    for name, n, h in rows:
+        print(f"{name:<18}{n:>8}{f'{h}/{total}':>10}")
+
+
+def _run_titles(jd_text: str, client) -> None:
+    total = len(TITLES_GOOD)
+    rows = []
+    for name, prompt in TITLES_VARIANTS.items():
+        obj = _extract(prompt, jd_text, client) or {}
+        titles = obj.get("job_titles", [])
+        good, bad = _title_good_hits(titles), _title_bad_hits(titles)
+        rows.append((name, len(titles), len(good), len(bad)))
+        print(f"\n=== {name} ===  titles={len(titles)}  relevant={len(good)}/{total} "
+              f"({100*len(good)/total:.0f}%)  irrelevant={len(bad)}")
+        print("extracted:", titles)
+        print("MISSED relevant:", sorted(set(TITLES_GOOD) - good), "| IRRELEVANT:", bad)
+    print("\n=========== TITLES SUMMARY (greedy) ===========")
+    print(f"{'variant':<16}{'titles':>8}{'relevant':>12}{'irrelevant':>12}")
+    for name, n, g, b in rows:
+        print(f"{name:<16}{n:>8}{f'{g}/{total}':>12}{b:>12}")
+
+
+def main() -> int:
+    which = sys.argv[1] if len(sys.argv) > 1 else "skills"
+    settings = load_settings()
+    jd_text = resolve(settings.jd.path).read_text(encoding="utf-8")
+    client = index_gen_client(settings)
+    (_run_titles if which == "titles" else _run_skills)(jd_text, client)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/config.py

@@ -65,6 +65,13 @@ class JdSettings(BaseModel):
 
     path: str = "problem/job_description.md"                  # raw JD prose (live-parse input)
     extraction_path: str = "data/artifacts/jd_extraction.json"  # ONE combined artifact: objective + subjective + summary
+    # Objective-extraction recall. With temperature>0, draw up to ``parse_attempts`` samples and keep the
+    # RICHEST (best-of-N), stopping early once total skills reach ``min_skills``. temperature=0.0 ⇒ a single
+    # greedy/deterministic pass.
+    parse_temperature: float = 0.5                          # sampling temperature for the objective parse
+    parse_attempts: int = 3                                 # samples to draw when temperature>0; keep the most skills
+    min_skills: int = 14                                    # early-stop target for the best-of-N sampling path
+    parse_max_tokens: int = 1536                            # objective-parse generation budget (raise if JSON truncates)
 
 
 class HardFilterSettings(BaseModel):

src/jd/parse.py

@@ -36,30 +36,30 @@ hard filters, and every key maps to a candidate-database field — so list value
 never full phrases or sentences.
 
 # Task
-Extract the facts into ONE JSON object with EXACTLY these keys:
-- must_have_skills: required skill/technology KEYWORDS (e.g. "embeddings","hybrid search","Python")
-- nice_to_have: preferred / bonus skill KEYWORDS (e.g. "LoRA","QLoRA","learning-to-rank","distributed systems")
-- job_titles: MANY related job titles the ideal candidate may hold (e.g. "AI Engineer","Machine Learning Engineer","Search Engineer","Ranking Engineer","Applied Scientist") — several, not just the posted role
-- target_industries: industry KEYWORDS the ideal candidate should come from (e.g. "AI","search","fintech")
-- education_fields: field-of-study KEYWORDS (e.g. "Computer Science","Machine Learning")
-- certifications: required/preferred certification KEYWORDS (e.g. "AWS Solutions Architect"); [] if none
+Extract the facts into ONE JSON object with EXACTLY these keys (descriptions are GENERIC — values must come
+only from THIS job description, never from the wording here):
+- must_have_skills: EVERY skill the JD names, REQUIRED and PREFERRED/BONUS alike — every programming language, framework, library, tool, platform, database, algorithm, technique, and evaluation metric; include BOTH the broad concept AND each specifically-named product / library / metric
+- education_fields: field-of-study keywords
 - years_min: minimum years of experience (number)
 - years_max: maximum years of experience (number)
-- locations_preferred: the JD's PRIMARY work cities (e.g. "Pune","Noida")
-- locations_acceptable: ALL OTHER cities the JD explicitly welcomes — every other location mentioned (e.g. "Hyderabad","Mumbai","Delhi NCR","Bangalore"); [] if none beyond the preferred
-- acceptable_countries: countries candidates are accepted from (e.g. "India"); [] if remote/worldwide with no restriction (empty = accept everyone)
-- exclude_companies: company names the JD rules out or wants candidates NOT to come from; [] if none
+- locations: EVERY city/location the JD names — the primary work cities AND every OTHER city it says candidates are "welcome" from, can "apply" from, or are otherwise acceptable; list them ALL, do not stop at the primary ones
+- acceptable_countries: countries candidates are accepted from — INFER from the work locations/cities and phrases like "outside <country>" (e.g. Indian cities such as Pune/Noida, or "outside India", ⇒ ["India"]); [] only if the role is truly remote/worldwide with no restriction
+- job_titles: 12-18 relevant titles the candidate may hold now or previously. START with the JD's EXACT posted title, verbatim. THEN add the role family for the JD's field — the adjacent job titles that do the same core work (for an ML/AI role these are e.g. AI Engineer, Machine Learning Engineer, Search Engineer, Ranking Engineer, Applied Scientist, Research Scientist, Research Engineer, Data Scientist, MLOps Engineer, Software Engineer; for a different field use THAT field's equivalent roles) — and ALWAYS include the role titles named after the JD's CORE activities (e.g. a search/ranking/retrieval JD ⇒ Search Engineer, Ranking Engineer, Information Retrieval Engineer) — plus seniority variants of the main role (e.g. "Senior <role>", "Staff <role>", "Principal <role>"). Full, real role titles only — no bare words; keep every title on-topic for this JD's work
 
 # Constraints & Guidelines
 - Output SHORT keywords for the list fields — not phrases or sentences.
+- SKILL RECALL IS THE PRIORITY: put EVERY concrete skill / tool / library / metric / technique / platform named
+  ANYWHERE in the JD (required OR preferred) into must_have_skills — the responsibilities and narrative as well
+  as the skills lists, not only the bullet headers. Missing a named skill is the worst error.
+- Expand any parenthetical, comma, or slash list into separate keywords — each named item becomes its own keyword.
 - Output EVERY key above; use [] for an empty list and a bare number for the years fields.
-- Be exhaustive for job_titles and must_have_skills.
 - Mode: output your immediate final answer with no reasoning, planning, or explanation.
 - Return ONLY the JSON object — no markdown fences and no text before or after it.
 
 # Output Format
-A single JSON object of exactly the keys above, e.g.:
-{"must_have_skills":["embeddings","Python"],"nice_to_have":[],"job_titles":["AI Engineer","ML Engineer"],"target_industries":["AI"],"education_fields":["Computer Science"],"certifications":[],"years_min":5,"years_max":9,"locations_preferred":["Pune"],"locations_acceptable":["Bangalore"],"acceptable_countries":["India"],"exclude_companies":[]}
+A single JSON object with EXACTLY the keys above — list fields as arrays of short keyword strings, the years
+fields as bare numbers. Shape only (the [...] are placeholders to fill from the JD, NOT values to copy):
+{"must_have_skills":[...],"education_fields":[...],"years_min":0,"years_max":0,"locations":[...],"acceptable_countries":[...],"job_titles":[...]}
 
 # Job Description
 {jd_text}
@@ -129,17 +129,24 @@ def _as_years(value: object, fallback: float) -> float:
 
 
 def _coerce_objective(parsed: dict[str, Any]) -> dict[str, Any] | None:
-    """Clean the objective object into the JDSpec-shaped dict; None if no role AND no skills (unusable)."""
+    """Clean the objective object into the JDSpec-shaped dict; None if no role AND no skills (unusable).
+
+    The compressed prompt emits a slimmer key set — all skills in ``must_have_skills`` (nice_to_have merged)
+    and a single ``locations`` (preferred+acceptable merged). The dropped keys (target_industries,
+    certifications, exclude_companies) default to [] here, so JDSpec and the funnel are unaffected. Older keys
+    are still read as a fallback.
+    """
+    locations = _as_str_list(parsed.get("locations")) or _as_str_list(parsed.get("locations_preferred"))
     objective = {
         "must_have_skills": _as_str_list(parsed.get("must_have_skills")),
-        "nice_to_have": _as_str_list(parsed.get("nice_to_have")),
+        "nice_to_have": _as_str_list(parsed.get("nice_to_have")),  # merged into must_have now; [] from the new prompt
         "job_titles": _as_str_list(parsed.get("job_titles")),
         "target_industries": _as_str_list(parsed.get("target_industries")),
         "education_fields": _as_str_list(parsed.get("education_fields")),
         "certifications": _as_str_list(parsed.get("certifications")),
         "years_min": _as_years(parsed.get("years_min"), 5.0),
         "years_max": _as_years(parsed.get("years_max"), 9.0),
-        "locations_preferred": _as_str_list(parsed.get("locations_preferred")),
+        "locations_preferred": locations,
         "locations_acceptable": _as_str_list(parsed.get("locations_acceptable")),
         "acceptable_countries": _as_str_list(parsed.get("acceptable_countries")),
         "exclude_companies": _as_str_list(parsed.get("exclude_companies")),
@@ -156,23 +163,58 @@ def _coerce_subjective(parsed: dict[str, Any]) -> dict[str, Any] | None:
 
 
 def _generate_json(
-    prompt: str, client: LlmClient, concern: str, max_tokens: int = 1024
+    prompt: str, client: LlmClient, concern: str, max_tokens: int = 1024, temperature: float = 0.0
 ) -> dict[str, Any] | None:
-    """One greedy (temp=0) generation → parsed JSON object; None on any failure."""
+    """One generation → parsed JSON object; None on any failure. temperature=0 ⇒ greedy/deterministic."""
     try:
-        raw_text = client.generate(prompt, system=_SYSTEM, temperature=0.0, max_tokens=max_tokens)
+        raw_text = client.generate(prompt, system=_SYSTEM, temperature=temperature, max_tokens=max_tokens)
     except Exception as failure:
         get_logger("jd").warning(f"jd.{concern}.failed", reason=type(failure).__name__)
         return None
     return _extract_json_object(raw_text)
 
 
-def extract_objective(jd_text: str, client: LlmClient) -> dict[str, Any] | None:
-    """CALL 1 — objective keyword bags + filter facts; None on failure / nothing usable."""
+def _skill_count(objective: dict[str, Any]) -> int:
+    """Total extracted skills (must_have + nice_to_have) — the recall measure best-of-N maximizes."""
+    return len(objective.get("must_have_skills", [])) + len(objective.get("nice_to_have", []))
+
+
+def extract_objective(
+    jd_text: str, client: LlmClient, *,
+    temperature: float | None = None, attempts: int | None = None, min_skills: int | None = None,
+) -> dict[str, Any] | None:
+    """CALL 1 — objective keyword bags + filter facts, with a best-of-N recall pass.
+
+    Samples the objective parse at ``temperature`` up to ``attempts`` times and KEEPS THE RICHEST result (most
+    skills), stopping early once ``min_skills`` is reached. A greedy temperature (0.0) collapses to a single
+    deterministic pass (identical samples), as does ``attempts=1``. Overrides fall back to the JD config.
+    Returns None on failure / nothing usable.
+    """
     if not jd_text.strip():
         return None
-    parsed = _generate_json(_OBJECTIVE_PROMPT.replace("{jd_text}", jd_text), client, "objective")
-    return _coerce_objective(parsed) if parsed is not None else None
+    from config import load_settings  # lazy import — keeps this module config/backend-free at import time
+
+    jd_cfg = load_settings().jd
+    temperature = jd_cfg.parse_temperature if temperature is None else temperature
+    attempts = jd_cfg.parse_attempts if attempts is None else attempts
+    min_skills = jd_cfg.min_skills if min_skills is None else min_skills
+    attempts = max(1, attempts) if temperature > 0 else 1  # greedy ⇒ identical samples ⇒ one pass only
+    prompt = _OBJECTIVE_PROMPT.replace("{jd_text}", jd_text)
+    log = get_logger("jd")
+
+    best: dict[str, Any] | None = None
+    for attempt in range(1, attempts + 1):
+        parsed = _generate_json(prompt, client, "objective", max_tokens=jd_cfg.parse_max_tokens, temperature=temperature)
+        objective = _coerce_objective(parsed) if parsed is not None else None
+        if objective is None:
+            continue
+        if best is None or _skill_count(objective) > _skill_count(best):
+            best = objective
+        log.info("jd.objective.sample", attempt=attempt, attempts=attempts,
+                 skills=_skill_count(objective), best=_skill_count(best), target=min_skills)
+        if _skill_count(best) >= min_skills:
+            break
+    return best
 
 
 def extract_subjective(jd_text: str, client: LlmClient) -> dict[str, Any] | None:

src/streamlit_app.py

@@ -206,17 +206,29 @@ def _jd_phases(settings: Settings, regenerate: bool) -> list[PhaseOutput]:
         started = time.perf_counter()
         subjective = extract_subjective(jd_text, client) or {}
         sum_seconds = time.perf_counter() - started
-        atomic_write_bytes(  # one combined artifact, same shape run_jd_parse writes (objective + subjective)
-            extraction_path, orjson.dumps({**objective, "subjective": subjective}, option=orjson.OPT_INDENT_2)
+        # Persist the measured parse time alongside the spec so cached runs can replay the ORIGINAL timing.
+        # ``_timing`` is inert to the engine (extract_spec/read_subjective only read the keys they know).
+        atomic_write_bytes(
+            extraction_path,
+            orjson.dumps(
+                {**objective, "subjective": subjective,
+                 "_timing": {"objective_seconds": obj_seconds, "summary_seconds": sum_seconds}},
+                option=orjson.OPT_INDENT_2,
+            ),
         )
         source = "live Qwen3 parse"
-    else:  # cached read — still a (fast) phase so it appears in the funnel timing
+    else:  # cached read — replay the original parse time recorded in the artifact (else the bare file-read time)
         started = time.perf_counter()
         raw = orjson.loads(extraction_path.read_bytes()) if extraction_path.exists() else {}
-        obj_seconds = time.perf_counter() - started
+        read_seconds = time.perf_counter() - started
         raw = raw if isinstance(raw, dict) else {}
         subjective = raw.pop("subjective", {}) or {}
-        objective, sum_seconds, source = raw, 0.0, "cached jd_extraction.json"
+        timing = raw.pop("_timing", {}) or {}
+        objective = raw
+        obj_seconds = float(timing.get("objective_seconds", read_seconds))
+        sum_seconds = float(timing.get("summary_seconds", 0.0))
+        source = ("cached jd_extraction.json (original parse time)" if timing
+                  else "cached jd_extraction.json (no recorded time — tick Regenerate to time the live parse)")
 
     model = settings.models.index_gen_llm_repo
     obj_inputs = {

tests/test_jd.py

@@ -4,9 +4,24 @@ from __future__ import annotations
 
 from pathlib import Path
 
+import orjson
+
 from config import JdSettings, Settings
 from jd import extract_spec
-from jd.parse import _coerce_objective, _coerce_subjective, _extract_json_object
+from jd.parse import _coerce_objective, _coerce_subjective, _extract_json_object, extract_objective
+
+
+class _StubClient:
+    """A no-model LlmClient stand-in: returns a scripted JSON string per call (records call count)."""
+
+    def __init__(self, skill_lists: list[list[str]]) -> None:
+        self._skill_lists, self.calls = skill_lists, 0
+
+    def generate(self, prompt: str, system: str | None = None, temperature: float = 0.0,
+                 top_p: float = 0.95, max_tokens: int = 512, think: bool = False) -> str:
+        skills = self._skill_lists[min(self.calls, len(self._skill_lists) - 1)]
+        self.calls += 1
+        return "noise " + orjson.dumps({"job_titles": ["AI Engineer"], "must_have_skills": skills}).decode() + " end"
 
 
 def _settings(extraction_path: Path) -> Settings:
@@ -51,3 +66,24 @@ def test_coerce_objective_and_subjective() -> None:
     subjective = _coerce_subjective({"ideal_summary": "Senior AI Engineer with 7 years"})
     assert subjective == {"ideal_summary": "Senior AI Engineer with 7 years"}  # only the one field
     assert _coerce_subjective({"ideal_traits": ["x"]}) is None  # no ideal_summary → unusable
+
+
+def test_extract_objective_best_of_n_keeps_richest() -> None:
+    # two samples: the second is richer → best-of-N keeps it (and draws both since min_skills not reached)
+    client = _StubClient([["python"], ["python", "retrieval", "ranking", "embeddings"]])
+    objective = extract_objective("a real JD body", client, temperature=0.5, attempts=2, min_skills=99)
+    assert objective is not None
+    assert objective["must_have_skills"] == ["python", "retrieval", "ranking", "embeddings"]
+    assert client.calls == 2  # both samples drawn
+
+
+def test_extract_objective_early_stops_at_min_skills() -> None:
+    client = _StubClient([["a", "b", "c"]])
+    extract_objective("jd", client, temperature=0.5, attempts=5, min_skills=3)
+    assert client.calls == 1  # reached the skill target on the first sample → stop early
+
+
+def test_extract_objective_greedy_is_single_pass() -> None:
+    client = _StubClient([["a"]])
+    extract_objective("jd", client, temperature=0.0, attempts=5, min_skills=99)
+    assert client.calls == 1  # temperature 0 ⇒ identical samples ⇒ one pass regardless of attempts