halo-agent 2.0.2 → 2.0.4

package/detectFormErrors.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/**
+ * Post-submit form-error detector.
+ *
+ * The agent clicks Submit. Most ATSes (Greenhouse, Lever, Ashby, modern
+ * Workday) DON'T redirect on validation failure — they render inline:
+ *   - red banner at the top
+ *   - the failing field gets aria-invalid="true" + a class like .error
+ *   - a sibling/child element gets the literal text "This field is required"
+ *     or "Missing entry for ..."
+ *
+ * Firecrawl's verify-submit can detect these via LLM extract, but:
+ *   1. It's an external API round-trip (~3-8s)
+ *   2. It sometimes returns null when the page is JS-heavy or behind login
+ *   3. The DOM has this info FOR FREE, no LLM needed, in <100ms
+ *
+ * This module is the deterministic ground truth: walk the DOM, return a
+ * list of fields the form is currently complaining about. The orchestrator
+ * uses this to know whether to retry, regardless of what Firecrawl says.
+ *
+ * Output:
+ *   {
+ *     hasErrors:    boolean,
+ *     errorBanner:  string|null,       // top-level "form needs corrections" text
+ *     invalidFields: [{                // one per highlighted field
+ *       label, selector, mmid?, errorText
+ *     }],
+ *   }
+ */
+
+const FIELD_ERROR_PATTERNS = [
+  /is\s*required/i,
+  /this\s*field\s*is\s*required/i,
+  /missing\s*entry/i,
+  /please\s*(enter|select|fill|provide)/i,
+  /required\s*field/i,
+  /cannot\s*be\s*blank/i,
+  /^required$/i,
+];
+
+const BANNER_PATTERNS = [
+  /form\s*needs\s*corrections/i,
+  /please\s*correct/i,
+  /there\s*(was|were)\s*(an?|some)\s*errors?/i,
+  /please\s*review/i,
+];
+
+async function detectFormErrors(page) {
+  return await page.evaluate(({ fieldPatterns, bannerPatterns }) => {
+    const fp = fieldPatterns.map((s) => new RegExp(s.source, s.flags));
+    const bp = bannerPatterns.map((s) => new RegExp(s.source, s.flags));
+
+    function visibleText(el) {
+      if (!el) return '';
+      // Only count text from visible elements
+      const rect = el.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) return '';
+      const t = (el.innerText || el.textContent || '').trim();
+      if (!t) return '';
+      return t.replace(/\s+/g, ' ').slice(0, 300);
+    }
+
+    function nearestLabel(el) {
+      // Strategy ladder for finding a field's human label:
+      //   1. <label for=id>
+      //   2. el.labels
+      //   3. aria-labelledby chain
+      //   4. parent's label/legend/h*
+      //   5. fallback to name / id
+      if (el.id) {
+        const lbl = document.querySelector(`label[for="${el.id}"]`);
+        if (lbl) return visibleText(lbl).replace(/\*$/, '').trim();
+      }
+      if (el.labels && el.labels[0]) return visibleText(el.labels[0]).replace(/\*$/, '').trim();
+      const al = el.getAttribute('aria-labelledby');
+      if (al) {
+        const t = al.split(/\s+/).map((id) => document.getElementById(id)).filter(Boolean).map(visibleText).join(' ').trim();
+        if (t) return t;
+      }
+      let p = el.parentElement; let hops = 0;
+      while (p && hops < 6) {
+        const lbl = p.querySelector('label, legend, h3, h4');
+        if (lbl && !lbl.contains(el)) {
+          const t = visibleText(lbl).replace(/\*$/, '').trim();
+          if (t && t.length < 200) return t;
+        }
+        p = p.parentElement;
+        hops += 1;
+      }
+      return el.getAttribute('aria-label') || el.placeholder || el.name || el.id || '(unknown)';
+    }
+
+    function bestSelector(el) {
+      const mmid = el.getAttribute('mmid');
+      if (mmid) return { mmid, selector: `[mmid="${mmid}"]` };
+      if (el.id) return { selector: `#${CSS.escape(el.id)}` };
+      if (el.name) return { selector: `[name="${CSS.escape(el.name)}"]` };
+      return { selector: '' };
+    }
+
+    // 1. Top-level error banner — used for the log + the NEEDS_ATTENTION reason.
+    let errorBanner = null;
+    const bannerCandidates = document.querySelectorAll('[role="alert"], .error-banner, [class*="error-message"], [class*="form-error"], [class*="errors"]');
+    for (const b of bannerCandidates) {
+      const t = visibleText(b);
+      if (!t) continue;
+      if (bp.some((r) => r.test(t)) || t.length > 30) {
+        errorBanner = t.slice(0, 300);
+        break;
+      }
+    }
+
+    // 2. Per-field flags. Three independent signals — union them:
+    //    a. aria-invalid="true" set by the form's validator
+    //    b. ancestor/sibling has the literal text "is required" near a field
+    //    c. element matches a CSS error class
+    const invalidFields = [];
+    const seenMmids = new Set();
+
+    function addField(el, errorText) {
+      if (!el) return;
+      const sel = bestSelector(el);
+      const key = sel.mmid || sel.selector || el.outerHTML.slice(0, 80);
+      if (seenMmids.has(key)) return;
+      seenMmids.add(key);
+      invalidFields.push({
+        label: nearestLabel(el).slice(0, 200),
+        mmid: sel.mmid || null,
+        selector: sel.selector || null,
+        errorText: (errorText || 'flagged').slice(0, 200),
+      });
+    }
+
+    // Signal A: aria-invalid="true" — the cleanest, most reliable. Filter
+    // to actual inputs (not random divs).
+    document.querySelectorAll('[aria-invalid="true"]').forEach((el) => {
+      const tag = el.tagName.toLowerCase();
+      if (!['input', 'textarea', 'select'].includes(tag) && !el.isContentEditable && el.getAttribute('role') !== 'combobox') return;
+      // Find the error text near this field (sibling or descendant of parent)
+      let errTxt = '';
+      const parent = el.closest('div, fieldset, label, section');
+      if (parent) {
+        const errEl = parent.querySelector('[class*="error"], [class*="invalid"], [role="alert"]');
+        if (errEl && !errEl.contains(el)) errTxt = visibleText(errEl);
+      }
+      addField(el, errTxt || 'aria-invalid');
+    });
+
+    // Signal B: text-pattern walk. Any element containing required-pattern
+    // text → find the nearest fillable sibling/ancestor input. This catches
+    // Greenhouse's `<div class="application-error">Phone is required</div>`.
+    const allText = Array.from(document.querySelectorAll('div, span, p, small, li, label'));
+    for (const el of allText) {
+      const t = visibleText(el);
+      if (!t || t.length > 200) continue;
+      if (!fp.some((r) => r.test(t))) continue;
+      // Don't double-count error containers we already matched
+      if (el.querySelector('[aria-invalid="true"]')) continue;
+      // Find the nearest input by walking up + querying down
+      let cursor = el; let found = null; let hops = 0;
+      while (cursor && hops < 5 && !found) {
+        const parent = cursor.parentElement;
+        if (!parent) break;
+        found = parent.querySelector('input:not([type=hidden]), textarea, select, [contenteditable="true"], [role="combobox"]');
+        cursor = parent; hops += 1;
+      }
+      if (found) addField(found, t);
+    }
+
+    // Signal C: CSS error classes on the input itself. Some ATSes mark
+    // the input directly rather than the wrapper.
+    document.querySelectorAll('input[class*="error"], input[class*="invalid"], select[class*="error"], textarea[class*="error"]').forEach((el) => {
+      addField(el, 'has-error-class');
+    });
+
+    return {
+      hasErrors: errorBanner !== null || invalidFields.length > 0,
+      errorBanner,
+      invalidFields,
+    };
+  }, {
+    fieldPatterns: FIELD_ERROR_PATTERNS.map((r) => ({ source: r.source, flags: r.flags })),
+    bannerPatterns: BANNER_PATTERNS.map((r) => ({ source: r.source, flags: r.flags })),
+  });
+}
+
+module.exports = { detectFormErrors };

package/orchestrator.js

@@ -13,6 +13,7 @@ const path = require('path');
 const fs = require('fs');
 const { fillFields: legacyFillFields, uploadFile, findNextButton, findSubmitButton, waitForStableDOM, snapshotFieldLabels } = require('./filler');
 const { smartFillPage } = require('./smartFill');
+const { detectFormErrors } = require('./detectFormErrors');
 
 // Switchable filler — smart by default, can be killed via config.useSmartFill=false.
 // smartFill.js internally falls back to legacyFillFields if /smartfill/plan-fill
@@ -452,15 +453,90 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     });
     await submitBtn.click();
 
-    // Wait for confirmation page
+    // Wait for confirmation page OR for the form to render validation errors.
+    // Race the URL redirect against a stable-DOM wait — whichever resolves
+    // first tells us what happened. URL redirect → success path. Stable
+    // DOM (no redirect) → either validation error or in-page confirmation.
     try {
-      await page.waitForURL(/thank|confirm|success|applied|submitted/i, { timeout: 15000 });
+      await Promise.race([
+        page.waitForURL(/thank|confirm|success|applied|submitted/i, { timeout: 12000 }),
+        waitForStableDOM(page, 4000),
+      ]);
     } catch {
-      await page.waitForTimeout(3000); // fallback wait
+      await page.waitForTimeout(2000);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // DOM-side error detection. The page IS the ground truth — Firecrawl
+    // is a second opinion at best, and unavailable at worst. If the page
+    // tells us right now that fields are invalid, retry IMMEDIATELY
+    // without waiting on Firecrawl.
+    //
+    // Bounded to ONE retry via ctx.submitRetryAttempted so we never
+    // infinite-loop on a truly stuck form.
+    // ─────────────────────────────────────────────────────────────────────
+    const errors = await detectFormErrors(page).catch(() => ({ hasErrors: false, errorBanner: null, invalidFields: [] }));
+    if (errors.hasErrors && !ctx.submitRetryAttempted) {
+      ctx.submitRetryAttempted = true;
+      const errFieldList = errors.invalidFields.map((f) => f.label).slice(0, 6).join(' / ') || '(banner only)';
+      console.warn(`[orchestrator] Form has ${errors.invalidFields.length} validation error(s): ${errFieldList}`);
+      if (errors.errorBanner) console.warn(`[orchestrator]   banner: ${errors.errorBanner.slice(0, 200)}`);
+
+      await reportStatus('IN_PROGRESS', {
+        step: 'RETRY_FILL',
+        step_detail: `Form rejected: ${errors.errorBanner ? errors.errorBanner.slice(0, 80) : errFieldList.slice(0, 80)} — retrying`,
+      });
+
+      // Re-fill: smartFillPage will re-scan, so the planner sees the
+      // currently-invalid fields (aria-invalid="true" propagates into
+      // AX state, and the per-field error text becomes part of the
+      // description). Bounded retry.
+      try {
+        await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
+        await waitForStableDOM(page, 1500);
+        const retrySubmitBtn = await findSubmitButton(page);
+        if (retrySubmitBtn) {
+          console.log('[orchestrator] Retry: clicking submit again...');
+          await retrySubmitBtn.click();
+          try {
+            await Promise.race([
+              page.waitForURL(/thank|confirm|success|applied|submitted/i, { timeout: 10000 }),
+              waitForStableDOM(page, 3000),
+            ]);
+          } catch { await page.waitForTimeout(2000); }
+        } else {
+          console.warn('[orchestrator] Retry: submit button gone (form may have navigated).');
+        }
+      } catch (e) {
+        console.warn(`[orchestrator] Retry pass threw: ${e.message}`);
+      }
+    } else if (errors.hasErrors) {
+      // Already retried once; another error means the user has to step in.
+      console.warn(`[orchestrator] Form errors persist after retry: ${errors.invalidFields.length} field(s)`);
     }
 
     const confirmScreenshot = await page.screenshot({ type: 'jpeg', quality: 70 });
-    const confirmKey = await uploadScreenshot(config, confirmScreenshot, `confirm_${queueId}.jpg`);
+    let confirmKey = await uploadScreenshot(config, confirmScreenshot, `confirm_${queueId}.jpg`);
+
+    // After retry: if the page STILL has errors, short-circuit to
+    // NEEDS_ATTENTION without bothering Firecrawl. We know it's broken.
+    const errorsAfter = ctx.submitRetryAttempted
+      ? await detectFormErrors(page).catch(() => ({ hasErrors: false, invalidFields: [], errorBanner: null }))
+      : { hasErrors: false, invalidFields: [], errorBanner: null };
+    if (errorsAfter.hasErrors) {
+      const reason = errorsAfter.errorBanner
+        || `${errorsAfter.invalidFields.length} field(s) still invalid: ${errorsAfter.invalidFields.map((f) => f.label).slice(0, 4).join(', ')}`;
+      console.warn(`[orchestrator] Submission rejected after retry: ${reason}`);
+      await reportStatus('NEEDS_ATTENTION', {
+        review_screenshot_r2_key: confirmKey || null,
+        needs_attention_reason: `Submit rejected by form: ${reason}`,
+        intervention_type: 'submit_failed',
+        step: 'VERIFY',
+        step_detail: reason.slice(0, 200),
+        fields_filled: cumulativeFilled,
+      });
+      throw new Error(`Submission rejected: ${reason}`);
+    }
 
     // Verify-then-DONE: trusting waitForURL alone was wrong (the Chalk bug —
     // Ashby rendered "Missing entry for required field: Name, Email, ..."
@@ -491,11 +567,17 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     //                     screenshot — never silently mark DONE on
     //                     unverified submits (that was the Chalk bug).
     if (verdict.submitted === false) {
-      const reason = verdict.error_message || 'Submission did not confirm — form may still have errors';
-      console.warn(`[orchestrator] Submission NOT verified. Reason: ${reason}`);
+      // The DOM-error pass above already retried + short-circuited if errors
+      // remained. If we got here AND Firecrawl is saying false, the DOM was
+      // clean (no aria-invalid / no banner / no "is required" text) but
+      // Firecrawl still detected something wrong — probably a thank-you
+      // page that includes some apologetic text the LLM misread. Surface
+      // it gently rather than throwing; user can audit the screenshot.
+      const reason = verdict.error_message || 'Firecrawl could not confirm submission';
+      console.warn(`[orchestrator] Firecrawl says NOT submitted (DOM looked clean): ${reason}`);
       await reportStatus('NEEDS_ATTENTION', {
         review_screenshot_r2_key: confirmKey || null,
-        needs_attention_reason: `Submit clicked but Ashby/ATS rejected it: ${reason}`,
+        needs_attention_reason: `Verifier flagged this submit: ${reason}. Page DOM looked clean — please eyeball.`,
         intervention_type: 'submit_failed',
         step: 'VERIFY',
         step_detail: reason.slice(0, 200),
@@ -504,35 +586,55 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       throw new Error(`Submission failed verification: ${reason}`);
     }
 
+    // Decide final state (DONE / REVIEWING) based on verifier verdict +
+    // auto-submit, but DO NOT return — the audit-trail postFillSession
+    // call at the bottom of this block runs for every terminal state so
+    // the user's receipt detail always has resume PDF + cover letter PDF +
+    // per-field decisions.
+    let finalState = 'DONE';
     if (verdict.submitted === null) {
-      // EARLIER VERSION: when auto-submit was ON, we trusted the click and
-      // marked DONE. That was wrong — it produced false-positive submissions
-      // (applied=true in DB, no actual application sent). Auto-submit means
-      // "don't make me click Submit on the dashboard" — it does NOT mean
-      // "lie about delivery."
-      //
-      // Honest behavior: unverified == REVIEWING regardless of auto-submit.
-      // The screenshot is right there in the dashboard, one click confirms.
-      // Better to over-ask than to ghost-apply.
-      console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). REVIEWING — please eyeball the screenshot + click Submit.`);
+      const autoSubmit = config.autoSubmit || aep.agent_config?.auto_submit;
+      if (autoSubmit) {
+        // Auto-submit ON + verifier unavailable: trust the click; the
+        // screenshot becomes the audit trail.
+        console.log(`[orchestrator] Verifier unavailable (source: ${verdict.source}); auto-submit ON — trusting click, screenshot is the receipt.`);
+      } else {
+        // No auto-submit → REVIEWING so the user eyeballs first.
+        console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). REVIEWING — please eyeball the screenshot + click Submit.`);
+        finalState = 'REVIEWING';
+      }
+    }
+
+    if (finalState === 'REVIEWING') {
       await reportStatus('REVIEWING', {
         review_screenshot_r2_key: confirmKey || null,
         step: 'REVIEWING',
         step_detail: `Submit clicked at ${verdictUrl.slice(0, 100)} — verifier unavailable, please confirm`,
         fields_filled: cumulativeFilled,
       });
-      return;
+    } else {
+      await reportStatus('DONE', {
+        confirmation_screenshot_r2_key: confirmKey || null,
+        fields_filled: cumulativeFilled,
+      });
+      await clearCheckpoint(config, queueId);
+      const verifiedTag = verdict.source === 'firecrawl' ? 'firecrawl-verified'
+        : verdict.source === 'url_pattern' ? 'url-pattern-verified'
+        : 'unverified-but-auto-submit';
+      console.log(`[orchestrator] Done (${verifiedTag}): ${queueItem.company} - ${queueItem.title}`);
     }
 
-    await reportStatus('DONE', {
-      confirmation_screenshot_r2_key: confirmKey || null,
-      fields_filled: cumulativeFilled,
-    });
-    await clearCheckpoint(config, queueId);
-
-    console.log(`[orchestrator] Done (verified): ${queueItem.company} - ${queueItem.title} · firecrawl-verified`);
-
-    // Post fill session data to backend for learning loop
+    // Post fill session data to backend for learning loop + receipt audit
+    // trail. filled_actions becomes the per-field decision list the user
+    // sees on Applications detail — "agent typed X for First Name because
+    // facts.identity.first_name", etc. Truncated to keep payload sane on
+    // long forms.
+    const filledActions = Array.from(ctx.answeredFields.entries()).slice(0, 80).map(([label, data]) => ({
+      label: String(label).slice(0, 200),
+      action: 'filled',
+      value: String(data?.value || '').slice(0, 500),
+      source: data?.source || '',
+    }));
     await postFillSession(config, {
       job_id: jobId,
       ats_type: ats_type || 'unknown',
@@ -540,6 +642,11 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       fields_filled: cumulativeFilled,
       skipped_fields: ctx.skippedFields,
       conditional_fields: ctx.conditionalTriggers,
+      filled_actions: filledActions,
+      // Pass through which actual files were uploaded — backend writes to
+      // submissions.resume_pdf_r2_key / cover_letter_pdf_r2_key for receipt.
+      resume_pdf_r2_key: aep?.recommended_resume?.pdf_r2_key || null,
+      cover_letter_pdf_r2_key: aep?.cover_letter_pdf?.pdf_r2_key || null,
     }).catch(() => {}); // non-critical
 
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {
@@ -24,6 +24,7 @@
     "scanPage.js",
     "scanAccessibility.js",
     "smartFill.js",
+    "detectFormErrors.js",
     "captcha.js",
     "vision.js",
     "manusAutomate.js",

package/scanAccessibility.js

@@ -253,8 +253,17 @@ async function enrichFromDom(page, axFields) {
       if (el.id) selectorHint = `#${cssEscape(el.id)}`;
       else if (el.name) selectorHint = `${tag}[name="${el.name.replace(/"/g, '\\"')}"]`;
 
-      // Current value (skip already-filled)
-      const currentValue = (el.value || (isContentEditable ? safeText(el.innerText) : '') || '').trim();
+      // Current value (used for filledAlready detection downstream).
+      // SPECIAL CASE for checkboxes/radios: their .value attribute defaults
+      // to "on" even when UNCHECKED. Using that as a "filled" signal
+      // silently skipped Reddit's required consent checkbox. Check .checked
+      // instead — that's the only honest signal of state.
+      let currentValue = '';
+      if (type === 'checkbox' || type === 'radio') {
+        currentValue = el.checked ? 'checked' : '';
+      } else {
+        currentValue = (el.value || (isContentEditable ? safeText(el.innerText) : '') || '').trim();
+      }
 
       // Native <select> options
       let options = null;

package/smartFill.js

@@ -196,11 +196,93 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
  * Falls back to LLM synonym matching when local exact/substring
  * matching fails, so "Straight" still picks "Heterosexual."
  */
+/**
+ * Special-case intl-tel-input country picker. The Country field on
+ * Greenhouse forms isn't a normal dropdown — it's an <input type=tel>
+ * with a sibling .iti__selected-flag button. Clicking the input does
+ * NOTHING; you have to click the flag to open the list, then click the
+ * matching .iti__country list item.
+ *
+ * Returns null if this isn't an intl-tel-input field; otherwise the
+ * fill result.
+ */
+async function tryIntlTelCountry(page, triggerLocator, value) {
+  try {
+    // Is this field wrapped by an .iti container?
+    const wrap = await triggerLocator.evaluate((el) => {
+      const c = el.closest('.iti, .iti--allow-dropdown');
+      return c ? { has: true } : null;
+    }).catch(() => null);
+    if (!wrap) return null;
+
+    // Click the flag button to open the country list. There's only one
+    // active flag per .iti wrapper.
+    const flag = await triggerLocator.evaluateHandle((el) => {
+      const c = el.closest('.iti, .iti--allow-dropdown');
+      return c?.querySelector('.iti__selected-flag, [aria-label*="country" i]') || null;
+    });
+    if (!flag || !(await flag.evaluate((n) => !!n).catch(() => false))) return null;
+    await flag.click({ timeout: 1500 }).catch(async () => {
+      // Some intl-tel versions need force-click because the flag is
+      // positioned absolute under the input
+      await flag.click({ force: true, timeout: 1500 }).catch(() => {});
+    });
+    await page.waitForTimeout(400);
+
+    // Find the country whose name OR dial code matches `value`. Strip
+    // "+1" / parens for matching ("United States +1" → "United States").
+    const v = String(value).toLowerCase().replace(/\s*\+\d+\s*$/, '').trim();
+    const items = page.locator('.iti__country-list:visible .iti__country, .iti__dropdown-content .iti__country');
+    const count = await items.count().catch(() => 0);
+    if (count === 0) {
+      // Country list never opened
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: 'intl-tel country list did not open' };
+    }
+    // Collect the country names to find the right one
+    const names = await items.evaluateAll((nodes) => nodes.map((n) => {
+      const nm = n.querySelector('.iti__country-name')?.textContent?.trim() || '';
+      const dial = n.querySelector('.iti__dial-code')?.textContent?.trim() || '';
+      return { name: nm, dial };
+    })).catch(() => []);
+    let idx = names.findIndex((n) => n.name.toLowerCase() === v);
+    if (idx === -1) idx = names.findIndex((n) => n.name.toLowerCase().includes(v) || v.includes(n.name.toLowerCase()));
+    if (idx === -1) {
+      // Try matching by dial code (e.g. "+1")
+      const dialMatch = String(value).match(/\+(\d+)/);
+      if (dialMatch) idx = names.findIndex((n) => n.dial === `+${dialMatch[1]}`);
+    }
+    if (idx === -1) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: `no intl-tel country matched "${value}"` };
+    }
+    await items.nth(idx).click({ timeout: 1500 }).catch(async () => {
+      await items.nth(idx).click({ force: true, timeout: 1500 });
+    });
+    return { ok: true, reason: `intl-tel picked: ${names[idx].name} ${names[idx].dial}` };
+  } catch (e) {
+    return { ok: false, reason: `intl-tel handler threw: ${e.message}` };
+  }
+}
+
 async function openAndPickOption(page, triggerLocator, value, llmCtx) {
+  try {
+    // First: intl-tel-input special case. The Country dial-code picker on
+    // Greenhouse is a non-standard widget that ignores clicks to its
+    // input — has to click the flag button. tryIntlTelCountry returns
+    // null when the field isn't intl-tel, so other dropdowns continue.
+    const itlResult = await tryIntlTelCountry(page, triggerLocator, value);
+    if (itlResult !== null) return itlResult;
+  } catch {}
+
   try {
     // Snapshot option-list state BEFORE opening so we can identify
-    // the new options.
-    const optionSel = '[role="option"], [role="menuitem"], .select__option, li[class*="option"]';
+    // the new options. Includes:
+    //   .pac-item       — Google Places (Greenhouse Location)
+    //   .iti__country   — intl-tel-input (Greenhouse Country dial-code)
+    //   .select__option — React-Select
+    //   role=option     — ARIA-correct dropdowns
+    const optionSel = '[role="option"], [role="menuitem"], .select__option, li[class*="option"], .pac-item, .iti__country';
     const beforeCount = await page.locator(optionSel).count().catch(() => 0);
 
     await triggerLocator.click({ timeout: 2500 });
@@ -333,12 +415,35 @@ async function typeAndPickSuggestion(page, locator, value) {
     await locator.press('Delete').catch(() => {});
     const firstChunk = String(value).split(/[,;]/)[0].trim();
     await page.keyboard.type(firstChunk, { delay: 60 });
-    await page.waitForTimeout(700);
-    const optionSel = '[role="option"], [role="listbox"] li, .select__option, ul[class*="autocomplete"] li';
+    // Wait for suggestions to render. Google Places PAC takes longer than
+    // most (~800ms-1.2s), so wait a bit more aggressively before giving up.
+    await page.waitForTimeout(900);
+    // Selector ladder — Google Places (.pac-item) uses no role attribute,
+    // so we ADD it to the union. Without this, Greenhouse Location always
+    // failed because its dropdown is .pac-container > .pac-item.
+    const optionSel = [
+      '.pac-item',                        // Google Places (Greenhouse Location)
+      '[role="option"]',                  // ARIA-correct dropdowns
+      '[role="listbox"] li',              // older listbox conventions
+      '[role="listbox"] [role="option"]', // nested
+      '.select__option',                  // React-Select
+      'ul[class*="autocomplete"] li',     // generic autocomplete
+      'ul[class*="suggestion"] li',
+      'div[class*="suggestion"]',
+    ].join(', ');
+    // Wait for ANY option to actually appear (some libs lazy-render). Up
+    // to 1.5s additional. waitFor errors if nothing appears — that's the
+    // signal that the field accepted free text instead.
+    try {
+      await page.locator(optionSel).first().waitFor({ state: 'visible', timeout: 1500 });
+    } catch {
+      const got = await locator.inputValue({ timeout: 800 }).catch(() => null);
+      if (got && got.trim()) return { ok: true, reason: `typeahead (no suggestion, accepted): "${value.slice(0, 30)}"` };
+      return { ok: false, reason: 'typeahead opened no suggestions' };
+    }
     const opts = page.locator(optionSel);
     const count = await opts.count().catch(() => 0);
     if (count === 0) {
-      // Some fields accept the typed value directly. Verify.
       const got = await locator.inputValue({ timeout: 800 }).catch(() => null);
       if (got && got.trim()) return { ok: true, reason: `typeahead (no suggestion, accepted): "${value.slice(0, 30)}"` };
       return { ok: false, reason: 'typeahead opened no suggestions' };
@@ -348,7 +453,10 @@ async function typeAndPickSuggestion(page, locator, value) {
     let idx = texts.findIndex((t) => t.toLowerCase().trim() === v);
     if (idx === -1) idx = texts.findIndex((t) => t.toLowerCase().trim().startsWith(v));
     if (idx === -1) idx = 0;
-    await opts.nth(idx).click({ timeout: 2000 });
+    // Google Places PAC items have a quirky click handler that doesn't fire
+    // on Playwright's normal click — use force-click as fallback.
+    try { await opts.nth(idx).click({ timeout: 2000 }); }
+    catch { await opts.nth(idx).click({ force: true, timeout: 2000 }); }
     await page.waitForTimeout(200);
     return { ok: true, reason: `typeahead picked: ${texts[idx]}` };
   } catch (e) {