halo-agent 1.3.4 → 1.3.6

package/filler.js

@@ -259,7 +259,7 @@ async function uploadFile(page, triggerSelector, filePath) {
  *
  * Returns true if fill succeeded.
  */
-async function fillLocator(page, locator, value, label) {
+async function fillLocator(page, locator, value, label, dropdownCtx = null) {
   if (!value) return false;
 
   try {
@@ -271,7 +271,35 @@ async function fillLocator(page, locator, value, label) {
       isContentEditable: el.isContentEditable,
       hasOptions: el.tagName === 'SELECT',
       optionCount: el.tagName === 'SELECT' ? el.options.length : 0,
-    })).catch(() => ({ tag: 'input', type: 'text', role: '', isContentEditable: false, hasOptions: false, optionCount: 0 }));
+      // Typeahead heuristics: any of these signals means "type then pick a
+      // suggestion." Greenhouse Location, Lever City, Workday locations all
+      // use this pattern — a plain text input that mounts a <ul role=listbox>
+      // of city matches as you type. Plain .fill() leaves the field
+      // visually populated but React clears it on blur because no
+      // suggestion was committed.
+      isTypeahead: !!(
+        el.getAttribute('aria-autocomplete') === 'list' ||
+        el.getAttribute('aria-autocomplete') === 'both' ||
+        el.getAttribute('aria-haspopup') === 'listbox' ||
+        el.getAttribute('aria-haspopup') === 'true' ||
+        el.getAttribute('autocomplete') === 'off' && el.getAttribute('aria-expanded') !== null ||
+        // Greenhouse + Lever wrap their typeahead in role=combobox parent
+        el.closest('[role="combobox"]') ||
+        // "Locate me" sibling button is a strong Greenhouse Location signal
+        Array.from((el.closest('div') || el.parentElement || document).querySelectorAll('button, a')).some(b => /locate\s*me/i.test(b.textContent || ''))
+      ),
+    })).catch(() => ({ tag: 'input', type: 'text', role: '', isContentEditable: false, hasOptions: false, optionCount: 0, isTypeahead: false }));
+
+    // ── Typeahead text input (Greenhouse Location, Lever City) ──
+    // Check BEFORE the generic combobox path so a plain <input> with
+    // typeahead-flagged ancestors still gets the type-then-pick treatment
+    // (those inputs aren't role=combobox themselves).
+    if (meta.isTypeahead && (meta.tag === 'input' || meta.tag === 'textarea')) {
+      const ok = await fillTypeahead(page, locator, value);
+      if (ok) return true;
+      // Fall through to default text-input path if typeahead pick failed —
+      // some forms accept the typed value even without selecting a suggestion.
+    }
 
     // ── Native <select> ──
     if (meta.tag === 'select' || meta.hasOptions) {
@@ -293,13 +321,50 @@ async function fillLocator(page, locator, value, label) {
         );
         if (fuzzy) ok = await locator.selectOption(fuzzy.v).then(() => true).catch(() => false);
       }
