@enricai/barnacle 1.12.2 → 1.12.3

package/dist/scraper/flow-runner.js

@@ -24,6 +24,7 @@ exports.findRecentPageTransition = findRecentPageTransition;
 exports.isWizardExitAction = isWizardExitAction;
 exports.isAdvanceStep = isAdvanceStep;
 exports.shouldCaptureSelectionState = shouldCaptureSelectionState;
+exports.flowHasSubmitSemantics = flowHasSubmitSemantics;
 exports.shouldWarnMissingAdvancePattern = shouldWarnMissingAdvancePattern;
 exports.parseCaptureIndex = parseCaptureIndex;
 exports.latestCaptureIndex = latestCaptureIndex;
@@ -58,6 +59,7 @@ exports.normalizeDateValue = normalizeDateValue;
 exports.fillHtml5DateTimeInput = fillHtml5DateTimeInput;
 exports.fillTextDatepickerInput = fillTextDatepickerInput;
 exports.verifyFillReadback = verifyFillReadback;
+exports.verifyPromptSelectorCommitted = verifyPromptSelectorCommitted;
 exports.isUploadAffordanceLabel = isUploadAffordanceLabel;
 exports.writeFixtureToTempFile = writeFixtureToTempFile;
 exports.attachToSurfacedInput = attachToSurfacedInput;
@@ -396,6 +398,18 @@ const PROMPT_SELECTOR_SETTLE_MS = 400;
 const PROMPT_WIDGET_MARK_ATTR = "data-bcl-prompt-idx";
 /** Same role as {@link PROMPT_WIDGET_MARK_ATTR}, but for the popup's rendered option entries. */
 const PROMPT_OPTION_MARK_ATTR = "data-bcl-prompt-opt-idx";
+/**
+ * Cross-vendor selector for a genuine focusable form control — the only kind
+ * of element a native click event reliably opens. Phase 1's container walk
+ * marks the OUTERMOST widget-kit container so one widget resolves to one
+ * candidate, but that container is often a layout wrapper with no click
+ * handler of its own (e.g. a typeahead/chip widget's real open+filter control
+ * is an `<input>` nested a level deeper, inside its own `*InputContainer`
+ * wrapper). Phase 2 prefers clicking this interactive descendant over the
+ * marked container itself, falling back to the container only when it has
+ * none — no vendor branch, just "click the real control if one exists".
+ */
+const PROMPT_INTERACTIVE_CONTROL_SELECTORS = "button,[role='combobox'],[role='button'],input";
 /**
  * Cross-vendor selector union that identifies the TRIGGER of a native-control-less
  * popup-dropdown widget (a combobox that opens a listbox popup and renders no
@@ -486,6 +500,30 @@ const PROMPT_EMPTY_VALUE_RX_FLAGS = PROMPT_EMPTY_VALUE_RX.flags;
  * the remaining `textContent`.
  */
 const BUTTON_VALUE_EXPR = "((el) => { const c = el.cloneNode(true); for (const n of c.querySelectorAll(\"[role='option'],[role='listbox'],[aria-hidden='true'],abbr,svg\")) n.remove(); return c.textContent || \"\"; })";
