feat(ats): AUTO_AGGRESSIVE mode + risk severity levels

Automate the common case, pause only for genuinely risky terms.

- candidate_fit.severity: LOW_RISK_AUTO_INCLUDED / MEDIUM_RISK_REVIEW_RECOMMENDED
/ HIGH_RISK_NEEDS_CONFIRMATION / BLOCKED_DO_NOT_INCLUDE. Helpers auto_terms()
(LOW+MEDIUM) and high_risk_terms().
- Generation: LOW+MEDIUM auto-included (weave/skills/repair all gated to exclude
HIGH+BLOCKED); MEDIUM flags REVIEW_RECOMMENDED. HIGH never auto-woven — a job
that NEEDS them for 90 -> NEEDS_USER_INPUT with the terms listed; else ships
clean without claiming them.
- config.AUTOMATION: automation_mode, review_policy, download_policy.
- Download allowed for READY_90_PLUS + REVIEW_RECOMMENDED (no manual accept
needed); blocked otherwise.

Verified (real resume): 6 PM JDs -> READY CLEAN downloadable; security PM ->
NEEDS_USER_INPUT (confirm SIEM/SOAR, independent 66 without them); backend ->
NEEDS_USER_INPUT/WEAK (independent 81); 12yr -> NEEDS_REPAIR (seniority).
Anti-cheat: security tooling NOT auto-claimed. All 3 suites pass.

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

HISTORY.md

@@ -4,6 +4,38 @@ A running log of everything built, fixed, and changed. Most recent first.
 
 ---
 
+## 2026-06-19 (8) — AUTO_AGGRESSIVE mode + risk severity levels
+
+Goal: a 100-job batch runs mostly hands-off — automate the common case, pause
+only for genuinely risky terms.
+
+- **Risk severity** (`candidate_fit.severity`): every term → LOW_RISK_AUTO_INCLUDED
+  / MEDIUM_RISK_REVIEW_RECOMMENDED / HIGH_RISK_NEEDS_CONFIRMATION /
+  BLOCKED_DO_NOT_INCLUDE. LOW = common PM/product/analytics/agile craft, normal
+  tools/responsibilities/soft. MEDIUM = domain/industry terms & plausible tools
+  not in the base resume. HIGH = specialized platforms (SIEM/SOAR), compliance/
+  regulatory, engineering hard skills, seniority-sensitive. BLOCKED = creds/
+  licenses/fakes/seniority-jumps/deep specialties.
+- **AUTO_AGGRESSIVE generation**: LOW+MEDIUM auto-included everywhere (weaving,
+  skills, repair); MEDIUM flags REVIEW_RECOMMENDED. HIGH-risk terms are NEVER
+  auto-woven — if a job NEEDS them to hit 90 it pauses as NEEDS_USER_INPUT and
+  lists them for confirmation; otherwise it ships clean without claiming them.
+- **config.AUTOMATION**: `automation_mode="auto_aggressive"`, `review_policy`
+  (low→auto, medium→auto+flag, high→ask_user, blocked→exclude), `download_policy`
+  (READY/REVIEW allow, everything else block).
+- Download stays allowed for READY_90_PLUS and REVIEW_RECOMMENDED (no manual
+  accept/reject needed); blocked for WEAK/NEEDS_INPUT/LOW_FIT/PARSE_FAILED.
+
+### Verified (real resume, deterministic)
+6 in-domain PM JDs → READY_90_PLUS CLEAN (0 risk terms, downloadable). Security
+PM → NEEDS_USER_INPUT (independent 66 without security tooling; 7 HIGH terms to
+confirm) — matches the spec's "Cybersecurity PM → confirm SIEM/SOAR" example.
+Backend-eng → NEEDS_USER_INPUT/WEAK (independent 81). Sr-Director-12y →
+NEEDS_REPAIR (seniority fails). Anti-cheat: security tooling NOT auto-claimed
+(auto-claimed=[]). All three regression suites pass.
+
+---
+
 ## 2026-06-19 (7) — Anti-circular validation: independent scorer + anti-cheat
 
 Addressed the key risk: the 90%+ could be the internal scorer agreeing with our

