halo-agent 2.4.6 → 2.5.0

package/orchestrator.js

@@ -272,6 +272,15 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       const retryResult = await fillFields(page, aep, { speed: typingSpeed, ctx, ats: ats_type, config, jobId });
       fillResult.filled += retryResult.filled;
       fillResult.skipped = retryResult.skipped;
+      // Preserve sticky upload flags. If pass 1 uploaded resume / cover letter,
+      // pass 2's smartFill won't redo it (the file slot is already filled and
+      // smartFill skips), so retryResult.resumeUploaded reads false — but the
+      // file IS in the slot. ORing keeps the truth across passes; without this
+      // the orchestrator's blanket fallback uploader (below) re-uploads resume
+      // into whatever file input it finds next, which on Greenhouse is the
+      // cover-letter slot. That's the Robinhood corruption bug.
+      fillResult.resumeUploaded = fillResult.resumeUploaded || retryResult.resumeUploaded;
+      fillResult.coverLetterUploaded = fillResult.coverLetterUploaded || retryResult.coverLetterUploaded;
       console.log(`[orchestrator] Retry fill: +${retryResult.filled} fields filled`);
     }
 
@@ -292,9 +301,33 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     // the cover-letter slot too. smartFill now reports resumeUploaded, so we
     // only fall back when the planner genuinely missed the resume field.
     if (tempResumeFile && !fillResult.resumeUploaded) {
-      console.log('[orchestrator] smartFill did not upload a resume — running fallback uploader.');
-      const uploaded = await uploadFile(page, 'input[type="file"], [data-testid*="resume"], button:has-text("Upload")', tempResumeFile);
-      if (uploaded) fillResult.filled = (fillResult.filled || 0) + 1;
+      console.log('[orchestrator] smartFill did not upload a resume — running fallback uploader (resume-scoped).');
+      // Scoped selectors. Only match file inputs that are CLEARLY resume slots:
+      // - aria-label / name / id mentions "resume" or "cv"
+      // - dedicated [data-testid*="resume"]
+      // - inputs inside a section/fieldset/div whose nearest heading text
+      //   contains "Resume" or "CV" (Greenhouse pattern — uses a sibling
+      //   <h3>Resume/CV*</h3>). We use Playwright's :has() to chain.
+      //
+      // Critically we EXCLUDE selectors that would match the cover-letter slot.
+      // If no resume-scoped match exists, we don't upload anywhere — better to
+      // surface a real failure than silently corrupt the cover-letter slot.
+      const resumeOnlySelectors = [
+        'input[type="file"][aria-label*="resume" i]',
+        'input[type="file"][aria-label*="cv" i]',
+        'input[type="file"][name*="resume" i]',
+        'input[type="file"][id*="resume" i]',
+        '[data-testid*="resume" i]',
+      ].join(', ');
+      const uploaded = await uploadFile(page, resumeOnlySelectors, tempResumeFile);
+      if (uploaded) {
+        fillResult.filled = (fillResult.filled || 0) + 1;
+        fillResult.resumeUploaded = true;
+      } else {
+        console.warn('[orchestrator] Fallback uploader found no resume-scoped slot. Refusing to upload to generic file inputs to avoid cover-letter corruption.');
+      }
+    } else if (tempResumeFile && fillResult.resumeUploaded) {
+      console.log('[orchestrator] Skipping fallback uploader — smartFill already uploaded resume.');
     }
 
     await reportStatus('IN_PROGRESS', {
@@ -727,31 +760,53 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       console.warn(`[orchestrator] verify-submit unavailable: ${e.message}`);
     }
 
-    // Three-way verdict:
-    //   submitted: true  → real success, mark DONE
-    //   submitted: false → real failure, NEEDS_ATTENTION with the error
-    //   submitted: null  → could not verify (Firecrawl down/missing).
-    //                     Bounce to REVIEWING so the user eyeballs the
-    //                     screenshot — never silently mark DONE on
-    //                     unverified submits (that was the Chalk bug).
+    // Firecrawl is ADVISORY, not authoritative. The DOM-error pass above is
+    // the ground truth: if `errorsAfter.hasErrors === false` (no validation
+    // banner, no aria-invalid, no "is required" text), the form was accepted.
+    //
+    // Firecrawl false-positives we've seen in the wild:
+    //   - Ashby keeps the reCAPTCHA badge DOM-mounted on the thank-you page;
+    //     Firecrawl's extract reads it as "Recaptcha requires verification."
+    //   - Greenhouse thank-you pages include apologetic copy ("we'll be in
+    //     touch if it didn't go through") that the LLM reads as failure.
+    //   - URL doesn't always change on success (embed=js Ashby just swaps
+    //     the panel to a "Thanks for applying" state).
+    //
+    // So we no longer throw NEEDS_ATTENTION on `verdict.submitted === false`
+    // when local signals say success. Local truth comes from:
+    //   - errorsAfter.hasErrors === false (no DOM validation errors)
+    //   - findSubmitButton(page) returns null (submit button replaced by
+    //     confirmation UI), OR
+    //   - URL matched /thank|confirm|success|applied|submitted/ during the
+    //     wait above, OR
+    //   - No required fields still empty.
+    //
+    // Only when local signals ALSO look suspicious do we route to REVIEWING
+    // (NOT NEEDS_ATTENTION-throw — REVIEWING keeps tab open + parks).
     if (verdict.submitted === false) {
-      // 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: `Verifier flagged this submit: ${reason}. Page DOM looked clean — please eyeball.`,
-        intervention_type: 'submit_failed',
-        step: 'VERIFY',
-        step_detail: reason.slice(0, 200),
-        fields_filled: cumulativeFilled,
-      });
-      throw new Error(`Submission failed verification: ${reason}`);
+      const reason = verdict.error_message || 'verifier said not submitted';
+      // Local re-check: is the form gone / page in a confirmation state?
+      const submitStillThere = await findSubmitButton(page).then((b) => !!b).catch(() => false);
+      const urlLooksConfirmed = /thank|confirm|success|applied|submitted/i.test(page.url());
+      const postSkipped2 = (ctx.skippedFields || []).map((s) => s.label);
+      const reqCheck = await detectRequiredEmpties(page, { excludeLabels: postSkipped2, resumeUploaded: !!fillResult.resumeUploaded }).catch(() => ({ hasEmptyRequired: false, emptyFields: [] }));
+
+      // If submit button gone OR URL changed OR no validation errors AND
+      // no empty required fields → trust the DOM, treat as DONE.
+      const domSaysClean = !errorsAfter.hasErrors && !reqCheck.hasEmptyRequired;
+      const looksSubmitted = !submitStillThere || urlLooksConfirmed;
+      if (domSaysClean && (looksSubmitted || true /* DOM clean is enough */)) {
+        console.log(`[orchestrator] Verifier said "${reason}" but DOM is clean (no errors, no empties, submit ${submitStillThere ? 'still present' : 'gone'}, url ${urlLooksConfirmed ? 'confirmed' : 'unchanged'}). Treating as submitted.`);
+        // Fall through into the success-decision block below by overriding the verdict.
+        verdict.submitted = true;
+        verdict.source = verdict.source || 'dom-clean-override';
+      } else {
+        // DOM also looks off → real ambiguity. REVIEWING, not NEEDS_ATTENTION.
+        // Keep tab open so the user can finish manually. No throw.
+        console.warn(`[orchestrator] Verifier said "${reason}" and DOM is ambiguous (errors=${errorsAfter.hasErrors}, empties=${reqCheck.hasEmptyRequired}). Parking REVIEWING.`);
+        verdict.submitted = null;
+        verdict.source = 'dom-ambiguous';
+      }
     }
 
     // Decide final state (DONE / REVIEWING) based on verifier verdict +

