@enricai/barnacle 1.12.77 → 1.12.79

package/dist/scraper/flow-runner.js

@@ -27,6 +27,9 @@ exports.findRecentPageTransition = findRecentPageTransition;
 exports.isWizardExitAction = isWizardExitAction;
 exports.isAdvanceStep = isAdvanceStep;
 exports.isSubmitIntentStep = isSubmitIntentStep;
+exports.stripNegatedSubmitClauses = stripNegatedSubmitClauses;
+exports.classifyStepSubmitIntent = classifyStepSubmitIntent;
+exports.isStepSubmitShaped = isStepSubmitShaped;
 exports.isCheckboxOrRadioIntentStep = isCheckboxOrRadioIntentStep;
 exports.shouldCaptureSelectionState = shouldCaptureSelectionState;
 exports.flowHasSubmitSemantics = flowHasSubmitSemantics;
@@ -1141,6 +1144,14 @@ function findRecentBackendError(params) {
     }
     return null;
 }
+/**
+ * Network-capture transitions say a request succeeded, not where the page
+ * landed, so a credit must also see a landed URL the step could plausibly have
+ * targeted (e.g. not a sign-in bounce the instruction never asked for).
+ */
+async function isLandedUrlPlausibleForStep(page, target, step) {
+    return (0, phantom_click_1.isPlausibleStepDestination)(step, await (0, frame_target_1.readCurrentFrameUrl)(page, target));
+}
 /**
  * Detect whether the page legitimately transitioned within the supplied
  * capture-meta window — a 3xx redirect or a same-origin non-GET capture
@@ -1277,6 +1288,60 @@ function isSubmitIntentStep(instruction) {
     const haystack = instruction.toLowerCase();
     return SUBMIT_INTENT_STEP_PHRASES.some((p) => haystack.includes(p));
 }
+/**
+ * Targets whose negation declares the step is not a submit: a checkout/payment/
+ * order/submit action, or a "proceeds/leads/advances to" phrase naming one.
+ * Bare "do not click Book Now" stays undeclared — the control name alone says
+ * nothing about whether the author means a submit.
+ */
+const SUBMIT_TARGET_SRC = "(?:(?:proceed|advance|move|go|lead|take|navigate|continue)(?:s|ing|es)?\\s+(?:you\\s+)?(?:on\\s+)?(?:to|toward|towards|into|with)\\s+(?:the\\s+|a\\s+|your\\s+)?(?:\\w+\\s+)?(?:checkout|check ?out|payments?|purchase|order|booking|reservation)|(?:place|complete|finali[sz]e|confirm)(?:s|ing)?\\s+(?:the\\s+|your\\s+|an?\\s+)?(?:order|purchase|booking|reservation|payment|checkout)|(?:advance|move|go|lead|take|navigate|continue)(?:s|ing|es)?\\s+(?:you\\s+)?(?:on\\s+)?(?:to|toward|towards|into|with|past|through)\\s+(?:the\\s+|a\\s+|your\\s+)?(?:next|following|final|last)\\s+(?:step|page|screen|stage)|(?:advance|advances|advancing)\\s+(?:the\\s+|your\\s+)?(?:booking|order|reservation|purchase)|check ?out|pay(?:ment|ing)?|purchas(?:e|es|ing)|buy(?:s|ing)?|charg(?:e|es|ing)|submit(?:s|ting)?)";
+/**
+ * A negation followed, in the same clause, by a submit target ("Do NOT click
+ * ... any control that proceeds to checkout"), or an explicit "this is not a
+ * submit click" / "without submitting" declaration.
+ */
+const NEGATED_SUBMIT_CLAUSE = new RegExp(`\\b(?:do not|don't|dont|never|must not|should not|shouldn't|does not|doesn't|avoid|refrain from)\\b[^.;\\n]*?\\b${SUBMIT_TARGET_SRC}\\b[^.;\\n]*|\\b(?:(?:this|that|it)\\s+(?:is|are)\\s+not|is not|isn't|not)\\s+(?:a|an|the)?\\s*(?:final\\s+|actual\\s+)?(?:submit|submission|checkout|payment|purchase)\\b[^.;\\n]*|\\bwithout\\s+(?:${SUBMIT_TARGET_SRC})\\b[^.;\\n]*`, "gi");
+/** A positive submit imperative outside any negated clause ("Submit the form."). */
+const LEADING_SUBMIT_IMPERATIVE = /(?:^|[.;]\s*)(?:then\s+)?submit\b/i;
+/**
+ * The instruction with every negated submit clause blanked, so callers that
+ * match submit wording on the step text (flow-load seeding) read only what the
+ * step positively asks for and never a guardrail ("Do NOT ... proceeds to
+ * checkout"). Pure.
+ */
+function stripNegatedSubmitClauses(instruction) {
+    return instruction.replace(NEGATED_SUBMIT_CLAUSE, " ");
+}
+/**
+ * Reads the step's own instruction for a declared submit intent, so an
+ * explicit "this is NOT a submit/checkout click" can veto inferred submit
+ * shape. A positive submit phrase outside the negated clause keeps "submit"
+ * so a real submit step that mentions a guardrail is not demoted. Pure.
+ */
+function classifyStepSubmitIntent(instruction) {
+    if (!instruction)
+        return "unspecified";
+    const remainder = stripNegatedSubmitClauses(instruction);
+    if (isSubmitIntentStep(remainder) || LEADING_SUBMIT_IMPERATIVE.test(remainder))
+        return "submit";
+    if (remainder !== instruction)
+        return "non-submit";
+    return isSubmitIntentStep(instruction) ? "submit" : "unspecified";
+}
+/**
+ * Single seam answering "is this step submit-shaped?": an explicit `submitStep`
+ * flag is authoritative, a declared non-submit instruction vetoes every
+ * inferred path, otherwise final-step inference or submit-intent wording applies.
+ */
+function isStepSubmitShaped(params) {
+    const { step, submitStep, isFinalStep, flowHasSubmitSemantics: flowSubmit } = params;
+    if (submitStep)
+        return true;
+    const intent = classifyStepSubmitIntent(step);
+    if (intent === "non-submit")
+        return false;
+    return (isFinalStep && flowSubmit) || intent === "submit";
+}
 /**
  * Is this flow step's intent to check a checkbox or select a radio option?
  * Used to veto a weak page-wide DOM signal (htmlDelta/textChanged/formValueChanged)
@@ -1623,13 +1688,26 @@ function isDomOnlyAdvanceVerified(params) {
  * when the probe can't run (non-xpath selector, evaluate failure) it stays
  * at its default `true` so it never manufactures a veto out of missing
  * information. Only a confirmed `false` blocks the credit.
+ *
+ * **Destination-plausibility veto:** none of the signals above look at
+ * WHERE the click landed. A non-submit click that bounces to a page
+ * {@link isPlausibleStepDestination} rejects as implausible for the step
+ * (e.g. a settings-panel tab switcher landing on an unrelated marketing
+ * page) can still clear every byte/text threshold above, crediting a
+ * phantom transition the same way a same-page toggle is credited.
+ * `destinationPlausible` is optional and defaults to the `!== false`
+ * no-veto behavior — matching the sibling `destinationPlausible` param on
+ * `classifyPhantomClick` — so existing/future callers that don't thread it
+ * are unaffected.
  */
 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, submitStep, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, clickedElementStillPresent = true, resolvedElementIsSubmitShaped = false, } = params;
