halo-agent 2.1.0 → 2.2.1

package/detectFormErrors.js

@@ -286,4 +286,183 @@ async function detectFormErrorsInRoot(page) {
   });
 }
 
-module.exports = { detectFormErrors };
+/**
+ * Proactive required-field emptiness check.
+ *
+ * detectFormErrors is REACTIVE — it only reports a problem if the ATS has
+ * already rendered an error (aria-invalid, "is required" text, error class).
+ * On Ashby, a required combobox the agent failed to fill stays empty WITHOUT
+ * the form rendering a visible error until/unless submit is attempted — and
+ * sometimes not even then in the DOM snapshot we capture. So a reactive check
+ * sees a clean page and the agent auto-submits an incomplete form (the Plaid
+ * failure).
+ *
+ * This is the ground-truth, ATS-agnostic guard: walk every field the form
+ * marks REQUIRED (asterisked label, `required` attr, aria-required="true")
+ * and return the ones that are empty — using the same isEmptyField logic
+ * detectFormErrors uses, so react-select / Ashby comboboxes are judged by
+ * their rendered value chip, not the hidden input's .value.
+ *
+ * The orchestrator calls this BEFORE submitting: if any required field is
+ * empty, never auto-submit — route to REVIEWING with the list.
+ *
+ * Output: { hasEmptyRequired: boolean, emptyFields: [{label, selector?}] }
+ */
+async function detectRequiredEmpties(page) {
+  const roots = [page, ...page.frames().filter((f) => {
+    const u = f.url();
+    return f !== page.mainFrame() && u && DFE_EMBED_HOSTS.test(u) && !/google\.com|gstatic\.com|recaptcha/i.test(u);
+  })];
+  let merged = { hasEmptyRequired: false, emptyFields: [] };
+  for (const root of roots) {
+    const r = await detectRequiredEmptiesInRoot(root).catch(() => null);
+    if (r) {
+      merged.hasEmptyRequired = merged.hasEmptyRequired || r.hasEmptyRequired;
+      merged.emptyFields.push(...(r.emptyFields || []));
+    }
+  }
+  // Dedup by label
+  const seen = new Set();
+  merged.emptyFields = merged.emptyFields.filter((f) => {
+    const k = (f.label || '').toLowerCase().trim();
+    if (!k || seen.has(k)) return false;
+    seen.add(k); return true;
+  });
+  return merged;
+}
+
+async function detectRequiredEmptiesInRoot(page) {
+  return await page.evaluate(() => {
+    function visibleText(el) {
+      if (!el) return '';
+      const rect = el.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) return '';
+      const t = (el.innerText || el.textContent || '').trim();
+      return t ? t.replace(/\s+/g, ' ').slice(0, 300) : '';
+    }
+    function nearestLabel(el) {
+      if (el.id) {
+        const lbl = document.querySelector(`label[for="${el.id}"]`);
+        if (lbl) return visibleText(lbl).replace(/\*$/, '').trim();
+      }
+      if (el.labels && el.labels[0]) return visibleText(el.labels[0]).replace(/\*$/, '').trim();
+      const al = el.getAttribute('aria-labelledby');
+      if (al) {
+        const t = al.split(/\s+/).map((id) => document.getElementById(id)).filter(Boolean).map(visibleText).join(' ').trim();
+        if (t) return t;
+      }
+      let p = el.parentElement; let hops = 0;
+      while (p && hops < 6) {
+        const lbl = p.querySelector('label, legend, h3, h4');
+        if (lbl && !lbl.contains(el)) {
+          const t = visibleText(lbl).replace(/\*$/, '').trim();
+          if (t && t.length < 200) return t;
+        }
+        p = p.parentElement; hops += 1;
+      }
+      return el.getAttribute('aria-label') || el.placeholder || el.name || el.id || '(unknown)';
+    }
+    // Same emptiness logic as detectFormErrors (kept in sync deliberately).
+    function isEmptyField(el) {
+      const tag = el.tagName.toLowerCase();
+      const type = (el.type || '').toLowerCase();
+      if (type === 'checkbox' || type === 'radio') return !el.checked;
+      if (tag === 'select') {
+        if (!el.value) return true;
+        const selOpt = el.options[el.selectedIndex];
+        if (selOpt && !selOpt.value) return true;
+        return false;
+      }
+      if (type === 'file') return !el.files || el.files.length === 0;
+      if (el.isContentEditable) return !(el.innerText || '').trim();
+      if (el.getAttribute('role') === 'combobox' || tag === 'select') {
+        let wrap = el.closest('[class*="select__control"]');
+        if (!wrap) { let p = el; for (let i = 0; i < 8 && p; i++, p = p.parentElement) { if (/select__control|select-control/i.test(p.className || '')) { wrap = p; break; } } }
+        if (!wrap) wrap = el.closest('[class*="select"], [class*="combobox"], [class*="Select"]') || el.parentElement;
+        if (wrap) {
+          const valueEl = wrap.querySelector('[class*="single-value"], [class*="multi-value"], [class*="multiValue"], [class*="singleValue"], [class*="chip"], [class*="tag"]');
+          if (valueEl && (valueEl.innerText || valueEl.textContent || '').trim()) return false;
+          const wrapText = (wrap.innerText || '').trim();
+          const placeholderEl = wrap.querySelector('[class*="placeholder"]');
+          const placeholderText = placeholderEl ? (placeholderEl.innerText || '').trim() : '';
+          if (wrapText && wrapText !== placeholderText && !/^select\b|^choose\b|^start typing|^\.\.\./i.test(wrapText)) return false;
+        }
+        const v = (el.value || el.innerText || '').trim();
+        return !v;
+      }
+      return !(el.value || '').trim();
+    }
+
+    // A radiogroup / checkbox-set counts as "filled" if ANY member is checked.
+    // We track required groups by name so we don't flag every individual radio.
+    function isRequired(el) {
+      if (el.required) return true;
+      if (el.getAttribute('aria-required') === 'true') return true;
+      // Asterisked label is the most common ATS convention (Ashby, Greenhouse).
+      const lbl = nearestLabel(el);
+      // The raw label may have had its trailing * stripped by nearestLabel, so
+      // also look at the surrounding label text for an asterisk.
+      let p = el.parentElement; let hops = 0;
+      while (p && hops < 5) {
+        const labelEl = p.querySelector('label, legend, [class*="label"]');
+        if (labelEl) {
+          const raw = (labelEl.innerText || labelEl.textContent || '');
+          if (/\*\s*$/.test(raw.trim()) || /\brequired\b/i.test(raw)) return true;
+        }
+        p = p.parentElement; hops += 1;
+      }
+      return false;
+    }
+
+    const fields = Array.from(document.querySelectorAll(
+      'input:not([type=hidden]):not([type=submit]):not([type=button]), textarea, select, [role="combobox"], [contenteditable="true"]'
+    ));
+    const emptyFields = [];
+    const seen = new Set();
+    const radioGroupsChecked = new Map(); // name -> bool any-checked
+    const radioGroupRequired = new Map(); // name -> required
+
+    // First pass: tally radio/checkbox groups by name.
+    for (const el of fields) {
+      const type = (el.type || '').toLowerCase();
+      if ((type === 'radio' || type === 'checkbox') && el.name) {
+        if (el.checked) radioGroupsChecked.set(el.name, true);
+        else if (!radioGroupsChecked.has(el.name)) radioGroupsChecked.set(el.name, false);
+        if (isRequired(el)) radioGroupRequired.set(el.name, true);
+      }
+    }
+
+    for (const el of fields) {
+      const type = (el.type || '').toLowerCase();
+      // Skip non-rendered fields entirely (display:none templates etc).
+      const rect = el.getBoundingClientRect();
+      const inDom = rect.width > 0 || rect.height > 0 || el.offsetParent !== null;
+      if (!inDom && type !== 'file') continue; // file inputs are often 0x0 by design
+
+      // Radio/checkbox handled at group level.
+      if ((type === 'radio' || type === 'checkbox') && el.name) {
+        if (!radioGroupRequired.get(el.name)) continue;
+        if (radioGroupsChecked.get(el.name)) continue; // satisfied
+        const key = 'group:' + el.name;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        if (!radioGroupsChecked.get(el.name)) {
+          emptyFields.push({ label: nearestLabel(el).slice(0, 200), selector: `[name="${el.name}"]` });
+        }
+        continue;
+      }
+
+      if (!isRequired(el)) continue;
+      if (!isEmptyField(el)) continue;
+      const label = nearestLabel(el).slice(0, 200);
+      const key = label.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      emptyFields.push({ label, selector: el.id ? `#${el.id}` : (el.name ? `[name="${el.name}"]` : null) });
+    }
+
+    return { hasEmptyRequired: emptyFields.length > 0, emptyFields };
+  });
+}
+
+module.exports = { detectFormErrors, detectRequiredEmpties };

