halo-agent 2.4.3 → 2.4.5

package/orchestrator.js

@@ -550,6 +550,51 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
       // Wait for the human to fill + confirm. They resolve the blanks in
       // Chrome, then click Submit on the dashboard.
       await waitForSubmitConfirmation(config, queueId);
+
+      // SAFETY NET: re-check required-empties AFTER the wait returns. A stale
+      // submit-confirmed KV flag (from a previous run on the same queue id,
+      // or a multi-run debug loop) used to fast-forward the wait without the
+      // user actually filling anything. If Location is still empty after
+      // "confirmation," the form CANNOT submit successfully  refuse the
+      // click and bounce back to REVIEWING. This is the Artie bug: REVIEWING
+      // returned in 10s with no user action, agent submitted an incomplete
+      // form, Firecrawl couldn't verify, Chrome closed.
+      const recheck = await detectRequiredEmpties(page, {
+        excludeLabels: (ctx.skippedFields || []).map((s) => s.label),
+        resumeUploaded: !!fillResult.resumeUploaded,
+      }).catch(() => ({ hasEmptyRequired: false, emptyFields: [] }));
+      if (recheck.hasEmptyRequired) {
+        const stillEmpty = recheck.emptyFields.map((f) => f.label).slice(0, 6).join(', ');
+        console.warn(`[orchestrator] Submit-confirmed signal received but required field(s) still empty: ${stillEmpty}. Re-parking at REVIEWING.`);
+        await reportStatus('REVIEWING', {
+          review_screenshot_r2_key: reviewKey || null,
+          step: 'REVIEWING',
+          step_detail: `Still empty after confirm: ${stillEmpty}. Fill in Chrome + click Submit.`.slice(0, 200),
+          needs_attention_reason: `These fields are still blank: ${stillEmpty}. The form won't accept the submission until they're filled. Use your Chrome window to fill them, then click Submit on the dashboard.`,
+          fields_filled: cumulativeFilled,
+        });
+        // Wait again. The stale-flag case shouldn't re-fire because
+        // submit-confirmed deletes the KV key when read.
+        await waitForSubmitConfirmation(config, queueId);
+        // After the second wait, re-check ONE more time. If still empty,
+        // give up and throw  the human isn't going to fill it.
+        const finalCheck = await detectRequiredEmpties(page, {
+          excludeLabels: (ctx.skippedFields || []).map((s) => s.label),
+          resumeUploaded: !!fillResult.resumeUploaded,
+        }).catch(() => ({ hasEmptyRequired: false, emptyFields: [] }));
+        if (finalCheck.hasEmptyRequired) {
+          const blockers = finalCheck.emptyFields.map((f) => f.label).slice(0, 6).join(', ');
+          await reportStatus('NEEDS_ATTENTION', {
+            review_screenshot_r2_key: reviewKey || null,
+            needs_attention_reason: `Application can't submit  required fields still blank after two review passes: ${blockers}. Open the Chrome window and fill them, then re-queue this job.`,
+            intervention_type: 'required_fields_empty',
+            step: 'NEEDS_ATTENTION',
+            step_detail: `Blocked on: ${blockers}`.slice(0, 200),
+            fields_filled: cumulativeFilled,
+          });
+          throw new Error(`Required fields still empty after two review passes: ${blockers}`);
+        }
+      }
     } else {
       await reportStatus('REVIEWING', {
         review_screenshot_r2_key: reviewKey || null,
@@ -841,27 +886,35 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     let interventionType = 'generic';
     if (/timeout|timed.out|deadline/.test(msg)) interventionType = 'timeout';
     else if (/login|sign.?in|auth.?required|please.+log.?in/.test(msg)) interventionType = 'login_wall';
+    else if (/required fields|still empty|still blank|verification/.test(msg)) interventionType = 'required_fields_empty';
     await reportStatus('NEEDS_ATTENTION', {
       needs_attention_reason: err.message,
       intervention_type: interventionType,
       step: 'NEEDS_ATTENTION',
       step_detail: err.message?.slice(0, 120),
     }).catch(() => {});
+    // KEEP THE TAB OPEN on user-facing failures. The Artie bug had us close
+    // Chrome the instant Firecrawl said "verification failed,"  so the user
+    // couldn't see what state the form was in, couldn't manually finish, and
+    // had to re-queue from scratch. Whenever an intervention type is one the
+    // user can resolve in-browser, leave the page open so they can act.
+    if (interventionType !== 'generic' || /verification|empty|blank|location/.test(msg)) {
+      leaveTabOpen = true;
+      console.log('[orchestrator] Leaving tab open so you can finish manually  see the cockpit Applications page for what needs attention.');
+    }
   } finally {
     // Clean up temp resume file
     if (tempResumeFile) {
       try { fs.unlinkSync(tempResumeFile); } catch {}
     }
-    // Close the tab on failure/cleanup — but on a successful submit, LEAVE
-    // it open so the user sees the confirmation page (visual loop-closure).
+    // Close the tab on failure/cleanup — but on a successful submit OR a
+    // user-actionable failure, LEAVE it open so the user can see / fix it.
     // The next job opens its own new tab, so leaving this one doesn't block
-    // anything; sequential processing is enforced by the poller (one job at
-    // a time). Stale success tabs accumulate, but that's the user's call to
-    // close — they asked for the satisfaction of seeing it land.
+    // anything; sequential processing is enforced by the poller.
     if (page && !leaveTabOpen) {
       try { await page.close(); } catch {}
     } else if (page && leaveTabOpen) {
-      console.log('[orchestrator] Leaving confirmation tab open for your review.');
+      console.log('[orchestrator] Leaving tab open for your review.');
     }
   }
 }
@@ -1274,6 +1327,22 @@ async function getUnmatchedFields(page, aep) {
 
 async function waitForSubmitConfirmation(config, queueId) {
   console.log(`[orchestrator] Waiting for user to confirm submission from dashboard...`);
+  // Drain any stale flag FIRST. The submit-confirmed KV flag has a 5-min
+  // TTL on the worker; a previous run on the SAME queue_id (or a debug
+  // loop that re-queued the same job) could leave the flag set so this
+  // wait would return immediately without the user clicking anything.
+  // The Artie bug: wait returned in 10s, agent submitted incomplete form,
+  // verification failed, Chrome closed silently.
+  //
+  // We do ONE drain read to clear any leftover flag, ignore its value,
+  // then start the real polling loop. The drain read deletes the KV key
+  // server-side, so a fresh "Submit" click is required from here on.
+  try {
+    await fetch(`${config.apiUrl}/apply-queue/submit-confirmed/${queueId}`, {
+      headers: { Authorization: `Bearer ${config.token}` },
+    });
+  } catch {}
+
   for (let i = 0; i < 180; i++) { // up to 15 minutes
     await new Promise(r => setTimeout(r, 5000));
     try {

package/package.json

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

package/smartFill.js

@@ -123,7 +123,7 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
       // it as click_option.
       if (field.role === 'combobox' || field.role === 'listbox') {
         const result = await openAndPickOption(root, locator, item.value, {
-          config: ctx.config, jobId: ctx.jobId, label: field.label,
+          config: ctx.config, jobId: ctx.jobId, label: field.label, field,
         });
         if (result.ok) return result;
         // Fall through to text-fill if no option matched at all
@@ -151,7 +151,7 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
 
     case 'click_option': {
       return await openAndPickOption(root, locator, item.value, {
-        config: ctx.config, jobId: ctx.jobId, label: field.label,
+        config: ctx.config, jobId: ctx.jobId, label: field.label, field,
       });
     }
 
@@ -636,6 +636,67 @@ async function openAndPickOption(root, triggerLocator, value, llmCtx) {
   // need the Page. For in-frame fields, option menus render inside the
   // frame so root.locator finds them.
   const page = (root && typeof root.page === 'function') ? root.page() : root;
+
+  // ── Async-listbox typeahead (shape-agnostic): try FIRST. ─────────────
+  // Any combobox where options are NOT pre-rendered — Ashby Location,
+  // Greenhouse Google Places, Workday city pickers, school/company
+  // autocompletes — must be typed into BEFORE options can appear. The
+  // generic "click and snapshot" path below opens the menu, waits 350ms,
+  // and bails on empty — but Ashby's geo fetch alone takes ~700ms.
+  //
+  // We probe DOM signals on the located element AND on its descendants AND
+  // on its closest field-group, because the planner's mmid may resolve to
+  // the hidden input, the wrapper div, or the toggle button — and Ashby's
+  // wrapper has no role/aria attrs of its own.
+  //
+  // Triggers:
+  //   - role=combobox + (aria-haspopup=listbox | aria-autocomplete=list)
+  //   - aria-autocomplete=list (canonical ARIA for async listbox)
+  //   - scanAccessibility-tagged field.isTypeahead === true
+  //   - 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) => {
+      const probe = (n) => {
+        if (!n || n.nodeType !== 1) return false;
+        const role = n.getAttribute('role');
+        const ac = n.getAttribute('aria-autocomplete');
+        const hp = n.getAttribute('aria-haspopup');
+        if (ac === 'list' || ac === 'both') return true;
+        if (role === 'combobox' && (hp === 'listbox' || hp === 'true')) return true;
+        return false;
+      };
+      // 1. element itself
+      if (probe(el)) return true;
+      // 2. descendant input/combobox (when locator is wrapper or toggle button)
+      const innerSelectors = 'input[role="combobox"], [aria-autocomplete="list"], [aria-autocomplete="both"], [role="combobox"][aria-haspopup="listbox"]';
+      const inner = el.querySelector?.(innerSelectors);
+      if (probe(inner)) return true;
+      // 3. closest field-group, then re-descend (handles ATS-specific wrappers)
+      const groupSel = '[class*="_fieldEntry_"], .ashby-application-form-field-entry, .application-question, [data-question-id], [class*="formField"], .field';
+      const group = el.closest?.(groupSel);
+      if (group) {
+        const groupInner = group.querySelector(innerSelectors);
+        if (probe(groupInner)) return true;
+      }
+      // 4. Ashby's emotion-hashed input class as a supplementary signal
+      const cls = String(el.className || '');
+      if (/_input_/.test(cls) && el.closest?.('[class*="_fieldEntry_"], .ashby-application-form-field-entry')) return true;
+      return false;
+    }).catch(() => false);
+
+    if (fieldIsTypeahead || domIsTypeahead) {
+      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);
+      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.`);
+    }
+  } catch {}
+
   try {
     const rs = await tryReactSelect(root, triggerLocator, value);
     if (rs !== null) {
@@ -652,29 +713,6 @@ 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
@@ -1075,9 +1113,34 @@ async function smartFillPage(page, aep, options) {
         // required-empty guard can EXCLUDE them. The planner has full
         // context (it saw "If yes…" conditional dependencies); the guard is
         // a blind DOM walk. A field the planner intentionally left blank
-        // (conditional-not-applicable, honeypot, optional) must not be
-        // mistaken for an unfilled required field.
-        if (ctx && Array.isArray(ctx.skippedFields) && f.label) {
+        // (conditional-not-applicable, optional, already-filled) must not
+        // be mistaken for an unfilled required field.
+        //
+        // BUT  do NOT trust the planner's "honeypot" reasoning on a real
+        // required fillable field. The Artie bug: planner saw an Ashby
+        // combobox with placeholder "Start typing..." (no other visible
+        // label since the actual <label> is a sibling React node) and called
+        // it a honeypot. Real honeypots are inputs with anti-bot instructions
+        // ("if you're a real human, leave blank") or display:none traps.
+        // A visible required combobox is never a honeypot.
+        //
+        // Policy: when the field IS required and IS fillable (textbox /
+        // combobox / select / textarea / file), only honor the skip if the
+        // planner gave a LEGITIMATE skip reason. "honeypot" on a required
+        // combobox falls through  guard catches it as still-empty + routes
+        // to REVIEWING with the human in the loop.
+        const isFillable = ['textbox', 'combobox', 'listbox', 'searchbox', 'spinbutton'].includes(f.role)
+          || ['textarea', 'select'].includes(f.tag)
+          || (f.tag === 'input' && !['button', 'submit', 'hidden'].includes(f.inputType || ''));
+        const reasonLower = (item.reasoning || result.reason || '').toLowerCase();
+        const legitimateSkip = /already filled|conditional|not applicable|optional|n\/a|cover letter not provided|no cover_letter file/.test(reasonLower);
+        const looksLikeBadHoneypotCall = /honeypot|hidden input|bot detection/.test(reasonLower);
+
+        if (f.required && isFillable && looksLikeBadHoneypotCall && !legitimateSkip) {
+          console.warn(`[smartFill] OVERRIDE: planner called required ${f.role || f.tag} "${labelShort}" a honeypot  not adding to skippedFields. The required-empty guard will catch it.`);
+          // Do not push to ctx.skippedFields. The guard will see this field
+          // as empty and route to REVIEWING.
+        } else if (ctx && Array.isArray(ctx.skippedFields) && f.label) {
           ctx.skippedFields.push({ label: f.label, reason: (item.reasoning || result.reason || '').slice(0, 160) });
         }
       } else {