+      // 5. AI synonym pick — "Straight" → "Heterosexual", "Asian" →
+      // "South Asian" etc. We hand the LLM the user's literal answer
+      // plus the EXACT option list and let it pick the equivalent.
+      if (!ok && dropdownCtx && opts.length > 0) {
+        try {
+          const optionTexts = opts.map(o => o.t).filter(Boolean);
+          const res = await fetch(`${dropdownCtx.config.apiUrl}/smartfill/field-answer`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${dropdownCtx.config.token}` },
+            body: JSON.stringify({
+              job_id: dropdownCtx.jobId,
+              field_label: label || '',
+              field_type: 'select',
+              options: optionTexts,
+              previously_answered: [{ label: 'user intent', value: String(value) }],
+            }),
+          });
+          if (res.ok) {
+            const { value: picked } = await res.json();
+            if (picked && picked !== 'SKIP') {
+              const pickedV = picked.toLowerCase().trim();
+              const match = opts.find(o => o.t.toLowerCase().trim() === pickedV)
+                || opts.find(o => o.t.toLowerCase().includes(pickedV) || pickedV.includes(o.t.toLowerCase()));
+              if (match) {
+                ok = await locator.selectOption(match.v).then(() => true).catch(() => false);
+                if (ok) console.log(`[filler] AI-picked select: "${label}" "${value}" → "${match.t}"`);
+              }
+            }
+          }
+        } catch (e) {
+          console.warn(`[filler] AI native-select pick failed for "${label}": ${e.message}`);
+        }
+      }
       return ok;
     }
 
     // ── Custom dropdown / combobox (React Select, Ashby, Lever custom selects) ──
     if (meta.role === 'combobox' || meta.role === 'listbox' ||
         meta.tag === 'div' || meta.tag === 'button') {
-      return await fillCustomDropdown(page, locator, value);
+      return await fillCustomDropdown(page, locator, value, dropdownCtx ? {
+        config: dropdownCtx.config,
+        jobId: dropdownCtx.jobId,
+        label,
+      } : {});
     }
 
     // ── Radio group (native) ──
@@ -362,49 +427,144 @@ async function fillLocator(page, locator, value, label) {
  * Strategy: click trigger → wait for option list → find closest matching option → click it.
  * Handles React Select, Ashby custom select, Lever, Greenhouse custom dropdowns.
  */
-async function fillCustomDropdown(page, triggerLocator, value) {
+/**
+ * Type-and-pick handler for autocomplete/typeahead inputs (Greenhouse
+ * Location, Lever City, Workday location pickers). Strategy:
+ *
+ *   1. Click the input to focus
+ *   2. Clear any existing text
+ *   3. Type the value SLOWLY, character-by-character (suggestions fire
+ *      on each keystroke; typing too fast can race the network)
+ *   4. Wait for a listbox/option container to render
+ *   5. Pick the best matching option (exact > startsWith > first)
+ *   6. Verify the input now shows a committed value
+ *
+ * Returns false if no suggestion list appears — caller can fall back to
+ * a plain fill.
+ */
+async function fillTypeahead(page, locator, value) {
+  try {
+    await locator.click({ timeout: 2000 });
+    // Clear via select-all + delete (more reliable than .fill('') for
+    // autocompletes that have their own state)
+    await locator.press('Meta+A').catch(() => locator.press('Control+A')).catch(() => {});
+    await locator.press('Delete').catch(() => {});
+    // Type the FIRST PART (city name only) — typing "San Francisco, CA"
+    // when the typeahead expects "San Francisco" can suppress matches.
+    const firstChunk = String(value).split(/[,;]/)[0].trim();
+    await page.keyboard.type(firstChunk, { delay: 60 });
+    // Wait briefly for suggestions to render
+    await page.waitForTimeout(700);
+    // Look for a listbox / option container — multiple common patterns
+    const optionSel = [
+      '[role="option"]',
+      '[role="listbox"] li',
+      '[role="listbox"] [role="option"]',
+      '[class*="option"][class*="select"]',
+      '[class*="suggestion"]',
+      'ul[class*="autocomplete"] li',
+      // Greenhouse-specific
+      '.select__option',
+      '.select__menu [role="option"]',
+    ].join(', ');
+    const options = page.locator(optionSel);
+    const count = await options.count().catch(() => 0);
+    if (count === 0) return false;
+    // Prefer exact-match option; fall back to "starts with"; else first.
+    const allTexts = await options.allTextContents().catch(() => []);
+    const v = firstChunk.toLowerCase();
+    let pickIdx = allTexts.findIndex(t => t.toLowerCase().trim() === v);
+    if (pickIdx === -1) pickIdx = allTexts.findIndex(t => t.toLowerCase().trim().startsWith(v));
+    if (pickIdx === -1) pickIdx = 0;
+    await options.nth(pickIdx).click({ timeout: 2000 });
+    await page.waitForTimeout(200);
+    // Verify the input now shows a real value
+    const got = await locator.inputValue({ timeout: 1000 }).catch(() => null);
+    return !!(got && got.trim());
+  } catch {
+    return false;
+  }
+}
+
+async function fillCustomDropdown(page, triggerLocator, value, options = {}) {
   try {
     await triggerLocator.click();
     await page.waitForTimeout(350);
 
-    // Look for an open listbox, menu, or option list
-    const optionSelectors = [
-      `[role="option"]:has-text("${value}")`,
-      `[role="menuitem"]:has-text("${value}")`,
-      `li:has-text("${value}")`,
-      `.Select-option:has-text("${value}")`,
-      `[class*="option"]:has-text("${value}")`,
-    ];
-
-    for (const sel of optionSelectors) {
-      try {
-        const opt = page.locator(sel).first();
-        if (await opt.isVisible({ timeout: 800 })) {
-          await opt.click();
-          return true;
-        }
-      } catch {}
+    // STEP 1: Discover ALL available options (visible after opening). We
+    // need this for two reasons:
+    //   a) substring/exact match locally (cheap, no LLM round trip)
+    //   b) if no local match, ask the LLM to pick from this exact list —
+    //      that's how "Straight" maps to "Heterosexual" without us having
+    //      to hardcode a synonym table for every form
+    // We collect texts BEFORE any click attempts so the LLM has the same
+    // option universe the user would see.
+    const optionLocators = page.locator('[role="option"], [role="menuitem"], .select__option, li[class*="option"]');
+    const optionCount = await optionLocators.count().catch(() => 0);
+    const optionTexts = [];
+    for (let i = 0; i < Math.min(optionCount, 40); i++) {
+      const t = (await optionLocators.nth(i).textContent().catch(() => '')).trim();
+      if (t) optionTexts.push(t);
     }
 
-    // Fuzzy: get all visible options and find closest match
-    const allOptions = await page.locator('[role="option"], [role="menuitem"]').all();
-    let bestMatch = null;
-    let bestScore = 0;
-    for (const opt of allOptions) {
-      const text = (await opt.textContent().catch(() => '')).trim().toLowerCase();
-      const target = value.toLowerCase();
-      const score = text === target ? 1 :
-                    text.includes(target) ? 0.8 :
-                    target.includes(text) ? 0.7 : 0;
-      if (score > bestScore) { bestScore = score; bestMatch = opt; }
+    // STEP 2: Local exact match (case-insensitive)
+    const v = String(value).toLowerCase().trim();
+    let pickIdx = optionTexts.findIndex(t => t.toLowerCase().trim() === v);
+
+    // STEP 3: Local substring match (either direction)
+    if (pickIdx === -1) {
+      pickIdx = optionTexts.findIndex(t => {
+        const tt = t.toLowerCase().trim();
+        return tt.includes(v) || v.includes(tt);
+      });
     }
-    if (bestMatch && bestScore >= 0.7) {
-      await bestMatch.click();
+
+    if (pickIdx !== -1) {
+      await optionLocators.nth(pickIdx).click({ timeout: 2000 });
       return true;
     }
 
-    // Nothing found — press Escape to close the dropdown
-    await page.keyboard.press('Escape');
+    // STEP 4: LLM picks from the option universe — the smart-fill path.
+    // Sends user's intent ("Straight") + question text + the EXACT list
+    // of options Greenhouse is rendering ("Heterosexual", "Gay or
+    // Lesbian", "Bisexual", "Prefer not to say"). Backend already has
+    // the /smartfill/field-answer endpoint with options[] support.
+    if (optionTexts.length > 0 && options.config && options.jobId && options.label) {
+      try {
+        const res = await fetch(`${options.config.apiUrl}/smartfill/field-answer`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${options.config.token}` },
+          body: JSON.stringify({
+            job_id: options.jobId,
+            field_label: options.label,
+            field_type: 'select',
+            options: optionTexts,
+            // Pass user's stated intent so the LLM picks the closest
+            // option that REPRESENTS that intent, not just text similarity.
+            previously_answered: [{ label: 'user intent', value: String(value) }],
+          }),
+        });
+        if (res.ok) {
+          const { value: picked } = await res.json();
+          if (picked && picked !== 'SKIP') {
+            // Match the picked text back to an option locator
+            const pickedV = picked.toLowerCase().trim();
+            const aiIdx = optionTexts.findIndex(t => t.toLowerCase().trim() === pickedV)
+              ?? optionTexts.findIndex(t => t.toLowerCase().includes(pickedV) || pickedV.includes(t.toLowerCase()));
+            if (aiIdx !== -1 && aiIdx >= 0) {
+              await optionLocators.nth(aiIdx).click({ timeout: 2000 });
+              console.log(`[filler] AI-picked dropdown: "${options.label}" "${value}" → "${optionTexts[aiIdx]}"`);
+              return true;
+            }
+          }
+        }
+      } catch (e) {
+        console.warn(`[filler] AI dropdown pick failed for "${options.label}": ${e.message}`);
+      }
+    }
+
+    // Nothing matched — close dropdown gracefully so the next field can fill
+    await page.keyboard.press('Escape').catch(() => {});
     return false;
   } catch {
     return false;
@@ -642,6 +802,12 @@ async function fillFields(page, aep, options = {}) {
   const speed = options.speed || 'normal';
   const ctx = options.ctx || null;
   const ats = options.ats || 'generic';
+  // dropdownCtx flows to fillLocator → fillCustomDropdown so custom selects
+  // can call the backend's /smartfill/field-answer with the question text +
+  // available options. That's the "Straight" → "Heterosexual" synonym fix.
+  const dropdownCtx = options.config && options.jobId
+    ? { config: options.config, jobId: options.jobId }
+    : null;
   const delay = () => new Promise(r => setTimeout(r, jitter(100 + Math.random() * 150)));
 
   let filled = 0, skipped = 0, failed = 0;
@@ -665,8 +831,37 @@ async function fillFields(page, aep, options = {}) {
       continue;
     }
 
-    // File uploads — handled separately by uploadResume() in orchestrator
-    if (source === 'file_upload') continue;
+    // File uploads — resume is handled separately by uploadResume() in the
+    // gate handler. Cover letter is its own thing: ATSes like Greenhouse and
+    // Ashby render a dedicated cover-letter file input alongside the resume
+    // one. When the user compiled a cover letter PDF (in PacketPrep studio),
+    // upload it here against the matching field.
+    if (source === 'file_upload') {
+      if (field.category === 'file:cover_letter' && aep.__coverLetterLocalPath) {
+        try {
+          // setInputFiles works directly on hidden <input type=file>; no need
+          // to traverse to a sibling button when we already have the input.
+          const inputLoc = field.selector ? page.locator(field.selector).first() : null;
+          if (inputLoc) {
+            // Some forms hide the input via CSS — unhide briefly so Playwright
+            // doesn't reject the setInputFiles call on a 0x0 element.
+            await inputLoc.evaluate(el => {
+              el.style.display = 'block'; el.style.opacity = '1'; el.style.visibility = 'visible';
+              el.style.width = '1px'; el.style.height = '1px';
+            }).catch(() => {});
+            await inputLoc.setInputFiles(aep.__coverLetterLocalPath, { timeout: 5000 });
+            console.log(`[filler] filled (file): "${labelShort}" = cover-letter.pdf`);
+            filled++;
+            if (ctx && trackKey) ctx.answeredFields.set(trackKey, { value: 'cover-letter.pdf', pageIndex: ctx.currentPageIndex, source: 'file' });
+            await delay();
+            continue;
+          }
+        } catch (e) {
+          console.warn(`[filler] cover-letter upload failed for "${labelShort}": ${e.message}`);
+        }
+      }
+      continue;
+    }
 
     // EEO / consent — skip silently (vision handles EEO, user handles consent)
     if (source === 'skip') continue;
@@ -746,7 +941,7 @@ async function fillFields(page, aep, options = {}) {
         await delay();
       } else {
         // Try clicking the locator directly (custom styled radio)
-        const ok2 = await fillLocator(page, locator, value, field.label);
+        const ok2 = await fillLocator(page, locator, value, field.label, dropdownCtx);
         if (ok2) { filled++; if (ctx && trackKey) ctx.answeredFields.set(trackKey, { value, pageIndex: ctx.currentPageIndex, source }); await delay(); }
         else { skipped++; }
       }
@@ -768,7 +963,7 @@ async function fillFields(page, aep, options = {}) {
 
     // All other types — use universal fillLocator
     try {
-      const ok = await fillLocator(page, locator, value, field.label);
+      const ok = await fillLocator(page, locator, value, field.label, dropdownCtx);
       if (ok) {
         const valShort = String(value).slice(0, 40).replace(/\n/g, ' ');
         console.log(`[filler] filled (${source}): "${labelShort}" = "${valShort}${String(value).length > 40 ? '...' : ''}"`);

package/orchestrator.js

@@ -68,6 +68,18 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       tempResumeFile = await downloadResume(aep.recommended_resume.pdf_presigned_url);
     }
 
+    // Download cover-letter PDF too — separate file because Greenhouse/Ashby
+    // have separate file inputs for each. Only present when the user
+    // compiled it in PacketPrep (cover_letter_pdf_status='ready').
+    let tempCoverLetterFile = null;
+    if (aep.cover_letter_pdf?.pdf_presigned_url) {
+      tempCoverLetterFile = await downloadResume(aep.cover_letter_pdf.pdf_presigned_url);
+      if (tempCoverLetterFile) console.log('[orchestrator] Cover letter PDF downloaded');
+    }
+    // Expose to fillFields via aep so the file:cover_letter category resolver
+    // can hand it to the uploader.
+    aep.__coverLetterLocalPath = tempCoverLetterFile;
+
     // Check for an existing checkpoint — if a previous run got past page 1
     // before crashing, resume from where it stopped. The fillFields path uses
     // ctx.answeredFields to skip already-completed labels, so restoring the
@@ -118,7 +130,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       console.log(`[orchestrator] Using vision fallback for ${ats_type}`);
       fillResult = await visionFill(page, aep, anthropicKey, { alreadyFilled: ctx.answeredFields });
     } else {
-      fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+      fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
     }
 
     // Fetch AI answers for any fields that scanPage identified as needing AI
@@ -145,7 +157,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
         }
       }
       // Second fill pass with newly fetched answers
-      const retryResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+      const retryResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
       fillResult.filled += retryResult.filled;
       fillResult.skipped = retryResult.skipped;
       console.log(`[orchestrator] Retry fill: +${retryResult.filled} fields filled`);
@@ -268,7 +280,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       ctx.currentPageIndex++;
 
       // Fill any new fields that appeared on this page
-      const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+      const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
       cumulativeFilled += pageResult.filled || 0;
 
       // Fetch AI answers for custom fields scanPage identified on this page
@@ -285,7 +297,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
             }
           } catch {}
         }
-        const retryPage = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+        const retryPage = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
         cumulativeFilled += retryPage.filled || 0;
       }
 
@@ -424,6 +436,22 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     }
 
     if (verdict.submitted === null) {
+      // Auto-submit mode means "don't ask me, just submit." If we can't
+      // verify but the user opted into hands-off, trust the click and
+      // mark DONE (the screenshot is the receipt; user can audit later).
+      // Without this, autoSubmit was silently being ignored every time
+      // Firecrawl was slow/down — exactly the case user hit.
+      const autoSubmit = config.autoSubmit || aep.agent_config?.auto_submit;
+      if (autoSubmit) {
+        console.log(`[orchestrator] Could not verify (source: ${verdict.source}) — auto-submit ON, trusting click.`);
+        await reportStatus('DONE', {
+          confirmation_screenshot_r2_key: confirmKey || null,
+          fields_filled: cumulativeFilled,
+        });
+        await clearCheckpoint(config, queueId);
+        console.log(`[orchestrator] Done (auto-submit, unverified): ${queueItem.company} - ${queueItem.title}`);
+        return;
+      }
       console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). Sending to REVIEWING for your eyeball.`);
       await reportStatus('REVIEWING', {
         review_screenshot_r2_key: confirmKey || null,
@@ -1018,7 +1046,7 @@ async function runExtensionFill({
     log(`Vision fill for ${ats_type}`);
     fillResult = await visionFill(page, aep, anthropicKey, { alreadyFilled: ctx.answeredFields });
   } else {
-    fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+    fillResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
   }
 
   reportFillStatus('FILLING', { fieldsFilled: fillResult.filled || 0, message: `Filled ${fillResult.filled || 0} fields...` });
@@ -1043,7 +1071,7 @@ async function runExtensionFill({
         }
       } catch (e) { log(`AI answer failed for "${f.label}": ${e.message}`); }
     }
-    const retry = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+    const retry = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
     fillResult.filled += retry.filled;
     fillResult.skipped = retry.skipped;
   }
@@ -1107,7 +1135,7 @@ async function runExtensionFill({
     }
 
     ctx.currentPageIndex++;
-    const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type });
+    const pageResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
     cumulativeFilled += pageResult.filled || 0;
 
     if (anthropicKey && !useVisionForThis && (pageResult.skipped > 2 || pageResult.failed > 0)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {

package/scanPage.js

@@ -268,6 +268,21 @@ async function scanGreenhouse(page) {
     if (f.id && ghSystemIds[f.id]) {
       return { ...f, category: f.id === 'resume' || f.id === 'cover_letter' ? 'file:' + f.id : 'profile:' + ghSystemIds[f.id] };
     }
+    // File inputs — Greenhouse's modern job-boards UI labels both file
+    // inputs as "Attach" (the visible button text), not "Resume" or
+    // "Cover Letter". Distinguish by name= attribute instead.
+    // resume:    name="resume"        or name="job_application[resume]"
+    // cover ltr: name="cover_letter"  or name="job_application[cover_letter]"
+    if (f.inputType === 'file') {
+      const n = (f.name || '').toLowerCase();
+      if (n.includes('cover_letter') || n.includes('coverletter')) return { ...f, category: 'file:cover_letter' };
+      if (n.includes('resume') || n.includes('cv')) return { ...f, category: 'file:resume' };
+      // Order on the page: first file input is resume, second is cover letter.
+      // Without name/id signals, fall back to ordering. We mark unknowns
+      // 'file:resume' here and re-tag the second occurrence below after
+      // the map (where we have the whole list).
+      return { ...f, category: 'file:unknown' };
+    }
     // Custom question fields: id like question_12345678
     if (f.id && /^question_\d+$/.test(f.id)) {
       return { ...f, category: 'custom' };
@@ -281,7 +296,17 @@ async function scanGreenhouse(page) {
       return { ...f, category: 'profile:' + f.id.split('--')[0] };
     }
     return { ...f, category: classifyField(f) };
-  }).filter(f => f.category !== 'ignore' && f.inputType !== 'hidden');
+  }).reduce((acc, f) => {
+    // Position-based resolution for ambiguous file inputs: first unknown
+    // file → resume, second → cover_letter. Greenhouse always renders
+    // resume above cover letter; the DOM walk preserves that order.
+    if (f.category === 'file:unknown') {
+      const sawResume = acc.some(p => p.category === 'file:resume');
+      f.category = sawResume ? 'file:cover_letter' : 'file:resume';
+    }
+    acc.push(f);
+    return acc;
+  }, []).filter(f => f.category !== 'ignore' && f.inputType !== 'hidden');
 }
 
 /**
@@ -597,8 +622,57 @@ function resolveFieldValues(fields, aep) {
       return { field, value: null, source: 'file_upload' };
     }
 
-    // EEO/consent — skip (handled by vision or user)
-    if (cat === 'eeo' || cat === 'consent') {
+    // Consent checkboxes — user-only (we don't auto-accept terms).
+    if (cat === 'consent') {
+      return { field, value: null, source: 'skip' };
+    }
+
+    // EEO — answer from profile self-ID when set, OR infer common
+    // implications from what IS set. The profile already collects
+    // gender_self_id / race / veteran / disability. We hand those back
+    // directly for matching dropdown labels, plus do a small amount of
+    // inference for derived questions ("transgender experience?" → No
+    // when user is cisgender, "veteran?" → No is the safe default the
+    // user can override). Anything we can't infer falls through to
+    // 'skip' so it gets reviewed.
+    if (cat === 'eeo') {
+      const label = (field.label || '').toLowerCase();
+      const pf = aep.profile_fill || {};
+      // Direct mapping by question text
+      if (/gender|sex/.test(label) && !/transgender|trans\s*experience/.test(label)) {
+        if (pf.gender) return { field, value: pf.gender, source: 'profile:eeo' };
+      }
+      if (/race|ethnicit|hispanic/.test(label)) {
+        if (pf.race) return { field, value: pf.race, source: 'profile:eeo' };
+      }
+      if (/veteran|military/.test(label)) {
+        if (pf.veteran) return { field, value: pf.veteran, source: 'profile:eeo' };
+        // Inference: most users are non-veterans; safer default is "No"
+        // (recruiters expect this field answered; blank → required-field
+        // error). User can change in profile.
+        return { field, value: 'I am not a protected veteran', source: 'profile:eeo-default' };
+      }
+      if (/disabilit/.test(label)) {
+        if (pf.disability) return { field, value: pf.disability, source: 'profile:eeo' };
+        return { field, value: "I don't wish to answer", source: 'profile:eeo-default' };
+      }
+      // Transgender / trans experience: cisgender implication when gender
+      // is set to non-trans. Cisgender users almost never want to
+      // accidentally self-ID as trans; defaulting to "No" when gender is
+      // explicit is safer than skipping (which causes a required-field
+      // error). Don't infer when gender is unset — that becomes 'skip'.
+      if (/transgender|trans\s*experience/.test(label)) {
+        if (pf.gender) return { field, value: 'No', source: 'profile:eeo-inferred' };
+      }
+      // Sexual orientation — never infer. User must self-ID.
+      if (/sexual\s*orientation|orientation\b/.test(label)) {
+        return { field, value: "I don't wish to answer", source: 'profile:eeo-default' };
+      }
+      // Pronouns — derivable from gender
+      if (/pronoun/.test(label)) {
+        if (pf.gender && /female|woman/i.test(pf.gender)) return { field, value: 'she/her', source: 'profile:eeo-inferred' };
+        if (pf.gender && /male|man/i.test(pf.gender)) return { field, value: 'he/him', source: 'profile:eeo-inferred' };
+      }
       return { field, value: null, source: 'skip' };
     }