config.py

@@ -182,6 +182,30 @@ ASSESSMENT = {
     "test_jobs_limit":          10,    # Max jobs in test mode
 }
 
+# ── Resume automation policy (AUTO_AGGRESSIVE) ─────────────────────────────────
+# Controls how aggressively plausible JD terms are auto-included and which
+# resumes are downloadable, so a 100-job batch runs mostly hands-off.
+AUTOMATION = {
+    "automation_mode": "auto_aggressive",
+    # What to do per risk severity (see candidate_fit.severity):
+    "review_policy": {
+        "LOW_RISK_AUTO_INCLUDED":          "auto_include",
+        "MEDIUM_RISK_REVIEW_RECOMMENDED":  "auto_include_with_review_flag",
+        "HIGH_RISK_NEEDS_CONFIRMATION":    "ask_user",
+        "BLOCKED_DO_NOT_INCLUDE":          "exclude",
+    },
+    # Which statuses are downloadable:
+    "download_policy": {
+        "READY_90_PLUS":                    "allow",
+        "READY_90_PLUS_REVIEW_RECOMMENDED": "allow_with_warning",
+        "WEAK_90_INTERNAL_ONLY":            "block",
+        "NEEDS_REPAIR":                     "block",
+        "NEEDS_USER_INPUT":                 "block",
+        "NOT_ELIGIBLE_LOW_FIT":             "block",
+        "PARSE_FAILED":                     "block",
+    },
+}
+
 # ── ever-jobs integration ─────────────────────────────────────────────────────
 from src.ever_jobs_bridge.platforms import INDIA_DEFAULT_PLATFORMS
 

scripts/verify_90_pipeline.py

@@ -53,8 +53,12 @@ for jf, co in JOBS:
     status = job.get("_v2_status", "")
     jd_m, rd = sc.get("jd_match", 0), sc.get("ats_readability", 0)
     print(f"{jf:<16}{status:<34}{jd_m:>4}{rd:>6}")
+    # AUTO_AGGRESSIVE: a security PM JD reaches 90 on PM craft alone (security
+    # tooling is HIGH-risk and not auto-claimed) → READY is fine; if PM craft
+    # alone can't hit 90 it pauses as NEEDS_USER_INPUT. Either is acceptable.
     if jf == "sumo_logic_pm":
-        ok = ok and (jd_m >= 90 and status == "READY_90_PLUS_REVIEW_RECOMMENDED")
+        ok = ok and (status in ("READY_90_PLUS", "READY_90_PLUS_REVIEW_RECOMMENDED",
+                                 "NEEDS_USER_INPUT"))
     else:
         ok = ok and (jd_m >= 90 and rd >= 90 and status == "READY_90_PLUS")
 

scripts/verify_anticheat.py

@@ -68,13 +68,17 @@ check("internal >= 90", internal >= 90, f"internal={internal}")
 check("independent >= 90", indep >= 90, f"independent={indep}")
 check("download allowed", job.get("download_allowed") is True)
 
-print("2. Cybersecurity PM -> review flagged:")
+print("2. Cybersecurity PM -> security tooling is HIGH-risk (confirm), not auto-faked:")
 jd, job, r = gen("sumo_logic_pm", "Sec")
-check("security terms flagged for review",
-      any(t.lower() in ("siem", "soar", "xdr", "secops", "threat intelligence",
-                        "threat detection", "security operations")
-          for t in r.get("review_terms_for_user_review", [])),
-      str(r.get("review_terms_for_user_review", []))[:80])
+_sec = ("siem", "soar", "xdr", "secops", "threat intelligence",
+        "threat detection", "security operations")
+_high = [t.lower() for t in r.get("high_risk_terms_for_confirmation", [])]
+check("security terms classified HIGH-risk (need confirmation)",
+      any(t in _high for t in _sec), str(_high)[:90])
+parsed_sec = _read_docx_text(os.path.join(rc.output_dir, "Sec.docx")).lower()
+auto_claimed = [t for t in _sec if t in parsed_sec]
+check("security tooling NOT auto-claimed in resume (HIGH not auto-included)",
+      not auto_claimed, f"auto-claimed={auto_claimed}")
 
 print("3. Backend-engineer JD must NOT be CLEAN_90_PLUS for a PM:")
 jd, job, r = gen("backend_engineer", "Backend")

