halo-agent 1.3.1 → 1.3.3

package/filler.js

@@ -637,6 +637,8 @@ async function fillFields(page, aep, options = {}) {
 
   // ── Pass 3: fill each field ───────────────────────────────────────────────
   for (const { field, value, source } of resolved) {
+    const labelShort = (field.label || field.selector || '?').slice(0, 50);
+
     // Skip if already answered on a previous page
     const trackKey = field.label || field.selector;
     if (ctx && trackKey && ctx.answeredFields.has(trackKey)) {
@@ -660,8 +662,15 @@ async function fillFields(page, aep, options = {}) {
       continue;
     }
 
-    // No value for a profile field — missing from profile, skip
-    if (!value) { skipped++; continue; }
+    // No value for a profile field — missing from profile, skip.
+    // Log this loudly: it's almost always the actual cause of "the agent
+    // didn't fill anything." profile_fill missing a value the user definitely
+    // entered means the AEP builder isn't sending it from strategic_profile.
+    if (!value) {
+      console.warn(`[filler] no-value ${source}: "${labelShort}" (category=${field.category}) — value missing from AEP`);
+      skipped++;
+      continue;
+    }
 
     // Locate the element — use the scanner's selector first, then fall back to semantic finder
     let locator = null;
@@ -690,7 +699,10 @@ async function fillFields(page, aep, options = {}) {
       locator = await semanticFindField(page, { field_id: field.id || field.name, label: field.label }).catch(() => null);
     }
 
-    if (!locator) { skipped++; continue; }
+    if (!locator) {
+      console.warn(`[filler] no-locator: "${labelShort}" (selector="${(field.selector || '').slice(0,60)}") — element not visible / selector dead`);
+      skipped++; continue;
+    }
 
     // Special case: cover letter — type character by character
     if (field.category === 'cover_letter' && field.tag === 'textarea') {
@@ -739,11 +751,19 @@ async function fillFields(page, aep, options = {}) {
     try {
       const ok = await fillLocator(page, locator, value, field.label);
       if (ok) {
+        const valShort = String(value).slice(0, 40).replace(/\n/g, ' ');
+        console.log(`[filler] filled (${source}): "${labelShort}" = "${valShort}${String(value).length > 40 ? '...' : ''}"`);
         filled++;
         if (ctx && trackKey) ctx.answeredFields.set(trackKey, { value, pageIndex: ctx.currentPageIndex, source });
         await delay();
-      } else { failed++; }
-    } catch { failed++; }
+      } else {
+        console.warn(`[filler] fill-failed: "${labelShort}" — fillLocator returned false`);
+        failed++;
+      }
+    } catch (e) {
+      console.warn(`[filler] fill-threw: "${labelShort}" — ${e.message}`);
+      failed++;
+    }
   }
 
   // ── Legacy fallback: also run old profile map + semantic matcher ──────────

package/orchestrator.js

@@ -381,13 +381,68 @@ 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`);
 
+    // Verify-then-DONE: trusting waitForURL alone was wrong (the Chalk bug —
+    // Ashby rendered "Missing entry for required field: Name, Email, ..."
+    // inline without a URL change, and we marked DONE on a failed submit).
+    // The backend re-fetches the page through Firecrawl + extract and tells
+    // us if the submit actually went through. On Firecrawl failure or no
+    // key, the endpoint returns submitted:true so we don't deadlock — we're
+    // strictly more correct than before, not less.
+    const verdictUrl = page.url();
+    console.log(`[orchestrator] Verifying submission at ${verdictUrl}...`);
+    let verdict = { submitted: true, error_message: null, confirmation_text: 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) verdict = await vRes.json();
+    } catch (e) {
+      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).
+    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}`);
+      await reportStatus('NEEDS_ATTENTION', {
+        review_screenshot_r2_key: confirmKey || null,
+        needs_attention_reason: `Submit clicked but Ashby/ATS rejected it: ${reason}`,
+        intervention_type: 'submit_failed',
+        step: 'VERIFY',
+        step_detail: reason.slice(0, 200),
+        fields_filled: cumulativeFilled,
+      });
+      throw new Error(`Submission failed verification: ${reason}`);
+    }
+
+    if (verdict.submitted === null) {
+      console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). Sending to REVIEWING for your eyeball.`);
+      await reportStatus('REVIEWING', {
+        review_screenshot_r2_key: confirmKey || null,
+        step: 'REVIEWING',
+        step_detail: 'Could not auto-verify — please confirm the submit',
+        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;
+    }
+
     await reportStatus('DONE', {
       confirmation_screenshot_r2_key: confirmKey || null,
       fields_filled: cumulativeFilled,
     });
     await clearCheckpoint(config, queueId);
 
-    console.log(`[orchestrator] Done: ${queueItem.company} - ${queueItem.title}`);
+    console.log(`[orchestrator] Done (verified): ${queueItem.company} - ${queueItem.title} · firecrawl-verified`);
 
     // Post fill session data to backend for learning loop
     await postFillSession(config, {

package/package.json

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

package/scanPage.js

@@ -207,8 +207,27 @@ const CONSENT_PATTERNS = [
   /privacy\s*policy/i,
 ];
 
+// Normalize a label so trailing decorations don't break strict regex matches.
+// Ashby/Greenhouse often render labels like "Name *", "Email (required)",
+// "LinkedIn Profile — Required", "Phone *Required". Without this, the
+// PROFILE_PATTERNS (which use ^anchored regexes for short fields like name)
+// silently miss and the field falls through to 'custom', which means the
+// agent skips filling it with profile data.
+function normalizeLabel(raw) {
+  if (!raw) return '';
+  return raw
+    .toLowerCase()
+    .replace(/[*†‡]/g, ' ')                              // markers
+    .replace(/\((required|optional|mandatory)\)/g, ' ')   // "(required)"
+    .replace(/\b(required|optional|mandatory)\b/g, ' ')   // "required"
+    .replace(/[—–-]+\s*(required|optional)\s*$/g, ' ')   // "— required"
+    .replace(/[:?]+$/g, '')                               // trailing : ?
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
 function classifyField(field) {
-  const label = field.label.toLowerCase().trim();
+  const label = normalizeLabel(field.label);
 
   // Consent checkboxes
   if (field.inputType === 'checkbox' && CONSENT_PATTERNS.some(r => r.test(label))) {
@@ -222,7 +241,7 @@ function classifyField(field) {
     if (regex.test(label)) return 'profile:' + name;
   }
 
-  // Ashby system fields by name attribute
+  // Ashby system fields by name attribute (legacy form schema)
   if (field.name && field.name.startsWith('_systemfield_')) {
     const sfName = field.name.replace('_systemfield_', '');
     if (['name', 'email', 'phone', 'resume', 'linkedin', 'website'].includes(sfName)) {
@@ -320,14 +339,22 @@ async function scanAshby(page) {
     if (f.name && f.name.startsWith('_systemfield_')) {
       const sfField = f.name.replace('_systemfield_', '');
       const profileMap = { name: 'full_name', email: 'email', phone: 'phone', linkedin: 'linkedin', website: 'portfolio', resume: null };
-      if (sfField === 'resume' || f.inputType === 'file') return { ...f, category: 'file:resume' };
+      if (sfField === 'resume') return { ...f, category: 'file:resume' };
       if (profileMap[sfField] !== undefined) return { ...f, category: 'profile:' + profileMap[sfField] };
     }
-    // UUID-named fields are custom questions
-    if (f.name && /^[0-9a-f-]{36}$/.test(f.name)) {
-      return { ...f, category: 'custom' };
+    // File inputs: distinguish resume vs cover-letter vs other by the visible
+    // label. Without this, Ashby's separate cover-letter file input was being
+    // shadowed by 'file:resume' and uploadResume() only handles one resume.
+    if (f.inputType === 'file') {
+      const lbl = (f.label || '').toLowerCase();
+      if (/cover\s*letter/.test(lbl)) return { ...f, category: 'file:cover_letter' };
+      return { ...f, category: 'file:resume' };
     }
-    if (f.inputType === 'file') return { ...f, category: 'file:resume' };
+    // Modern Ashby uses UUID names for ALL fields (Name, Email, Phone, custom).
+    // Classify by LABEL first — that's the only signal that distinguishes
+    // a profile field from a custom question when the name attr is opaque.
+    // Don't shortcut UUID-named fields to 'custom' — that's exactly the
+    // Chalk bug where Name/Email/Phone/LinkedIn all fell through unfilled.
     return { ...f, category: classifyField(f) };
   }).filter(f => f.category !== 'ignore');
 }
@@ -505,6 +532,12 @@ async function scanPage(page, ats) {
   });
 
   console.log(`[scanPage] ${platform}: found ${out.length} fields (${out.filter(f => f.category.startsWith('profile')).length} profile, ${out.filter(f => f.category === 'custom').length} custom, ${out.filter(f => f.category === 'eeo').length} eeo)`);
+  // Per-field breakdown so we can SEE why a "Name" field ended up classified
+  // as 'custom' instead of 'profile:full_name' — without this, every fill
+  // failure is a guessing game.
+  for (const f of out) {
+    console.log(`[scanPage]   - ${f.category.padEnd(22)} | ${(f.label || '(no label)').slice(0, 60)} | ${f.tag}/${f.inputType}`);
+  }
   return out;
 }