package/index.js

@@ -17,6 +17,7 @@ const { loadConfig, saveConfig } = require('./config');
 const { connectToChrome } = require('./browser');
 const { startPolling } = require('./poller');
 const { startLocalServer } = require('./localServer');
+const ui = require('./ui');
 
 const [,, command, ...cmdArgs] = process.argv;
 
@@ -34,13 +35,18 @@ async function main() {
   } else if (command === 'uninstall-autostart') {
     await runUninstallAutostart();
   } else {
-    console.log('Usage:');
-    console.log('  halo-agent pair <code>          — one-click pair with the dashboard');
-    console.log('  halo-agent start                — start the agent');
-    console.log('  halo-agent install-autostart    — auto-start at login');
-    console.log('  halo-agent uninstall-autostart  — remove login auto-start');
-    console.log('  halo-agent init                 — first-time setup (legacy: token paste)');
-    console.log('  halo-agent token <value>        — update auth token');
+    let v = '';
+    try { v = require('./package.json').version; } catch {}
+    ui.banner(v);
+    console.log('');
+    console.log(`  ${ui.bold('Usage')}`);
+    console.log(`    ${ui.cyan('halo-agent pair')} ${ui.gray('<code>')}            One-click pair with the dashboard`);
+    console.log(`    ${ui.cyan('halo-agent start')}                   Start the agent`);
+    console.log(`    ${ui.cyan('halo-agent install-autostart')}       Auto-start at login`);
+    console.log(`    ${ui.cyan('halo-agent uninstall-autostart')}     Remove login auto-start`);
+    console.log(`    ${ui.cyan('halo-agent init')}                    First-time setup (legacy: token paste)`);
+    console.log(`    ${ui.cyan('halo-agent token')} ${ui.gray('<value>')}          Update auth token`);
+    console.log('');
     process.exit(1);
   }
 }
