@enricai/barnacle 1.8.0 → 1.9.1

package/dist/scraper/flow-runner.js

@@ -22,6 +22,7 @@ exports.findRecentBackendError = findRecentBackendError;
 exports.findRecentPageTransition = findRecentPageTransition;
 exports.isWizardExitAction = isWizardExitAction;
 exports.isAdvanceStep = isAdvanceStep;
+exports.shouldWarnMissingAdvancePattern = shouldWarnMissingAdvancePattern;
 exports.parseCaptureIndex = parseCaptureIndex;
 exports.latestCaptureIndex = latestCaptureIndex;
 exports.capturesAfterIndex = capturesAfterIndex;
@@ -30,6 +31,7 @@ exports.windowHasAdvanceTransition = windowHasAdvanceTransition;
 exports.shouldVetoFallbackAdvance = shouldVetoFallbackAdvance;
 exports.isDomOnlyAdvanceVerified = isDomOnlyAdvanceVerified;
 exports.isClickViewSwapVerified = isClickViewSwapVerified;
+exports.shouldReadbackFillOnActSuccess = shouldReadbackFillOnActSuccess;
 exports.countNgInvalidContainers = countNgInvalidContainers;
 exports.describeAttemptEffectSignals = describeAttemptEffectSignals;
 exports.shouldSkipTechnique = shouldSkipTechnique;
@@ -51,6 +53,7 @@ exports.extractSubmitFailureEvidence = extractSubmitFailureEvidence;
 exports.extractGaEventEvidence = extractGaEventEvidence;
 exports.normalizeDateValue = normalizeDateValue;
 exports.fillHtml5DateTimeInput = fillHtml5DateTimeInput;
+exports.fillTextDatepickerInput = fillTextDatepickerInput;
 exports.verifyFillReadback = verifyFillReadback;
 exports.isUploadAffordanceLabel = isUploadAffordanceLabel;
 exports.writeFixtureToTempFile = writeFixtureToTempFile;
@@ -58,6 +61,7 @@ exports.attachToSurfacedInput = attachToSurfacedInput;
 exports.surfaceAndUpload = surfaceAndUpload;
 exports.parseSelectStep = parseSelectStep;
 exports.parseFillStep = parseFillStep;
+exports.parseFillValueIntent = parseFillValueIntent;
 exports.parseRadioStep = parseRadioStep;
 exports.pollEnumerate = pollEnumerate;
 exports.waitForTransitionBody = waitForTransitionBody;
@@ -78,6 +82,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const ai_1 = require("ai");
+const date_fns_1 = require("date-fns");
 const config_1 = require("../config");
 const errors_1 = require("../lib/errors");
 const error_messages_1 = require("../lib/llm/judges/error-messages");
@@ -694,6 +699,20 @@ function isAdvanceStep(instruction) {
     const haystack = instruction.toLowerCase();
     return ADVANCE_STEP_PHRASES.some((p) => haystack.includes(p));
 }
