halo-agent 2.0.2 → 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.2",
+  "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;