halo-agent 2.0.0 → 2.0.2

package/orchestrator.js

@@ -369,15 +369,46 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       });
 
       if (visionResult.submitted) {
-        // Vision already submitted — we're done
+        // Vision THINKS it submitted, but we shouldn't trust that without
+        // verifying — vision can confuse "review page rendered" with
+        // "application accepted." Route through the same verify-submit
+        // gate everything else uses. Worst case → REVIEWING, user clicks
+        // Submit. Better than a false-positive DONE.
         const confirmShot = await page.screenshot({ type: 'jpeg', quality: 70 }).catch(() => null);
         const confirmKey = confirmShot ? await uploadScreenshot(config, confirmShot, `confirm_${queueId}.jpg`) : null;
-        await reportStatus('DONE', {
-          confirmation_screenshot_r2_key: confirmKey || null,
+        const verdictUrl = page.url();
+        let vVerdict = { submitted: null, error_message: null, source: 'unavailable' };
+        try {
+          const vRes = 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: verdictUrl }),
+          });
+          if (vRes.ok) vVerdict = await vRes.json();
+        } catch {}
+        if (vVerdict.submitted === true) {
+          await reportStatus('DONE', { confirmation_screenshot_r2_key: confirmKey || null, fields_filled: cumulativeFilled });
+          await clearCheckpoint(config, queueId);
+          console.log(`[orchestrator] Done via vision (verified): ${queueItem.company} - ${queueItem.title}`);
+          return;
+        }
+        if (vVerdict.submitted === false) {
+          await reportStatus('NEEDS_ATTENTION', {
+            review_screenshot_r2_key: confirmKey || null,
+            needs_attention_reason: `Vision submitted but ATS rejected: ${vVerdict.error_message || 'unknown'}`,
+            intervention_type: 'submit_failed',
+            step: 'VERIFY',
+            step_detail: (vVerdict.error_message || '').slice(0, 200),
+            fields_filled: cumulativeFilled,
+          });
+          throw new Error(`Vision-submit failed verification: ${vVerdict.error_message || 'unknown'}`);
+        }
+        await reportStatus('REVIEWING', {
+          review_screenshot_r2_key: confirmKey || null,
+          step: 'REVIEWING',
+          step_detail: 'Vision attempted submit — verifier unavailable, please eyeball',
           fields_filled: cumulativeFilled,
         });
-        await clearCheckpoint(config, queueId);
-        console.log(`[orchestrator] Done via vision: ${queueItem.company} - ${queueItem.title}`);
         return;
       }
 
@@ -474,31 +505,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.`);
+      // 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.
+      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,
         step: 'REVIEWING',
-        step_detail: 'Could not auto-verify — please confirm the submit',
+        step_detail: `Submit clicked at ${verdictUrl.slice(0, 100)} — verifier unavailable, please confirm`,
         fields_filled: cumulativeFilled,
       });
-      // Stop here; user clicks Submit on dashboard → /apply-queue/submit/:id
-      // will flip to DONE. Don't return — let the function return naturally.
       return;
     }
 

package/package.json

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

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}`);