+    const { resolvedAction, submitStep, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, clickedElementStillPresent = true, resolvedElementIsSubmitShaped = false, destinationPlausible, } = params;
     if (resolvedAction?.method !== "click")
         return false;
+    if (destinationPlausible === false)
+        return false;
     // Only the step's own explicit submitStep flag identifies the step that
     // actually needs network/URL verification — mirrors the submit-judge
     // gate's hasSubmitTransitionSignal discipline (see 5763ac2). Inferring
@@ -3341,7 +3419,7 @@ function xpathTailForRetarget(xpath) {
  * bar, preserving the previous behavior for every single-match (the common)
  * case.
  */
-const XPATH_TAIL_RETARGET_RESOLVE_FN_SRC = `((tail) => {
+const XPATH_TAIL_RETARGET_RESOLVE_FN_SRC = `((tail, preferSubmit) => {
     const isNegative = ${submit_control_1.NEGATIVE_TEXT_EXPR};
     const accessibleName = (el) =>
       (el.getAttribute("aria-label") || el.textContent || "").replace(/\\s+/g, " ").trim().toLowerCase();
@@ -3350,6 +3428,7 @@ const XPATH_TAIL_RETARGET_RESOLVE_FN_SRC = `((tail) => {
     const nodes = [];
     for (let i = 0; i < r.snapshotLength; i++) nodes.push(r.snapshotItem(i));
     if (nodes.length <= 1) return nodes[0] || null;
+    if (!preferSubmit) return nodes[0];
     const preferred = nodes.find((el) => isSubmitShaped(el) && !isNegative(accessibleName(el)));
     return preferred || nodes[0];
   })`;
@@ -3696,7 +3775,7 @@ async function resolvedClickTargetIsSubmitShaped(target, selector, xpathTail = n
     const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
     let el = r.singleNodeValue;
     if (!el && ${JSON.stringify(xpathTail)}) {
-      el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)});
+      el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}, ${JSON.stringify(true)});
     }
     const isSubmitShaped = ${submit_control_1.SUBMIT_SHAPE_EXPR};
     return isSubmitShaped(el);
@@ -4873,10 +4952,11 @@ Object.defineProperty(exports, "hasOriginOrPathChanged", { enumerable: true, get
  * independently of whether `advanceTransitionBodyPattern` is configured.
  */
 async function waitForCaptchaNavigation(params) {
-    const { page, captchaTarget, baselineUrl, timeoutMs, intervalMs } = params;
+    const { page, captchaTarget, baselineUrl, step, timeoutMs, intervalMs } = params;
     const check = async () => {
         const currentUrl = await (0, frame_target_1.readCurrentFrameUrl)(page, captchaTarget);
-        return (0, phantom_click_1.hasOriginOrPathChanged)(baselineUrl, currentUrl);
+        return ((0, phantom_click_1.hasOriginOrPathChanged)(baselineUrl, currentUrl) &&
+            (0, phantom_click_1.isPlausibleStepDestination)(step, currentUrl));
     };
     if (await check())
         return true;
@@ -5246,6 +5326,7 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
                 pre,
                 post,
                 isSubmitShapedStep: true,
+                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, post.url),
             });
             if (verdict !== "phantom")
                 return true;