src/candidate_fit.py

@@ -223,6 +223,45 @@ def classify_all_fit(req: JDRequirements, base_resume_text: str,
             for r in req.all_requirements()]
 
 
+# ── Risk severity (AUTO_AGGRESSIVE mode) ─────────────────────────────────────
+
+LOW = "LOW_RISK_AUTO_INCLUDED"
+MEDIUM = "MEDIUM_RISK_REVIEW_RECOMMENDED"
+HIGH = "HIGH_RISK_NEEDS_CONFIRMATION"
+BLOCKED = "BLOCKED_DO_NOT_INCLUDE"
+
+
+def severity(v: FitVerdict) -> str:
+    """Map a fit verdict to a risk severity level.
+
+    LOW    — common PM/product/business/analytics/agile terms, normal tools,
+             normal responsibilities, soft skills, anything already in the resume.
+    MEDIUM — domain/industry terms & plausible tools not in the base resume
+             (auto-include but flag for review).
+    HIGH   — specialized platforms (SIEM/SOAR), compliance/regulatory terms,
+             engineering hard skills, seniority-sensitive, credential-required
+             (only used with explicit user confirmation).
+    BLOCKED— degrees/certs/licenses/fakes/seniority jumps/deep specialties.
+    """
+    if v.action == "block":
+        return BLOCKED
+    if v.action in ("ask_user", "include_carefully"):
+        # specialized-domain / engineering / credential / regulatory → confirm
+        return HIGH
+    # action == include
+    if v.fit_status == "explicit":
+        return LOW
+    if v.category == "domain":
+        return MEDIUM
+    if v.fit_status == "adjacent":
+        return MEDIUM
+    return LOW   # plausible common PM craft / tools / methods / soft skills
+
+
+def by_severity(verdicts: List[FitVerdict], level: str) -> List[FitVerdict]:
+    return [v for v in verdicts if severity(v) == level]
+
+
 # ── Convenience splits for the tailoring engine ──────────────────────────────
 
 def includable(verdicts: List[FitVerdict]) -> List[FitVerdict]:
@@ -230,6 +269,16 @@ def includable(verdicts: List[FitVerdict]) -> List[FitVerdict]:
     return [v for v in verdicts if v.action == "include"]
 
 
+def auto_terms(verdicts: List[FitVerdict]) -> List[FitVerdict]:
+    """AUTO_AGGRESSIVE: LOW + MEDIUM are auto-included (MEDIUM flags review)."""
+    return [v for v in verdicts if severity(v) in (LOW, MEDIUM)]
+
+
+def high_risk_terms(verdicts: List[FitVerdict]) -> List[FitVerdict]:
+    """HIGH — only included with user confirmation; gate the job if needed for 90."""
+    return [v for v in verdicts if severity(v) == HIGH]
+
+
 def review_terms(verdicts: List[FitVerdict]) -> List[FitVerdict]:
     """risky → include only when needed for 90%, flagged for user review."""
     return [v for v in verdicts if v.action == "include_carefully"]

src/resume_customizer.py

@@ -1288,56 +1288,53 @@ class ResumeCustomizer:
         # being woven into bullets as "skills".
         from .ats_scorer import (
             extract_jd_keywords as _ext_kw, _kw_in_text as _kw_check,
+            _is_taxonomy_skill as _istax,
+        )
+        from .jd_analyzer import analyze_jd as _analyze_jd
+        from .candidate_fit import (
+            classify_all_fit, auto_terms as _auto_terms,
+            high_risk_terms as _high_terms, severity as _severity,
+            MEDIUM as _MED, HIGH as _HIGH, BLOCKED as _BLK,
         )
         try:
+            jd_low = jd_text.lower()
+            base_text = base_resume.to_flat_text()
+
+            # ── Candidate Fit Expansion (AUTO_AGGRESSIVE) — classify FIRST so we
+            # never weave HIGH-risk / blocked terms anywhere. The uploaded resume
+            # is a BASE PROFILE: auto-include LOW+MEDIUM (MEDIUM flags review);
+            # HIGH-risk (specialized platforms/compliance/engineering/seniority)
+            # are gated; BLOCKED (creds/fakes/seniority-jumps) excluded.
+            req_struct = _analyze_jd(jd_text)
+            fit_verdicts = classify_all_fit(req_struct, base_text)
+            _excluded_kw = {v.keyword.lower() for v in fit_verdicts
+                            if _severity(v) in (_HIGH, _BLK)}
+
+            # 2b. Weave AUTO (LOW+MEDIUM) JD keywords missing from the resume into
+            # bullets — never the HIGH-risk / blocked ones.
             jd_kw = _ext_kw(jd_text)
             for kw in assessed_kw or []:
                 if kw and kw.lower() not in jd_kw:
                     jd_kw.append(kw.lower())
             flat = tailored.to_flat_text().lower()
-            missing = [k for k in jd_kw if not _kw_check(k, flat)]
+            missing = [
+                k for k in jd_kw
+                if not _kw_check(k, flat)
+                and len(k) >= 3
+                and not (len(k) >= 5 and k.endswith(("at", "iz", "ic")))
+                and k.lower() not in self._BUZZWORDS
+                and k.lower() not in self._KEYWORD_BLOCKLIST
+                and k.lower() not in _excluded_kw
+            ]
             if missing:
-                # Smart fill (user directive): weave EVERY meaningful JD keyword
-                # into bullets where relevant — not just a narrow allowlist.
-                # These already passed extract_jd_keywords' meaningful filter
-                # (real nouns/skills, no prose/locations/company names). We only
-                # additionally drop lemmatizer artifacts and vague BUZZWORDS that
-                # real checkers penalise. The blocklist still removes known
-                # company/prose terms.
-                missing = [
-                    k for k in missing
-                    if len(k) >= 3
-                    and not (len(k) >= 5 and k.endswith(("at", "iz", "ic")))
-                    and k.lower() not in self._BUZZWORDS
-                    and k.lower() not in self._KEYWORD_BLOCKLIST
-                ]
-                if missing:
-                    self._weave_keywords_into_bullets(tailored, missing, jd_text)
-
-            # ── Candidate Fit Expansion (aggressive_plausible_match) ─────────
-            # The uploaded resume is a BASE PROFILE, not the full truth. Include
-            # every JD term that is plausible for the candidate's role/seniority
-            # (explicit + plausible + adjacent). RISKY domain terms (e.g. SIEM/
-            # SOAR for a non-security PM) are held back for the repair loop and
-            # flag the resume REVIEW_RECOMMENDED. Truly unsafe terms (regulated
-            # credentials, deep-tech specialties, seniority jumps) are BLOCKED.
-            from .ats_scorer import _is_taxonomy_skill as _istax
-            from .jd_analyzer import analyze_jd as _analyze_jd
-            from .candidate_fit import (
-                classify_all_fit, includable as _includable,
-                review_terms as _review_terms,
-            )
-            jd_low = jd_text.lower()
-            base_text = base_resume.to_flat_text()
+                self._weave_keywords_into_bullets(tailored, missing, jd_text)
 
-            req_struct = _analyze_jd(jd_text)
-            fit_verdicts = classify_all_fit(req_struct, base_text)
-            # Seniority signals ("7 years", "Director") are NOT skills — never
-            # list them (injecting a tenure claim would game the seniority check).
-            include_pool = [v.keyword for v in _includable(fit_verdicts)
-                            if v.category != "seniority"]
-            review_pool = [v.keyword for v in _review_terms(fit_verdicts)
-                           if v.category != "seniority"]
+            _auto_v = [v for v in _auto_terms(fit_verdicts) if v.category != "seniority"]
+            include_pool = [v.keyword for v in _auto_v]
+            medium_set = {v.keyword.lower() for v in _auto_v if _severity(v) == _MED}
+            high_pool = [v.keyword for v in _high_terms(fit_verdicts)
+                         if v.category != "seniority"]
+            review_pool = []   # HIGH terms are gated, not auto-woven
 
             # LLM jd_skills that are real JD terms (broadens to AI-checker breadth)
             for s in (tailored_dict.get("jd_skills") or []):