+/**
+ * Browser-side expression reading a prompt-selector widget's OWN committed-value
+ * text — the single source of truth for "is this widget filled?", shared by the
+ * widget-enumeration phase ({@link tryPromptSelectorPrimitive}'s
+ * `enumerateWidgetsExpr`) and the act-success committed-value gate
+ * ({@link verifyPromptSelectorCommitted}) so the two never drift into separate
+ * ideas of "committed". Value via the union: `aria-activedescendant` → the
+ * referenced option's text, else the widget's own value (an `<input>`'s
+ * `value`, or a `<button>`-trigger's own label text via {@link BUTTON_VALUE_EXPR}),
+ * else a selection-label node ({@link PROMPT_VALUE_SELECTORS}) — treating the
+ * widget-kit empty-state phrase ({@link PROMPT_EMPTY_VALUE_RX}) as no value.
+ */
+const PROMPT_CURRENT_TEXT_EXPR = `((w, valueSel, emptyRx) => {
+  const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
+  const buttonValue = ${BUTTON_VALUE_EXPR};
+  const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
+  if (adid) { const opt = document.getElementById(adid); if (opt && opt.textContent.trim()) return norm(opt.textContent); }
+  if (w.tagName === "INPUT" && (w.value || "").trim()) return norm(w.value);
+  if (w.tagName === "BUTTON" && buttonValue(w).trim()) return norm(buttonValue(w));
+  const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
+  const raw = lbl ? (lbl.textContent || "") : "";
+  if (raw.trim() && !emptyRx.test(raw.trim())) return norm(raw);
+  return "";
+})`;
 /**
  * Browser-side expression resolving the DOM root within which a chosen widget's
  * popup options / filter input live. Popup placement is vendor-split: the ARIA
@@ -923,8 +961,20 @@ function isAdvanceStep(instruction) {
  * cascade depends on is unit-testable, not buried in `executeStepWithHealing`.
  */
 function shouldCaptureSelectionState(params) {
-    const { step, isFinalStep, submitStep } = params;
-    return !(isFinalStep || submitStep || isAdvanceStep(step));
+    const { step, isFinalStep, submitStep, flowHasSubmitSemantics } = params;
+    return !(submitStep || (isFinalStep && flowHasSubmitSemantics) || isAdvanceStep(step));
+}
+/**
+ * Whether a flow has ANY submit semantics at all — a step flagged
+ * `submitStep: true`, a `submitEndpointPattern`, or `requireSubmitEndpointMatch`.
+ * A read-only flow (none of the three) has no submit shape anywhere, so its
+ * final step is an ordinary read/click, not a submit. Pure + exported so
+ * callers can stop inferring submit-shape from `isFinalStep` alone on flows
+ * that never declared a submit.
+ */
+function flowHasSubmitSemantics(params) {
+    const { steps, submitEndpointPattern, requireSubmitEndpointMatch } = params;
+    return (steps.some((s) => s.submitStep) || submitEndpointPattern !== null || requireSubmitEndpointMatch);
 }
 /**
  * Whether a flow should be WARNed that its DOM-only advance guard is disarmed.
@@ -1200,10 +1250,10 @@ function isDomOnlyAdvanceVerified(params) {
 function isClickViewSwapVerified(params) {
     const VIEW_SWAP_MIN_BYTES = config_1.config.scraper.viewSwapMinBytesThreshold;
     const VIEW_SWAP_REVEAL_MIN_BYTES = config_1.config.scraper.viewSwapRevealMinBytesThreshold;
-    const { resolvedAction, isFinalStep, submitStep, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, } = params;
+    const { resolvedAction, isFinalStep, submitStep, flowHasSubmitSemantics, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, } = params;
     if (resolvedAction?.method !== "click")
         return false;
-    if (isFinalStep || submitStep)
+    if (submitStep || (isFinalStep && flowHasSubmitSemantics))
         return false;
     if (isAdvanceWithPattern)
         return false;
@@ -2715,6 +2765,50 @@ async function verifyFillReadback(target, selector, expectedValue) {
         return null;
     }
 }
+/**
+ * Committed-value guard for the prompt-selector widget family
+ * (`data-uxi-widget-type='multiselect'`/`selectinput`, `role=combobox`, …),
+ * mirroring {@link verifyFillReadback}'s role for plain inputs but reading the
+ * widget's OWN committed-value node ({@link PROMPT_CURRENT_TEXT_EXPR}) instead
+ * of a bare `<input>.value` — a chip multiselect's committed state lives on
+ * `aria-activedescendant`/a selection-label node, not the trigger's own value.
+ * Walks UP from the resolved element to the nearest {@link PROMPT_TRIGGER_SELECTORS}
+ * ancestor (the resolved element is often the inner filter input or icon, not
+ * the widget container itself — same resolution discipline as
+ * `tryPromptSelectorPrimitive`'s widget-container walk). Returns
+ * `isPromptWidget: false` for a resolved element that isn't part of this
+ * widget family at all, so a non-prompt click/fill is untouched.
+ */
+async function verifyPromptSelectorCommitted(target, selector) {
+    const xpath = xpathBodyForEvaluate(selector);
+    if (xpath === null)
+        return null;
+    const expr = `(() => {
+    const triggerSel = ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)};
+    const valueSel = ${JSON.stringify(PROMPT_VALUE_SELECTORS)};
+    const emptyRx = new RegExp(${JSON.stringify(PROMPT_EMPTY_VALUE_RX_SRC)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_FLAGS)});
+    const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
+    const xpath = ${JSON.stringify(xpath)};
+    const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = result.singleNodeValue;
+    if (!el) return { isPromptWidget: false, committed: false };
+    const widget = el.matches && el.matches(triggerSel) ? el : el.closest(triggerSel);
+    if (!widget) return { isPromptWidget: false, committed: false };
+    return { isPromptWidget: true, committed: currentText(widget, valueSel, emptyRx) !== "" };
+  })()`;
+    try {
+        const raw = await target.evaluate(expr);
+        if (raw === null || typeof raw !== "object")
+            return null;
+        const r = raw;
+        if (typeof r.isPromptWidget !== "boolean" || typeof r.committed !== "boolean")
+            return null;
+        return { isPromptWidget: r.isPromptWidget, committed: r.committed };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Pull field-level errors out of an arbitrary JSON response body. Walks a
  * few of the conventional ATS shapes; falls through to `[]` so the caller
@@ -3521,11 +3615,54 @@ async function setFilesViaCdp(params) {
  * Recognizes the flow's conventional phrasings, all quoted:
  *   "select 'Yes'", "select or check 'BLS'",
  *   "for 'What is your highest level…?' select 'BSN completed'",
- *   "select 'Texas' in the State/Region dropdown".
+ *   "select 'Texas' in the State/Region dropdown",
+ *   "…then select the option 'Job Boards' from the popup list" (a compound
+ *   step that opens the widget in one clause and selects in another —
+ *   "select" is followed by a noun phrase like "the option"/"the value"
+ *   before the quoted option itself, rather than the quote directly).
  * Returns null when the step is not a single-dropdown select (e.g. generic
  * "for any remaining question…" catch-alls, or radio/checkbox-only steps) so
  * the caller falls through to the normal cascade.
  */
+// Nouns that name a form widget/question, used by `pickQuestionLabel` to tell
+// a genuine field label ("'How Did You Hear About Us?' prompt selector")
+// apart from an unrelated leading quoted phrase that just happens to precede
+// it in the instruction (e.g. a page/step-context quote like "'My
+// Information' step").
+const WIDGET_NOUN_RE = /\b(prompt\s+selector|multiselect|typeahead|dropdown|field|question|checkbox|radio\s+button|radio)\b/i;
+/**
+ * Pick the QUESTION LABEL out of an instruction's quoted phrases, given the
+ * already-extracted OPTION.
+ *
+ * Why this exists: an instruction can carry more than one quoted phrase that
+ * is not the option — e.g. a page/step-context phrase ("On the authenticated
+ * 'My Information' step, open the 'How Did You Hear About Us?' prompt
+ * selector…") — so naively taking the first non-option quote picks the
+ * context phrase instead of the actual widget label. This prefers a quote
+ * that sits immediately next to a widget noun (`multiselect`/`typeahead`/
+ * `dropdown`/`field`/`question`/`checkbox`/`radio button`/`prompt selector`)
+ * or is introduced
+ * by "for"/"for the"/"for the question"/"for the answer" (e.g. "click the
+ * 'Yes' answer for the question '…'"), before falling back to the first
+ * non-option quote so existing un-adorned phrasings keep working.
+ */
+function pickQuestionLabel(instruction, option) {
+    // biome-ignore lint/style/noNonNullAssertion: capture group 1 is required by the pattern, so it is present on every match
+    const candidates = [...instruction.matchAll(/'([^']+)'/g)].filter((m) => m[1].trim() !== option);
+    if (candidates.length === 0)
+        return null;
+    const adjacentToWidgetNoun = candidates.find((m) => {
+        const start = m.index ?? 0;
+        const end = start + m[0].length;
+        const before = instruction.slice(Math.max(0, start - 25), start);
+        const after = instruction.slice(end, end + 40);
+        return (/\bfor(?:\s+the)?(?:\s+(?:question|answer))?\s*$/i.test(before) || WIDGET_NOUN_RE.test(after));
+    });
+    // biome-ignore lint/style/noNonNullAssertion: candidates is guarded non-empty above, so the fallback element is always present
+    const picked = (adjacentToWidgetNoun ?? candidates[0]);
+    // biome-ignore lint/style/noNonNullAssertion: capture group 1 is required by the pattern, so it is present on every match
+    return picked[1].trim();
+}
 function parseSelectStep(instruction) {
     const lower = instruction.toLowerCase();
     // Must look like a dropdown selection, not a radio/checkbox click. "select
@@ -3541,16 +3678,20 @@ function parseSelectStep(instruction) {
     const quoted = [...instruction.matchAll(/'([^']+)'/g)].map((m) => m[1]);
     if (quoted.length === 0)
         return null;
-    // The OPTION is the quoted string immediately following the word "select".
-    const selMatch = instruction.match(/\bselect(?:\s+or\s+check)?\s+'([^']+)'/i);
+    // The OPTION is the quoted string following the word "select", allowing a
+    // short filler ("the option", "the answer") between the verb and the
+    // quote — real flow phrasing like "select the option 'Job Boards'" or
+    // "select the answer 'X'" otherwise fails to parse and the caller
+    // silently no-ops before touching the DOM.
+    const selMatch = instruction.match(/\bselect(?:\s+or\s+check)?\s+(?:the\s+\S+\s+)?'([^']+)'/i);
     if (!selMatch)
         return null;
     // biome-ignore lint/style/noNonNullAssertion: guarded by the !selMatch early-return; group 1 is required by the pattern
     const option = selMatch[1].trim();
     // The QUESTION LABEL, when present, is a DIFFERENT quoted string — the one
-    // introduced by "for '…'" or "in the '…' dropdown". Pick the first quoted
-    // string that is not the option.
-    const questionLabel = quoted.find((q) => q.trim() !== option)?.trim() ?? null;
+    // introduced by "for '…'" or adjacent to a widget noun like "'…' dropdown"
+    // or "'…' prompt selector". See `pickQuestionLabel`.
+    const questionLabel = pickQuestionLabel(instruction, option);
     return { option, questionLabel };
 }
 /**
@@ -3668,8 +3809,9 @@ function parseRadioStep(instruction) {
     // introduced by "for the question '…'" / "for the '…' question". Some steps
     // phrase the question un-quoted ("…about requiring visa sponsorship"); in
     // that case there is no second quoted string and questionLabel stays null,
-    // which the primitive handles via LLM group-matching.
-    const questionLabel = quoted.find((q) => q.trim() !== option)?.trim() ?? null;
+    // which the primitive handles via LLM group-matching. See
+    // `pickQuestionLabel`.
+    const questionLabel = pickQuestionLabel(instruction, option);
     return { option, questionLabel };
 }
 /**
@@ -4969,28 +5111,15 @@ async function tryPromptSelectorPrimitive(params) {
       }
       return "";
     };
-    const currentText = (w) => {
-      // Value via the union: aria-activedescendant → option text, the widget's
-      // own value (an <input>'s value, or a <button>-trigger's own label text —
-      // a button that IS the trigger carries the committed choice as its own
-      // text), else a selection-label node — treating the widget-kit empty-state
-      // phrase as no value.
-      const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
-      if (adid) { const opt = document.getElementById(adid); if (opt && opt.textContent.trim()) return norm(opt.textContent); }
-      if (w.tagName === "INPUT" && (w.value || "").trim()) return norm(w.value);
-      if (w.tagName === "BUTTON" && buttonValue(w).trim()) return norm(buttonValue(w));
-      const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
-      const raw = lbl ? (lbl.textContent || "") : "";
-      if (raw.trim() && !emptyRx.test(raw.trim())) return norm(raw);
-      return "";
-    };
+    const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
+    const currentTextOf = (w) => currentText(w, valueSel, emptyRx);
     const isUnfilled = (w) => {
       let node = w;
       for (let d = 0; d < 6 && node; d++) {
         if (node.getAttribute && isInvalid(node)) return true;
         node = node.parentElement;
       }
-      return currentText(w) === "";
+      return currentTextOf(w) === "";
     };
     // Clear stale marks from a prior call on this same page (this primitive
     // runs once per "select 'X'" step, and an application wizard answers several
@@ -5040,7 +5169,23 @@ async function tryPromptSelectorPrimitive(params) {
         }
         // Phase 2 (real gesture): open the popup. These widgets' trigger requires a
         // genuine click — a synthetic dispatchEvent does not fire its handler.
-        const triggerSel = `[${PROMPT_WIDGET_MARK_ATTR}="${chosen.wIdx}"]`;
+        // Prefer the marked widget's own interactive descendant (a real form
+        // control) over the marked container itself, since the container is
+        // frequently a non-interactive layout wrapper for widget shapes whose
+        // actual trigger sits a level deeper (see PROMPT_INTERACTIVE_CONTROL_SELECTORS).
+        const containerTriggerSel = `[${PROMPT_WIDGET_MARK_ATTR}="${chosen.wIdx}"]`;
+        const innerTriggerSel = PROMPT_INTERACTIVE_CONTROL_SELECTORS.split(",")
+            .map((s) => `${containerTriggerSel} ${s}`)
+            .join(",");
+        let triggerSel = containerTriggerSel;
+        try {
+            const innerCount = await target.locator(innerTriggerSel).count();
+            if (innerCount > 0)
+                triggerSel = innerTriggerSel;
+        }
+        catch {
+            // Fall back to the container selector.
+        }
         try {
             await target.locator(triggerSel).first().click();
         }
@@ -6146,7 +6291,7 @@ async function probeStepBeforeAttempts(params) {
     }
 }
 async function executeStepWithHealing(params) {
-    const { stagehand, page, step, optional, upload, submitStep, stepIndex, totalSteps, phase, signalCounter, recentCaptures, recentCaptureMeta, anthropic, rephraseModel, logger, captureFn, uploadFixture, isFinalStep, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, getSuppressedAisdkElementIdErrorCount, trajectory, onStepFailure, } = params;
+    const { stagehand, page, step, optional, upload, submitStep, flowHasSubmitSemantics: flowHasSubmitSemanticsFlag, stepIndex, totalSteps, phase, signalCounter, recentCaptures, recentCaptureMeta, anthropic, rephraseModel, logger, captureFn, uploadFixture, isFinalStep, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, getSuppressedAisdkElementIdErrorCount, trajectory, onStepFailure, } = params;
     // Mutable (not the destructured const above) so a lost frame-attach race
     // can be upgraded in place once the OOPIF attaches later in the cascade —
     // see reresolveFrameTargetIfLost below. Every existing reference in this
@@ -6214,7 +6359,12 @@ async function executeStepWithHealing(params) {
     // false-credit the step, and whose advance/submit verdicts require a real
     // network/URL transition. Also keeps the extra full-DOM evaluate off the
     // submit/advance path. Step-level intent (available before the attempt loop).
-    const captureSelectionState = shouldCaptureSelectionState({ step, isFinalStep, submitStep });
+    const captureSelectionState = shouldCaptureSelectionState({
+        step,
+        isFinalStep,
+        submitStep,
+        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+    });
     const attempts = [];
     const triedSelectors = [];
     const failureReasons = [];
@@ -6648,7 +6798,7 @@ async function executeStepWithHealing(params) {
         // techniques faster.
         if (attempt > 1) {
             const wouldBeTechnique = attempt === 2
-                ? phantomClickAfterAttempt1 && (isFinalStep || submitStep)
+                ? phantomClickAfterAttempt1 && (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))
                     ? "deep-submit-locator"
                     : phantomClickAfterAttempt1
                         ? "trusted-click-retry"
@@ -6667,7 +6817,7 @@ async function executeStepWithHealing(params) {
                 })),
                 advanceUnmovedAfterAttempt1,
                 phantomClickAfterAttempt1,
-                submitShapedStep: isFinalStep || submitStep,
+                submitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
             });
             if (decision.skip) {
                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt} (${wouldBeTechnique}) skipped: ${decision.reason}`);
@@ -6795,7 +6945,9 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
-            else if (attempt === 2 && phantomClickAfterAttempt1 && (isFinalStep || submitStep)) {
+            else if (attempt === 2 &&
+                phantomClickAfterAttempt1 &&
+                (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))) {
                 // Deep submit-control locator: attempt 1 phantom-clicked (Stagehand
                 // reported success but pre/post showed zero effect), so the target is
                 // almost certainly unreachable via document.querySelectorAll — most
@@ -6917,7 +7069,9 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
-            else if (attempt === 2 && phantomClickAfterAttempt1 && !(isFinalStep || submitStep)) {
+            else if (attempt === 2 &&
+                phantomClickAfterAttempt1 &&
+                !(submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))) {
                 // Trusted-click retry: attempt 1 phantom-clicked a NON-submit control —
                 // Stagehand reported success but pre/post showed zero effect. On a
                 // design-system widget (React synthetic-event delegation, custom
@@ -7595,7 +7749,7 @@ async function executeStepWithHealing(params) {
         // `advanceTransitionBodyPattern` are unaffected.
         const domVerifiedForStep = isDomOnlyAdvanceVerified({
             hasPattern: advanceTransitionBodyPattern !== null,
-            isFinalOrSubmit: isFinalStep || submitStep,
+            isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
             isAdvance: isAdvanceStep(step),
             domVerified,
             networkIsRealAdvance,
@@ -7628,6 +7782,7 @@ async function executeStepWithHealing(params) {
             resolvedAction,
             isFinalStep,
             submitStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
             isAdvanceWithPattern: isAdvanceStep(step) && advanceTransitionBodyPattern !== null,
             networkDelta: post.networkCount - pre.networkCount,
             bytesDelta: post.bodyHtmlLength - pre.bodyHtmlLength,
@@ -7714,11 +7869,44 @@ async function executeStepWithHealing(params) {
                 }
             }
         }
+        // Committed-value guard for the prompt-selector widget family (popup
+        // multiselect/typeahead trigger widgets). The primitive's own picking
+        // gesture ({@link tryPromptSelectorPrimitive}) only runs on the observe-act
+        // fallback path; a resolved-as-click act against the SAME widget shape can
+        // open its popup, report success, and — since opening a popup mutates the
+        // DOM (bytes changed) — ride `clickViewSwapVerified` to a phantom success
+        // without ever committing an option. Gate it the same way as the datepicker
+        // guard above: readback the widget's own committed-value node
+        // ({@link verifyPromptSelectorCommitted}) and, when the resolved element IS
+        // this widget shape but nothing committed, suppress the weak signals.
+        // `isPromptWidget: false` for anything outside this widget family, so a
+        // plain click/fill is untouched.
+        let promptSelectorRejected = false;
+        // Exempt only on a genuine network-advance or URL-change signal, not the
+        // broader `hasStrongSignal` (which the sibling datepicker gate above
+        // legitimately relies on) — `domVerifiedForStep` is true here simply
+        // because opening the widget's popup mutates the DOM, so reusing it would
+        // let that popup-open alone skip the readback below.
+        const hasNetworkOrUrlSignal = networkIsRealAdvance || urlChanged;
+        if (record.actResultSuccess === true && !hasNetworkOrUrlSignal) {
+            const readbackSelector = resolvedAction?.selector ?? triedSelectors[triedSelectors.length - 1] ?? null;
+            if (readbackSelector) {
+                const readbackTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+                const promptReadback = await verifyPromptSelectorCommitted(readbackTarget, readbackSelector);
+                if (promptReadback?.isPromptWidget === true && promptReadback.committed === false) {
+                    promptSelectorRejected = true;
+                    record.actResultSuccess = false;
+                    record.errorMessage = `prompt-selector-fill-rejected: resolved element <${readbackSelector}> is a prompt-selector-shaped widget but no committed value landed`;
+                }
+            }
+        }
         let verified = networkIsRealAdvance ||
             urlChanged ||
             domVerifiedForStep ||
             datepickerCommitted ||
-            (!datepickerRejected && (clickViewSwapVerified || formValueVerified));
+            (!datepickerRejected &&
+                !promptSelectorRejected &&
+                (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
@@ -8004,7 +8192,7 @@ async function executeStepWithHealing(params) {
                         }));
                     const fallbackDomOnlyAdvance = shouldVetoFallbackAdvance({
                         hasPattern: advanceTransitionBodyPattern !== null,
-                        isFinalOrSubmit: isFinalStep || submitStep,
+                        isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
                         isAdvance: isAdvanceStep(step),
                         retryUrlChanged,
                         retryNetworkIsRealAdvance,
@@ -8159,7 +8347,7 @@ async function executeStepWithHealing(params) {
             // checked) into `domVerified`. A registered selection toggle no longer
             // reads as a phantom just because it moved no network/URL/bytes.
             elementStateChanged: domVerified,
-            isSubmitShapedStep: isFinalStep || submitStep,
+            isSubmitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
         });
         const reason = record.errorMessage
             ? effectSignals
@@ -8178,7 +8366,8 @@ async function executeStepWithHealing(params) {
         // Empirically grounded: 22 of 22 JSON-envelope ATS Continue/Submit step-failure
         // dumps in a 2026-06-10 survey had the paired touched+dirty + visible
         // error text pattern with 3 distinct rejection messages.
-        if (record.resolvedMethod === "click" && (isFinalStep || submitStep)) {
+        if (record.resolvedMethod === "click" &&
+            (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))) {
             const live = await extractLivePageFormEvidence(page, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), {
                 client: anthropic,
                 knownErrorClassPrefixes,
@@ -8223,7 +8412,7 @@ async function executeStepWithHealing(params) {
             phantomClickAfterAttempt1 = record.phantomClickVerdict === "phantom";
             if (phantomClickAfterAttempt1) {
                 const suppressedCount = getSuppressedAisdkElementIdErrorCount?.();
-                const escalationTarget = isFinalStep || submitStep
+                const escalationTarget = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag)
                     ? "escalating attempt 2 to deep-submit-locator"
                     : "non-submit step — escalating attempt 2 to trusted-click-retry (trusted CDP click on the resolved target)";
                 logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} phantom click detected on attempt 1 (${record.technique}): reported success with no network/url/dom change${suppressedCount !== undefined ? `; ${suppressedCount} AISDK elementId errors suppressed this session (corroborating, not causal)` : ""} — ${escalationTarget}`);
@@ -8233,7 +8422,7 @@ async function executeStepWithHealing(params) {
                 // Treat the canonical submit click as "final" for this predicate
                 // even when it lives mid-flow. See requireSubmitEndpoint derivation
                 // above for the same gate-widening rationale.
-                isFinalStep: isFinalStep || submitStep,
+                isFinalStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
                 requireSubmitEndpoint,
                 resolvedMethod: record.resolvedMethod,
                 effectSignals,
@@ -8253,7 +8442,7 @@ async function executeStepWithHealing(params) {
             // can reorder a later step forward — instead of burning the cascade.
             const advanceStalled = isAdvanceStalled({
                 isAdvance: isAdvanceStep(step),
-                isFinalOrSubmit: isFinalStep || submitStep,
+                isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
                 hasPattern: advanceTransitionBodyPattern !== null,
                 clickFired: record.resolvedMethod === "click" && record.actResultSuccess === true,
                 networkFired,
@@ -8399,6 +8588,11 @@ async function runHealingFlow(deps) {
             }
         },
     });
+    const flowHasSubmitSemanticsFlag = flowHasSubmitSemantics({
+        steps,
+        submitEndpointPattern: deps.submitEndpointPattern ?? null,
+        requireSubmitEndpointMatch: deps.requireSubmitEndpointMatch ?? false,
+    });
     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");
     }
@@ -8423,6 +8617,7 @@ async function runHealingFlow(deps) {
                 optional: s.optional,
                 upload: s.upload,
                 submitStep: s.submitStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
                 stepIndex: i,
                 totalSteps: () => steps.length,
                 phase: "flow",