halo-agent 2.2.4 → 2.3.0

package/orchestrator.js

@@ -48,13 +48,21 @@ async function fillFields(page, aep, opts) {
     plannedActions: result.planned || 0,
     fellBackToLegacy: !!result.fallback,
     resumeUploaded: !!result.resumeUploaded,
+    coverLetterUploaded: !!result.coverLetterUploaded,
   };
 }
 const { detectCaptcha, solveCaptcha, injectCaptchaToken } = require('./captcha');
 const { visionFill, visionNavigateAndSubmit, visionFillSkipped } = require('./vision');
+const { scanWorkday } = require('./scanWorkday');
 
-// ATS types that need vision fallback due to shadow DOM / canvas
-const VISION_ATS = new Set(['workday', 'icims', 'taleo', 'sap', 'successfactors']);
+// ATS types that need vision fallback due to shadow DOM / canvas.
+// 'workday' was here historically because the AX-tree scan returned no usable
+// fields on Workday's shadow-DOM forms. Phase 3 of the Workday end-to-end fix
+// added scanWorkday() (DOM walk via [data-automation-id^="formField-"]) +
+// pickWorkdayOption (scroll-and-scrape for long dropdowns), so Workday is now
+// DOM-first like Greenhouse/Lever, with vision reserved as fallback only.
+const VISION_ATS = new Set(['icims', 'taleo', 'sap', 'successfactors']);
+const WORKDAY_ATS = 'workday';
 
 /**
  * Create a fresh FormContext for tracking state across a multi-page application.
@@ -684,12 +692,45 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     }
 
     if (finalState === 'REVIEWING') {
+      // CRITICAL: keep the Chrome tab OPEN and the agent ALIVE so the user can
+      // actually take over. Previously this branch reported REVIEWING then
+      // fell through → the `finally` closed the tab and the agent moved on,
+      // leaving a REVIEWING row with no open tab and nothing listening — a
+      // dead-end the user couldn't resolve. Now: leave the tab open, tell the
+      // user what's blank, and wait for them to finish in Chrome + click
+      // Submit (which the agent's waitForSubmitConfirmation is parked on).
+      leaveTabOpen = true;
+      // Re-check exactly which required fields are still empty so the message
+      // names them (the user is staring at the form; tell them what to fix).
+      const stillEmpty = await detectRequiredEmpties(page, {
+        excludeLabels: (ctx.skippedFields || []).map((s) => s.label),
+        resumeUploaded: !!fillResult.resumeUploaded,
+      }).catch(() => ({ emptyFields: [] }));
+      const emptyList = stillEmpty.emptyFields.map((f) => f.label).slice(0, 8).join(', ');
+      const reason = emptyList
+        ? `${stillEmpty.emptyFields.length} field(s) need you: ${emptyList}. Fill them in the open Chrome tab, then click Submit.`
+        : `Couldn't auto-confirm this submit. Eyeball the open Chrome tab, then click Submit.`;
       await reportStatus('REVIEWING', {
         review_screenshot_r2_key: confirmKey || null,
         step: 'REVIEWING',
-        step_detail: `Submit clicked at ${verdictUrl.slice(0, 100)} — verifier unavailable, please confirm`,
+        step_detail: reason.slice(0, 200),
+        needs_attention_reason: reason,
         fields_filled: cumulativeFilled,
       });
+      console.log(`[orchestrator] REVIEWING — tab left open. ${reason}`);
+      // Park here until the user clicks Submit on the dashboard. The tab stays
+      // open the whole time so they can fill the blanks in their own Chrome.
+      await waitForSubmitConfirmation(config, queueId);
+      // They filled the blanks and clicked Submit — click the form's submit.
+      const finishBtn = await findSubmitButton(page).catch(() => null);
+      if (finishBtn) {
+        console.log('[orchestrator] User confirmed — clicking submit on the finished form.');
+        await finishBtn.click().catch(() => {});
+        await page.waitForTimeout(2500);
+      }
+      await reportStatus('DONE', { confirmation_screenshot_r2_key: confirmKey || null, fields_filled: cumulativeFilled });
+      await clearCheckpoint(config, queueId);
+      console.log(`[orchestrator] Done (user-completed): ${queueItem.company} - ${queueItem.title}`);
     } else {
       leaveTabOpen = true;
       await reportStatus('DONE', {
@@ -724,8 +765,13 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       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,
+      // ONLY report a file key if the agent ACTUALLY uploaded it. Previously
+      // the cover-letter key was sent whenever the packet HAD one, even when
+      // the upload FAILED ("no cover_letter file available") — so the receipt
+      // claimed a cover letter that was never submitted. The receipt must
+      // reflect what landed on the form, not what the packet contained.
+      resume_pdf_r2_key: (fillResult.resumeUploaded || tempResumeFile) ? (aep?.recommended_resume?.pdf_r2_key || null) : null,
+      cover_letter_pdf_r2_key: fillResult.coverLetterUploaded ? (aep?.cover_letter_pdf?.pdf_r2_key || null) : null,
     }).catch(() => {}); // non-critical
 
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {
@@ -23,6 +23,7 @@
     "filler.js",
     "scanPage.js",
     "scanAccessibility.js",
+    "scanWorkday.js",
     "smartFill.js",
     "detectFormErrors.js",
     "captcha.js",

package/scanAccessibility.js

@@ -609,4 +609,4 @@ async function scanAccessibility(page) {
   return out;
 }
 
-module.exports = { scanAccessibility };
+module.exports = { scanAccessibility, injectMmid };

package/scanWorkday.js

@@ -0,0 +1,154 @@
+'use strict';
+
+/**
+ * Workday DOM scanner (Phase 3 of the Workday end-to-end fix).
+ *
+ * Workday forms live in a React shadow-DOM and the canonical anchor for every
+ * fillable widget is `[data-automation-id^="formField-"]`. The public repo
+ * shanjilcoding/resume-tailor-public's workday.js proved this approach is
+ * reliable enough for the common case — we borrow the SELECTORS and
+ * HEURISTICS (not the bookmarklet runtime) into Playwright.
+ *
+ * Why it exists: previously the agent treated Workday as VISION-ONLY in
+ * orchestrator.js (VISION_ATS set), which meant every Workday job cost a
+ * Claude Opus call per field (~40 iterations / $0.06 per job, slow). This
+ * scanner returns fields in the same shape scanAccessibility produces, so the
+ * existing smartFillPage / planner pipeline can drive Workday DOM-first.
+ * Vision stays as a fallback for fields this DOM pass misses (custom widgets,
+ * vendor-extended Workday tenants).
+ *
+ * Output shape (matches scanAccessibility for executor compatibility):
+ *   {
+ *     mmid, role, label, description, required, options, selectorHint,
+ *     inputType, value, isTypeahead, groupLabel, filledAlready,
+ *   }
+ */
+
+const { injectMmid } = require('./scanAccessibility');
+
+async function scanWorkday(page) {
+  await injectMmid(page).catch(() => 0);
+
+  return await page.evaluate(() => {
+    function clean(s) { return String(s || '').replace(/\s+/g, ' ').trim(); }
+
+    // Workday inputs live INSIDE the formField wrapper; pick the most
+    // representative one (the visible interactive element).
+    function pickInner(root) {
+      return root.querySelector(
+        'input:not([type=hidden]):not([type=submit]),' +
+        'textarea, select,' +
+        '[role="combobox"], button[aria-haspopup="listbox"], button[aria-haspopup="dialog"],' +
+        '[role="checkbox"], [role="radio"]'
+      );
+    }
+
+    // Map DOM tag/role → the same role string scanAccessibility uses, so the
+    // planner doesn't need a special case for Workday.
+    function inferRole(root, inner) {
+      if (!inner) return 'textbox';
+      const tag = (inner.tagName || '').toLowerCase();
+      const role = inner.getAttribute('role');
+      const type = (inner.getAttribute('type') || '').toLowerCase();
+      if (tag === 'textarea') return 'textarea';
+      if (tag === 'select') return 'listbox';
+      if (role === 'combobox' || (tag === 'button' && /listbox|dialog/.test(inner.getAttribute('aria-haspopup') || ''))) return 'combobox';
+      if (role === 'checkbox' || type === 'checkbox') return 'checkbox';
+      if (role === 'radio' || type === 'radio') return 'radio';
+      if (type === 'file' || root.querySelector('input[type=file]')) return 'file_upload';
+      return 'textbox';
+    }
+
+    function nearestLabel(root, inner) {
+      // 1. label[for=id]
+      if (inner && inner.id) {
+        const lbl = document.querySelector(`label[for="${inner.id}"]`);
+        if (lbl) return clean(lbl.innerText || lbl.textContent || '').replace(/\*\s*$/, '').trim();
+      }
+      // 2. aria-labelledby
+      const ariaLbl = (inner && inner.getAttribute('aria-labelledby')) || root.getAttribute('aria-labelledby');
+      if (ariaLbl) {
+        const t = ariaLbl.split(/\s+/).map((id) => document.getElementById(id)).filter(Boolean)
+          .map((n) => clean(n.innerText || '')).join(' ').trim();
+        if (t) return t.replace(/\*\s*$/, '').trim();
+      }
+      // 3. A label/legend inside the formField wrapper (Workday's typical layout)
+      const lbl = root.querySelector('label, legend, [class*="label"]');
+      if (lbl) return clean(lbl.innerText || '').replace(/\*\s*$/, '').trim();
+      // 4. data-automation-id minus prefix as a last resort
+      const daid = root.getAttribute('data-automation-id') || '';
+      return daid.replace(/^formField-/, '').replace(/[-_]/g, ' ').trim() || '(unknown)';
+    }
+
+    function isRequired(root, inner) {
+      if (inner) {
+        if (inner.required) return true;
+        if (inner.getAttribute('aria-required') === 'true') return true;
+      }
+      // Workday marks required labels with a trailing * inside the wrapper.
+      const lbl = root.querySelector('label, legend');
+      const raw = lbl ? (lbl.innerText || lbl.textContent || '') : '';
+      return /\*\s*$/.test(raw.trim()) || /\brequired\b/i.test(raw);
+    }
+
+    // Get options if they're eagerly rendered. Workday's dropdowns mount their
+    // listbox on click, so this often returns null — smartFill's openAndPickOption
+    // already handles the click-then-look-then-scrape pattern.
+    function eagerOptions(root) {
+      const opts = [];
+      root.querySelectorAll('option, [role="option"]').forEach((o) => {
+        const t = clean(o.innerText || o.textContent || '');
+        if (t && opts.indexOf(t) === -1) opts.push(t);
+      });
+      return opts.length > 0 ? opts.slice(0, 200) : null;
+    }
+
+    function isCurrentlyFilled(inner, root) {
+      if (!inner) return false;
+      const tag = (inner.tagName || '').toLowerCase();
+      const type = (inner.getAttribute('type') || '').toLowerCase();
+      if (type === 'checkbox' || type === 'radio') return !!inner.checked;
+      if (type === 'file') return !!(inner.files && inner.files.length > 0);
+      if (tag === 'select') return !!inner.value && !!inner.value.trim();
+      // Combobox / button trigger: look for the value display sibling.
+      if (inner.getAttribute('role') === 'combobox' || tag === 'button') {
+        // Workday renders the selected value in a span with the displayed text.
+        const valEl = root.querySelector('[data-automation-id*="value"], [class*="selectedValue"]');
+        if (valEl) return !!clean(valEl.innerText || valEl.textContent || '');
+      }
+      return !!clean(inner.value || '');
+    }
+
+    const results = [];
+    const seen = new Set();
+    document.querySelectorAll('[data-automation-id^="formField-"]').forEach((node) => {
+      const root = node;
+      const daid = root.getAttribute('data-automation-id') || '';
+      // De-dup: some Workday templates nest formField wrappers; keep the outermost.
+      if (seen.has(daid)) return;
+      seen.add(daid);
+      const inner = pickInner(root);
+      const mmid = (inner && inner.getAttribute('mmid')) || root.getAttribute('mmid') || null;
+      if (!mmid) return; // injectMmid skipped it — likely not interactive
+      const label = nearestLabel(root, inner);
+      const role = inferRole(root, inner);
+      results.push({
+        mmid: String(mmid),
+        role,
+        label,
+        description: (inner && (inner.getAttribute('aria-description') || inner.getAttribute('placeholder'))) || null,
+        required: isRequired(root, inner),
+        options: eagerOptions(root),
+        selectorHint: `[data-automation-id="${daid}"]`,
+        inputType: (inner && inner.getAttribute('type')) || null,
+        value: (inner && clean(inner.value || '')) || '',
+        isTypeahead: role === 'combobox',
+        groupLabel: null,
+        filledAlready: isCurrentlyFilled(inner, root),
+      });
+    });
+    return results;
+  }).catch(() => []);
+}
+
+module.exports = { scanWorkday };

package/smartFill.js

@@ -17,6 +17,7 @@
  */
 
 const { scanAccessibility } = require('./scanAccessibility');
+const { scanWorkday } = require('./scanWorkday');
 const { fillFields: legacyFillFields } = require('./filler');
 
 // ── Plan executor ───────────────────────────────────────────────────────────
@@ -188,14 +189,61 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
             }
           }
         }
-        // Strategy 2: just click the labeled option directly (custom radios).
+        // Strategy 2: custom radios (Ashby etc) — click the labeled option,
+        // but SCOPED to THIS field's own radiogroup. The old code matched
+        // `[role="radio"]:has-text("Yes")` across the WHOLE page via .first(),
+        // so on a form with several Yes/No questions it clicked the first
+        // "Yes" on the page (or nothing) instead of the one for this field —
+        // the Gen Digital bug where sponsorship + office-commitment radios
+        // ended up blank. Anchor on the scanned element's group container.
         const v = String(item.value);
-        const opt = root.locator(`[role="radio"]:has-text("${v}"), label:has-text("${v}")`).first();
-        if (await opt.isVisible({ timeout: 800 }).catch(() => false)) {
-          await opt.click({ timeout: 1500 });
-          return { ok: true, reason: `radio (label): ${v}` };
+        // Tag the field's enclosing radiogroup so we can scope option lookup.
+        const groupId = await locator.evaluate((el) => {
+          // Walk up to the nearest radiogroup / fieldset / Ashby field entry.
+          let p = el;
+          for (let i = 0; i < 8 && p; i++, p = p.parentElement) {
+            const role = p.getAttribute && p.getAttribute('role');
+            const cls = String(p.className || '');
+            if (role === 'radiogroup' || p.tagName === 'FIELDSET'
+                || /_fieldEntry_|ashby-application-form-field-entry|radio.?group/i.test(cls)) {
+              const gid = 'halo-rg-' + Math.random().toString(36).slice(2, 8);
+              p.setAttribute('data-halo-rg', gid);
+              return gid;
+            }
+          }
+          return null;
+        }).catch(() => null);
+
+        const groupRoot = groupId ? root.locator(`[data-halo-rg="${groupId}"]`) : root;
+        // Within the group, find the option whose visible label matches value.
+        // Try role=radio, label, and a generic clickable row with the text.
+        const optInGroup = groupRoot.locator(
+          `[role="radio"]:has-text("${v}"), label:has-text("${v}"), ` +
+          `[class*="option"]:has-text("${v}"), [class*="radio"]:has-text("${v}")`
+        ).first();
+        if (await optInGroup.isVisible({ timeout: 1000 }).catch(() => false)) {
+          await optInGroup.click({ timeout: 1500 }).catch(async () => {
+            await optInGroup.click({ force: true, timeout: 1500 });
+          });
+          // Verify it registered: the matched radio should now be checked /
+          // aria-checked. Ashby toggles aria-checked on the role=radio element.
+          await page.waitForTimeout(150);
+          const stuck = await optInGroup.evaluate((el) => {
+            const r = el.querySelector('[role="radio"]') || el.closest('[role="radio"]') || el;
+            return r.getAttribute('aria-checked') === 'true'
+              || (r.querySelector && r.querySelector('input:checked') != null)
+              || (r.tagName === 'INPUT' && r.checked);
+          }).catch(() => true); // if we can't tell, assume click worked
+          if (stuck) return { ok: true, reason: `radio (scoped label): ${v}` };
+          // Didn't register — click the input inside the option as a fallback.
+          const innerInput = optInGroup.locator('input[type="radio"]').first();
+          if (await innerInput.count().catch(() => 0)) {
+            await innerInput.check({ force: true, timeout: 1500 }).catch(() => {});
+            return { ok: true, reason: `radio (scoped input): ${v}` };
+          }
+          return { ok: true, reason: `radio (clicked, unverified): ${v}` };
         }
-        return { ok: false, reason: `radio option "${item.value}" not found` };
+        return { ok: false, reason: `radio option "${item.value}" not found in group` };
       } catch (e) {
         return { ok: false, reason: `radio failed: ${e.message}` };
       }
