Parallel LLM radio picks + Workable early resume upload

Parallel radio LLM picks (form_filler.py):
  Pre-scan all radio groups needing LLM before the fill loop and run
  them concurrently with asyncio.gather. Previously 8 YES/NO qualification
  questions × ~2s sequential = ~16s; now all run in parallel = ~2-3s.
  The fill loop reads from the pre-built cache; cache misses fall back to
  a direct call so correctness is preserved.

Workable early resume upload (form_prefill.py):
  When ATS is Workable, upload the resume before fill_form runs. Workable
  processes the PDF and auto-populates name, email, work history, and
  education fields. A 3s wait after upload lets the pre-fill settle before
  the field scanner re-runs. This avoids manually filling fields that
  Workable would have filled from the resume anyway.

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

Author: mcherif

utils/form_filler.py

@@ -360,6 +360,38 @@ def _log(msg: str) -> None:
     # Build DOM context for anonymous fields once (expensive JS call).
     context_map = await _build_context_map(page, fields)
 
+    # Pre-scan all radio groups that will need an LLM pick and run them in
+    # parallel BEFORE the fill loop starts.  Sequential LLM calls (one per
+    # group) are the dominant cost for qualification YES/NO questions (8 groups
+    # × ~2 s each = 16 s sequential vs ~2-3 s parallel).
+    _radio_llm_cache: dict[str, str | None] = {}
+    if not dry_run:
+        from utils.form_answers import pick_option as _pick_opt_pre
+        _pre_handled: set[str] = set()
+        _pending_picks: list[tuple[str, str, list[str]]] = []  # (group_key, question, options)
+        for _pi, _pf in enumerate(fields):
+            if _pf.get("type") != "radio":
+                continue
+            _pgk = _pf.get("name") or f"radio-group-{_pi}"
+            if _pgk in _pre_handled:
+                continue
+            _pre_handled.add(_pgk)
+            _pgfs = [f for f in fields if f.get("type") == "radio"
+                     and (f.get("name") == _pf.get("name") if _pf.get("name") else f is _pf)]
+            _popts = [_effective_label(f, context_map.get(fields.index(f), "")).lower()
+                      for f in _pgfs]
+            _plbl = _effective_label(_pf, context_map.get(_pi, "")).lower()
+            if _pick_radio(_popts, _plbl, profile, job) is None:
+                _pdisp = context_map.get(_pi, _pgk) or _pgk
+                _pending_picks.append((_pgk, _pdisp, _popts))
+        if _pending_picks:
+            _llm_results = await asyncio.gather(
+                *[_pick_opt_pre(q, opts, profile, job) for _, q, opts in _pending_picks],
+                return_exceptions=True,
+            )
+            for (_pgk, _, _), _res in zip(_pending_picks, _llm_results):
+                _radio_llm_cache[_pgk] = None if isinstance(_res, Exception) else _res  # type: ignore[assignment]
+
     # Phone number: if the form has a separate country/country-code field, fill
     # only the local number in the phone field; otherwise use the full
     # international number (country code + local).
@@ -584,14 +616,17 @@ def _is_anonymous_text(f: dict) -> bool:
             group_display = context_map.get(idx, group_key) or group_key
 
             # LLM fallback for radio groups that no rule matched.
+            # Results are pre-fetched in parallel above (_radio_llm_cache).
             if chosen is None and not dry_run and option_labels:
                 try:
-                    from utils.form_answers import pick_option as _pick_opt
-                    _log(
-                        f'LLM picking radio for "{(group_display or label_lower)[:60]}"')
-                    chosen_text = await _pick_opt(
-                        group_display or label_lower, option_labels, profile, job
-                    )
+                    chosen_text = _radio_llm_cache.get(group_key)
+                    if chosen_text is None:
+                        # Cache miss (shouldn't normally happen) — fall back to direct call.
+                        from utils.form_answers import pick_option as _pick_opt
+                        _log(f'LLM picking radio for "{(group_display or label_lower)[:60]}"')
+                        chosen_text = await _pick_opt(
+                            group_display or label_lower, option_labels, profile, job
+                        )
                     if chosen_text:
                         chosen_lower = chosen_text.lower()
                         for i, opt in enumerate(option_labels):

utils/form_prefill.py

@@ -913,6 +913,20 @@ def _log(msg: str) -> None:
         except Exception:
             pass
 
+    # Workable pre-fill: upload resume first so Workable auto-populates
+    # name, email, work history, etc. before we fill remaining fields.
+    if result.get("ats") == "workable" and fields:
+        try:
+            _log("Workable detected — uploading resume first to enable profile pre-fill…")
+            early = await try_upload_resume(fill_target, profile, job, log_fn=_log)
+            _log(f"Early resume upload: {early}")
+            if early and "uploaded" in early:
+                _log("Waiting for Workable to process resume pre-fill…")
+                await fill_target.wait_for_timeout(3000)
+                fields, fill_target = await _scan_with_frame_fallback(page)
+        except Exception as exc:
+            _log(f"Early Workable resume upload error: {exc}")
+
     cl_file_uploaded = False
     resume_uploaded = False
     if fields: