halo-agent 2.0.3 → 2.0.5

package/detectFormErrors.js

@@ -0,0 +1,231 @@
+'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();
+
+    // CRITICAL: only flag fields that are ACTUALLY empty. Otherwise we
+    // get a cascade of false positives — Greenhouse marks every required
+    // field's LABEL red after a failed submit (visual highlight), and the
+    // text-pattern walk matches "First Name is required" near a perfectly-
+    // filled First Name field. That triggered the retry to re-touch fields
+    // that didn't need fixing, which is how Gender went from Male → Female
+    // and Ethnicity East Asian → South Asian.
+    function isEmptyField(el) {
+      const tag = el.tagName.toLowerCase();
+      const type = (el.type || '').toLowerCase();
+      // Checkboxes / radios: empty means !checked.
+      if (type === 'checkbox' || type === 'radio') return !el.checked;
+      // Native select: empty value or selected option is the placeholder.
+      if (tag === 'select') {
+        if (!el.value) return true;
+        const selOpt = el.options[el.selectedIndex];
+        // A select whose first option is "Select..." with empty value AND
+        // that option is selected → empty.
+        if (selOpt && !selOpt.value) return true;
+        return false;
+      }
+      // File inputs: empty means files.length === 0.
+      if (type === 'file') return !el.files || el.files.length === 0;
+      // contenteditable: empty when innerText is whitespace.
+      if (el.isContentEditable) return !(el.innerText || '').trim();
+      // Combobox role with no inner input (custom dropdown trigger): look
+      // for the displayed value via aria-activedescendant or innerText.
+      if (el.getAttribute('role') === 'combobox') {
+        const v = (el.value || el.innerText || '').trim();
+        // Empty AND no chip/pill rendered as a sibling means truly empty.
+        const wrap = el.closest('[class*="select"], [class*="combobox"]');
+        const chip = wrap?.querySelector('[class*="chip"], [class*="multi-value"], [class*="tag"]');
+        if (chip && (chip.innerText || '').trim()) return false;
+        return !v;
+      }
+      // Plain inputs / textareas
+      return !(el.value || '').trim();
+    }
+
+    function addField(el, errorText) {
+      if (!el) return;
+      // Skip fields that are already filled — they're not the cause of
+      // the form rejection even if their label happens to be near
+      // required-text styling.
+      if (!isEmptyField(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,16 +453,91 @@ 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 });
     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, ..."
     // inline without a URL change, and we marked DONE on a failed submit).
@@ -491,68 +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}`);
-
-      // Fill-validate-retry: when the page shows inline validation errors
-      // (red banners + highlighted fields), the right move is to rescan +
-      // re-plan + fix + re-submit ONCE. Most validation failures are
-      // recoverable: a missed required checkbox, an empty optional field
-      // that turned out to be required, an LLM picked a too-creative answer.
-      // Bounded to ONE retry to prevent infinite loops on truly stuck forms.
-      const alreadyRetried = !!ctx.submitRetryAttempted;
-      if (!alreadyRetried) {
-        console.log('[orchestrator] Attempting fill-validate-retry: re-scanning page for highlighted errors...');
-        ctx.submitRetryAttempted = true;
-        await reportStatus('IN_PROGRESS', {
-          step: 'RETRY_FILL',
-          step_detail: `ATS rejected: ${reason.slice(0, 100)} — fixing & retrying`,
-        });
-        // Re-fill. The new scan will pick up red-highlighted required fields
-        // (their AX 'invalid' or 'required' state will tell the planner to
-        // re-attempt them). Already-filled correct fields stay put.
-        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 page.waitForURL(/thank|confirm|success|applied|submitted/i, { timeout: 12000 }); } catch { await page.waitForTimeout(2500); }
-            // Re-verify
-            const retryUrl = page.url();
-            const retryShot = await page.screenshot({ type: 'jpeg', quality: 70 }).catch(() => null);
-            const retryShotKey = retryShot ? await uploadScreenshot(config, retryShot, `confirm_retry_${queueId}.jpg`) : confirmKey;
-            let retryVerdict = { submitted: null, error_message: null, source: 'unavailable' };
-            try {
-              const rRes = await fetch(`${config.apiUrl}/agent/verify-submit`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.token}` },
-                body: JSON.stringify({ queue_id: queueId, page_url: retryUrl }),
-              });
-              if (rRes.ok) retryVerdict = await rRes.json();
-            } catch {}
-            if (retryVerdict.submitted === true) {
-              await reportStatus('DONE', { confirmation_screenshot_r2_key: retryShotKey || null, fields_filled: cumulativeFilled });
-              await clearCheckpoint(config, queueId);
-              console.log(`[orchestrator] Done (retry-after-validation-error): ${queueItem.company} - ${queueItem.title}`);
-              return;
-            }
-            // Retry verifier also unsure — fall through to NEEDS_ATTENTION with both screenshots
-            console.warn(`[orchestrator] Retry verdict: ${retryVerdict.submitted}; source=${retryVerdict.source}`);
-            confirmKey = retryShotKey || confirmKey;
-          } else {
-            console.warn('[orchestrator] Retry: no submit button visible after re-fill — page may have navigated.');
-          }
-        } catch (e) {
-          console.warn(`[orchestrator] Retry pass threw: ${e.message}`);
-        }
-      }
-
-      // No retry available (or retry didn't succeed) — surface for human.
+      // 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 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),
@@ -561,44 +586,44 @@ 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) {
       const autoSubmit = config.autoSubmit || aep.agent_config?.auto_submit;
       if (autoSubmit) {
-        // Auto-submit ON + verifier unavailable: trust the click AND make
-        // the screenshot the audit trail. The receipt detail surfaces this
-        // screenshot prominently — if it shows a red banner, the user
-        // clicks "Not submitted" on the receipt and we re-queue.
-        // This is the user-chosen policy: false-positives surface visually,
-        // not as a blocked REVIEWING row. Faster loop, audit by eyeball.
+        // 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.`);
-        await reportStatus('DONE', {
-          confirmation_screenshot_r2_key: confirmKey || null,
-          fields_filled: cumulativeFilled,
-          step: 'DONE',
-          step_detail: 'Submitted (verifier unavailable, trust-on-click)',
-        });
-        await clearCheckpoint(config, queueId);
-        return;
+      } 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';
       }