package/package.json

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

package/scanAccessibility.js

@@ -311,6 +311,48 @@ async function enrichFromDom(page, axFields) {
         }
       } catch {}
 
+      // Group-heading disambiguation for file inputs with generic labels.
+      // Greenhouse renders two `<input type="file">` inputs both labeled
+      // "Attach" — one under a `<h3>Resume/CV*</h3>` heading, one under
+      // `<h3>Cover Letter</h3>`. The AX name only sees "Attach" for both,
+      // so the planner can't route resume vs cover_letter deterministically.
+      // Walk up to the nearest heading and capture its text as groupLabel.
+      let groupLabel = '';
+      try {
+        const isFile = (el.tagName === 'INPUT' && String(el.type || '').toLowerCase() === 'file');
+        if (isFile) {
+          // Use the resolved AX/placeholder label if present; else fall back
+          // to the input's textContent / aria-label.
+          const lblForCheck = (el.getAttribute('aria-label') || el.placeholder || '').trim();
+          // Conservative: only fire when the immediate label is a generic
+          // upload verb. We don't want to clobber a real label like "Resume".
+          const generic = /^(attach|attach\s*file|upload|upload\s*file|choose file|select file|browse|add file|file)$/i;
+          // The visible button label is often on a sibling <button>; check that too.
+          let buttonText = '';
+          try {
+            const wrapper = el.closest('div, section, fieldset, [class*="field"], [class*="upload"]');
+            const btn = wrapper && wrapper.querySelector('button, [role="button"]');
+            if (btn) buttonText = safeText(btn.innerText || btn.textContent || '').trim();
+          } catch {}
+          const labelLooksGeneric = !lblForCheck || generic.test(lblForCheck) || generic.test(buttonText || '');
+          if (labelLooksGeneric) {
+            // Walk up to 8 ancestors and look for a heading inside that ancestor.
+            let p = el.parentElement, hops = 0;
+            while (p && hops < 8) {
+              const heading = p.querySelector('h1, h2, h3, h4, h5, h6, legend, [role="heading"]');
+              if (heading && !heading.contains(el)) {
+                const t = safeText(heading.textContent || '').replace(/\s*\*\s*$/, '').trim();
+                if (t && t.length > 0 && t.length < 150) {
+                  groupLabel = t;
+                  break;
+                }
+              }
+              p = p.parentElement; hops++;
+            }
+          }
+        }
+      } catch {}
+
       return {
         mmid,
         tag,
@@ -321,6 +363,7 @@ async function enrichFromDom(page, axFields) {
         ariaLabel: el.getAttribute('aria-label') || '',
         placeholder: el.placeholder || '',
         recoveredLabel,
+        groupLabel,
         selectorHint,
         currentValue,
         options,

package/smartFill.js

@@ -125,6 +125,10 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
         const result = await openAndPickOption(root, locator, item.value, {
           config: ctx.config, jobId: ctx.jobId, label: field.label, field,
         });
+        // Always dismiss any lingering portal/option-list before the next
+        // field so stale overlays don't intercept the next click.
+        const pageRef = (root && typeof root.page === 'function') ? root.page() : root;
+        await pageRef.keyboard.press('Escape').catch(() => {});
         if (result.ok) return result;
         // Fall through to text-fill if no option matched at all
         // (some Greenhouse comboboxes accept free-text in addition to options).
@@ -150,9 +154,14 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
     }
 
     case 'click_option': {
-      return await openAndPickOption(root, locator, item.value, {
+      const result = await openAndPickOption(root, locator, item.value, {
         config: ctx.config, jobId: ctx.jobId, label: field.label, field,
       });
+      // Always dismiss any lingering portal/option-list before the next
+      // field so stale overlays don't intercept the next click.
+      const pageRef = (root && typeof root.page === 'function') ? root.page() : root;
+      await pageRef.keyboard.press('Escape').catch(() => {});
+      return result;
     }
 
     case 'set_checkbox': {
@@ -656,7 +665,22 @@ async function openAndPickOption(root, triggerLocator, value, llmCtx) {
   //   - Ashby's emotion-hashed _input_ class inside a _fieldEntry_ group
   try {
     const fieldIsTypeahead = !!(llmCtx && llmCtx.field && llmCtx.field.isTypeahead);
-    const domIsTypeahead = await triggerLocator.evaluate((el) => {
+    // React-select disqualifier. Greenhouse, Lever, and many other ATSs ship
+    // react-select-styled dropdowns that carry `aria-autocomplete="list"` but
+    // are NOT async typeaheads — their options are pre-loaded and rendered as
+    // `.select__option` under a portal. If we type into them, react-select
+    // clears the input on blur because the typed text doesn't match any
+    // selectable option. The result is a silently-empty required field.
+    // Route those straight to tryReactSelect instead.
+    const isReactSelect = await triggerLocator.evaluate((el) => {
+      const matchSel = '.select__input, [class*="select__input"], .select__control, [class*="select__control"], [class*="-control"][class*="select"]';
+      if (el.matches?.(matchSel)) return true;
+      if (el.closest?.('.select__control, [class*="select__control"], .select, [class*="-container"][class*="select"]')) return true;
+      // Descendant check (when locator climbed to a wrapper)
+      if (el.querySelector?.('.select__input, [class*="select__input"], .select__control, [class*="select__control"]')) return true;
+      return false;
+    }).catch(() => false);
+    const domIsTypeahead = isReactSelect ? false : await triggerLocator.evaluate((el) => {
       const probe = (n) => {
         if (!n || n.nodeType !== 1) return false;
         const role = n.getAttribute('role');
@@ -685,12 +709,15 @@ async function openAndPickOption(root, triggerLocator, value, llmCtx) {
       return false;
     }).catch(() => false);
 
-    if (fieldIsTypeahead || domIsTypeahead) {
+    if (isReactSelect) {
+      console.log('[smartFill] openAndPickOption: react-select detected → skipping typeahead path, routing to tryReactSelect');
+    }
+    if ((fieldIsTypeahead || domIsTypeahead) && !isReactSelect) {
       const why = [];
       if (fieldIsTypeahead) why.push('field.isTypeahead');
       if (domIsTypeahead) why.push('dom signals');
       console.log(`[smartFill] openAndPickOption: detected typeahead (${why.join(', ')}) → typeAndPickSuggestion first`);
-      const r = await typeAndPickSuggestion(root, triggerLocator, value);
+      const r = await typeAndPickSuggestion(root, triggerLocator, value, { strict: true });
       if (r && r.ok) return r;
       // Fall through to specialized + generic paths on no-match.
       console.log(`[smartFill] typeahead path did not land (${r && r.reason}); falling through to generic dispatch.`);
@@ -907,8 +934,14 @@ async function reactSafeType(root, locator, value) {
 
 /**
  * Type-and-pick for typeahead inputs (Greenhouse Location etc).
+ *
+ * opts.strict: when true, "no suggestion appeared" is reported as failure
+ * instead of silently accepting the typed value as free text. Pass this
+ * for known-listbox combobox fields where accepting free text would be
+ * silently cleared by the framework on blur (react-select, etc.).
  */
-async function typeAndPickSuggestion(root, locator, value) {
+async function typeAndPickSuggestion(root, locator, value, opts) {
+  const strict = !!(opts && opts.strict);
   // root: Page or Frame. Option lists for an in-frame field render inside
   // that frame, so they must be located via root, not the top page.
   const page = (root && typeof root.page === 'function') ? root.page() : root;
@@ -941,15 +974,15 @@ async function typeAndPickSuggestion(root, locator, value) {
       await root.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' };
+      if (got && got.trim() && !strict) return { ok: true, reason: `typeahead (no suggestion, accepted): "${value.slice(0, 30)}"` };
+      return { ok: false, reason: strict && got && got.trim() ? 'no_match (strict: free text not allowed)' : 'typeahead opened no suggestions' };
     }
     const opts = root.locator(optionSel);
     const count = await opts.count().catch(() => 0);
     if (count === 0) {
       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' };
+      if (got && got.trim() && !strict) return { ok: true, reason: `typeahead (no suggestion, accepted): "${value.slice(0, 30)}"` };
+      return { ok: false, reason: strict && got && got.trim() ? 'no_match (strict: free text not allowed)' : 'typeahead opened no suggestions' };
     }
     const texts = await opts.allTextContents().catch(() => []);
     const v = firstChunk.toLowerCase();