@@ -456,6 +504,133 @@ async function tryReactSelect(root, triggerLocator, value) {
   }
 }
 
+/**
+ * Workday combobox / multi-select option picker.
+ *
+ * Workday's dropdowns mount a popover with [data-automation-id="activeListContainer"]
+ * holding [data-automation-id="promptOption"] entries. Long lists (country,
+ * university, state) are VIRTUALIZED — only ~10 entries render at once; you
+ * have to scroll the container to materialize the rest. The legacy
+ * openAndPickOption path would click + look once + give up on a 5-of-200 hit
+ * rate, which is why VISION_ATS = ['workday'] existed in the first place.
+ *
+ * Strategy (borrowed from shanjilcoding/resume-tailor-public/src/lib/workday.js
+ * lines ~600-750):
+ *   1. Click trigger, wait for activeListContainer.
+ *   2. Type the value to filter (Workday narrows the list as you type — saves
+ *      most of the scrolling).
+ *   3. Snapshot visible promptOptions, scroll the container, snapshot again.
+ *      Repeat until the option set is stable for 2 consecutive rounds OR we
+ *      exceed a scroll budget.
+ *   4. Fuzzy-match the typed value against the union of all option texts.
+ *   5. Click the matching promptOption; verify the trigger now shows a value.
+ */
+async function pickWorkdayOption(root, triggerLocator, value) {
+  const page = (root && typeof root.page === 'function') ? root.page() : root;
+  try {
+    // Open the dropdown by clicking the trigger. Workday's trigger is often
+    // a button or div with role="combobox" — both respond to .click().
+    await triggerLocator.click({ timeout: 2500 }).catch(async () => {
+      await triggerLocator.click({ force: true, timeout: 1500 });
+    });
+    await page.waitForTimeout(300);
+
+    // Locate the popover. It's appended at document.body and identified by
+    // [data-automation-id="activeListContainer"] (Workday's canonical anchor).
+    const containerSel = '[data-automation-id="activeListContainer"]';
+    const optionSel = '[data-automation-id="promptOption"]';
+    try {
+      await root.locator(containerSel).first().waitFor({ state: 'visible', timeout: 2200 });
+    } catch {
+      return { ok: false, reason: 'workday: activeListContainer never appeared' };
+    }
+
+    // If the trigger also accepts text (searchable combobox), type the value
+    // to filter the list. Speeds up long-list matching dramatically.
+    const typed = String(value).split(/[,;]/)[0].trim();
+    try {
+      const isTextInput = await triggerLocator.evaluate((el) => {
+        const tag = (el.tagName || '').toLowerCase();
+        const type = (el.getAttribute('type') || '').toLowerCase();
+        return tag === 'input' && (type === 'text' || type === 'search' || type === '');
+      }).catch(() => false);
+      if (isTextInput && typed) {
+        await triggerLocator.fill('').catch(() => {});
+        await page.keyboard.type(typed, { delay: 30 });
+        await page.waitForTimeout(450); // let virtualized list re-render filtered set
+      }
+    } catch { /* not a text input — skip filter step */ }
+
+    // Scroll-and-scrape. Snapshot options, scroll, snapshot, repeat until
+    // stable for 2 rounds or we hit the scroll budget.
+    const container = root.locator(containerSel).first();
+    const seen = new Map(); // text → first index seen
+    const MAX_SCROLLS = 30;
+    let stableRounds = 0;
+    let prevSize = 0;
+    for (let i = 0; i < MAX_SCROLLS; i++) {
+      const visible = await root.locator(optionSel).evaluateAll((nodes) => {
+        return nodes.map((n) => (n.innerText || n.textContent || '').replace(/\s+/g, ' ').trim()).filter(Boolean);
+      }).catch(() => []);
+      for (const t of visible) { if (!seen.has(t)) seen.set(t, seen.size); }
+      if (seen.size === prevSize) {
+        stableRounds += 1;
+        if (stableRounds >= 2) break; // list exhausted
+      } else {
+        stableRounds = 0;
+        prevSize = seen.size;
+      }
+      // Scroll the container to materialize more entries.
+      await container.evaluate((el) => { el.scrollTop = el.scrollTop + el.clientHeight; }).catch(() => {});
+      await page.waitForTimeout(180);
+    }
+
+    const options = Array.from(seen.keys());
+    if (options.length === 0) {
+      return { ok: false, reason: 'workday: scrolled but no promptOption text found' };
+    }
+
+    // Fuzzy match: exact → starts-with → contains → token overlap.
+    const v = String(value).toLowerCase().trim();
+    let pickText = options.find((t) => t.toLowerCase() === v)
+      || options.find((t) => t.toLowerCase().startsWith(v))
+      || options.find((t) => t.toLowerCase().includes(v) || v.includes(t.toLowerCase()));
+    if (!pickText) {
+      const vTokens = v.split(/\s+/).filter((t) => t.length > 2);
+      pickText = options.find((t) => {
+        const tt = t.toLowerCase();
+        return vTokens.some((vt) => tt.includes(vt));
+      });
+    }
+    if (!pickText) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: `workday: no option matched "${value}" (had ${options.length}: ${options.slice(0, 4).join(' / ')}${options.length > 4 ? '…' : ''})` };
+    }
+
+    // Click by visible text — scoped to the popover so we don't accidentally
+    // hit a same-named link elsewhere on the page.
+    const target = root.locator(`${containerSel} ${optionSel}`).filter({ hasText: pickText }).first();
+    await target.scrollIntoViewIfNeeded({ timeout: 1500 }).catch(() => {});
+    await target.click({ timeout: 1500 }).catch(async () => {
+      await target.click({ force: true, timeout: 1500 });
+    });
+    await page.waitForTimeout(200);
+
+    // Verify: the popover should have closed and the trigger should reflect
+    // the selection. If neither holds, the click silently failed.
+    const stillOpen = await root.locator(containerSel).first().isVisible({ timeout: 400 }).catch(() => false);
+    if (stillOpen) {
+      // One more try with a keyboard Enter (Workday sometimes needs that on the
+      // highlighted option).
+      await page.keyboard.press('Enter').catch(() => {});
+      await page.waitForTimeout(150);
+    }
+    return { ok: true, reason: `workday picked: ${pickText}` };
+  } catch (e) {
+    return { ok: false, reason: `workday option picker threw: ${e.message}` };
+  }
+}
+
 async function openAndPickOption(root, triggerLocator, value, llmCtx) {
   // root: Page or Frame. .locator works on both; keyboard/waitForTimeout
   // need the Page. For in-frame fields, option menus render inside the
@@ -477,6 +652,49 @@ async function openAndPickOption(root, triggerLocator, value, llmCtx) {
     if (itlResult !== null && itlResult.ok) return itlResult;
   } catch {}
 
+  try {
+    // Ashby async typeahead. Ashby's Location field is role="combobox" with
+    // aria-haspopup="listbox" and an input class like `_input_v5ami_28`. It
+    // renders NO options until you type, then fetches matches over the
+    // network (~700ms) and shows them as [role="option"]. The generic
+    // open-and-look path opened it, saw an empty menu, and bailed — that's
+    // the Gen Digital "dropdown opened but no visible options found" failure.
+    // Detect Ashby's widget and route to type-then-wait-for-async-options.
+    const isAshbyCombo = await triggerLocator.evaluate((el) => {
+      const role = el.getAttribute('role');
+      const hasPopup = el.getAttribute('aria-haspopup');
+      const cls = String(el.className || '');
+      // Ashby's emotion-hashed input class, or the generic combobox+listbox shape.
+      const ashbyClass = /_input_/.test(cls) && !!el.closest('[class*="_fieldEntry_"], .ashby-application-form-field-entry');
+      return (role === 'combobox' && (hasPopup === 'listbox' || hasPopup === 'true')) || ashbyClass;
+    }).catch(() => false);
+    if (isAshbyCombo) {
+      const r = await typeAndPickSuggestion(root, triggerLocator, value);
+      if (r.ok) return r;
+      // If typeahead didn't land, fall through to the generic path below.
+    }
+  } catch {}
+
+  try {
+    // Workday combobox / multi-select. Workday wraps every form widget in a
+    // [data-automation-id^="formField-"] container and its dropdowns mount a
+    // popover with [data-automation-id="activeListContainer"], whose options
+    // are [data-automation-id="promptOption"] entries. Long lists (country,
+    // state, university) are virtualized: scrolling triggers more entries to
+    // render. We borrow the scroll-and-scrape pattern from the public
+    // shanjilcoding/resume-tailor-public/src/lib/workday.js bookmarklet.
+    const isWorkdayCombo = await triggerLocator.evaluate((el) => {
+      const inside = !!el.closest('[data-automation-id^="formField-"]');
+      const onWorkday = /myworkdayjobs\.com|workday\.com/i.test(window.location.href);
+      return inside || onWorkday;
+    }).catch(() => false);
+    if (isWorkdayCombo) {
+      const r = await pickWorkdayOption(root, triggerLocator, value);
+      if (r && r.ok) return r;
+      // If it failed (not actually a Workday combobox after all), fall through.
+    }
+  } 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
@@ -725,13 +943,33 @@ async function typeAndPickSuggestion(root, locator, value) {
  * @returns {Promise<{filled, skipped, failed, askUserReasons, planned}>}
  */
 async function smartFillPage(page, aep, options) {
-  const { config, jobId, resumePath, coverLetterPath, ctx } = options;
+  const { config, jobId, resumePath, coverLetterPath, ctx, ats } = options;
 
-  // 1. Scan via AX tree
-  const fields = await scanAccessibility(page).catch((e) => {
-    console.warn(`[smartFill] scanAccessibility failed: ${e.message}`);
-    return [];
-  });
+  // 1. Scan via AX tree. For Workday, prefer the DOM-walker that targets
+  // [data-automation-id^="formField-"] — the AX-tree scan returns mostly
+  // nothing on Workday's shadow-DOM React, which is what historically forced
+  // the entire job into vision (expensive). If scanWorkday returns <5 fields
+  // (atypical posting, login wall) we fall through to scanAccessibility so
+  // the orchestrator's downstream vision precision-fill still gets a shot.
+  const isWorkdayAts = (String(ats || '').toLowerCase() === 'workday')
+    || /myworkdayjobs\.com|workday\.com/i.test(page.url());
+  let fields = [];
+  if (isWorkdayAts) {
+    const wd = await scanWorkday(page).catch((e) => {
+      console.warn(`[smartFill] scanWorkday failed: ${e.message}`);
+      return [];
+    });
+    if (wd.length >= 5) {
+      fields = wd;
+      console.log(`[scanWorkday] ${fields.length} fields detected via data-automation-id`);
+    }
+  }
+  if (fields.length === 0) {
+    fields = await scanAccessibility(page).catch((e) => {
+      console.warn(`[smartFill] scanAccessibility failed: ${e.message}`);
+      return [];
+    });
+  }
   if (fields.length === 0) {
     console.warn('[smartFill] no fields detected on page');
     return { filled: 0, skipped: 0, failed: 0, askUserReasons: [], planned: 0, fallback: false };
@@ -776,12 +1014,37 @@ async function smartFillPage(page, aep, options) {
 
   console.log(`[smartFill] planner returned ${plan.length} actions for ${fields.length} fields`);
 
+  // Phase 4 of the Workday end-to-end fix: dry-run preview, Workday only.
+  // Workday forms are LONG (often 30+ fields across multiple pages) and the
+  // cost of a wrong fill — especially on demographic / sponsorship / clearance
+  // fields where the form rejects misclicks — is high. We render every
+  // planned action as a single readable line and hold 8 seconds before
+  // touching the DOM, letting the user Ctrl-C if anything looks off.
+  // Off-switch: config.workdayDryRun = false in ~/.halo-agent/config.json.
+  // Greenhouse / Lever / Ashby do NOT get this gate — their forms are short
+  // enough that the existing post-fill REVIEWING gate covers it.
+  if (isWorkdayAts && config?.workdayDryRun !== false) {
+    console.log('');
+    console.log(`[dry-run] Workday — about to fill ${plan.length} fields. Ctrl-C in the next 8s to cancel.`);
+    const planByMmidPreview = new Map(plan.map((p) => [String(p.mmid), p]));
+    for (const f of fields) {
+      const it = planByMmidPreview.get(String(f.mmid));
+      if (!it || it.action === 'skip') continue;
+      const labelShort = (f.label || f.selectorHint || '?').slice(0, 50);
+      const valShort = String(it.value || '').slice(0, 60).replace(/\s+/g, ' ');
+      console.log(`  · ${it.action.padEnd(13)} ${labelShort.padEnd(50)}  ${valShort}`);
+    }
+    console.log('');
+    await page.waitForTimeout(8000);
+  }
+
   // 4. Execute the plan in DOM order (planner doesn't dictate order; we
   // mirror the field scan order so dependent fields fill after their parents).
   const fieldByMmid = new Map(fields.map((f) => [String(f.mmid), f]));
   const planByMmid = new Map(plan.map((p) => [String(p.mmid), p]));
   let filled = 0, skipped = 0, failed = 0;
-  let resumeUploaded = false; // so the orchestrator can skip its blanket fallback
+  let resumeUploaded = false;      // so the orchestrator can skip its blanket fallback
+  let coverLetterUploaded = false; // so the receipt only claims a cover letter if one actually went in
   const askUserReasons = [];
 
   for (const f of fields) {
@@ -820,11 +1083,14 @@ async function smartFillPage(page, aep, options) {
       } else {
         console.log(`[smartFill] ${item.action} "${labelShort}" — ${result.reason}${item.reasoning ? ` (why: ${item.reasoning.slice(0, 80)})` : ''}`);
         filled += 1;
-        // Note a successful resume upload so the orchestrator doesn't run its
-        // legacy blanket "upload resume to the first file input" fallback,
-        // which was dumping the resume into the COVER-LETTER slot too.
-        if (item.action === 'upload_file' && String(item.value).toLowerCase().trim() !== 'cover_letter') {
-          resumeUploaded = true;
+        // Track which files actually went in. resumeUploaded gates the
+        // orchestrator's blanket fallback; coverLetterUploaded gates whether
+        // the RECEIPT is allowed to claim a cover letter was submitted (it was
+        // lying before — packet had a cover-letter key, upload FAILED, receipt
+        // still showed it).
+        if (item.action === 'upload_file') {
+          if (String(item.value).toLowerCase().trim() === 'cover_letter') coverLetterUploaded = true;
+          else resumeUploaded = true;
         }
         // Track in ctx for cross-page dedup
         if (ctx && ctx.answeredFields) {
@@ -843,7 +1109,7 @@ async function smartFillPage(page, aep, options) {
     }
   }
 
-  return { filled, skipped, failed, askUserReasons, planned: plan.length, fallback: false, resumeUploaded };
+  return { filled, skipped, failed, askUserReasons, planned: plan.length, fallback: false, resumeUploaded, coverLetterUploaded };
 }
 
 module.exports = { smartFillPage };