halo-agent 2.0.1 → 2.0.3

package/orchestrator.js

@@ -460,7 +460,7 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     }
 
     const confirmScreenshot = await page.screenshot({ type: 'jpeg', quality: 70 });
-    const confirmKey = await uploadScreenshot(config, confirmScreenshot, `confirm_${queueId}.jpg`);
+    let confirmKey = await uploadScreenshot(config, confirmScreenshot, `confirm_${queueId}.jpg`);
 
     // Verify-then-DONE: trusting waitForURL alone was wrong (the Chalk bug —
     // Ashby rendered "Missing entry for required field: Name, Email, ..."
@@ -493,9 +493,66 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     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.
       await reportStatus('NEEDS_ATTENTION', {
         review_screenshot_r2_key: confirmKey || null,
-        needs_attention_reason: `Submit clicked but Ashby/ATS rejected it: ${reason}`,
+        needs_attention_reason: `Submit clicked but ATS rejected it: ${reason}`,
         intervention_type: 'submit_failed',
         step: 'VERIFY',
         step_detail: reason.slice(0, 200),
@@ -505,15 +562,25 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     }
 
     if (verdict.submitted === null) {
-      // EARLIER VERSION: when auto-submit was ON, we trusted the click and
-      // marked DONE. That was wrong — it produced false-positive submissions
-      // (applied=true in DB, no actual application sent). Auto-submit means
-      // "don't make me click Submit on the dashboard" — it does NOT mean
-      // "lie about delivery."
-      //
-      // Honest behavior: unverified == REVIEWING regardless of auto-submit.
-      // The screenshot is right there in the dashboard, one click confirms.
-      // Better to over-ask than to ghost-apply.
+      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.
+        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;
+      }
+      // 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.`);
       await reportStatus('REVIEWING', {
         review_screenshot_r2_key: confirmKey || null,
@@ -532,7 +599,17 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
 
     console.log(`[orchestrator] Done (verified): ${queueItem.company} - ${queueItem.title} · firecrawl-verified`);
 
-    // Post fill session data to backend for learning loop
+    // Post fill session data to backend for learning loop + receipt audit
+    // trail. filled_actions becomes the per-field decision list the user
+    // sees on Applications detail — "agent typed X for First Name because
+    // facts.identity.first_name", etc. Truncated to keep payload sane on
+    // long forms.
+    const filledActions = Array.from(ctx.answeredFields.entries()).slice(0, 80).map(([label, data]) => ({
+      label: String(label).slice(0, 200),
+      action: 'filled',
+      value: String(data?.value || '').slice(0, 500),
+      source: data?.source || '',
+    }));
     await postFillSession(config, {
       job_id: jobId,
       ats_type: ats_type || 'unknown',
@@ -540,6 +617,11 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       fields_filled: cumulativeFilled,
       skipped_fields: ctx.skippedFields,
       conditional_fields: ctx.conditionalTriggers,
+      filled_actions: filledActions,
+      // Pass through which actual files were uploaded — backend writes to
+      // submissions.resume_pdf_r2_key / cover_letter_pdf_r2_key for receipt.
+      resume_pdf_r2_key: aep?.recommended_resume?.pdf_r2_key || null,
+      cover_letter_pdf_r2_key: aep?.cover_letter_pdf?.pdf_r2_key || null,
     }).catch(() => {}); // non-critical
 
   } catch (err) {

package/package.json

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

package/scanAccessibility.js

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

package/smartFill.js

@@ -55,6 +55,21 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
 
     case 'type': {
       if (!item.value) return { ok: true, reason: 'skip: empty value' };
+      // If the field is actually a combobox/dropdown (scanAccessibility
+      // tagged it that way), the planner shouldn't have typed — the value
+      // we got is the user's INTENT (e.g. "Straight"), and we need to
+      // pick the closest dropdown option ("Heterosexual"). This is the
+      // case where the planner saw no options[] (because they're
+      // hidden until clicked) and fell back to type. Recover by treating
+      // it as click_option.
+      if (field.role === 'combobox' || field.role === 'listbox') {
+        const result = await openAndPickOption(page, locator, item.value, {
+          config: ctx.config, jobId: ctx.jobId, label: field.label,
+        });
+        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).
+      }
       // Typeahead path: open suggestion list, pick first match.
       if (field.isTypeahead) {
         return await typeAndPickSuggestion(page, locator, item.value);
@@ -76,29 +91,9 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
     }
 
     case 'click_option': {
-      // Custom dropdown: click trigger, find option by text, click it.
-      try {
-        await locator.click({ timeout: 2500 });
-        await page.waitForTimeout(300);
-        // Look for an option whose visible text equals the planner's pick.
-        const optionSel = '[role="option"], [role="menuitem"], .select__option, li[class*="option"]';
-        const opts = page.locator(optionSel);
-        const count = await opts.count().catch(() => 0);
-        if (count === 0) return { ok: false, reason: 'dropdown opened but no options' };
-        const texts = await opts.allTextContents().catch(() => []);
-        const v = String(item.value).toLowerCase().trim();
-        let idx = texts.findIndex((t) => t.toLowerCase().trim() === v);
-        if (idx === -1) idx = texts.findIndex((t) => t.toLowerCase().includes(v) || v.includes(t.toLowerCase()));
-        if (idx === -1) {
-          await page.keyboard.press('Escape').catch(() => {});
-          return { ok: false, reason: `option "${item.value}" not in dropdown (have: ${texts.slice(0, 5).join(', ')})` };
-        }
-        await opts.nth(idx).click({ timeout: 2000 });
-        return { ok: true, reason: `clicked option: ${texts[idx]}` };
-      } catch (e) {
-        await page.keyboard.press('Escape').catch(() => {});
-        return { ok: false, reason: `click_option failed: ${e.message}` };
-      }
+      return await openAndPickOption(page, locator, item.value, {
+        config: ctx.config, jobId: ctx.jobId, label: field.label,
+      });
     }
 
     case 'set_checkbox': {
@@ -182,6 +177,122 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
  * keyboard.type, then native-setter — but with verify-after-write to catch
  * React rejecting our value.
  */
+/**
+ * Open a custom dropdown and pick the closest option matching `value`.
+ * Handles the two architectural pitfalls today's Reddit run exposed:
+ *
+ *   1. Stale option lists. Greenhouse's intl-tel-input mounts a
+ *      <ul role="listbox"> of country dial codes the first time the
+ *      Phone field is touched, and never unmounts it. A naive
+ *      page.locator('[role="option"]') matches those FIRST, so we
+ *      end up trying to click "Afghanistan" when the user wanted
+ *      "Heterosexual." Fix: snapshot the page's option count BEFORE
+ *      opening this dropdown, then only look at options that
+ *      appeared AFTER the click — they belong to OUR dropdown.
+ *
+ *   2. Off-screen / hidden options. allTextContents returns text for
+ *      hidden options too. Filter to visible-only before matching.
+ *
+ * Falls back to LLM synonym matching when local exact/substring
+ * matching fails, so "Straight" still picks "Heterosexual."
+ */
+async function openAndPickOption(page, triggerLocator, value, llmCtx) {
+  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"]';
+    const beforeCount = await page.locator(optionSel).count().catch(() => 0);
+
+    await triggerLocator.click({ timeout: 2500 });
+    await page.waitForTimeout(350);
+
+    // Newly mounted options live at indexes >= beforeCount. If no new
+    // ones appeared, the dropdown may have rendered options earlier
+    // (already-open select). Fall through to scanning all visible.
+    const allOpts = page.locator(optionSel);
+    const totalCount = await allOpts.count().catch(() => 0);
+    const newCount = totalCount - beforeCount;
+
+    // Collect candidate {text, idx} pairs — prefer new options, but if
+    // none, scan all visible ones.
+    const startIdx = newCount > 0 ? beforeCount : 0;
+    const endIdx = totalCount;
+    const candidates = [];
+    for (let i = startIdx; i < endIdx; i++) {
+      const opt = allOpts.nth(i);
+      const visible = await opt.isVisible({ timeout: 200 }).catch(() => false);
+      if (!visible) continue;
+      const text = (await opt.textContent().catch(() => '') || '').replace(/\s+/g, ' ').trim();
+      if (!text) continue;
+      candidates.push({ idx: i, text });
+    }
+
+    if (candidates.length === 0) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: 'dropdown opened but no visible options found' };
+    }
+
+    // STEP 1: exact match (case-insensitive)
+    const v = String(value).toLowerCase().trim();
+    let pick = candidates.find((c) => c.text.toLowerCase() === v);
+
+    // STEP 2: substring either direction (handles "Asian" → "South Asian")
+    if (!pick) pick = candidates.find((c) => {
+      const t = c.text.toLowerCase();
+      return t.includes(v) || v.includes(t);
+    });
+
+    // STEP 3: token overlap (handles "Hispanic" → "Hispanic or Latino")
+    if (!pick) {
+      const vTokens = v.split(/\s+/).filter((t) => t.length > 2);
+      pick = candidates.find((c) => {
+        const tTokens = c.text.toLowerCase().split(/\s+/);
+        return vTokens.some((vt) => tTokens.some((tt) => tt.includes(vt) || vt.includes(tt)));
+      });
+    }
+
+    if (!pick) {
+      // No local match — try LLM pick if we have context. This is the
+      // "Straight" → "Heterosexual" path when synonyms don't appear in
+      // canonical facts.
+      if (llmCtx && llmCtx.config && llmCtx.jobId && llmCtx.label) {
+        try {
+          const res = await fetch(`${llmCtx.config.apiUrl}/smartfill/field-answer`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${llmCtx.config.token}` },
+            body: JSON.stringify({
+              job_id: llmCtx.jobId,
+              field_label: llmCtx.label,
+              field_type: 'select',
+              options: candidates.map((c) => c.text),
+              previously_answered: [{ label: 'user intent', value: String(value) }],
+            }),
+          });
+          if (res.ok) {
+            const { value: picked } = await res.json();
+            if (picked && picked !== 'SKIP') {
+              const pv = picked.toLowerCase().trim();
+              pick = candidates.find((c) => c.text.toLowerCase() === pv)
+                || candidates.find((c) => c.text.toLowerCase().includes(pv) || pv.includes(c.text.toLowerCase()));
+            }
+          }
+        } catch {}
+      }
+    }
+
+    if (!pick) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: `no option matched "${value}" (had ${candidates.length}: ${candidates.slice(0, 4).map((c) => c.text).join(' / ')}${candidates.length > 4 ? '...' : ''})` };
+    }
+
+    await allOpts.nth(pick.idx).click({ timeout: 2000 });
+    return { ok: true, reason: `clicked option: ${pick.text}` };
+  } catch (e) {
+    await page.keyboard.press('Escape').catch(() => {});
+    return { ok: false, reason: `openAndPickOption failed: ${e.message}` };
+  }
+}
+
 async function reactSafeType(page, locator, value) {
   const v = String(value);
   try {
@@ -325,7 +436,12 @@ async function smartFillPage(page, aep, options) {
       continue;
     }
     const labelShort = (f.label || f.selectorHint || '?').slice(0, 50);
-    const result = await executePlanItem(page, item, fieldByMmid, { resumePath, coverLetterPath });
+    const result = await executePlanItem(page, item, fieldByMmid, {
+      resumePath, coverLetterPath,
+      // Threaded so openAndPickOption can hit /smartfill/field-answer for
+      // synonym matching when local fuzzy fails ("Straight" → "Heterosexual").
+      config, jobId,
+    });
     if (result.ok === 'ask_user') {
       askUserReasons.push(`${labelShort}: ${result.reason}`);
       console.warn(`[smartFill] ASK USER: "${labelShort}" — ${result.reason}`);