@@ -59,7 +65,7 @@ async function runUpdateToken(newToken) {
   const config = loadConfig() || {};
   config.token = resolved.trim();
   saveConfig(config);
-  console.log('Token updated.');
+  ui.success('Token updated');
 }
 
 // One-click pairing. The user generates a 6-char code in the dashboard
@@ -68,8 +74,11 @@ async function runUpdateToken(newToken) {
 // the user to copy-paste an API token.
 async function runPair(code) {
   if (!code) {
-    console.error('Usage: halo-agent pair <code>');
-    console.error('Get a code from the HALO dashboard: Profile -> Connect agent.');
+    ui.fail('Missing pairing code.');
+    console.log('');
+    console.log(`  ${ui.bold('Usage')}  ${ui.cyan('halo-agent pair')} ${ui.gray('<code>')}`);
+    console.log(`  ${ui.gray('Get a code from the HALO dashboard: Profile')} ${ui.gray(ui.sym.arrow)} ${ui.gray('Connect agent.')}`);
+    console.log('');
     process.exit(1);
   }
   const trimmed = String(code).trim().toUpperCase();
@@ -77,7 +86,8 @@ async function runPair(code) {
   // Default API URL — overridable via env for self-hosted Workers.
   const apiUrl = process.env.HALO_API_URL || 'https://halo-apply-os.amoghi2tb.workers.dev';
 
-  console.log(`\nPairing with ${apiUrl}...`);
+  console.log('');
+  const spin = ui.spinner(`Pairing with ${ui.gray(apiUrl)}`);
   let res;
   try {
     res = await fetch(`${apiUrl}/agent-pair/claim`, {
@@ -86,19 +96,19 @@ async function runPair(code) {
       body: JSON.stringify({ code: trimmed }),
     });
   } catch (e) {
-    console.error('Network error reaching HALO:', e.message);
+    spin.stop(`Network error reaching HALO: ${e.message}`, false);
     process.exit(1);
   }
 
   if (!res.ok) {
     let msg = `HTTP ${res.status}`;
     try { const j = await res.json(); msg = j.error || msg; } catch {}
-    console.error(`Pair failed: ${msg}`);
-    console.error('Codes expire 5 minutes after they are generated — get a fresh one if needed.');
+    spin.stop(`Pair failed: ${msg}`, false);
+    ui.muted('Codes expire 5 minutes after they are generated. Get a fresh one if needed.');
     process.exit(1);
   }
   const data = await res.json();
-  if (!data.token) { console.error('Pair response missing token.'); process.exit(1); }
+  if (!data.token) { spin.stop('Pair response missing token.', false); process.exit(1); }
 
   const { loadConfig, saveConfig } = require('./config');
   const existing = loadConfig() || {};
@@ -110,8 +120,11 @@ async function runPair(code) {
   };
   saveConfig(config);
 
-  console.log('\nPaired. Token saved to ~/.halo-agent/config.json');
-  console.log('Run `halo-agent start` to connect the agent.\n');
+  spin.stop(`Paired with HALO`);
+  ui.muted(`  Token saved to ~/.halo-agent/config.json`);
+  console.log('');
+  console.log(`  ${ui.gray('Next:')} ${ui.cyan('halo-agent start')}`);
+  console.log('');
 }
 
 // Auto-start at login. The user picked "always on" — once installed, the
@@ -166,10 +179,12 @@ async function runInstallAutostart() {
       spawnSync('launchctl', ['unload', plistPath], { stdio: 'ignore' });
       spawnSync('launchctl', ['load', plistPath], { stdio: 'ignore' });
     } catch { /* user can `launchctl load` manually */ }
-    console.log(`\nInstalled login auto-start (macOS LaunchAgent).`);
-    console.log(`  plist: ${plistPath}`);
-    console.log(`  logs:  ${logPath}`);
-    console.log(`The agent will start automatically at login. It's running now.`);
+    console.log('');
+    ui.success('Login auto-start installed (macOS LaunchAgent)');
+    ui.muted(`  plist: ${plistPath}`);
+    ui.muted(`  logs:  ${logPath}`);
+    ui.muted('  The agent will start automatically at login. It is running now.');
+    console.log('');
     return;
   }
 
@@ -183,10 +198,12 @@ async function runInstallAutostart() {
 WshShell.Run """${nodePath.replace(/"/g, '""')}"" ""${agentPath.replace(/"/g, '""')}"" start", 0, False
 Set WshShell = Nothing`;
     fs.writeFileSync(vbsPath, vbs);
-    console.log(`\nInstalled login auto-start (Windows Startup folder).`);
-    console.log(`  vbs: ${vbsPath}`);
-    console.log(`  logs: ${logPath} (agent appends its own output)`);
-    console.log(`The agent will start at your next login. Run \`halo-agent start\` now to begin this session.`);
+    console.log('');
+    ui.success('Login auto-start installed (Windows Startup folder)');
+    ui.muted(`  vbs: ${vbsPath}`);
+    ui.muted(`  logs: ${logPath} (agent appends its own output)`);
+    ui.muted(`  Starts at next login. Run ${ui.cyan('halo-agent start')} now to begin this session.`);
+    console.log('');
     return;
   }
 
@@ -217,10 +234,12 @@ WantedBy=default.target
     // Linger so the unit survives logout — best effort.
     spawnSync('loginctl', ['enable-linger', os.userInfo().username], { stdio: 'ignore' });
   } catch { /* user can enable manually */ }
-  console.log(`\nInstalled login auto-start (systemd --user).`);
-  console.log(`  unit: ${unitPath}`);
-  console.log(`  logs: ${logPath}`);
-  console.log(`The agent should be running now: systemctl --user status halo-agent`);
+  console.log('');
+  ui.success('Login auto-start installed (systemd --user)');
+  ui.muted(`  unit: ${unitPath}`);
+  ui.muted(`  logs: ${logPath}`);
+  ui.muted(`  Check status: ${ui.cyan('systemctl --user status halo-agent')}`);
+  console.log('');
 }
 
 async function runUninstallAutostart() {
@@ -235,13 +254,13 @@ async function runUninstallAutostart() {
       spawnSync('launchctl', ['unload', plistPath], { stdio: 'ignore' });
     } catch {}
     if (fs.existsSync(plistPath)) fs.unlinkSync(plistPath);
-    console.log('Removed macOS LaunchAgent.');
+    ui.success('Removed macOS LaunchAgent');
     return;
   }
   if (process.platform === 'win32') {
     const vbsPath = path.join(process.env.APPDATA || os.homedir(), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'halo-agent.vbs');
     if (fs.existsSync(vbsPath)) fs.unlinkSync(vbsPath);
-    console.log('Removed Windows Startup entry.');
+    ui.success('Removed Windows Startup entry');
     return;
   }
   try {
@@ -250,7 +269,7 @@ async function runUninstallAutostart() {
   } catch {}
   const unitPath = path.join(os.homedir(), '.config', 'systemd', 'user', 'halo-agent.service');
   if (fs.existsSync(unitPath)) fs.unlinkSync(unitPath);
-  console.log('Removed systemd --user unit.');
+  ui.success('Removed systemd --user unit');
 }
 
 async function runInit() {
@@ -287,8 +306,10 @@ async function runInit() {
   };
 
   saveConfig(config);
-  console.log('\nConfig saved to ~/.halo-agent/config.json');
-  console.log('Run "halo-agent start" to begin.\n');
+  console.log('');
+  ui.success('Config saved to ~/.halo-agent/config.json');
+  console.log(`  ${ui.gray('Next:')} ${ui.cyan('halo-agent start')}`);
+  console.log('');
 }
 
 // Is Chrome running without the --remote-debugging-port=9222 flag?
@@ -325,13 +346,13 @@ async function detectChromeRunningWithoutDebug() {
 function offerChromeRestart() {
   return new Promise((resolve) => {
     console.log('');
-    console.log('Chrome is running, but without the debug flag the agent needs.');
-    console.log('I can restart Chrome for you — your tabs will reopen automatically');
-    console.log('(if your "On startup" setting is "Continue where you left off").');
+    ui.warn('Chrome is running, but without the debug flag the agent needs.');
+    ui.muted('  I can restart it for you. Your tabs reopen automatically');
+    ui.muted('  (if your "On startup" setting is "Continue where you left off").');
     console.log('');
     const readline = require('readline');
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question('Restart Chrome now? [Y/n] ', (ans) => {
+    rl.question(`${ui.cyan(ui.sym.arrow)} Restart Chrome now? ${ui.gray('[Y/n]')} `, (ans) => {
       rl.close();
       const a = (ans || '').trim().toLowerCase();
       resolve(a === '' || a === 'y' || a === 'yes');
@@ -446,12 +467,14 @@ async function waitForChromeGone(timeoutMs) {
 async function runStart() {
   const config = loadConfig();
   if (!config || !config.token) {
-    console.error('No config found. Run "halo-agent init" first.');
+    ui.fail('No config found.');
+    console.log(`  ${ui.gray('Run')} ${ui.cyan('halo-agent pair <code>')} ${ui.gray('first. Get a code from the HALO dashboard.')}`);
     process.exit(1);
   }
 
-  console.log('\nHALO Agent starting...');
-  console.log('Connecting to your Chrome browser...\n');
+  let version = '';
+  try { version = require('./package.json').version; } catch {}
+  ui.banner(version);
 
   // The agent runs its own isolated Chrome instance (separate --user-data-dir
   // at ~/.halo-agent/chrome-profile) so it never collides with the user's
@@ -459,22 +482,25 @@ async function runStart() {
   // into Workday / LinkedIn ONCE in the agent's Chrome and those sessions
   // persist across runs. No need to detect or restart the user's Chrome.
   let chromeConn;
+  const spin = ui.spinner('Launching Chrome');
   try {
     chromeConn = await connectToChrome(10);
-    console.log('\nConnected to Chrome. Polling for queued jobs...');
-    console.log('First time? Log into Workday/LinkedIn in this Chrome window — sessions persist.');
-    console.log('Go to your HALO dashboard and click "Auto-Apply" on any job.\n');
+    spin.stop('Connected to Chrome');
   } catch (err) {
-    console.error('\nCould not connect to Chrome:', err.message);
+    spin.stop(`Could not connect to Chrome: ${err.message}`, false);
     process.exit(1);
   }
+  ui.muted(`  First time? Sign into Workday / LinkedIn once in this Chrome window — sessions persist.`);
+  ui.muted(`  Then queue a job from your HALO dashboard.`);
+  console.log('');
 
   // Start the local HTTP server so the HALO dashboard can trigger Manus automation
   startLocalServer();
 
   // Graceful shutdown
   process.on('SIGINT', async () => {
-    console.log('\nShutting down...');
+    console.log('');
+    ui.muted('Shutting down…');
     try { await chromeConn.browser.close(); } catch {}
     process.exit(0);
   });
@@ -483,6 +509,6 @@ async function runStart() {
 }
 
 main().catch(err => {
-  console.error('Fatal error:', err.message);
+  ui.fail(`Fatal: ${err.message}`);
   process.exit(1);
 });

package/orchestrator.js

@@ -13,7 +13,7 @@ const path = require('path');
 const fs = require('fs');
 const { fillFields: legacyFillFields, uploadFile, findNextButton, findSubmitButton, waitForStableDOM, snapshotFieldLabels } = require('./filler');
 const { smartFillPage } = require('./smartFill');
-const { detectFormErrors } = require('./detectFormErrors');
+const { detectFormErrors, detectRequiredEmpties } = require('./detectFormErrors');
 
 // Switchable filler — smart by default, can be killed via config.useSmartFill=false.
 // smartFill.js internally falls back to legacyFillFields if /smartfill/plan-fill
@@ -432,23 +432,59 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
 
     console.log(`[orchestrator] Reached review/submit page. Waiting for confirmation...`);
 
+    // ─────────────────────────────────────────────────────────────────────
+    // HONESTY GUARD (the Plaid/Ashby fix). Before we even consider
+    // auto-submitting, check — proactively, not waiting for the ATS to
+    // render an error — whether any REQUIRED field is still empty. The
+    // Plaid run auto-submitted with Location + dates blank because:
+    //   (a) the comboboxes never filled (element-not-visible, now fixed), and
+    //   (b) detectFormErrors is reactive — a clean-looking DOM let
+    //       auto-submit "trust the click."
+    // If required fields are empty, auto-submit is OFF for this job no matter
+    // what the config/agent_config says: we route to REVIEWING so the human
+    // sees exactly which fields are blank. Never silently submit incomplete.
+    // ─────────────────────────────────────────────────────────────────────
+    const requiredCheck = await detectRequiredEmpties(page).catch(() => ({ hasEmptyRequired: false, emptyFields: [] }));
+    let forceReview = false;
+    if (requiredCheck.hasEmptyRequired) {
+      const list = requiredCheck.emptyFields.map((f) => f.label).slice(0, 8).join(', ');
+      console.warn(`[orchestrator] ${requiredCheck.emptyFields.length} required field(s) still EMPTY: ${list}`);
+      console.warn(`[orchestrator] Overriding auto-submit → REVIEWING. Will not submit an incomplete form.`);
+      forceReview = true;
+    }
+
     // Take a screenshot of the review page
     const reviewScreenshot = await page.screenshot({ type: 'jpeg', quality: 70 });
     const reviewKey = await uploadScreenshot(config, reviewScreenshot, `review_${queueId}.jpg`);
 
-    await reportStatus('REVIEWING', {
-      review_screenshot_r2_key: reviewKey || null,
-      step: 'REVIEWING',
-      step_detail: `${cumulativeFilled} fields filled · awaiting your confirm`,
-    });
-
-    // Wait for user to confirm submission from dashboard
-    // OR auto-submit if config.autoSubmit is true
-    if (config.autoSubmit || aep.agent_config?.auto_submit) {
-      const timeout = (aep.agent_config?.review_timeout_seconds || 30) * 1000;
-      await page.waitForTimeout(timeout);
-    } else {
+    if (forceReview) {
+      const list = requiredCheck.emptyFields.map((f) => f.label).slice(0, 8).join(', ');
+      await reportStatus('NEEDS_ATTENTION', {
+        review_screenshot_r2_key: reviewKey || null,
+        needs_attention_reason: `${requiredCheck.emptyFields.length} required field(s) could not be filled: ${list}. Fill them in Chrome, then click Submit / Resume.`,
+        intervention_type: 'incomplete_fields',
+        step: 'REVIEWING',
+        step_detail: `Empty required: ${list}`.slice(0, 200),
+        fields_filled: cumulativeFilled,
+      });
+      // Wait for the human to fill + confirm, exactly like the no-auto-submit
+      // path. They resolve the blanks in Chrome, then click Submit/Resume.
       await waitForSubmitConfirmation(config, queueId);
+    } else {
+      await reportStatus('REVIEWING', {
+        review_screenshot_r2_key: reviewKey || null,
+        step: 'REVIEWING',
+        step_detail: `${cumulativeFilled} fields filled · awaiting your confirm`,
+      });
+
+      // Wait for user to confirm submission from dashboard
+      // OR auto-submit if config.autoSubmit is true AND the form is complete.
+      if (config.autoSubmit || aep.agent_config?.auto_submit) {
+        const timeout = (aep.agent_config?.review_timeout_seconds || 30) * 1000;
+        await page.waitForTimeout(timeout);
+      } else {
+        await waitForSubmitConfirmation(config, queueId);
+      }
     }
 
     // STEP 6: SUBMITTING
@@ -601,10 +637,31 @@ async function runJob(queueItem, chromeConn, config, reportStatus) {
     let finalState = 'DONE';
     if (verdict.submitted === null) {
       const autoSubmit = config.autoSubmit || aep.agent_config?.auto_submit;
-      if (autoSubmit) {
-        // Auto-submit ON + verifier unavailable: trust the click; the
-        // screenshot becomes the audit trail.
-        console.log(`[orchestrator] Verifier unavailable (source: ${verdict.source}); auto-submit ON — trusting click, screenshot is the receipt.`);
+
+      // Even with auto-submit ON, don't "trust the click" blindly. Two cheap
+      // local signals tell us the submit probably did NOT go through:
+      //   1. The URL never changed to a confirmation pattern (still on the
+      //      form). A successful ATS submit almost always redirects.
+      //   2. Required fields are STILL empty after the click — proof the form
+      //      bounced us (this is the Plaid case: blank Location/dates, no
+      //      redirect, verifier down → it had said "trusting click").
+      // If either holds, we refuse the silent DONE and route to REVIEWING.
+      const stillOnForm = !/thank|confirm|success|applied|submitted/i.test(verdictUrl);
+      const postCheck = await detectRequiredEmpties(page).catch(() => ({ hasEmptyRequired: false, emptyFields: [] }));
+
+      if (postCheck.hasEmptyRequired) {
+        const list = postCheck.emptyFields.map((f) => f.label).slice(0, 8).join(', ');
+        console.warn(`[orchestrator] After submit, required field(s) STILL empty: ${list}. Not a real submit — REVIEWING.`);
+        finalState = 'REVIEWING';
+      } else if (autoSubmit && !stillOnForm) {
+        // Form complete + URL redirected away + verifier just unavailable:
+        // this is the defensible "trust the click" case. Screenshot is the receipt.
+        console.log(`[orchestrator] Verifier unavailable (source: ${verdict.source}); form complete + redirected — trusting click, screenshot is the receipt.`);
+      } else if (autoSubmit && stillOnForm) {
+        // Auto-submit ON but no redirect and no obvious empties: ambiguous.
+        // Don't claim DONE on a page that still looks like the form.
+        console.warn(`[orchestrator] Auto-submit ON but still on form URL and verifier unavailable — REVIEWING rather than a blind DONE.`);
+        finalState = 'REVIEWING';
       } else {
         // No auto-submit → REVIEWING so the user eyeballs first.
         console.warn(`[orchestrator] Could not verify submission (source: ${verdict.source}). REVIEWING — please eyeball the screenshot + click Submit.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {
@@ -28,6 +28,7 @@
     "captcha.js",
     "vision.js",
     "manusAutomate.js",
+    "ui.js",
     "README.md"
   ],
   "keywords": [

package/poller.js

@@ -8,12 +8,15 @@
 
 const { runJob } = require('./orchestrator');
 const { cfAccessHeaders } = require('./config');
+const ui = require('./ui');
 
 let active = false;
 let sessionId = null;
 
 async function startPolling(chromeConn, config) {
-  console.log('[poller] Started. Polling for queued jobs every 5s...');
+  ui.success('Listening for jobs');
+  ui.muted(`  Polling every 5s. ${ui.cyan('Ctrl-C')} to stop.`);
+  console.log('');
 
   // Register agent session with backend
   sessionId = await registerSession(config);
@@ -28,7 +31,8 @@ async function startPolling(chromeConn, config) {
     if (!item) continue;
 
     active = true;
-    console.log(`[poller] Picked up job: ${item.company} - ${item.title} (${item.id})`);
+    console.log('');
+    ui.info(`${ui.bold(item.company)} ${ui.gray(ui.sym.dot)} ${item.title}`);
 
     // Update session status
     await heartbeat(config, sessionId, 'filling', item.job_id);
@@ -37,7 +41,7 @@ async function startPolling(chromeConn, config) {
     try {
       await runJob(item, chromeConn, config, reportStatus);
     } catch (err) {
-      console.error('[poller] runJob threw:', err.message);
+      ui.fail(`Job error: ${err.message}`);
       // Last-resort safety net — orchestrator usually classifies, but if a
       // throw escaped without classification, fall back to 'generic'.
       await reportStatus('NEEDS_ATTENTION', {
@@ -80,7 +84,7 @@ function makeReporter(config, queueId, sessionId) {
         body: JSON.stringify({ status, ...extra }),
       });
     } catch (e) {
-      console.warn('[poller] Could not report status:', e.message);
+      ui.warn(`Could not report status: ${e.message}`);
     }
 
     // Granular step PATCH — drives the live SSE feed. Fire-and-forget; if the
@@ -142,14 +146,14 @@ async function registerSession(config) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => res.status);
-      console.warn(`[poller] Session registration failed (${res.status}):`, text);
+      ui.warn(`Session registration failed (${res.status}): ${text}`);
       return null;
     }
     const data = await res.json();
-    console.log('[poller] Session registered:', data.session_id);
+    ui.muted(`  Session ${ui.gray(data.session_id)}`);
     return data.session_id;
   } catch (e) {
-    console.warn('[poller] Session registration error:', e.message);
+    ui.warn(`Session registration error: ${e.message}`);
     return null;
   }
 }

package/smartFill.js

@@ -58,7 +58,50 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
     visible = await locator.isVisible({ timeout: 800 }).catch(() => false);
   }
   if (!visible) {
-    return { ok: false, reason: `element not visible (mmid=${item.mmid}${field.frameUrl ? ', in-frame' : ''})` };
+    // The scanned element being invisible doesn't always mean "give up." Many
+    // ATSes (Ashby, react-select) render the REAL combobox <input> at 0x0 and
+    // expose only a clickable WRAPPER (".select__control", a styled div, the
+    // value-display button). scanAccessibility tags the inner input, so the
+    // executor would FAIL "element not visible" and the required field stays
+    // empty — exactly the Ashby Location/School/date failure. Recover by
+    // re-pointing the locator at the nearest visible interactive ancestor and
+    // letting the dropdown handlers below open it.
+    const looksLikeDropdown = field.role === 'combobox' || field.role === 'listbox'
+      || /select|combobox|dropdown|month|year|listbox/i.test(String(field.selectorHint || ''))
+      || (Array.isArray(field.options) && field.options.length > 0);
+    const isOpenable = looksLikeDropdown
+      || item.action === 'click_option' || item.action === 'select_option';
+    if (isOpenable) {
+      const wrapperSel = await locator.evaluate((el) => {
+        // Climb to the closest ancestor that's actually rendered (non-zero box)
+        // and looks interactive (select-control class, role, or just a sized
+        // container holding this input). Tag it so Playwright can target it.
+        const sized = (n) => { const r = n.getBoundingClientRect?.(); return r && (r.width > 0 || r.height > 0); };
+        let p = el;
+        for (let i = 0; i < 8 && p; i++, p = p.parentElement) {
+          const cls = String(p.className || '');
+          const looksControl = /select__control|select-control|control|combobox|dropdown|trigger|css-/i.test(cls)
+            || p.getAttribute?.('role') === 'combobox'
+            || p.getAttribute?.('aria-haspopup');
+          if (sized(p) && (looksControl || p !== el)) {
+            const cid = 'halo-wrap-' + Math.random().toString(36).slice(2, 8);
+            p.setAttribute('data-halo-wrap', cid);
+            return cid;
+          }
+        }
+        return null;
+      }).catch(() => null);
+      if (wrapperSel) {
+        const wrap = root.locator(`[data-halo-wrap="${wrapperSel}"]`).first();
+        if (await wrap.isVisible({ timeout: 600 }).catch(() => false)) {
+          locator = wrap;
+          visible = true;
+        }
+      }
+    }
+    if (!visible) {
+      return { ok: false, reason: `element not visible (mmid=${item.mmid}${field.frameUrl ? ', in-frame' : ''})` };
+    }
   }
 
   switch (item.action) {

package/ui.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Tiny zero-dep terminal styling helpers. ANSI escapes only — no chalk/ora,
+ * because the agent is CommonJS and those packages are ESM-only in v5/v8.
+ *
+ * Auto-disables color when stdout isn't a TTY (e.g. piped to a file, or
+ * the LaunchAgent/systemd log) or when NO_COLOR is set (https://no-color.org).
+ *
+ * Used everywhere we want the agent to look like a modern CLI on camera
+ * (Vercel, Bun, pnpm) instead of plain console.log output.
+ */
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+const wrap = (open, close) => (s) => useColor ? `\x1b[${open}m${s}\x1b[${close}m` : String(s);
+
+const bold    = wrap(1, 22);
+const dim     = wrap(2, 22);
+const red     = wrap(31, 39);
+const green   = wrap(32, 39);
+const yellow  = wrap(33, 39);
+const blue    = wrap(34, 39);
+const magenta = wrap(35, 39);
+const cyan    = wrap(36, 39);
+const gray    = wrap(90, 39);
+
+// HALO's brand color is ember; render as bright orange when supported.
+const ember = (s) => useColor ? `\x1b[38;5;208m${s}\x1b[39m` : String(s);
+
+// Status glyphs — match what modern CLIs do. ASCII fallbacks for terminals
+// that can't render the unicode (rare in 2026, but cheap insurance).
+const sym = process.platform === 'win32' && !process.env.WT_SESSION
+  ? { tick: '√', cross: '×', bullet: '*', arrow: '→', dot: '·' }
+  : { tick: '✓', cross: '✗', bullet: '•', arrow: '→', dot: '·' };
+
+const success = (msg) => console.log(`${green(sym.tick)} ${msg}`);
+const fail    = (msg) => console.log(`${red(sym.cross)} ${msg}`);
+const info    = (msg) => console.log(`${cyan(sym.arrow)} ${msg}`);
+const warn    = (msg) => console.log(`${yellow('!')} ${msg}`);
+const muted   = (msg) => console.log(gray(msg));
+const step    = (msg) => console.log(`${gray(sym.dot)} ${msg}`);
+
+// Banner shown on `start`. Three lines so it has presence on camera without
+// being a giant ASCII-art block that ages badly.
+function banner(version) {
+  const v = version ? gray(`v${version}`) : '';
+  const line = gray('─'.repeat(40));
+  console.log('');
+  console.log(`  ${ember(bold('HALO'))} ${bold('Agent')}  ${v}`);
+  console.log(`  ${gray('Auto-apply, in your own Chrome.')}`);
+  console.log(`  ${line}`);
+}
+
+// Lightweight spinner for waiting states ("Connecting to Chrome..."). Frames
+// match the standard braille spinner most users have seen. Returns a stop()
+// fn — call it with a final message + status to render a success/fail line
+// in place of the spinner.
+function spinner(message) {
+  if (!useColor) {
+    process.stdout.write(`${gray(sym.dot)} ${message}\n`);
+    return { stop: (finalMsg, ok = true) => (ok ? success(finalMsg) : fail(finalMsg)) };
+  }
+  const frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+  let i = 0;
+  const render = () => {
+    process.stdout.write(`\r${cyan(frames[i = (i + 1) % frames.length])} ${message}   `);
+  };
+  const handle = setInterval(render, 80);
+  render();
+  return {
+    update: (newMessage) => { message = newMessage; },
+    stop: (finalMsg, ok = true) => {
+      clearInterval(handle);
+      process.stdout.write('\r\x1b[K'); // clear the spinner line
+      if (ok) success(finalMsg);
+      else fail(finalMsg);
+    },
+  };
+}
+
+module.exports = {
+  bold, dim, red, green, yellow, blue, magenta, cyan, gray, ember,
+  sym, success, fail, info, warn, muted, step, banner, spinner,
+};