@@ -5258,8 +5339,18 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
                         return { clicked: false };
                     throw err;
                 });
-                if (runnerUpClickResult.clicked)
-                    return true;
+                if (runnerUpClickResult.clicked) {
+                    const runnerUpPost = await snapshotPage(target, verification.signalCounter, verification.page);
+                    const runnerUpVerdict = (0, phantom_click_1.classifyPhantomClick)({
+                        actResultSuccess: true,
+                        pre: post,
+                        post: runnerUpPost,
+                        isSubmitShapedStep: true,
+                        destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, runnerUpPost.url),
+                    });
+                    if (runnerUpVerdict !== "phantom")
+                        return true;
+                }
             }
         }
     }
@@ -7973,7 +8064,7 @@ function redactIfSensitive(text, sensitiveValue) {
  * candidate was actually clickable, or every click phantomed.
  */
 async function probeChildFrameSubmitFallback(params) {
-    const { page, signalCounter } = params;
+    const { page, signalCounter, step } = params;
     // `page.mainFrameId`/`page.frames` are read defensively: some call sites
     // (and their test fakes) model a `Page` that never attaches child frames at
     // all and doesn't implement this pair, which is indistinguishable here from
@@ -8032,6 +8123,7 @@ async function probeChildFrameSubmitFallback(params) {
             pre,
             post,
             isSubmitShapedStep: true,
+            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, post.url),
         });
         if (verdict !== "phantom")
             return target;
@@ -8047,6 +8139,7 @@ async function probeChildFrameSubmitFallback(params) {
             pre,
             post: runnerUpPost,
             isSubmitShapedStep: true,
+            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, runnerUpPost.url),
         });
         if (runnerUpVerdict !== "phantom")
             return target;
@@ -8228,7 +8321,8 @@ async function executeStepWithHealing(params) {
     // Submit, and unfilled required fields produce silent submit failures
     // (verified 2026-06-15 on one measured tenant's telemetry). Site-agnostic: any flow
     // whose submit is mid-list can mark its submit step explicitly.
-    const requireSubmitEndpoint = (isFinalStep || submitStep) && submitEndpointPattern !== null;
+    const stepDeclaredNonSubmit = !submitStep && classifyStepSubmitIntent(step) === "non-submit";
+    const requireSubmitEndpoint = (isFinalStep || submitStep) && !stepDeclaredNonSubmit && submitEndpointPattern !== null;
     // Capture the per-element selection baseline (for verifyDomEffect's element-
     // scoped click read-back) ONLY for selection/field-answer click steps — never
     // for submit/advance steps, whose own self-toggling buttons must not
@@ -8380,7 +8474,12 @@ async function executeStepWithHealing(params) {
     // when no solver key is configured or the solve otherwise fails — that
     // propagates out of this function unchanged, so the step fails cleanly
     // instead of silently falling through as if unverified-but-passing.
-    const isSubmitOrFinalStep = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step);
+    const isSubmitOrFinalStep = isStepSubmitShaped({
+        step,
+        submitStep,
+        isFinalStep,
+        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+    });
     if (captchaGated && isSubmitOrFinalStep) {
         let captchaTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
         const sitekeyProbeExpr = `(() => {
@@ -8523,6 +8622,7 @@ async function executeStepWithHealing(params) {
                         fallbackSubmitted = await submitCaptchaGatedForm(captchaTarget, "h-captcha-response", {
                             signalCounter,
                             page,
+                            step,
                         });
                     }
                     catch (err) {
@@ -8567,6 +8667,7 @@ async function executeStepWithHealing(params) {
                     page,
                     captchaTarget,
                     baselineUrl: pageUrl,
+                    step,
                     timeoutMs: CAPTCHA_TRANSITION_POLL_MS,
                     intervalMs: ADVANCE_TRANSITION_POLL_INTERVAL_MS,
                 });
@@ -8586,7 +8687,8 @@ async function executeStepWithHealing(params) {
                     recentCaptureMeta,
                     preMetaLength: preCaptchaMetaLength,
                 });
-                if (networkTransitionUrl !== null) {
+                if (networkTransitionUrl !== null &&
+                    (await isLandedUrlPlausibleForStep(page, captchaTarget, step))) {
                     logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: post-submit network response confirmed the advance (${networkTransitionUrl})`);
                     trajectory?.push({ stepIndex, verifiedBy: "network" });
                     return "completed";
@@ -8703,7 +8805,8 @@ async function executeStepWithHealing(params) {
             recentCaptureMeta,
             preMetaLength: stepStartMetaLength,
         });