@@ -1429,16 +1426,21 @@ class ResumeCustomizer:
                 # ── Repair. Priority: terms that are MISSING entirely, then
                 # terms present only in Skills (weave THOSE into bullets so they
                 # become evidenced and the independent score rises).
-                missing = list(report.get("missing_terms", []))
-                skills_only = list(report.get("skills_only_terms", []))
+                # AUTO_AGGRESSIVE: never add/weave HIGH-risk or blocked terms.
+                _excl = locals().get("_excluded_kw", set())
+                missing = [t for t in report.get("missing_terms", [])
+                           if t.lower() not in _excl]
+                skills_only = [t for t in report.get("skills_only_terms", [])
+                               if t.lower() not in _excl]
                 cur = {s.lower() for s in tailored.skills}
-                add = [t for t in (missing + review_pool + include_pool)
-                       if t.lower() not in cur]
-                if any(t in review_pool for t in add):
+                add = [t for t in (missing + include_pool)
+                       if t.lower() not in cur and t.lower() not in _excl]
+                # Flag review if any MEDIUM-severity term gets included.
+                med_added = [t for t in add if t.lower() in medium_set]
+                if med_added:
                     review_used = True
                     self._review_terms_used = list(dict.fromkeys(
-                        getattr(self, "_review_terms_used", []) +
-                        [t for t in add if t in review_pool]))
+                        getattr(self, "_review_terms_used", []) + med_added))
                 # Weave evidence into bullets: missing must-haves + skills-only
                 # terms (the latter directly lifts the independent score).
                 weave_now = [t for t in (skills_only + missing)
@@ -1457,19 +1459,24 @@ class ResumeCustomizer:
                 jm = report["estimated_scores"]["jd_match"]
                 rd = report["estimated_scores"]["ats_readability"]
                 ind = val.independent_jd_match
-                weak = [w.lower() for w in report.get("weak_matches", [])]
-                ask = [a.lower() for a in report.get("needs_user_input", [])]
-                credential_blocked = bool(weak) and all(w in ask for w in weak)
                 if not valid:
                     status = PARSE_FAILED
                 elif jm >= 90 and rd >= 90 and ind >= 90:
                     status = READY_REVIEW if review_used else READY
                 elif jm < 55 or ind < 55:
                     status = LOW_FIT
-                elif credential_blocked:
-                    status = NEEDS_USER_INPUT
                 else:
-                    status = NEEDS_REPAIR
+                    # Below 90 with LOW+MEDIUM only. Would the HIGH-risk terms
+                    # (specialized platforms/compliance/engineering the candidate
+                    # must CONFIRM) close the gap? If so, pause for the user.
+                    needs_high = False
+                    if high_pool:
+                        from .ats_scoring_v2 import score_jd_match as _sjm
+                        synth = parsed + "\n" + " . ".join(high_pool)
+                        if _sjm(synth, req_struct).score >= 90:
+                            needs_high = True
+                    status = NEEDS_USER_INPUT if needs_high else NEEDS_REPAIR
+                    report["high_risk_terms_for_confirmation"] = high_pool
         except Exception as e:
             print(f"[repair-loop] {e}")
             try:
@@ -1541,6 +1548,10 @@ class ResumeCustomizer:
             report["download_allowed"] = download_allowed
             report["repair_attempts"] = repair_attempts
             report["review_terms_for_user_review"] = review_list
+            # HIGH-risk terms the candidate could confirm to strengthen further
+            # (not auto-claimed). Always surfaced for transparency.
+            report.setdefault("high_risk_terms_for_confirmation",
+                              locals().get("high_pool", []))
             job["_v2_report"] = report
             job["_v2_status"] = status
             job["quality_flag"] = quality