-      // No auto-submit → bounce to REVIEWING so the user eyeballs first.
-      console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). REVIEWING — please eyeball the screenshot + click Submit.`);
+    }
+
+    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 + receipt audit
     // trail. filled_actions becomes the per-field decision list the user
     // sees on Applications detail — "agent typed X for First Name because

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "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

@@ -429,6 +429,20 @@ async function scanAccessibility(page) {
     const label = pickLabel(f);
     // Filter noise: no label AND no visible role → skip
     if (!label && !['button', 'link'].includes(normalizeRole(f))) continue;
+    // Filter out the "Remove X" chip-clear buttons that React-Select
+    // renders next to selected items in multi-select dropdowns. The
+    // planner was treating these as separate fields and "filling" them
+    // (clicking them, which DELETED the correct answer) on the retry
+    // pass — that's how Gender flipped Male → Female on retry. Same for
+    // the X button that clears a single-select's value.
+    if (normalizeRole(f) === 'button' && (
+      /^remove\s+\S/i.test(label) ||
+      /^clear\s+selection/i.test(label) ||
+      /^remove\s+item/i.test(label) ||
+      label === '×' || label === '✕' || label === 'x'
+    )) {
+      continue;
+    }
     out.push({
       mmid: f.mmid,
       role: normalizeRole(f),

package/smartFill.js

@@ -196,11 +196,145 @@ 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 {
+    // Detect intl-tel-input by looking for ANY characteristic class within
+    // a reasonable ancestor radius. Newer versions (v18+) shifted from
+    // .iti to .iti--allow-dropdown / .iti-mobile, plus they may wrap
+    // in .country-select instead. Scan up to 6 ancestors.
+    const probe = await triggerLocator.evaluate((el) => {
+      let p = el; let hops = 0;
+      while (p && hops < 6) {
+        const cls = String(p.className || '');
+        if (/\biti\b|\biti--|country-select|country-picker/i.test(cls)) {
+          // Found the wrapper. Find the flag/trigger inside.
+          const flag = p.querySelector(
+            '.iti__selected-flag, .iti__country-container, ' +
+            '[class*="selected-flag"], [class*="country-button"], ' +
+            '[aria-haspopup="listbox"][class*="iti"], ' +
+            'button[class*="country"]'
+          );
+          return { found: true, wrapperOuterClass: cls.slice(0, 200), hasFlag: !!flag };
+        }
+        p = p.parentElement; hops += 1;
+      }
+      return { found: false };
+    }).catch(() => ({ found: false }));
+    if (!probe.found) return null;
+
+    // Click the flag/trigger element to open the country list.
+    const flag = await triggerLocator.evaluateHandle((el) => {
+      let p = el; let hops = 0;
+      while (p && hops < 6) {
+        const cls = String(p.className || '');
+        if (/\biti\b|\biti--|country-select|country-picker/i.test(cls)) {
+          return p.querySelector(
+            '.iti__selected-flag, .iti__country-container, ' +
+            '[class*="selected-flag"], [class*="country-button"], ' +
+            '[aria-haspopup="listbox"][class*="iti"], ' +
+            'button[class*="country"]'
+          ) || null;
+        }
+        p = p.parentElement; hops += 1;
+      }
+      return null;
+    });
+    if (!flag || !(await flag.evaluate((n) => !!n).catch(() => false))) {
+      return { ok: false, reason: `intl-tel wrapper found (${probe.wrapperOuterClass}) but no flag button inside` };
+    }
+    await flag.click({ timeout: 1500 }).catch(async () => {
+      await flag.click({ force: true, timeout: 1500 }).catch(() => {});
+    });
+    await page.waitForTimeout(500);
+
+    // Country items — try several known class patterns
+    const itemSel = '.iti__country-list:visible .iti__country, .iti__dropdown-content .iti__country, [class*="country-list"] [class*="country-item"], [role="listbox"] [role="option"][class*="iti"]';
+    const items = page.locator(itemSel);
+    const count = await items.count().catch(() => 0);
+    if (count === 0) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: `intl-tel country list did not open (wrapper=${probe.wrapperOuterClass})` };
+    }
+    const v = String(value).toLowerCase().replace(/\s*\+\d+\s*$/, '').trim();
+    const names = await items.evaluateAll((nodes) => nodes.map((n) => {
+      const nm = n.querySelector('.iti__country-name, [class*="country-name"]')?.textContent?.trim()
+        || (n.getAttribute('data-country-name') || '').trim()
+        || (n.textContent || '').replace(/\+\d+/, '').trim();
+      const dial = n.querySelector('.iti__dial-code, [class*="dial-code"]')?.textContent?.trim()
+        || (n.getAttribute('data-dial-code') ? `+${n.getAttribute('data-dial-code')}` : '');
+      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) {
+      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}" (${count} items)` };
+    }
+    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 {}
+
+  // Second: Google Places typeahead. The Greenhouse Location field is
+  // marked role=combobox in AX, so the planner sends click_option — but
+  // it's really a type-then-pick autocomplete that opens a .pac-container
+  // mounted at document.body (NOT inside the field's wrapper). Detect
+  // by checking for adjacent "Locate me" UI or for an existing pac-container.
+  try {
+    const isPac = await triggerLocator.evaluate((el) => {
+      // Heuristic 1: a "Locate me" link/button nearby (Greenhouse-specific)
+      const ancestor = el.closest('div, section, fieldset') || el.parentElement;
+      const hasLocateMe = ancestor && Array.from(ancestor.querySelectorAll('a, button')).some((b) => /locate\s*me/i.test(b.textContent || ''));
+      // Heuristic 2: a pac-container is mounted somewhere on the page
+      const hasPacContainer = !!document.querySelector('.pac-container, .pac-target-input');
+      // Heuristic 3: the input itself is a pac-target-input (Google sets this when initialized)
+      const isPacInput = el.classList?.contains('pac-target-input');
+      return hasLocateMe || hasPacContainer || isPacInput;
+    }).catch(() => false);
+    if (isPac) {
+      const r = await typeAndPickSuggestion(page, triggerLocator, value);
+      // If typeahead failed, fall through to the normal dropdown path
+      // (some fields are both, weirdly)
+      if (r.ok) return r;
+    }
+  } 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 +467,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 +505,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) {