+/**
+ * Whether a flow should be WARNed that its DOM-only advance guard is disarmed.
+ * `isDomOnlyAdvanceVerified` only vetoes a DOM-only "advance" when
+ * `advanceTransitionBodyPattern` is set; a flow with advance steps but no
+ * pattern silently loses that veto, so a validation-re-render wizard can desync
+ * its step pointer from the page. Pure + exported so the WARN condition is
+ * unit-testable without driving the whole runner. Author-side guard-rail only —
+ * no behavior change.
+ */
+function shouldWarnMissingAdvancePattern(instructions, advanceTransitionBodyPattern) {
+    if (advanceTransitionBodyPattern)
+        return false;
+    return instructions.some((s) => isAdvanceStep(s));
+}
 /**
  * Parse the monotonic capture index from a capture filename. Every capture is
  * written as `<idx>-<phase>-<unix-ms>-<hash>.json` where `<idx>` is a
@@ -952,6 +971,22 @@ function isClickViewSwapVerified(params) {
         return true;
     return textChanged && bytesDelta >= VIEW_SWAP_REVEAL_MIN_BYTES;
 }
+/**
+ * Whether an act-success step warrants a committed-value read-back before the
+ * weak view-swap/form-value signals are allowed to accept it. A controlled
+ * datepicker (react-datepicker) accepts the keystrokes, discards the value on
+ * its next render, and — because the resolved action opened its calendar popup
+ * as a `click` — rides `isClickViewSwapVerified` to a phantom `dom=false`
+ * success without ever committing the date. The read-back (and, on a rejected
+ * value, the datepicker fill primitive) is only worth running when the step's
+ * PROSE asked for a fill AND no strong signal (network/url/dom) already verified
+ * it — so the happy path (a real fill, a real click, an advance) is untouched.
+ * Keyed on step intent, not the resolved method, because the widget resolves as
+ * a click and its accessible name identifies the popup, not the field.
+ */
+function shouldReadbackFillOnActSuccess(params) {
+    return params.actReportedSuccess && params.isFillIntent && !params.hasStrongSignal;
+}
 /**
  * Read-only count of ng-invalid form controls on the resolved frame. Side-effect-free
  * counterpart to `probeFormValidityBeforeSubmit` (which also auto-fills
@@ -2150,6 +2185,200 @@ async function fillHtml5DateTimeInput(target, xpath, value) {
         return null;
     }
 }
+/**
+ * Parse a loosely-formatted date string into calendar parts. The recon flow
+ * passes dates in whatever shape the plan text used (ISO `yyyy-MM`, US
+ * `MM/dd/yyyy`, etc.), but a react-datepicker commits through year/month/day
+ * selection, so we need the numeric parts, not a display string. Uses date-fns
+ * per project convention; returns null when no candidate format matches so the
+ * caller skips the datepicker path rather than picking a wrong month.
+ */
+function parseDatepickerValue(value) {
+    const candidates = ["yyyy-MM", "yyyy-MM-dd", "MM/dd/yyyy", "MM-dd-yyyy", "MM/yyyy", "M/yyyy"];
+    for (const fmt of candidates) {
+        const parsed = (0, date_fns_1.parse)(value.trim(), fmt, new Date(2000, 0, 1));
+        if ((0, date_fns_1.isValid)(parsed)) {
+            return { year: parsed.getFullYear(), monthIndex: parsed.getMonth(), day: parsed.getDate() };
+        }
+    }
+    return null;
+}
+/** Dispatch a real Enter keydown/keyup on the element (Stagehand's Locator has no `press`). */
+async function dispatchEnterKey(target, xpath) {
+    const expr = `(() => {
+    const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = r.singleNodeValue;
+    if (!el) return "no-element";
+    const opts = { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true };
+    el.dispatchEvent(new KeyboardEvent("keydown", opts));
+    el.dispatchEvent(new KeyboardEvent("keyup", opts));
+    return "dispatched";
+  })()`;
+    try {
+        await target.evaluate(expr);
+    }
+    catch {
+        // best-effort: an Enter-dispatch failure shouldn't fail the fill
+    }
+}
+/** A readback whose value is a non-empty, date-shaped string counts as committed. */
+function isCommittedDateReadback(readback) {
+    if (readback === null)
+        return false;
+    if (readback.outcome === "rejected")
+        return false;
+    // A datepicker reformats what it accepts (e.g. "01/2020" → "2020-01"), so
+    // "differs" is a commit, not a rejection — require only a non-empty value
+    // that contains a 4-digit year, ruling out stray placeholder text.
+    return readback.postValue.trim().length > 0 && /\d{4}/.test(readback.postValue);
+}
+/**
+ * Fill a `type="text"` datepicker widget (react-datepicker — the standard
+ * ATS start/end-date control), which `fillHtml5DateTimeInput`
+ * cannot: react-datepicker rejects a programmatic `.value` write and commits
+ * only through its own keyboard/calendar `onChange`. Returns `null` for any
+ * input that is NOT a date-like text control, so every other text field stays
+ * on today's exact fill path.
+ *
+ * Two gestures, in order:
+ *  1. Keyboard entry — real keystrokes via `locator.type` (the proven
+ *     framework-control path at {@link verifyDomEffect}) + Enter. Works for
+ *     *typeable* datepickers.
+ *  2. Open-and-pick — click to open `.react-datepicker`, then either set the
+ *     year/month `.range-select` dropdowns and click the `.react-datepicker__month-N`
+ *     cell (month/year-picker variant — the reported ATS widget, which is
+ *     picker-only and ignores typed input) or click the matching
+ *     `.react-datepicker__day` cell (day-grid variant). Commit fires on the cell
+ *     click.
+ *
+ * The committed value is confirmed via {@link verifyFillReadback}; a datepicker
+ * reformats what it accepts, so a non-empty date-shaped readback is success.
+ *
+ * Return contract mirrors {@link fillHtml5DateTimeInput}: `null` means "not a
+ * datepicker — caller falls through to the generic readback verifier"; a
+ * non-null object means "this WAS a datepicker, here's the outcome". A non-null
+ * `filled:false` therefore deliberately TERMINATES the cascade (the caller
+ * records the failure and does NOT run the generic verifier) — a gated-in
+ * datepicker that neither gesture commits is a real fill failure, not an
+ * unrecognized field.
+ *
+ * Site-agnostic: react-datepicker's markup + commit model is universal across
+ * ATS tenants using it.
+ */
+async function fillTextDatepickerInput(target, selector, value) {
+    const xpath = xpathBody(selector);
+    if (!xpath)
+        return null;
+    const parts = parseDatepickerValue(value);
+    if (!parts)
+        return null;
+    // Gate: only proceed for a text input that looks like a datepicker. The
+    // definitive signal is a `.react-datepicker__input-container` wrapper; we
+    // also accept id/name/class/aria date hints for non-react libraries.
+    const gateExpr = `(() => {
+    const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = r.singleNodeValue;
+    if (!el || el.tagName !== "INPUT") return { match: false };
+    const type = (el.getAttribute("type") || "text").toLowerCase();
+    if (type !== "text") return { match: false };
+    const inContainer = !!(el.closest && el.closest(".react-datepicker__input-container, .react-datepicker-wrapper"));
+    const hint = ((el.id || "") + " " + (el.name || "") + " " + (el.className || "") + " " + (el.getAttribute("aria-label") || "") + " " + (el.getAttribute("placeholder") || "")).toLowerCase();
+    const looksDate = /date|datepicker/.test(hint) || /\\bmm[\\/-]?(dd[\\/-]?)?yyyy\\b/.test(hint);
+    return { match: inContainer || looksDate };
+  })()`;
+    try {
+        const gate = await target.evaluate(gateExpr);
+        if (!gate || typeof gate !== "object" || gate.match !== true) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    // Strategy 1 — keyboard entry (typeable datepickers). Mirrors the Angular
+    // reactive-form re-type at verifyDomEffect: real CDP keystrokes flow through
+    // the widget's own onChange, unlike a programmatic value write.
+    const typed = (0, date_fns_1.format)(new Date(parts.year, parts.monthIndex, parts.day), "MM/dd/yyyy");
+    try {
+        const locator = target.locator(selector).first();
+        await locator.fill("");
+        await locator.type(typed, { delay: 50 });
+        // react-datepicker commits typed input on Enter/blur. The Stagehand Locator
+        // has no `press`, so dispatch the Enter keydown/keyup from page context
+        // (the widget's own keydown handler listens here) then blur via the shared
+        // jQuery-change helper.
+        await dispatchEnterKey(target, xpath);
+        await dispatchJqueryChangeEvent(target, selector);
+        const readback = await verifyFillReadback(target, xpath, value);
+        if (isCommittedDateReadback(readback)) {
+            return { filled: true, postValue: readback.postValue, strategy: "keyboard" };
+        }
+    }
+    catch {
+        // fall through to open-and-pick
+    }
+    // Strategy 2 — open-and-pick. Required for picker-only widgets (the reported
+    // month/year picker ignores typed input entirely).
+    try {
+        const locator = target.locator(selector).first();
+        await locator.click();
+    }
+    catch {
+        return { filled: false, postValue: "", strategy: "none" };
+    }
+    const pickExpr = `(() => {
+    const year = ${parts.year};
+    const monthIndex = ${parts.monthIndex};
+    const day = ${parts.day};
+    const cal = document.querySelector(".react-datepicker");
+    if (!cal) return { picked: false, reason: "no-calendar" };
+    const fireChange = (el) => { el.dispatchEvent(new Event("input", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); };
+    const monthCells = cal.querySelectorAll(".react-datepicker__month-text");
+    const dayGrid = cal.querySelectorAll(".react-datepicker__day:not(.react-datepicker__day--outside-month):not(.react-datepicker__day--disabled)");
+    // Month/year-picker variant: click the target month cell (0-based month
+    // index maps to the __month-N class) — THIS is the commit. The year/month
+    // dropdowns are set first only so the calendar shows the right year's month
+    // page. NOTE: "range-select" is a SITE-SPECIFIC class (the ATS site's own
+    // CSS), not a react-datepicker class; the bare "select" fallback covers
+    // other wrappers.
+    // Stock react-datepicker renders its month/year dropdowns as clickable divs,
+    // so on those the select loop is inert and the month-cell click carries it.
+    if (monthCells.length > 0) {
+      const selects = cal.querySelectorAll("select.range-select, select");
+      for (const sel of selects) {
+        const opts = Array.from(sel.options).map((o) => (o.value || "").trim());
+        const yearOpt = opts.indexOf(String(year));
+        if (yearOpt >= 0) { sel.selectedIndex = yearOpt; fireChange(sel); continue; }
+        const monthOpt = opts.indexOf(String(monthIndex));
+        if (monthOpt >= 0) { sel.selectedIndex = monthOpt; fireChange(sel); }
+      }
+      const monthCell = cal.querySelector(".react-datepicker__month-" + monthIndex + ".react-datepicker__month-text");
+      const cell = monthCell || cal.querySelectorAll(".react-datepicker__month-text")[monthIndex];
+      if (cell) { cell.click(); return { picked: true, variant: "month-year" }; }
+      return { picked: false, reason: "no-month-cell" };
+    }
+    // Day-grid variant: click the day cell matching the parsed day number.
+    if (dayGrid.length > 0) {
+      for (const cell of dayGrid) {
+        if ((cell.textContent || "").trim() === String(day)) { cell.click(); return { picked: true, variant: "day-grid" }; }
+      }
+      return { picked: false, reason: "no-day-cell" };
+    }
+    return { picked: false, reason: "empty-calendar" };
+  })()`;
+    try {
+        const picked = await target.evaluate(pickExpr);
+        const didPick = !!picked && typeof picked === "object" && picked.picked === true;
+        const readback = await verifyFillReadback(target, xpath, value);
+        if (didPick && isCommittedDateReadback(readback)) {
+            return { filled: true, postValue: readback.postValue, strategy: "calendar-pick" };
+        }
+        return { filled: false, postValue: readback?.postValue ?? "", strategy: "none" };
+    }
+    catch {
+        return { filled: false, postValue: "", strategy: "none" };
+    }
+}
 /**
  * Read back an element's value after a fill action and compare to the
  * expected value. Catches silent-value-rejection cases that the verifier's
@@ -2811,6 +3040,30 @@ function parseFillStep(instruction) {
         return null;
     return { fieldLabel, value };
 }
+/**
+ * Extract the quoted VALUE a fill step wants written, tolerant of the field-
+ * label phrasing `parseFillStep` is strict about. `parseFillStep` requires the
+ * canonical `<label> field with '<value>'` shape, so real-world prose that
+ * inserts words between the field noun and `with` — e.g. "Fill in the Start
+ * Date field FOR WORK EXPERIENCE with '01/2020'" — parses to `null`, missing
+ * the fill intent entirely. This looser parser recognizes a fill verb plus a
+ * `with '<value>'` clause and returns just the value, so the act-success
+ * datepicker guard can key off intent that survives that phrasing drift.
+ *
+ * Deliberately excludes select steps (checked first, mirroring
+ * `resolveDeepLocatorActuation`'s precedence) so a `select '…'` step whose
+ * prose happens to trail a quoted value is never mistaken for a fill. Returns
+ * `null` for clicks, selects, and any step without a quoted `with '…'` value.
+ */
+function parseFillValueIntent(instruction) {
+    if (parseSelectStep(instruction))
+        return null;
+    if (!/\bfill(?:\s+in)?\b/i.test(instruction))
+        return null;
+    const match = instruction.match(/\bwith\s+'([^']+)'/i);
+    const value = match?.[1]?.trim();
+    return value ? { value } : null;
+}
 /**
  * Parse a single-choice RADIO flow step into the option to click and (when
  * present) the question label that scopes which radio group it targets.
@@ -5721,20 +5974,42 @@ async function executeStepWithHealing(params) {
                                 }
                             }
                             else {
-                                // Fix I: not a date input — verify the regular fill landed.
-                                // Catches silent-value-rejection cases (HTML5 type validation
-                                // on number/email/url/tel inputs, framework-controlled-
-                                // component rejection, masked-input library reformatting).
-                                // Generic primitive that the verifier's existing signals
-                                // (network/url/dom/htmlDelta/textChanged) miss.
-                                const readback = await verifyFillReadback(dateFillTarget, overriddenTarget.selector, fillValue);
-                                if (readback !== null) {
-                                    if (readback.outcome === "rejected") {
-                                        record.errorMessage = `fill-value-rejected: tried "${fillValue.slice(0, 60)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                                // Not an HTML5 date input. First try the text-datepicker
+                                // primitive (react-datepicker — ATS start/end-date
+                                // controls): those are `type="text"`, so fillHtml5DateTimeInput
+                                // returns null, and the generic fill's value-write never commits
+                                // the widget. Returns null for any non-datepicker text input, so
+                                // every other field falls through to the readback verifier below
+                                // unchanged.
+                                const datepickerFill = await fillTextDatepickerInput(dateFillTarget, overriddenTarget.selector, fillValue);
+                                if (datepickerFill !== null) {
+                                    record.errorMessage = datepickerFill.filled
+                                        ? `text-datepicker-fill: filled via ${datepickerFill.strategy} "${datepickerFill.postValue}"`
+                                        : `text-datepicker-fill: failed to commit "${fillValue.slice(0, 60)}" (post=${datepickerFill.postValue})`;
+                                    if (datepickerFill.filled) {
+                                        record.actResultSuccess = true;
+                                        resolvedAction = overriddenTarget;
+                                    }
+                                    else {
                                         record.actResultSuccess = false;
                                     }
-                                    else if (readback.outcome === "differs") {
-                                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} fill-value-differs: tried "${fillValue.slice(0, 60)}" got "${readback.postValue.slice(0, 60)}" (framework reformatted)`);
+                                }
+                                else {
+                                    // Fix I: not a date input — verify the regular fill landed.
+                                    // Catches silent-value-rejection cases (HTML5 type validation
+                                    // on number/email/url/tel inputs, framework-controlled-
+                                    // component rejection, masked-input library reformatting).
+                                    // Generic primitive that the verifier's existing signals
+                                    // (network/url/dom/htmlDelta/textChanged) miss.
+                                    const readback = await verifyFillReadback(dateFillTarget, overriddenTarget.selector, fillValue);
+                                    if (readback !== null) {
+                                        if (readback.outcome === "rejected") {
+                                            record.errorMessage = `fill-value-rejected: tried "${fillValue.slice(0, 60)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                                            record.actResultSuccess = false;
+                                        }
+                                        else if (readback.outcome === "differs") {
+                                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} fill-value-differs: tried "${fillValue.slice(0, 60)}" got "${readback.postValue.slice(0, 60)}" (framework reformatted)`);
+                                        }
                                     }
                                 }
                             }
@@ -6074,11 +6349,66 @@ async function executeStepWithHealing(params) {
         // actions (fill/check/etc.), same as domVerified, so it never lets an
         // advance/submit step ride a stray value mutation elsewhere on the page.
         const formValueVerified = isStateClass && post.formValueSignature !== pre.formValueSignature;
+        // Committed-value guard on the act-success path. A controlled datepicker
+        // (react-datepicker) accepts the typed value, discards it on React's next
+        // render, and — since the act resolved as a `click` that opened the calendar
+        // popup — rides `clickViewSwapVerified` to a phantom `dom=false` success
+        // without ever committing the date. The 1.9.0 `fillTextDatepickerInput`
+        // primitive (the open-and-pick gesture that DOES commit) sits in a fallback
+        // block only reached when the act "technically failed", so it never runs on
+        // this path. Route a fill-intent step whose value did NOT land (read-back
+        // rejected) into that primitive before the weak view-swap/form-value signals
+        // accept it — keyed on step PROSE, since the widget resolves as a click and
+        // its accessible name identifies the popup, not the field.
+        const fillIntent = parseFillValueIntent(step);
+        const hasStrongSignal = networkIsRealAdvance || urlChanged || domVerifiedForStep;
+        let datepickerCommitted = false;
+        let datepickerRejected = false;
+        if (shouldReadbackFillOnActSuccess({
+            actReportedSuccess: record.actResultSuccess === true,
+            isFillIntent: fillIntent !== null,
+            hasStrongSignal,
+        })) {
+            const readbackSelector = resolvedAction?.selector ?? triedSelectors[triedSelectors.length - 1] ?? null;
+            if (readbackSelector && fillIntent !== null) {
+                const readbackTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+                const readback = await verifyFillReadback(readbackTarget, readbackSelector, fillIntent.value);
+                if (readback?.outcome === "rejected") {
+                    // Value didn't land. First try the datepicker primitive; it self-gates
+                    // on react-datepicker's `.react-datepicker__input-container` and returns
+                    // null for any non-datepicker input, so a plain rejected fill falls
+                    // through to the failure path below unchanged.
+                    const datepickerFill = await fillTextDatepickerInput(readbackTarget, readbackSelector, fillIntent.value);
+                    if (datepickerFill !== null) {
+                        if (datepickerFill.filled) {
+                            datepickerCommitted = true;
+                            record.errorMessage = `text-datepicker-fill: filled via ${datepickerFill.strategy} "${datepickerFill.postValue}"`;
+                        }
+                        else {
+                            // A gated-in datepicker that neither gesture commits is a real fill
+                            // failure (per fillTextDatepickerInput's contract) — authoritative,
+                            // so suppress the weak view-swap/form-value acceptance and escalate.
+                            datepickerRejected = true;
+                            record.actResultSuccess = false;
+                            record.errorMessage = `text-datepicker-fill: failed to commit "${fillIntent.value.slice(0, 60)}" (post=${datepickerFill.postValue})`;
+                        }
+                    }
+                    else {
+                        // Not a datepicker — the fill was genuinely rejected. Same message
+                        // shape as the observe-act fill-fallback's readback verifier so the
+                        // failure dump reads identically regardless of which path caught it.
+                        datepickerRejected = true;
+                        record.actResultSuccess = false;
+                        record.errorMessage = `fill-value-rejected: tried "${fillIntent.value.slice(0, 60)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                    }
+                }
+            }
+        }
         let verified = networkIsRealAdvance ||
             urlChanged ||
             domVerifiedForStep ||
-            clickViewSwapVerified ||
-            formValueVerified;
+            datepickerCommitted ||
+            (!datepickerRejected && (clickViewSwapVerified || formValueVerified));
         // Final-step submit-verification gate. Replaces the deterministic
         // submitEndpointPattern regex with a Haiku 4.5 LLM judgment over
         // multi-signal evidence (network captures, page URL/title, DOM
@@ -6190,18 +6520,22 @@ async function executeStepWithHealing(params) {
         }
         if (verified && record.verifiedBy === null) {
             // Preserve a richer verdict set earlier in this attempt (e.g.
-            // "submitted-state-dom" from the final-step DOM fallback).
-            record.verifiedBy = clickViewSwapVerified
-                ? "view-swap"
-                : urlChanged
-                    ? "url"
-                    : networkFired
-                        ? "network"
-                        : domVerifiedForStep
-                            ? "dom"
-                            : formValueVerified
-                                ? "form-value"
-                                : "dom";
+            // "submitted-state-dom" from the final-step DOM fallback). A datepicker
+            // commit is a real DOM value change, so it ranks ahead of the weaker
+            // view-swap signal that the same calendar-open click also produces.
+            record.verifiedBy = datepickerCommitted
+                ? "dom"
+                : clickViewSwapVerified
+                    ? "view-swap"
+                    : urlChanged
+                        ? "url"
+                        : networkFired
+                            ? "network"
+                            : domVerifiedForStep
+                                ? "dom"
+                                : formValueVerified
+                                    ? "form-value"
+                                    : "dom";
         }
         // N+16 probe: Stagehand's CDP click sometimes lands on the button without
         // triggering React's SyntheticEvent layer (or jQuery delegated handlers).
@@ -6707,6 +7041,9 @@ async function runHealingFlow(deps) {
             }
         },
     });
+    if (shouldWarnMissingAdvancePattern(steps.map((s) => s.instruction), deps.advanceTransitionBodyPattern ?? null)) {
+        logger.warn("flow has advance steps but no advanceTransitionBodyPattern — DOM-only advance guard is disarmed; pointer/page desync is possible on validation-re-render wizards");
+    }
     try {
         for (const [i, s] of steps.entries()) {
             if (maxFlowMs !== undefined && Date.now() - start > maxFlowMs) {