-        if (transitionUrl !== null) {
+        if (transitionUrl !== null &&
+            (await isLandedUrlPlausibleForStep(page, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), step))) {
             logger.info(`${formatStepPrefix(stepIndex, totalSteps)} skipped (probe absent but recent transition detected: ${transitionUrl})`);
             trajectory?.push({ stepIndex, verifiedBy: "url" });
             return "completed";
@@ -8733,8 +8836,13 @@ async function executeStepWithHealing(params) {
         // a radio/select answer) could complete the step by clicking an unrelated
         // submit control in an unrelated same-origin child iframe.
         if (!frameTarget?.declaredFrameSelector &&
-            (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step))) {
-            const fallbackTarget = await probeChildFrameSubmitFallback({ page, signalCounter });
+            isStepSubmitShaped({
+                step,
+                submitStep,
+                isFinalStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            })) {
+            const fallbackTarget = await probeChildFrameSubmitFallback({ page, signalCounter, step });
             if (fallbackTarget) {
                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} probe-absent: no candidate in the resolved frame, but a same-origin child iframe surfaced a submit-shaped candidate — clicked and verified there instead of failing`);
                 trajectory?.push({ stepIndex, verifiedBy: "dom" });
@@ -8767,7 +8875,12 @@ async function executeStepWithHealing(params) {
         const unfocusedObserve = probeAbsentObservedUnfocused.length === 0 && frameTarget?.frame
             ? await deepLocatorCandidatesAsActions(page, frameTarget)
             : probeAbsentObservedUnfocused;
-        const targetResolutionDiagnostic = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step)
+        const targetResolutionDiagnostic = isStepSubmitShaped({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        })
             ? await (0, target_resolution_diagnostic_1.captureTargetResolutionDiagnosticSnapshot)(frameTarget, page)
             : null;
         const dumpPath = onStepFailure?.({
@@ -9052,6 +9165,7 @@ async function executeStepWithHealing(params) {
     // already has an up-to-date ranking to report from.
     let lastRankedSubmitCandidates = null;
     for (let attempt = 1; attempt <= MAX_STEP_ATTEMPTS; attempt++) {
+        params.abortSignal?.throwIfAborted();
         // Telemetry-driven technique-skip: when a cascade technique's
         // preconditions cannot be met by the prior attempts' state, running
         // it would burn the attempt slot without exercising new behaviour.
@@ -9060,7 +9174,12 @@ async function executeStepWithHealing(params) {
         if (attempt > 1) {
             const wouldBeTechnique = attempt === 2
                 ? attempt1UnreachableViaLightDom &&
-                    (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step))
+                    isStepSubmitShaped({
+                        step,
+                        submitStep,
+                        isFinalStep,
+                        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                    })
                     ? "deep-submit-locator"
                     : phantomClickAfterAttempt1
                         ? "trusted-click-retry"
@@ -9079,7 +9198,12 @@ async function executeStepWithHealing(params) {
                 })),
                 advanceUnmovedAfterAttempt1,
                 attempt1UnreachableViaLightDom,
-                submitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
+                submitShapedStep: isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                }),
             });
             if (decision.skip) {
                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt} (${wouldBeTechnique}) skipped: ${decision.reason}`);
@@ -9217,7 +9341,12 @@ async function executeStepWithHealing(params) {
             }
             else if (attempt === 2 &&
                 attempt1UnreachableViaLightDom &&
-                (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step))) {
+                isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                })) {
                 // Deep submit-control locator: attempt 1 either phantom-clicked
                 // (Stagehand reported success but pre/post showed zero effect) or
                 // came back "unresolved" (act() found zero candidates at all), so the
@@ -9301,6 +9430,7 @@ async function executeStepWithHealing(params) {
                                 // stray selection flip must not mask a top-pick phantom and skip
                                 // the runner-up retry.
                                 isSubmitShapedStep: true,
+                                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, midPost.url),
                             });
                             if (topVerdict === "phantom") {
                                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} deep-submit-locator top pick (${top.tag} "${top.accessibleName}") phantom-clicked; retrying runner-up ${runnerUp.tag} "${runnerUp.accessibleName}" (tier ${runnerUp.tier})`);
@@ -9343,7 +9473,12 @@ async function executeStepWithHealing(params) {
             }
             else if (attempt === 2 &&
                 phantomClickAfterAttempt1 &&
-                !(submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step))) {
+                !isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: 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
@@ -9997,7 +10132,10 @@ async function executeStepWithHealing(params) {
             record.resolvedArguments = (resolvedAction.arguments ?? []).map(String);
         }
         const networkFired = post.networkCount > pre.networkCount;
-        const urlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, post.url) && (0, phantom_click_1.isPlausibleStepDestination)(step, post.url);
+        // Computed once: gates every credit signal that takes no post-click URL
+        // (network, DOM read-back) and classifyPhantomClick's destinationPlausible.
+        const destinationPlausible = (0, phantom_click_1.isPlausibleStepDestination)(step, post.url);
+        const urlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, post.url) && destinationPlausible;
         const isStateClass = resolvedAction !== null && STATE_CLASS_METHODS.has(resolvedAction.method ?? "");
         const isClick = resolvedAction !== null && resolvedAction.method === "click";
         // State-class actions (fill/check/etc.) never move the network counter or URL,
@@ -10032,7 +10170,7 @@ async function executeStepWithHealing(params) {
         // short-circuits when the transition is already in-window (zero added latency
         // on the common path). Scoped by preCaptureIdx via an eviction-proof disk scan.
         const advanceGateTimeoutMs = captchaGated && isSubmitOrFinalStep ? CAPTCHA_TRANSITION_POLL_MS : ADVANCE_TRANSITION_POLL_MS;
-        const networkIsRealAdvance = !advanceGateActive
+        const networkAdvanced = !advanceGateActive
             ? networkFired
             : await waitForTransitionBody({
                 page,
@@ -10041,7 +10179,8 @@ async function executeStepWithHealing(params) {
                 timeoutMs: advanceGateTimeoutMs,
                 intervalMs: ADVANCE_TRANSITION_POLL_INTERVAL_MS,
             });
-        if (advanceGateActive && !networkIsRealAdvance) {
+        const networkIsRealAdvance = networkAdvanced && destinationPlausible;
+        if (advanceGateActive && !networkAdvanced) {
             logger.info(`${formatStepPrefix(stepIndex, totalSteps)} network fired but no advance-transition (type=next) body matched within ${advanceGateTimeoutMs}ms poll (non-advancing POST); not treating as verified`);
         }
         // DOM-only-advance veto (opt-in). A rephrase can turn an advance/"Next" step
@@ -10059,15 +10198,20 @@ async function executeStepWithHealing(params) {
         // `advanceTransitionBodyPattern` are unaffected.
         const domVerifiedForStep = isDomOnlyAdvanceVerified({
             hasPattern: advanceTransitionBodyPattern !== null,
-            isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
+            isFinalOrSubmit: isStepSubmitShaped({
+                step,
+                submitStep,
+                isFinalStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            }),
             isAdvance: isAdvanceStep(step),
-            domVerified,
+            domVerified: domVerified && destinationPlausible,
             networkIsRealAdvance,
             urlChanged,
         })
-            ? domVerified
+            ? domVerified && destinationPlausible
             : false;
-        if (domVerified && !domVerifiedForStep) {
+        if (domVerified && !domVerifiedForStep && destinationPlausible) {
             logger.info(`${formatStepPrefix(stepIndex, totalSteps)} advance step succeeded only via DOM state change (field toggle / non-advancing POST), not a real transition; not treating as verified`);
         }
         // Blocked-submit veto input for the view-swap gate below. Read post-click
@@ -10092,7 +10236,7 @@ async function executeStepWithHealing(params) {
         // Attribute-based submit-shape read of the resolved click target itself —
         // independent of the flow-authored `submitStep` flag. See
         // resolvedClickTargetIsSubmitShaped's doc comment.
-        const resolvedElementIsSubmitShaped = isClick && resolvedAction?.selector
+        const resolvedElementIsSubmitShaped = isClick && !stepDeclaredNonSubmit && resolvedAction?.selector
             ? await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector)
             : false;
         // Client-side view-swap gate: credit a click that produces substantial
@@ -10102,7 +10246,8 @@ async function executeStepWithHealing(params) {
         // Below that threshold, also credits a smaller text-changing reveal (≥500B) —
         // fixes the top-window site Work-History gate-message reveal (+789B) that used to
         // cascade to a 5-attempt failure and global replan. Vetoed when the click's
-        // ng-invalid marker count grew (see isClickViewSwapVerified's doc comment).
+        // ng-invalid marker count grew, or when the landed destination is implausible
+        // for the step (see isClickViewSwapVerified's doc comment).
         const clickViewSwapVerified = isClickViewSwapVerified({
             resolvedAction,
             submitStep,
@@ -10113,6 +10258,7 @@ async function executeStepWithHealing(params) {
             invalidMarkerDelta: postInvalidMarkerCount - preInvalidMarkerCount,
             clickedElementStillPresent,
             resolvedElementIsSubmitShaped,
+            destinationPlausible,
         });
         if (clickViewSwapVerified === false &&
             isClick &&
@@ -10145,12 +10291,15 @@ async function executeStepWithHealing(params) {
         // submitStep, inferred final-step, or an attribute-detected submit
         // control) may not ride this signal alone — only when the submit-judge
         // gate (requireSubmitEndpoint) will re-litigate the credit below.
-        const formValueWeakSignalAllowed = !(submitStep ||
-            (isFinalStep && flowHasSubmitSemanticsFlag) ||
-            resolvedElementIsSubmitShaped ||
-            isSubmitIntentStep(step)) || requireSubmitEndpoint;
+        const formValueWeakSignalAllowed = !(isStepSubmitShaped({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        }) || resolvedElementIsSubmitShaped) || requireSubmitEndpoint;
         const formValueVerified = isStateClass &&
             formValueWeakSignalAllowed &&
+            destinationPlausible &&
             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
@@ -10253,9 +10402,14 @@ async function executeStepWithHealing(params) {
             actResultSuccess: record.actResultSuccess,
             pre,
             post,
-            elementStateChanged: domVerified,
-            isSubmitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
-            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, post.url),
+            elementStateChanged: domVerified && destinationPlausible,
+            isSubmitShapedStep: isStepSubmitShaped({
+                step,
+                submitStep,
+                isFinalStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            }),
+            destinationPlausible,
         });
         // An `"effective"` verdict driven purely by the page-wide byte-delta
         // floor (`TRIVIAL_DOM_DELTA_BYTES`, 500B) is intentionally NOT trusted
@@ -10276,8 +10430,12 @@ async function executeStepWithHealing(params) {
         // respects the SAME DOM-only-advance veto as the block above: a wizard
         // "Next" step on a pattern-configured site whose only signal is a field
         // toggle must stay unverified, not get waved through by the verdict.
-        const domEffectiveVerdict = !(submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step)) &&
-            domVerifiedForStep;
+        const domEffectiveVerdict = !isStepSubmitShaped({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        }) && domVerifiedForStep;
         let verified = networkIsRealAdvance ||
             urlChanged ||
             domVerifiedForStep ||
@@ -10492,11 +10650,15 @@ async function executeStepWithHealing(params) {
                     // tail node `clickExpr` below is about to click, instead of only
                     // ever checking the (possibly unresolvable) primary xpath — see
                     // resolvedClickTargetIsSubmitShaped's doc comment.
-                    const retryResolvedElementIsSubmitShaped = await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector, xpathTail);
+                    const retryResolvedElementIsSubmitShaped = stepDeclaredNonSubmit
+                        ? false
+                        : await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector, xpathTail);
                     // See resolvedClickUsedXpathTailRetarget's doc comment: flags that
                     // this click's target identity came only from the loose tail
                     // heuristic, not Stagehand's own resolved selector.
-                    const retryClickUsedXpathTailRetarget = await resolvedClickUsedXpathTailRetarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector, xpathTail);
+                    const retryClickUsedXpathTailRetarget = stepDeclaredNonSubmit
+                        ? false
+                        : await resolvedClickUsedXpathTailRetarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector, xpathTail);
                     // Trusted-click delivery for the plain-click branch: attempted
                     // BEFORE the resolve/activate expression below (so a successful
                     // delivery can suppress the synthetic `clickActivationExpr`
@@ -10528,7 +10690,7 @@ async function executeStepWithHealing(params) {
                     const n16TrustedClickFailure = !n16TrustedDelivered && "reason" in n16TrustedClickResult
                         ? n16TrustedClickResult
                         : null;
-                    const clickExpr = `(() => { const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null); let el = r.singleNodeValue; if (!el && ${JSON.stringify(xpathTail)}) { el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}); } if (!el || typeof el.click !== "function") return { fired: false }; if (el.tagName === "LABEL") { const wrapped = el.querySelector("input[type=checkbox], input[type=radio]"); if (wrapped) el = wrapped; } if (el.type === "checkbox" || el.type === "radio") { el.checked = true; el.dispatchEvent(new Event("click", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); return { fired: true, kind: "checkbox", checked: el.checked }; } let __n16SmMatched = false; ${(0, browser_click_expr_1.retargetToSelectionMarkerExpr)("el", "__n16SmMatched")} ${n16TrustedDelivered ? "" : (0, browser_click_expr_1.clickActivationExpr)("el")} if (__n16SmMatched) { el.dispatchEvent(new Event("change", { bubbles: true })); } return { fired: true, kind: "click" }; })()`;
+                    const clickExpr = `(() => { const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null); let el = r.singleNodeValue; if (!el && ${JSON.stringify(xpathTail)}) { el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}, ${JSON.stringify(!stepDeclaredNonSubmit)}); } if (!el || typeof el.click !== "function") return { fired: false }; if (el.tagName === "LABEL") { const wrapped = el.querySelector("input[type=checkbox], input[type=radio]"); if (wrapped) el = wrapped; } if (el.type === "checkbox" || el.type === "radio") { el.checked = true; el.dispatchEvent(new Event("click", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); return { fired: true, kind: "checkbox", checked: el.checked }; } let __n16SmMatched = false; ${(0, browser_click_expr_1.retargetToSelectionMarkerExpr)("el", "__n16SmMatched")} ${n16TrustedDelivered ? "" : (0, browser_click_expr_1.clickActivationExpr)("el")} if (__n16SmMatched) { el.dispatchEvent(new Event("change", { bubbles: true })); } return { fired: true, kind: "click" }; })()`;
                     const n16FallbackTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
                     const probeResult = (await n16FallbackTarget.evaluate(clickExpr));
                     const fired = probeResult.fired;
@@ -10547,7 +10709,7 @@ async function executeStepWithHealing(params) {
               const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
               let node = r.singleNodeValue;
               if (!node && ${JSON.stringify(xpathTail)}) {
-                node = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)});
+                node = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}, ${JSON.stringify(!stepDeclaredNonSubmit)});
               }
               if (!node) return false;
               for (let depth = 0; depth < 6 && node; depth++) {
@@ -10631,7 +10793,7 @@ async function executeStepWithHealing(params) {
                 const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
                 let el = r.singleNodeValue;
                 if (!el && ${JSON.stringify(xpathTail)}) {
-                  el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)});
+                  el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}, ${JSON.stringify(!stepDeclaredNonSubmit)});
                 }
                 return el ? isDisabled(el) : false;
               })()`;
@@ -10659,7 +10821,11 @@ async function executeStepWithHealing(params) {
                     // Poll for the real TransitionWorklet(type="next") like the primary
                     // verifier — the transition POST can land after this snapshot, and a
                     // one-shot check would false-negative and retry into a back-bounce.
+                    // Destination-gated so an implausible landing URL's traffic cannot satisfy
+                    // the veto or the submit-transition carve-out downstream.
+                    const retryDestinationPlausible = (0, phantom_click_1.isPlausibleStepDestination)(step, retryPost.url);
                     const retryNetworkIsRealAdvance = retryNetworkFired &&
+                        retryDestinationPlausible &&
                         (await waitForTransitionBody({
                             page,
                             preIdx: preCaptureIdx,
@@ -10671,7 +10837,12 @@ async function executeStepWithHealing(params) {
                         }));
                     const fallbackDomOnlyAdvance = shouldVetoFallbackAdvance({
                         hasPattern: advanceTransitionBodyPattern !== null,
-                        isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
+                        isFinalOrSubmit: isStepSubmitShaped({
+                            step,
+                            submitStep,
+                            isFinalStep,
+                            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                        }),
                         isAdvance: isAdvanceStep(step),
                         retryUrlChanged,
                         retryNetworkIsRealAdvance,
@@ -10730,31 +10901,63 @@ async function executeStepWithHealing(params) {
                     // step resolving onto an objectively submit-shaped control is
                     // treated identically to an explicitly flagged one everywhere this
                     // value is read below.
-                    const retrySubmitShaped = submitStep ||
-                        (isFinalStep && flowHasSubmitSemanticsFlag) ||
-                        retryResolvedElementIsSubmitShaped ||
-                        isSubmitIntentStep(step);
-                    const weakDomSignalsAllowed = ((!isFinalStep && !submitStep && !retryResolvedElementIsSubmitShaped) ||
+                    const retrySubmitShaped = isStepSubmitShaped({
+                        step,
+                        submitStep,
+                        isFinalStep,
+                        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                    }) || retryResolvedElementIsSubmitShaped;
+                    const weakDomSignalsAllowed = ((!(isFinalStep && !stepDeclaredNonSubmit) &&
+                        !submitStep &&
+                        !retryResolvedElementIsSubmitShaped) ||
                         requireSubmitEndpoint) &&
                         !isCheckboxOrRadioIntentStep(step) &&
                         !clickTargetIsSelectionMarker;
+                    // `classifyPhantomClick`'s own `elementStateChanged` input is
+                    // UNGATED by `destinationPlausible` (phantom-click.ts ~220-229);
+                    // the primary attempt gates its credit paths (`domVerifiedForStep`,
+                    // `networkIsRealAdvance`) on destination itself. The n+16 fallback's
+                    // `retrySelectionStateChanged`, UNLIKE the primary technique's
+                    // `domVerified`, is partly driven by this fallback's OWN synthetic
+                    // `el.click()`/forced-checkbox probe rather than a genuine site
+                    // click handler — pre-gating it here (this call site only; the
+                    // primary technique's call above is untouched) closes the n+16-
+                    // specific path where `classifyPhantomClick`'s `"effective"`
+                    // verdict would otherwise re-credit a destination-implausible
+                    // click purely off `elementStateChanged`, bypassing the direct
+                    // `retrySelectionStateChanged`/`checkboxStateVerified` gates below.
                     const retryVerdict = (0, phantom_click_1.classifyPhantomClick)({
                         actResultSuccess: record.actResultSuccess,
                         pre,
                         post: retryPost,
                         elementStateChanged: retrySelectionStateChanged,
                         isSubmitShapedStep: retrySubmitShaped,
-                        destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, retryPost.url),
+                        destinationPlausible: retryDestinationPlausible,
                     });
+                    // Destination-plausibility audit of every remaining disjunct in
+                    // this OR (the recon report's closing instruction, see
+                    // flow-runner.retry-fallback-remaining-disjuncts-destination-
+                    // audit.test.ts): `retryNetworkFired` is a bare request COUNT with
+                    // zero awareness of destination (a request can fire en route to
+                    // ANY page, including a wrong one); `checkboxStateVerified` forces
+                    // `.checked = true` on whatever element the xpath resolves to on
+                    // the CURRENTLY LOADED page, independent of whether the click
+                    // fallback navigated there correctly; `retrySelectionStateChanged`
+                    // reads a fingerprint for whatever element the xpath/selector
+                    // resolves to post-click, same independence from destination. All
+                    // three get the same `isPlausibleStepDestination` gate
+                    // `weakDomSignalsAllowed` already has (bugfix-002) — `retryUrlChanged`
+                    // already folds the same check in at its own computation above.
                     let retryVerified = !clickBlockedByDisabled &&
                         !clickBlockedByInvalid &&
                         !fallbackDomOnlyAdvance &&
-                        (retryNetworkFired ||
+                        ((retryNetworkFired && retryDestinationPlausible) ||
                             retryUrlChanged ||
-                            checkboxStateVerified ||
-                            retrySelectionStateChanged ||
+                            (checkboxStateVerified && retryDestinationPlausible) ||
+                            (retrySelectionStateChanged && retryDestinationPlausible) ||
                             (!retrySubmitShaped && retryVerdict === "effective") ||
                             (weakDomSignalsAllowed &&
+                                retryDestinationPlausible &&
                                 (retryHtmlDelta !== 0 || retryTextChanged || retryFormValueChanged)));
                     if (retryVerified) {
                         record.phantomClickVerdict = retryVerdict;
@@ -10797,7 +11000,11 @@ async function executeStepWithHealing(params) {
                     // flow-runner.overlay-hidden-target-trusted-click-acceptance.test.ts
                     // and flow-runner.evidence-table-alternating-verdict-regression.test.ts,
                     // both of which rely on that carve-out and must stay green).
-                    const retryDestinationUnconfirmed = isFinalStep && !submitStep && retryUrlChanged && !retryResolvedElementIsSubmitShaped;
+                    const retryDestinationUnconfirmed = isFinalStep &&
+                        !submitStep &&
+                        !stepDeclaredNonSubmit &&
+                        retryUrlChanged &&
+                        !retryResolvedElementIsSubmitShaped;
                     if (retryVerified && retryDestinationUnconfirmed && !requireSubmitEndpoint) {
                         // Veto directly rather than routing through the judge below: no
                         // endpoint pattern and no submit-shaped element means there is
@@ -10885,7 +11092,18 @@ async function executeStepWithHealing(params) {
                     logger.info(`n+16 probe: step=${stepIndex + 1}/${totalSteps?.() ?? "?"} attempt=${attempt} el.click() fallback fired=${fired === true} kind=${probeResult.kind ?? "none"} checkboxStateVerified=${checkboxStateVerified} ancestorStillInvalid=${ancestorStillInvalid}; network=${retryNetworkFired} url=${retryUrlChanged} htmlDelta=${retryHtmlDelta} textChanged=${retryTextChanged} formValueChanged=${retryFormValueChanged} selectionStateChanged=${retrySelectionStateChanged} verified=${retryVerified} delivery=${n16DeliveryBranch}${n16TrustedClickFailureSuffix}`);
                     if (retryVerified) {
                         if (record.verifiedBy === null) {
-                            record.verifiedBy = retryUrlChanged ? "url" : retryNetworkFired ? "network" : "dom";
+                            // Mirror the same `retryDestinationPlausible` gate `retryVerified`
+                            // applies to `retryNetworkFired` above — otherwise a step verified
+                            // via `retryVerdict === "effective"` (or `weakDomSignalsAllowed`)
+                            // while the destination is implausible would still be labeled
+                            // "network" here off the raw, ungated flag, misreporting what
+                            // actually verified it and desyncing `verifiedBy` consumers (e.g.
+                            // the `priorDomVerified` check below) from the real gate.
+                            record.verifiedBy = retryUrlChanged
+                                ? "url"
+                                : retryNetworkFired && retryDestinationPlausible
+                                    ? "network"
+                                    : "dom";
                         }
                         record.post = retryPost;
                         attempts.push(record);
@@ -10957,7 +11175,12 @@ async function executeStepWithHealing(params) {
         // 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" &&
-            (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step))) {
+            isStepSubmitShaped({
+                step,
+                submitStep,
+                isFinalStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            })) {
             const live = await extractLivePageFormEvidence(page, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), {
                 client: anthropic,
                 knownErrorClassPrefixes,
@@ -11018,7 +11241,12 @@ async function executeStepWithHealing(params) {
                 // (triedSelectors), which is empty on an "unresolved" verdict, so a
                 // non-submit step with that verdict falls through to the normal
                 // ladder instead of escalating.
-                const escalationTarget = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step)
+                const escalationTarget = isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                })
                     ? "escalating attempt 2 to deep-submit-locator"
                     : phantomClickAfterAttempt1
                         ? "non-submit step — escalating attempt 2 to trusted-click-retry (trusted CDP click on the resolved target)"
@@ -11030,7 +11258,12 @@ 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: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
+                isFinalStep: isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                }),
                 requireSubmitEndpoint,
                 resolvedMethod: record.resolvedMethod,
                 effectSignals,
@@ -11050,7 +11283,12 @@ async function executeStepWithHealing(params) {
             // can reorder a later step forward — instead of burning the cascade.
             const advanceStalled = isAdvanceStalled({
                 isAdvance: isAdvanceStep(step),
-                isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
+                isFinalOrSubmit: isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                }),
                 hasPattern: advanceTransitionBodyPattern !== null,
                 clickFired: record.resolvedMethod === "click" && record.actResultSuccess === true,
                 networkFired,
@@ -11077,8 +11315,13 @@ async function executeStepWithHealing(params) {
     // firing on a non-submit step could complete it by clicking an unrelated
     // submit control in an unrelated same-origin child iframe.
     if (!frameTarget?.declaredFrameSelector &&
-        (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step))) {
-        const fallbackTarget = await probeChildFrameSubmitFallback({ page, signalCounter });
+        isStepSubmitShaped({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        })) {
+        const fallbackTarget = await probeChildFrameSubmitFallback({ page, signalCounter, step });
         if (fallbackTarget) {
             logger.info(`${formatStepPrefix(stepIndex, totalSteps)} cascade-exhausted: no candidate resolvable in the declared/main frame, but a same-origin child iframe surfaced a submit-shaped candidate — clicked and verified there instead of failing`);
             trajectory?.push({ stepIndex, verifiedBy: "dom" });
@@ -11110,7 +11353,12 @@ async function executeStepWithHealing(params) {
     const unfocusedObserve = cascadeExhaustObservedUnfocused.length === 0 && frameTarget?.frame
         ? await deepLocatorCandidatesAsActions(page, frameTarget)
         : cascadeExhaustObservedUnfocused;
-    const targetResolutionDiagnostic = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step)
+    const targetResolutionDiagnostic = isStepSubmitShaped({
+        step,
+        submitStep,
+        isFinalStep,
+        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+    })
         ? await (0, target_resolution_diagnostic_1.captureTargetResolutionDiagnosticSnapshot)(frameTarget, page, lastRankedSubmitCandidates)
         : null;
     const dumpPath = onStepFailure?.({
@@ -11255,6 +11503,7 @@ async function runHealingFlow(deps) {
                 stepPromise = executeStepWithHealing({
                     stagehand,
                     page,
+                    abortSignal: deps.abortSignal,
                     step: s.instruction,
                     optional: s.optional,
                     upload: s.upload,