@enricai/barnacle 1.12.78 → 1.12.80

package/dist/scraper/flow-runner.js

@@ -14,10 +14,11 @@
  * the terminal failure dump.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOriginOrPathChanged = exports.TRAILING_GRACE_WINDOW = exports.STEP_WATCHDOG_MS = exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR = exports.GOTO_TIMEOUT_MS = exports.waitForSpaReady = void 0;
+exports.hasOriginOrPathChanged = exports.SEGMENTED_DATE_ENUMERATE_EXPR = exports.ERROR_SUMMARY_EXPR = exports.ADVANCE_CLICK_RX = exports.TRAILING_GRACE_WINDOW = exports.STEP_WATCHDOG_MS = exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR = exports.GOTO_TIMEOUT_MS = exports.waitForSpaReady = void 0;
 exports.mergeResponseHeaders = mergeResponseHeaders;
 exports.wireSignalCapture = wireSignalCapture;
 exports.shouldRetryCaptchaRegistry = shouldRetryCaptchaRegistry;
+exports.buildDeepMarkerCentreExpr = buildDeepMarkerCentreExpr;
 exports.prepareFailureDumpBody = prepareFailureDumpBody;
 exports.fieldValuesAtFailureExpr = fieldValuesAtFailureExpr;
 exports.snapshotPage = snapshotPage;
@@ -27,6 +28,12 @@ exports.findRecentPageTransition = findRecentPageTransition;
 exports.isWizardExitAction = isWizardExitAction;
 exports.isAdvanceStep = isAdvanceStep;
 exports.isSubmitIntentStep = isSubmitIntentStep;
+exports.stripNegatedSubmitClauses = stripNegatedSubmitClauses;
+exports.classifyStepSubmitIntent = classifyStepSubmitIntent;
+exports.isStepDeclaredNonSubmit = isStepDeclaredNonSubmit;
+exports.isStepSubmitShaped = isStepSubmitShaped;
+exports.isStepSettleWaitShaped = isStepSettleWaitShaped;
+exports.isMidFlowSubmitShapedStep = isMidFlowSubmitShapedStep;
 exports.isCheckboxOrRadioIntentStep = isCheckboxOrRadioIntentStep;
 exports.shouldCaptureSelectionState = shouldCaptureSelectionState;
 exports.flowHasSubmitSemantics = flowHasSubmitSemantics;
@@ -38,6 +45,7 @@ exports.windowHasTransitionBody = windowHasTransitionBody;
 exports.windowHasAdvanceTransition = windowHasAdvanceTransition;
 exports.shouldVetoFallbackAdvance = shouldVetoFallbackAdvance;
 exports.isDomOnlyAdvanceVerified = isDomOnlyAdvanceVerified;
+exports.isNullVerdictAdvanceCredited = isNullVerdictAdvanceCredited;
 exports.isClickViewSwapVerified = isClickViewSwapVerified;
 exports.selectionCountFromSignature = selectionCountFromSignature;
 exports.shouldReadbackFillOnActSuccess = shouldReadbackFillOnActSuccess;
@@ -57,6 +65,8 @@ exports.formatValidationRejectedReason = formatValidationRejectedReason;
 exports.selectBodyExcerpt = selectBodyExcerpt;
 exports.extractLivePageFormEvidence = extractLivePageFormEvidence;
 exports.probeLeafInvalidContainers = probeLeafInvalidContainers;
+exports.buildSubmitJudgeStepContext = buildSubmitJudgeStepContext;
+exports.judgeStepOutcome = judgeStepOutcome;
 exports.renderLeafInvalidFields = renderLeafInvalidFields;
 exports.extractSubmitFailureEvidence = extractSubmitFailureEvidence;
 exports.extractGaEventEvidence = extractGaEventEvidence;
@@ -65,16 +75,24 @@ exports.fillHtml5DateTimeInput = fillHtml5DateTimeInput;
 exports.fillTextDatepickerInput = fillTextDatepickerInput;
 exports.verifyFillReadback = verifyFillReadback;
 exports.verifyPromptSelectorCommitted = verifyPromptSelectorCommitted;
+exports.tailRetargetPhrasesForStep = tailRetargetPhrasesForStep;
+exports.stepQuotesValueNotControlName = stepQuotesValueNotControlName;
 exports.isUploadAffordanceLabel = isUploadAffordanceLabel;
 exports.writeFixtureToTempFile = writeFixtureToTempFile;
 exports.attachToSurfacedInput = attachToSurfacedInput;
 exports.surfaceAndUpload = surfaceAndUpload;
+exports.clickUploadAffordance = clickUploadAffordance;
+exports.setFilesViaCdp = setFilesViaCdp;
 exports.parseSelectStep = parseSelectStep;
 exports.parseFillStep = parseFillStep;
 exports.parseFillValueIntent = parseFillValueIntent;
+exports.parseSegmentedDateValue = parseSegmentedDateValue;
+exports.resolveSegmentedDateGroup = resolveSegmentedDateGroup;
+exports.trySegmentedDateSpinbuttonPrimitive = trySegmentedDateSpinbuttonPrimitive;
 exports.parseRadioStep = parseRadioStep;
 exports.parseWidgetOptionClickStep = parseWidgetOptionClickStep;
 exports.parseCheckStep = parseCheckStep;
+exports.parseCheckStateStep = parseCheckStateStep;
 exports.pollEnumerate = pollEnumerate;
 exports.waitForTransitionBody = waitForTransitionBody;
 exports.injectCaptchaTokenAndSubmit = injectCaptchaTokenAndSubmit;
@@ -82,8 +100,11 @@ exports.submitCaptchaGatedForm = submitCaptchaGatedForm;
 exports.trySelectPrimitive = trySelectPrimitive;
 exports.chooseRequiredSelectOption = chooseRequiredSelectOption;
 exports.tryFillRequiredSelectsPrimitive = tryFillRequiredSelectsPrimitive;
+exports.tryCheckboxStatePrimitive = tryCheckboxStatePrimitive;
 exports.buildRadioIdXPath = buildRadioIdXPath;
 exports.selectRadioGroupOption = selectRadioGroupOption;
+exports.applyRadioSelection = applyRadioSelection;
+exports.dismissLeftoverPromptPopups = dismissLeftoverPromptPopups;
 exports.hasUnfilledRequiredControlForStep = hasUnfilledRequiredControlForStep;
 exports.simulateDragDropUpload = simulateDragDropUpload;
 exports.dispatchJqueryChangeEvent = dispatchJqueryChangeEvent;
@@ -95,6 +116,8 @@ exports.tryDeterministicFieldLabelActuation = tryDeterministicFieldLabelActuatio
 exports.probeStepBeforeAttempts = probeStepBeforeAttempts;
 exports.extractLinkFromMessage = extractLinkFromMessage;
 exports.extractCodeFromMessage = extractCodeFromMessage;
+exports.spliceEmailStepFillValue = spliceEmailStepFillValue;
+exports.primitiveOptionLabel = primitiveOptionLabel;
 exports.executeStepWithHealing = executeStepWithHealing;
 exports.executeNavigateStep = executeNavigateStep;
 exports.runHealingFlow = runHealingFlow;
@@ -110,15 +133,20 @@ const error_messages_1 = require("../lib/llm/judges/error-messages");
 const invalid_fields_1 = require("../lib/llm/judges/invalid-fields");
 const modal_priority_1 = require("../lib/llm/judges/modal-priority");
 const select_option_1 = require("../lib/llm/judges/select-option");
+const verify_step_advanced_1 = require("../lib/llm/judges/verify-step-advanced");
 const verify_submit_1 = require("../lib/llm/judges/verify-submit");
 const schemas_1 = require("../lib/llm/schemas");
 const logging_1 = require("../lib/logging");
+const pii_redaction_1 = require("../lib/pii-redaction");
 const call_capture_1 = require("../lib/telemetry/call-capture");
 const call_types_1 = require("../lib/telemetry/call-types");
 const capture_filters_1 = require("../recon/capture-filters");
+const actionable_visibility_expr_1 = require("./actionable-visibility-expr");
+const active_page_1 = require("./active-page");
 const browser_click_expr_1 = require("./browser-click-expr");
 const captcha_callback_capture_1 = require("./captcha-callback-capture");
 const captcha_solver_1 = require("./captcha-solver");
+const click_settle_1 = require("./click-settle");
 const deep_locator_actuate_1 = require("./deep-locator-actuate");
 const deep_locator_candidates_1 = require("./deep-locator-candidates");
 const deep_locator_click_1 = require("./deep-locator-click");
@@ -126,11 +154,14 @@ const deep_locator_scan_1 = require("./deep-locator-scan");
 const errors_2 = require("./errors");
 const frame_target_1 = require("./frame-target");
 const phantom_click_1 = require("./phantom-click");
+const quoted_spans_1 = require("./quoted-spans");
 const session_teardown_1 = require("./session-teardown");
 const spa_readiness_1 = require("./spa-readiness");
 const stagehand_guard_1 = require("./stagehand-guard");
 const submit_control_1 = require("./submit-control");
 const target_resolution_diagnostic_1 = require("./target-resolution-diagnostic");
+const trusted_click_1 = require("./trusted-click");
+const upload_affordance_expr_1 = require("./upload-affordance-expr");
 const watchdog_1 = require("./watchdog");
 const recon_shared_1 = require("../scripts/recon-shared");
 const client_1 = require("../testmail/client");
@@ -365,7 +396,9 @@ function wireSignalCapture(page, params) {
                 recentCaptureMeta.splice(0, recentCaptureMeta.length - RECENT_CAPTURES_WINDOW);
             }
         }
-        logger.info(`captured [${capture.status}] ${capture.method} ${req.url} → ${filename}`);
+        // Query strings carry form GETs and analytics beacons (often form-field
+        // values); origin + path is enough to follow the request sequence.
+        logger.info(`captured [${capture.status}] ${capture.method} ${req.url.split("?")[0]} → ${filename}`);
     };
     session.on("Network.requestWillBeSent", onRequest);
     session.on("Network.requestWillBeSentExtraInfo", onRequestExtraInfo);
@@ -615,11 +648,13 @@ const PROMPT_VALUE_SELECTORS = [
 ].join(",");
 /**
  * The widget-kit's empty-state value text ("0 items selected") — a filled
- * widget's value node reads the chosen option instead. Matched
+ * widget's value node reads the chosen option instead — as is a generic
+ * placeholder prompt ("Select One", "Choose a country") a trigger button shows
+ * until a value is picked. Matched
  * case-insensitively as a whole phrase so a non-empty selection ("1 item
  * selected, …") is correctly read as filled.
  */
-const PROMPT_EMPTY_VALUE_RX = /^\s*0\s+items?\s+selected\s*$/i;
+const PROMPT_EMPTY_VALUE_RX = /^\s*(?:0\s+items?\s+selected|(?:please\s+)?(?:select|choose|pick)(?:\s+[^\s]+){0,2}\s*(?:\.{3}|…)?)\s*$/i;
 /**
  * {@link PROMPT_EMPTY_VALUE_RX}'s source and flags as plain strings, passed into
  * the browser-evaluated expressions to reconstruct the RegExp there. Kept as
@@ -692,12 +727,73 @@ const PROMPT_CURRENT_TEXT_EXPR = `((w, valueSel, emptyRx) => {
   const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
   if (adid) { const opt = document.getElementById(adid); if (opt && optionLabel(opt)) return norm(optionLabel(opt)); }
   if (w.tagName === "INPUT" && (w.value || "").trim()) return norm(w.value);
-  if (w.tagName === "BUTTON" && buttonValue(w).trim()) return norm(buttonValue(w));
+  if (w.tagName === "BUTTON" && buttonValue(w).trim() && !emptyRx.test(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 reading what a prompt-selector widget ANNOUNCES it
+ * committed, lowercased and whitespace-collapsed, or `""` when nothing is
+ * readable. The announcement is ground truth over any inferred state: first the
+ * "N items selected, X" `aria-describedby` node on the container or one of its
+ * descendants (the trigger union may resolve to the OUTER container, so the
+ * container's own attribute alone misses it), else the nearest
+ * `selectedItemList` — while a popup is open the description can read only
+ * "Expanded", hence the fallback. Shared by the pick read-back and the
+ * act-success guard so the two never disagree on what the widget committed.
+ */
+const PROMPT_ANNOUNCED_VALUE_EXPR = `((w) => {
+  const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
+  const announceRxs = [
+    /\\d+\\s+items?\\s+selected\\s*,?\\s*(.*)$/,
+    /^(?:currently\\s+)?selected(?:\\s+(?:item|option|value))?\\s*[:,-]\\s*(.+)$/,
+    /^(.+?)\\s+(?:is\\s+)?selected\\.?$/,
+  ];
+  for (const el of [w, ...Array.from(w.querySelectorAll("[aria-describedby]"))]) {
+    for (const ref of (el.getAttribute("aria-describedby") || "").split(/\\s+/)) {
+      const refEl = ref ? document.getElementById(ref) : null;
+      const said = refEl ? norm(refEl.textContent) : "";
+      for (const rx of announceRxs) {
+        const m = rx.exec(said);
+        if (m && m[1] && !/^\\d+\\s+items?$/.test(m[1])) return m[1];
+      }
+    }
+  }
+  let anode = w;
+  for (let d = 0; d < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && anode; d++) {
+    const list = anode.querySelector ? anode.querySelector('[data-automation-id="selectedItemList"]') : null;
+    if (list && norm(list.textContent)) return norm(list.textContent);
+    anode = anode.parentElement;
+  }
+  return "";
+})`;
+/**
+ * Browser-side expression resolving ONE trigger-union hit to its widget
+ * container. A single widget often matches {@link PROMPT_TRIGGER_SELECTORS} more
+ * than once (e.g. an outer container AND its inner filter input both carry
+ * `data-uxi-widget-type`), so prefer a real interactive ancestor, else the
+ * OUTERMOST widget-kit container on the ancestor chain (so the inner input and
+ * its container collapse to the same node), else the element itself. Shared by
+ * widget enumeration and the option-scope ownership filter so both agree on what
+ * "a widget" is — including widgets that are already committed and so never
+ * stamped with the enumeration mark.
+ */
+const PROMPT_WIDGET_CONTAINER_EXPR = `((el) => {
+  const interactive = el.closest("button,[role='button'],[role='combobox']");
+  if (interactive) return interactive;
+  const kitSel = "[data-uxi-widget-type='selectinput'],[data-uxi-widget-type='multiselect'],[data-automation-id='multiSelectContainer']";
+  let container = el;
+  let node = el.closest(kitSel);
+  while (node) {
+    container = node;
+    const up = node.parentElement && node.parentElement.closest(kitSel);
+    if (!up || up === node) break;
+    node = up;
+  }
+  return container;
+})`;
 /**
  * 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
@@ -834,6 +930,55 @@ const ATTEMPT_BACKOFF_MS = 1_000;
  * actionable.
  */
 const N16_TRUSTED_CLICK_TIMEOUT_MS = 3_000;
+/**
+ * Shared pre-click centre + hit-test for a Stagehand-resolved selector, so
+ * observe-act and the natural-language act attempts share one routine.
+ * Returns a failure message when the control stays covered, null otherwise.
+ */
+async function centreObservedClickTarget(target, selector, onUnavailable, deferWhenMissing = false) {
+    try {
+        await (0, trusted_click_1.centreSelectorForClick)(target, selector);
+        return null;
+    }
+    catch (err) {
+        // A TypeError means the page cannot answer the hit-test probe (no
+        // evaluate seam), not that the control is covered; defer to the act.
+        if (err instanceof TypeError) {
+            onUnavailable(`centre hit-test unavailable: ${(0, errors_1.toErrorMessage)(err)}`);
+            return null;
+        }
+        // Stagehand's own resolution of a natural-language act can differ from the
+        // observe result, so an unresolvable element there is the act's to judge.
+        if (deferWhenMissing && (0, errors_1.toErrorMessage)(err).includes("is not in the document")) {
+            onUnavailable(`centre target unresolved: ${(0, errors_1.toErrorMessage)(err)}`);
+            return null;
+        }
+        return `observed click target not clickable: ${(0, errors_1.toErrorMessage)(err)}`;
+    }
+}
+/**
+ * Builds an in-page expression that finds the marker-stamped element, piercing
+ * open shadow roots (plain `querySelector` cannot), and centre + hit-tests it.
+ */
+function buildDeepMarkerCentreExpr(markerSelector) {
+    return `(() => {
+    const sel = ${JSON.stringify(markerSelector)};
+    const find = (root) => {
+      const hit = root.querySelector(sel);
+      if (hit) return hit;
+      for (const n of root.querySelectorAll("*")) {
+        if (n.shadowRoot) {
+          const r = find(n.shadowRoot);
+          if (r) return r;
+        }
+      }
+      return null;
+    };
+    const el = find(document);
+    if (!el) return { state: "missing" };
+    return (${trusted_click_1.CENTRE_AND_HIT_TEST_FN}).call(el);
+  })()`;
+}
 /**
  * Per-step watchdog passed as Stagehand's native `timeout` on every
  * `act()`/`observe()`. Stagehand's `ensureTimeRemaining()` checks the
@@ -952,6 +1097,10 @@ function prepareFailureDumpBody(raw) {
  * entry, so the weak page-wide signature and the strict per-element gate
  * agree on exactly what counts as a class-token selection marker.
  */
+/** Shared by both checkbox credit sites so they agree on what "aria-managed" reads. */
+function ariaCheckedReadExpr(elVar) {
+    return `${elVar}.getAttribute("aria-checked")`;
+}
 const DOM_SNAPSHOT_EXPR = `(() => { const b = document.body; if (!b) return { html: 0, text: "", values: "", state: "" }; const t = b.innerText || ""; const controls = Array.from(b.querySelectorAll("input, textarea, select")).filter((el) => el.offsetParent !== null); const values = controls.map((el) => { if (el.type === "checkbox" || el.type === "radio") return el.checked ? "1" : "0"; return el.value || ""; }).join("|").slice(0, 2000); const ariaSel = "[aria-pressed],[aria-checked],[aria-selected],[data-state],[data-selected],[data-checked],[role=option],[role=switch],[role=checkbox],[role=menuitemcheckbox]"; const classSel = ${JSON.stringify(browser_click_expr_1.SELECTION_MARKER_CLASS_SELECTOR_SRC)}; const classRx = ${browser_click_expr_1.SELECTION_MARKER_CLASS_TOKEN_REGEX_SRC}; const skip = (el) => el.closest("[role=dialog],[role=tooltip],[aria-live]") !== null; const seen = new Set(); for (const el of b.querySelectorAll(ariaSel + "," + classSel)) { if (el.offsetParent !== null && !skip(el)) seen.add(el); } let idx = 0; const parts = []; for (const el of seen) { const ap = el.getAttribute("aria-pressed") || ""; const ac = el.getAttribute("aria-checked") || ""; const as = el.getAttribute("aria-selected") || ""; const dsRaw = el.getAttribute("data-state") || ""; const ds = (dsRaw === "open" || dsRaw === "closed") ? "" : dsRaw; const dsel = el.hasAttribute("data-selected") ? "1" : ""; const dchk = el.hasAttribute("data-checked") ? "1" : ""; const clsHit = classRx.test(el.getAttribute("class") || "") ? "1" : "0"; const i = idx++; if (!ap && !ac && !as && !ds && !dsel && !dchk && clsHit === "0") continue; parts.push(i + ":" + ap + "," + ac + "," + as + "," + ds + "," + dsel + "," + dchk + "," + clsHit); } const joined = parts.join("|"); let h = 2166136261; for (let k = 0; k < joined.length; k++) { h ^= joined.charCodeAt(k); h = Math.imul(h, 16777619); } const state = (h >>> 0).toString(36) + ":" + parts.length; return { html: (b.outerHTML || "").length, text: t.length + ":" + t.slice(0, 200), values, state }; })()`;
 /** Caps mirroring {@link DOM_SNAPSHOT_EXPR}'s truncation so a pathological page can't bloat the failure bundle. */
 const FIELD_VALUES_AT_FAILURE_MAX_CONTROLS = 200;
@@ -1240,6 +1389,25 @@ const ADVANCE_STEP_PHRASES = [
     "proceed to the next",
     "advance to the next",
 ];
+/** Advance-click step wording ("Next"/"Continue"/"Save and continue") for the n+16 error-summary veto. */
+exports.ADVANCE_CLICK_RX = /\b(next|continue|proceed|advance)\b/i;
+/**
+ * Page-level error summary check, evaluated in the page after an advance
+ * click: an error-summary container, a visible `role=alert` that mentions an
+ * error, or a heading/button whose WHOLE text is "Errors Found" / "N errors
+ * found" (prose such as "no errors found" is not a summary). Network and text
+ * movement on a page showing its own validation summary is the form rejecting
+ * the advance, not progress.
+ */
+exports.ERROR_SUMMARY_EXPR = `(() => {
+  const vis = (e) => !!(e.offsetWidth || e.offsetHeight || e.getClientRects().length);
+  const text = (e) => (e.textContent || "").trim();
+  const summarySel = '[class*="error-summary" i],[class*="errorsummary" i],[class*="validation-summary" i],[id*="error-summary" i]';
+  if (Array.from(document.querySelectorAll(summarySel)).some((e) => vis(e) && text(e))) return true;
+  if (Array.from(document.querySelectorAll('[role="alert"]')).some((e) => vis(e) && /\\berrors?\\b/i.test(text(e)))) return true;
+  const titles = 'h1,h2,h3,h4,h5,h6,[role="heading"],button,[role="button"]';
+  return Array.from(document.querySelectorAll(titles)).some((e) => vis(e) && /^(?:\\d+\\s+)?errors?\\s+found$/i.test(text(e)));
+})()`;
 /**
  * Is this flow step an advance/"Next" click (move to the next wizard page),
  * rather than a field-answer? Used to veto a DOM-only "success" (a field toggle)
@@ -1285,6 +1453,83 @@ 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, a purchase-action control named directly ("Book Now",
+ * "Reserve", "Add to Cart"), or a "proceeds/leads/advances to" phrase naming one.
+ */
+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|book(?:s|ing)? now|reserv(?:e|es|ing)|add(?:s|ing)? to (?:the |your )?(?:cart|basket|bag)|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.", "Place the order."). */
+const LEADING_SUBMIT_IMPERATIVE = /(?:^|[.;]\s*)(?:then\s+)?(?:click\s+(?:on\s+)?(?:the\s+)?['"]?)?(?:submit\b|place\s+(?:the\s+)?order\b|complete\s+(?:the\s+)?(?:order|purchase|application|checkout)\b|finish\s+(?:and\s+)?(?:order|purchase|application|checkout)\b|confirm\s+(?:and\s+)?(?:order|purchase|application)\b|save\s+and\s+continue\b|finali[sz]e\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 derivation of "this step's own instruction declares it non-submit",
+ * so every submit-judge gate honours the veto identically. An explicit
+ * `submitStep` flag always overrides the declaration.
+ */
+function isStepDeclaredNonSubmit(params) {
+    return !params.submitStep && classifyStepSubmitIntent(params.step) === "non-submit";
+}
+/**
+ * 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;
+    if (isStepDeclaredNonSubmit({ step, submitStep }))
+        return false;
+    return (isFinalStep && flowSubmit) || classifyStepSubmitIntent(step) === "submit";
+}
+/**
+ * Whether a click may need the long idle settle wait: a submit-shaped step or
+ * one naming an advance word, since both can start their round-trip late.
+ */
+function isStepSettleWaitShaped(params) {
+    return isStepSubmitShaped(params) || isAdvanceStep(params.step);
+}
+/**
+ * Submit-shaped but NOT the flow's final step: a mid-flow advancing submit
+ * (e.g. account creation) that can be credited on a demonstrable page advance
+ * instead of needing the final submit's network/URL proof.
+ */
+function isMidFlowSubmitShapedStep(params) {
+    if (params.isFinalStep)
+        return false;
+    return isStepSubmitShaped(params) || params.elementSubmitShaped === true;
+}
 /**
  * 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)
@@ -1339,9 +1584,16 @@ function shouldCaptureSelectionState(params) {
 function flowHasSubmitSemantics(params) {
     const { steps, submitEndpointPattern, requireSubmitEndpointMatch } = params;
     const hasExplicitSubmitStep = steps.some((s) => s.submitStep);
-    return hasExplicitSubmitStep
-        ? (steps[steps.length - 1]?.submitStep ?? false)
-        : submitEndpointPattern !== null || requireSubmitEndpointMatch;
+    if (hasExplicitSubmitStep)
+        return steps[steps.length - 1]?.submitStep ?? false;
+    if (submitEndpointPattern === null && !requireSubmitEndpointMatch)
+        return false;
+    // An earlier step whose own wording declares submit already owns the role;
+    // the fallback is only for a self-heal-appended final step.
+    const earlierStepOwnsSubmit = steps
+        .slice(0, -1)
+        .some((s) => classifyStepSubmitIntent(s.instruction) === "submit");
+    return !earlierStepOwnsSubmit;
 }
 /**
  * Whether a flow should be WARNed that its DOM-only advance guard is disarmed.
@@ -1560,6 +1812,20 @@ function isDomOnlyAdvanceVerified(params) {
     // non-advancing POST) does not verify it.
     return networkIsRealAdvance || urlChanged;
 }
+/**
+ * Decides whether a non-final submit-shaped step is credited when the outcome
+ * judge returned no verdict. An unavailable judge is missing evidence, not a
+ * rejection, so strong structural click signals (a real network advance or a
+ * demonstrable page advance) credit the step instead of failing it and
+ * re-clicking at the same position. Final steps and weak-signal cases return
+ * false and keep the DOM-state fallback / failure path.
+ */
+function isNullVerdictAdvanceCredited(params) {
+    if (!params.midFlowSubmit || !params.judgeUnavailable || params.invalidMarkerCount > 0) {
+        return false;
+    }
+    return params.networkAdvanced || params.pageAdvanced;
+}
 /**
  * Client-side view-swap verification gate. Credits a click that produces
  * substantial DOM growth with zero network as a verified step outcome when
@@ -1625,12 +1891,18 @@ function isDomOnlyAdvanceVerified(params) {
  * page), which also nets a large negative byte delta with zero network/url
  * and no text-signature match. A reset replaces the clicked control itself
  * along with everything else, whereas a genuine same-page toggle leaves the
- * clicked control in place. `clickedElementStillPresent` — whether the
+ * clicked control in place. A click-driven view swap (a login-to-registration
+ * form swap, a chooser-to-form swap) also removes its own trigger because the
+ * trigger belonged to the replaced view, but it GROWS the DOM, whereas a reset
+ * reverts to an earlier, smaller screen. The veto therefore keys on absence
+ * combined with a DOM that did not grow (`bytesDelta <= 0`), not on absence
+ * alone. `clickedElementStillPresent` — whether the
  * resolved click target can still be found in the post-click DOM, from a
  * best-effort live probe — is `false` only on POSITIVE proof of absence;
  * 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.
+ * information. Only a confirmed `false` paired with a non-growing DOM 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
@@ -1642,15 +1914,43 @@ function isDomOnlyAdvanceVerified(params) {
  * no-veto behavior — matching the sibling `destinationPlausible` param on
  * `classifyPhantomClick` — so existing/future callers that don't thread it
  * are unaffected.
+ *
+ * **Mid-flow submit:** `midFlowSubmit` (see {@link isMidFlowSubmitShapedStep})
+ * lets a submit-shaped, non-final step be credited when `pageAdvanced` (the
+ * shared {@link hasPageAdvanced} judgement of the visible text; defaults to
+ * `textChanged` when omitted) holds — byte delta is not required, since a
+ * wizard swap can keep the HTML size — with the same invalid-marker and
+ * destination vetoes. The clicked control being gone is NOT a veto here: a
+ * wizard advance normally replaces the button along with the page. The
+ * credit also holds when Stagehand reported a successful act with no
+ * resolved action (`actSucceeded`) or a non-click, non-state-class method.
+ * Omitted,
+ * the submit-shaped rejection is unchanged.
  */
 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, destinationPlausible, } = params;
+    const { resolvedAction, submitStep, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, clickedElementStillPresent = true, resolvedElementIsSubmitShaped = false, destinationPlausible, midFlowSubmit = false, pageAdvanced = textChanged, actSucceeded = false, } = params;
+    // The page advancing is the evidence for a mid-flow submit, so it does not
+    // depend on how Stagehand reported the gesture: a successful act that
+    // listed no actions, or a non-state-class method, still ran a click-class
+    // action. Mirrors the settle gate's `mayTriggerRoundTrip`.
+    const midFlowActRan = resolvedAction === null ? actSucceeded : !STATE_CLASS_METHODS.has(resolvedAction.method ?? "");
+    if (midFlowSubmit &&
+        midFlowActRan &&
+        destinationPlausible !== false &&
+        !isAdvanceWithPattern &&
+        invalidMarkerDelta <= 0 &&
+        textChanged &&
+        pageAdvanced) {
+        return true;
+    }
     if (resolvedAction?.method !== "click")
         return false;
     if (destinationPlausible === false)
         return false;
+    if (midFlowSubmit && (submitStep || resolvedElementIsSubmitShaped))
+        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
@@ -1673,7 +1973,7 @@ function isClickViewSwapVerified(params) {
         return false;
     if (invalidMarkerDelta > 0)
         return false;
-    if (!clickedElementStillPresent)
+    if (!clickedElementStillPresent && bytesDelta <= 0)
         return false;
     if (Math.abs(bytesDelta) >= VIEW_SWAP_MIN_BYTES)
         return true;
@@ -2066,7 +2366,7 @@ For yes/no questions, choose the candidate-favorable answer ('No' for adverse qu
 
 `
         : "";
-    const prompt = `You are helping a browser automation agent recover from a failed step in a recon flow.
+    const rawPrompt = `You are helping a browser automation agent recover from a failed step in a recon flow.
 
 ${redirectBlock}ORIGINAL INSTRUCTION:
 ${originalStep}
@@ -2102,6 +2402,10 @@ PAGE TRANSITION + VALIDATOR TELEMETRY (parsed from Google Analytics Measurement
 ${gaEventEvidence || "(none)"}
 
 Rewrite the instruction so a Stagehand act() call can resolve it unambiguously to a different element than the ones already tried. Keep it short — one sentence, natural language, no quotes around it. If the invalid-fields section above names a field AND the interactive-targets section below lists clickable options inside that same container, your rewrite picks one of those options (e.g. for a yes/no question rendered as two radio labels, choose the candidate-favorable answer — 'No' for "do you have a non-compete", 'Yes' for "are you authorized to work", 'Prefer not to say' for demographic disclosures) rather than retrying the original click. If the unfocused observe section shows an open modal/dialog with a Save or Close action, your rewrite invokes that action so the underlying form can clear its blocking state. Set outcome to "impossible" with a one-line reason only when the original instruction's element does not exist on the current page and no redirect target is available.`;
+    // Request values reach the rephrase LLM only as %tokens%; the rewrite is
+    // resolved back before the cascade acts on it (which re-tokenizes it for
+    // Stagehand). A rewrite citing a token we never issued is unusable.
+    const { text: prompt, variables } = (0, pii_redaction_1.tokenizeSensitiveValues)(rawPrompt);
     const model = client.modelId;
     const t0 = performance.now();
     try {
@@ -2131,7 +2435,9 @@ Rewrite the instruction so a Stagehand act() call can resolve it unambiguously t
         });
         if (parsed.outcome === "impossible")
             return null;
-        return parsed.instruction;
+        if ((0, pii_redaction_1.unresolvedTokens)(parsed.instruction, variables).length > 0)
+            return null;
+        return (0, pii_redaction_1.detokenize)(parsed.instruction, variables);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -2539,6 +2845,107 @@ async function probeLeafInvalidContainers(target) {
         return [];
     }
 }
+/**
+ * Reads live body text for the submit judge, because a SPA's page title often
+ * stays stale after a mid-flow transition. Failure yields "" so the judge
+ * simply reasons without it.
+ */
+async function probeVisibleTextForJudge(target) {
+    return (await probeRawVisibleText(target)).slice(0, 3000);
+}
+/**
+ * Untruncated body text, so a settle signature built from it uses the same
+ * unit (raw `innerText.length`) as {@link DOM_SNAPSHOT_EXPR}'s pre-click one.
+ */
+async function probeRawVisibleText(target) {
+    try {
+        const text = await (0, watchdog_1.withWatchdog)(() => target.evaluate(`(() => (document.body ? document.body.innerText || "" : ""))()`), {
+            timeoutMs: config_1.config.scraper.frameEvaluateTimeoutMs,
+            label: "flow-runner: submit-verification visible text probe",
+        });
+        return typeof text === "string" ? text : "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Shared step-context slice of the submit judge's input, so every judge call
+ * site tells the judge what the step was meant to do, whether it is the final
+ * submit, and what the page shows now.
+ */
+async function buildSubmitJudgeStepContext(params) {
+    return {
+        stepInstruction: params.step,
+        isFinalStep: params.isFinalStep,
+        visibleText: await probeVisibleTextForJudge(params.target),
+    };
+}
+const STEP_REJUDGE_DELAY_MS = 5000;
+const STEP_REJUDGE_COMPARE_CHARS = 1200;
+/**
+ * Single entry for both submit-verification judge sites. The final step keeps
+ * the strict submit judge; a non-final step is judged on whether the page
+ * advanced, against the settled post-click text, because the page is still
+ * mid-transition when the click returns and a pre-transition read would make
+ * a successful advance look like no change.
+ */
+async function judgeStepOutcome(params) {
+    const { client, captureFn, step, isFinalStep, target } = params;
+    if (isFinalStep) {
+        return (0, verify_submit_1.verifySubmitWithLLM)({
+            client,
+            input: {
+                ...(await buildSubmitJudgeStepContext({ step, isFinalStep, target })),
+                ...params.submitInput,
+            },
+            captureFn,
+        });
+    }
+    await (0, click_settle_1.settleAfterClick)(params.page, params.signalCounter, params.preNetworkCount, isStepSettleWaitShaped({ step, submitStep: false, isFinalStep, flowHasSubmitSemantics: false }), async () => {
+        const text = await probeRawVisibleText(target);
+        return `${text.length}:${text.slice(0, 200)}`;
+    }, params.preVisibleTextSignature);
+    const colon = params.preVisibleTextSignature.indexOf(":");
+    const beforeText = (colon === -1 ? params.preVisibleTextSignature : params.preVisibleTextSignature.slice(colon + 1))
+        .replace(/\s+/g, " ")
+        .trim();
+    const judgeText = (afterText) => (0, verify_step_advanced_1.verifyStepAdvancedWithLLM)({
+        client,
+        input: {
+            stepInstruction: step,
+            beforeText,
+            afterText,
+            invalidMarkerCount: params.submitInput.invalidMarkerCount,
+        },
+        captureFn,
+    });
+    const rejudgeIfTextMoved = async (first, judgedText) => {
+        if (first === null || first.advanced)
+            return first;
+        await params.page.waitForTimeout(STEP_REJUDGE_DELAY_MS);
+        const laterText = await probeVisibleTextForJudge(target);
+        if (laterText.slice(0, STEP_REJUDGE_COMPARE_CHARS) ===
+            judgedText.slice(0, STEP_REJUDGE_COMPARE_CHARS)) {
+            return first;
+        }
+        return (await judgeText(laterText)) ?? first;
+    };
+    const afterText = await probeVisibleTextForJudge(target);
+    const firstVerdict = await judgeText(afterText);
+    const verdict = await rejudgeIfTextMoved(firstVerdict, afterText);
+    if (verdict === null)
+        return null;
+    return verdict.advanced
+        ? {
+            verified: true,
+            network_signal: null,
+            dom_signal: null,
+            url_signal: null,
+            rationale: verdict.reason,
+        }
+        : { verified: false, reason: verdict.reason };
+}
 /**
  * Render a list of structured leaf-invalid records as the numbered evidence
  * lines the prompt's FORM FIELDS section expects. Surfaces label + framework
@@ -2961,7 +3368,7 @@ async function dispatchEnterKey(target, xpath) {
 function isCommittedDateReadback(readback) {
     if (readback === null)
         return false;
-    if (readback.outcome === "rejected")
+    if (readback.outcome === "rejected" || readback.outcome === "segment")
         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
@@ -3056,8 +3463,7 @@ async function fillTextDatepickerInput(target, selector, value) {
     // 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();
+        await (0, trusted_click_1.clickCentredTrusted)(target, selector, { label: "date input" });
     }
     catch {
         return { filled: false, postValue: "", strategy: "none" };
@@ -3151,6 +3557,10 @@ async function verifyFillReadback(target, selector, expectedValue) {
     if (!el) return null;
     const tag = el.tagName ? el.tagName.toLowerCase() : "";
     let actual = "";
+    const siblings = el.parentElement ? el.parentElement.querySelectorAll("[role='spinbutton']").length : 0;
+    if (el.getAttribute && el.getAttribute("role") === "spinbutton" && siblings > 1) {
+      return { outcome: "segment", postValue: el.value || el.getAttribute("aria-valuenow") || "", tag };
+    }
     if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
       actual = el.value || "";
     } else if (el.isContentEditable) {
@@ -3169,8 +3579,12 @@ async function verifyFillReadback(target, selector, expectedValue) {
         if (raw === null || typeof raw !== "object")
             return null;
         const r = raw;
-        if (r.outcome !== "matched" && r.outcome !== "rejected" && r.outcome !== "differs")
+        if (r.outcome !== "matched" &&
+            r.outcome !== "rejected" &&
+            r.outcome !== "differs" &&
+            r.outcome !== "segment") {
             return null;
+        }
         return {
             outcome: r.outcome,
             postValue: typeof r.postValue === "string" ? r.postValue : "",
@@ -3194,8 +3608,13 @@ async function verifyFillReadback(target, selector, expectedValue) {
  * `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.
+ *
+ * When the step names the option it wants (`requestedOption`), "committed"
+ * means the widget's announced/readable value names THAT option: a widget that
+ * holds a different option is a wrong commit, not a landed one. Without a
+ * requested option any readable value counts, as before.
  */
-async function verifyPromptSelectorCommitted(target, selector) {
+async function verifyPromptSelectorCommitted(target, selector, requestedOption) {
     const xpath = xpathBodyForEvaluate(selector);
     if (xpath === null)
         return null;
@@ -3204,13 +3623,17 @@ async function verifyPromptSelectorCommitted(target, selector) {
     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 announcedValue = ${PROMPT_ANNOUNCED_VALUE_EXPR};
+    const squash = (s) => (s || "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+    const want = squash(${JSON.stringify(requestedOption ?? "")});
     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) !== "" };
+    const value = announcedValue(widget) || currentText(widget, valueSel, emptyRx);
+    return { isPromptWidget: true, committed: value !== "" && (!want || squash(value).includes(want)) };
   })()`;
     try {
         const raw = await target.evaluate(expr);
@@ -3361,19 +3784,63 @@ function xpathTailForRetarget(xpath) {
  * Falls back to the first document-order match when no candidate clears that
  * bar, preserving the previous behavior for every single-match (the common)
  * case.
+ *
+ * `phrases` (optional): the step's quoted target phrases. Matches whose text
+ * (innerText/textContent/aria-label, case-insensitive, containment in either
+ * direction) names none of them are dropped, so the loose tag/position tail
+ * cannot hand back an element that is not the named target. An empty list, or
+ * a match with no text at all, is unrestricted.
  */
-const XPATH_TAIL_RETARGET_RESOLVE_FN_SRC = `((tail) => {
+const XPATH_TAIL_RETARGET_RESOLVE_FN_SRC = `((tail, preferSubmit, phrases) => {
     const isNegative = ${submit_control_1.NEGATIVE_TEXT_EXPR};
     const accessibleName = (el) =>
       (el.getAttribute("aria-label") || el.textContent || "").replace(/\\s+/g, " ").trim().toLowerCase();
     const isSubmitShaped = ${submit_control_1.SUBMIT_SHAPE_EXPR};
     const r = document.evaluate("//" + tail, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+    const names = (phrases || []).map((p) => String(p).replace(/\\s+/g, " ").trim().toLowerCase()).filter(Boolean);
+    const namesTarget = (el) => {
+      if (names.length === 0) return true;
+      const texts = [el.innerText, el.textContent, el.getAttribute("aria-label")]
+        .map((t) => (t || "").replace(/\\s+/g, " ").trim().toLowerCase())
+        .filter(Boolean);
+      if (texts.length === 0) return true;
+      return texts.some((t) => names.some((n) => t.includes(n) || n.includes(t)));
+    };
     const nodes = [];
-    for (let i = 0; i < r.snapshotLength; i++) nodes.push(r.snapshotItem(i));
+    for (let i = 0; i < r.snapshotLength; i++) {
+      const node = r.snapshotItem(i);
+      if (namesTarget(node)) nodes.push(node);
+    }
     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];
   })`;
+/**
+ * The quoted, non-negated target phrases a plain click step names, used to
+ * refuse a tail-retargeted element that is not that target. Field-label,
+ * select, and radio steps quote option/label values rather than the clicked
+ * control's own text, so they yield no phrases and keep the unrestricted
+ * retarget.
+ */
+function tailRetargetPhrasesForStep(step) {
+    if (stepQuotesValueNotControlName(step))
+        return [];
+    return (0, deep_locator_candidates_1.extractTaggedPhrases)(step)
+        .filter((p) => !p.negated)
+        .map((p) => p.text);
+}
+/**
+ * True when the step's quoted text is a value (fill/select/radio/field-label)
+ * rather than the clicked control's own name, however loosely the prose is
+ * phrased. Shared so every quoted-phrase guard exempts the same steps.
+ */
+function stepQuotesValueNotControlName(step) {
+    return Boolean(parseFieldLabelTarget(step) ||
+        parseFillValueIntent(step) ||
+        parseSelectStep(step) ||
+        parseRadioStep(step));
+}
 /**
  * Resolve any selector a caller might hold into a bare XPath body for
  * `document.evaluate`. `verifyFillReadback` is shared across call sites that
@@ -3538,10 +4005,10 @@ const NEARBY_SELECTION_CONTAINER_FN_SRC = `(el) => {
  * source {@link selectionAncestorChanged} recomputes ancestor keys with, so the
  * two byte-match each other and Stagehand's resolved `xpath=/html[1]/…`
  * selectors. `[role=dialog],[role=tooltip],[aria-live]` subtrees are
- * skipped — they churn without a selection change. Visibility uses the same
- * rect + `getComputedStyle` idiom as `deep-locator-scan.ts`'s `IS_VISIBLE_EXPR`
- * (rather than `offsetParent`), so on-screen `position:fixed` controls — a
- * sticky Next/Submit bar, whose `offsetParent` is `null` — still enter the map.
+ * skipped — they churn without a selection change. Visibility uses the shared
+ * {@link ACTIONABLE_VISIBILITY_EXPR} (rect + `getComputedStyle`, skipping an
+ * element's own `aria-hidden="true"`; not `offsetParent`), so on-screen
+ * `position:fixed` controls — a sticky Next/Submit bar — still enter the map.
  * The visibility gate is waived for an `input`/`select` nested inside a nearby
  * combobox/listbox/group container: a design-system option commits its real
  * selection to a `display:none` or `aria-hidden` sibling input, not to the
@@ -3562,12 +4029,7 @@ const SELECTION_STATE_MAP_EXPR = `(() => {
   if (!b) return {};
   const xpathOf = ${XPATH_OF_FN_SRC};
   const nearbySelectionContainer = ${NEARBY_SELECTION_CONTAINER_FN_SRC};
-  const visible = (el) => {
-    const rect = el.getBoundingClientRect();
-    if (rect.width === 0 && rect.height === 0) return false;
-    const style = getComputedStyle(el);
-    return style.display !== "none" && style.visibility !== "hidden";
-  };
+  const visible = ${actionable_visibility_expr_1.ACTIONABLE_VISIBILITY_EXPR};
   const sel = "button,[role=button],a,li,[tabindex],input,select,textarea,[role=option],[role=tab],[role=switch],[role=checkbox],[role=menuitemcheckbox],[role=combobox]," + ${JSON.stringify(browser_click_expr_1.SELECTION_MARKER_CLASS_SELECTOR_SRC)};
   const skip = (el) => el.closest("[role=dialog],[role=tooltip],[aria-live]") !== null;
   const isCommittedValueControl = (el) =>
@@ -3660,7 +4122,10 @@ async function readElementSelectionFingerprint(target, selector) {
  * own xpath still resolve to a node in the post-click DOM? A same-page
  * toggle (a settings-page tab switcher swapping its panel content) leaves
  * the clicked control itself in place; a full client-side reset that reverts
- * to an earlier screen replaces it along with everything else. Returns
+ * to an earlier screen replaces it along with everything else. A view swap
+ * (e.g. a login-to-registration form swap) also removes its trigger, so
+ * absence only vetoes when the DOM did not grow; the caller applies that
+ * direction check. Returns
  * `true` — never veto — whenever presence genuinely can't be determined (a
  * non-xpath selector, an evaluate failure): only a positive `false` read
  * back from the DOM counts as proof of absence.
@@ -3709,7 +4174,7 @@ async function resolvedClickTargetStillPresent(target, selector) {
  * (Stagehand act()) call site never passes this — its resolved selector came
  * from Stagehand's own successful resolution, so no retarget applies there.
  */
-async function resolvedClickTargetIsSubmitShaped(target, selector, xpathTail = null) {
+async function resolvedClickTargetIsSubmitShaped(target, selector, xpathTail = null, phrases = []) {
     const xpath = xpathBodyForEvaluate(selector);
     if (!xpath)
         return false;
@@ -3717,7 +4182,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)}, ${JSON.stringify(phrases)});
     }
     const isSubmitShaped = ${submit_control_1.SUBMIT_SHAPE_EXPR};
     return isSubmitShaped(el);
@@ -3746,7 +4211,7 @@ async function resolvedClickTargetIsSubmitShaped(target, selector, xpathTail = n
  * strong signal (a real URL/network transition) instead of trusting it
  * blindly, without touching the (already well-tested) weak DOM-signal path.
  */
-async function resolvedClickUsedXpathTailRetarget(target, selector, xpathTail) {
+async function resolvedClickUsedXpathTailRetarget(target, selector, xpathTail, phrases = []) {
     if (!xpathTail)
         return false;
     const xpath = xpathBodyForEvaluate(selector);
@@ -3754,7 +4219,8 @@ async function resolvedClickUsedXpathTailRetarget(target, selector, xpathTail) {
         return false;
     const expr = `(() => {
     const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-    return r.singleNodeValue === null;
+    if (r.singleNodeValue !== null) return false;
+    return ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}, ${JSON.stringify(true)}, ${JSON.stringify(phrases)}) !== null;
   })()`;
     try {
         return (await target.evaluate(expr)) === true;
@@ -4034,7 +4500,16 @@ const UPLOAD_WIDGET_RENDER_INTERVAL_MS = 600;
  * matches `/attachment`; the others cover the other ATS upload sinks. Module-
  * level so both the raw-input path and the click-to-surface path share one list.
  */
-const UPLOAD_URL_PATTERNS = ["/upload", "/resume", "/file", "/attachment", "/document"];
+const UPLOAD_URL_PATTERNS = [
+    "/upload",
+    "/resume",
+    "/file",
+    "/attach",
+    "/document",
+    "/cv",
+    "/media",
+    "/import",
+];
 /**
  * Poll the recent-capture window for an upload-related POST after a file has
  * been attached. Extracted from `tryUploadPrimitive` so the raw-input path,
@@ -4043,7 +4518,7 @@ const UPLOAD_URL_PATTERNS = ["/upload", "/resume", "/file", "/attachment", "/doc
  * {@link UPLOAD_URL_PATTERNS} lands; false if the timeout elapses first.
  */
 async function waitForUploadNetworkSignal(params) {
-    const { page, fixture, logger, signalCounter, recentCaptureMeta } = params;
+    const { page, fixture, logger, signalCounter, recentCaptureMeta, stopWhen } = params;
     const networkCountBefore = signalCounter.n;
     const captureMetaCountBefore = recentCaptureMeta.length;
     const startedAt = performance.now();
@@ -4061,6 +4536,8 @@ async function waitForUploadNetworkSignal(params) {
                 return true;
             }
         }
+        if (stopWhen?.())
+            return false;
         await page.waitForTimeout(UPLOAD_NETWORK_POLL_INTERVAL_MS);
     }
     return false;
@@ -4074,14 +4551,7 @@ async function waitForUploadNetworkSignal(params) {
  * surface path never fires a skip/decline/submit control.
  */
 function isUploadAffordanceLabel(label) {
-    const norm = label.replace(/\s+/g, " ").trim().toLowerCase();
-    if (norm.length === 0)
-        return false;
-    if (/\b(later|skip|without|remove|delete|cancel)\b/.test(norm))
-        return false;
-    if (/\bno file\b/.test(norm))
-        return false;
-    return /\b(upload|browse|select file|choose file|attach|add (a )?(resume|cv|file)|resume\/cv)\b/.test(norm);
+    return (0, upload_affordance_expr_1.matchesUploadAffordanceVocabulary)(label);
 }
 /**
  * Materialize the in-memory upload fixture to a temp file so CDP
@@ -4157,13 +4627,33 @@ async function tryUploadPrimitive(params) {
             logger,
             signalCounter,
             recentCaptureMeta,
+            browserbaseSessionId: params.browserbaseSessionId,
         });
         if (surfaced)
             return true;
         logger.info("upload primitive: click-to-surface failed; falling through to cascade");
         return false;
     }
-    return attachToSurfacedInput({ page, target, fixture, logger, signalCounter, recentCaptureMeta });
+    const attached = await attachToSurfacedInput({
+        page,
+        target,
+        fixture,
+        logger,
+        signalCounter,
+        recentCaptureMeta,
+    });
+    if (attached)
+        return true;
+    logger.info("upload primitive: existing input did not take the file; attempting click-to-surface");
+    return surfaceAndUpload({
+        page,
+        target,
+        fixture,
+        logger,
+        signalCounter,
+        recentCaptureMeta,
+        browserbaseSessionId: params.browserbaseSessionId,
+    });
 }
 /**
  * Attach the fixture to an already-surfaced `<input type=file>` (raw or freshly
@@ -4174,7 +4664,11 @@ async function tryUploadPrimitive(params) {
  */
 async function attachToSurfacedInput(params) {
     const { page, target, fixture, logger, signalCounter, recentCaptureMeta } = params;
-    const inputLocator = target.locator("xpath=//input[@type='file']").first();
+    // Prefer an enabled input (a widget can keep a disabled decoy beside the live one);
+    // the second union branch only matches when no enabled file input exists.
+    const inputLocator = target
+        .locator("xpath=(//input[@type='file' and not(@disabled)] | //input[@type='file'][not(//input[@type='file' and not(@disabled)])])[1]")
+        .first();
     try {
         await inputLocator.setInputFiles({
             name: fixture.name,
@@ -4263,28 +4757,21 @@ async function attachToSurfacedInput(params) {
  * was attached.
  */
 async function surfaceAndUpload(params) {
-    const { page, target, fixture, logger, signalCounter, recentCaptureMeta } = params;
+    const { page, target, fixture, logger, signalCounter, recentCaptureMeta, browserbaseSessionId } = params;
     // Render-gate: the input-less strategies below (drag-drop is one-shot, the
     // affordance click resolves what's in the DOM) all race the async widget
     // mount. Wait (bounded, same window as the raw-input probe) for ANY upload
     // target to appear — a dropzone, an upload-affordance button, or an
     // <input type=file> — so every downstream strategy runs against a rendered
-    // widget. Static evaluate literal (no interpolation); dropzone list parallels
+    // widget. Dropzone list is the shared FIND_DROP_ZONE_EXPR used by
     // simulateDragDropUpload and the button matcher parallels clickUploadAffordance.
     const targetExpr = `(() => {
-    const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
-    const isUpload = (raw) => {
-      const t = norm(raw);
-      if (!t) return false;
-      if (/\\b(later|skip|without|remove|delete|cancel)\\b/.test(t)) return false;
-      if (/\\bno file\\b/.test(t)) return false;
-      return /\\b(upload|browse|select file|choose file|attach|add (a )?(resume|cv|file)|resume\\/cv)\\b/.test(t);
-    };
+    const isUpload = ${upload_affordance_expr_1.UPLOAD_AFFORDANCE_MATCHER_EXPR};
     if (document.querySelector("input[type=file]")) return { present: true };
-    const dz = document.querySelector("[class*='dropzone'],[class*='drop-zone'],[class*='file-drop'],[class*='upload-zone'],[class*='ResumeUpload'],[class*='resumeUpload'],[class*='resume-upload'],uapp-upload,app-upload");
-    if (dz) return { present: true };
-    const btns = Array.from(document.querySelectorAll("button,[role='button'],a"));
-    if (btns.some((el) => isUpload(el.getAttribute("aria-label") || el.textContent || ""))) return { present: true };
+    if (${upload_affordance_expr_1.FIND_DROP_ZONE_EXPR}(document)) return { present: true };
+    const actionable = ${actionable_visibility_expr_1.ACTIONABLE_VISIBILITY_EXPR};
+    const btns = Array.from(document.querySelectorAll(${JSON.stringify(upload_affordance_expr_1.UPLOAD_AFFORDANCE_CONTROL_SELECTOR)}));
+    if (btns.some((el) => actionable(el) && isUpload(el.getAttribute("aria-label") || el.textContent || ""))) return { present: true };
     return { present: false };
   })()`;
     const gate = await pollEnumerate(page, target, targetExpr, (r) => r?.present === true, {
@@ -4329,39 +4816,53 @@ async function surfaceAndUpload(params) {
         if (!(await clickUploadAffordance(page, target, logger)))
             return false;
         // Strategy 0: some MUI widgets XHR straight to attachment_upload_url on
-        // click, no chooser, no input.
-        if (await waitForUploadNetworkSignal({ page, fixture, logger, signalCounter, recentCaptureMeta })) {
+        // click, no chooser, no input. Stops waiting the moment a chooser is
+        // intercepted — that widget wants the file via the chooser, so burning the
+        // full network window first only delays Strategy B.
+        if (await waitForUploadNetworkSignal({
+            page,
+            fixture,
+            logger,
+            signalCounter,
+            recentCaptureMeta,
+            stopWhen: () => chooserBackendNodeId !== null,
+        })) {
             logger.info("upload primitive: resolved via click → immediate upload POST");
             return true;
         }
-        // Strategy A: the click lazily mounted a hidden <input type=file>.
-        const appeared = await pollEnumerate(page, target, "document.querySelectorAll('input[type=file]').length", (n) => (n ?? 0) > 0);
-        if ((appeared ?? 0) > 0) {
-            logger.info("upload primitive: click surfaced a hidden <input type=file>");
-            if (await attachToSurfacedInput({
+        // Strategy B: the click opened a native chooser we intercepted. Tried before A —
+        // the chooser names the exact input the widget wants, while A re-sets whatever
+        // input exists, which a React widget may ignore.
+        if (chooserBackendNodeId !== null) {
+            logger.info(`upload primitive: native file chooser intercepted (backendNodeId=${chooserBackendNodeId}); setting files via CDP`);
+            if (await setFilesViaCdp({
                 page,
                 target,
+                session,
+                backendNodeId: chooserBackendNodeId,
                 fixture,
                 logger,
                 signalCounter,
                 recentCaptureMeta,
+                browserbaseSessionId,
             })) {
                 return true;
             }
         }
-        // Strategy B: the click opened a native chooser we intercepted.
-        if (chooserBackendNodeId !== null) {
-            logger.info(`upload primitive: native file chooser intercepted (backendNodeId=${chooserBackendNodeId}); setting files via CDP`);
-            return setFilesViaCdp({
+        // Strategy A: the click lazily mounted a hidden <input type=file>.
+        const appeared = await pollEnumerate(page, target, "document.querySelectorAll('input[type=file]').length", (n) => (n ?? 0) > 0);
+        if ((appeared ?? 0) > 0) {
+            logger.info("upload primitive: click surfaced a hidden <input type=file>");
+            if (await attachToSurfacedInput({
                 page,
                 target,
-                session,
-                backendNodeId: chooserBackendNodeId,
                 fixture,
                 logger,
                 signalCounter,
                 recentCaptureMeta,
-            });
+            })) {
+                return true;
+            }
         }
         return false;
     }
@@ -4370,6 +4871,7 @@ async function surfaceAndUpload(params) {
         await session.send("Page.setInterceptFileChooserDialog", { enabled: false }).catch(() => { });
     }
 }
+const UPLOAD_AFFORDANCE_MARKER = "data-barnacle-upload-affordance";
 /**
  * Locate and click the resume-upload affordance in the page DOM. Uses a DOM
  * enumerate (NOT Stagehand observe, which returns [] for these MUI buttons)
@@ -4382,40 +4884,71 @@ async function surfaceAndUpload(params) {
  * (the frame the enumerate/click runs against).
  */
 async function clickUploadAffordance(page, target, logger) {
-    // The browser-side matcher parallels isUploadAffordanceLabel; kept as a literal
-    // so the enumerate is a static string (same trust posture as the other
-    // primitives). No external interpolation.
+    // The browser-side matcher is the shared upload-affordance vocabulary; the enumerate stays
+    // a static string (same trust posture as the other
+    // primitives); only shared constants are interpolated.
     const expr = `(() => {
     const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
-    const isUpload = (raw) => {
-      const t = norm(raw);
-      if (!t) return false;
-      if (/\\b(later|skip|without|remove|delete|cancel)\\b/.test(t)) return false;
-      if (/\\bno file\\b/.test(t)) return false;
-      return /\\b(upload|browse|select file|choose file|attach|add (a )?(resume|cv|file)|resume\\/cv)\\b/.test(t);
-    };
-    const els = Array.from(document.querySelectorAll("button,[role='button'],a"));
+    const isUpload = ${upload_affordance_expr_1.UPLOAD_AFFORDANCE_MATCHER_EXPR};
+    const els = Array.from(document.querySelectorAll(${JSON.stringify(upload_affordance_expr_1.UPLOAD_AFFORDANCE_CONTROL_SELECTOR)}));
     const scoped = (el) => !!el.closest("[class*='ttachment'],[class*='pload'],[class*='esume']");
-    const matches = els.filter((el) => isUpload(el.getAttribute("aria-label") || el.textContent || ""));
-    if (matches.length === 0) return { clicked: false };
+    const actionable = ${actionable_visibility_expr_1.ACTIONABLE_VISIBILITY_EXPR};
+    const matches = els.filter((el) => actionable(el) && isUpload(el.getAttribute("aria-label") || el.textContent || ""));
+    if (matches.length === 0) return { marked: false };
     const chosen = matches.find(scoped) || matches[0];
-    chosen.click();
-    return { clicked: true, text: norm(chosen.getAttribute("aria-label") || chosen.textContent || "").slice(0, 50) };
+    chosen.setAttribute("${UPLOAD_AFFORDANCE_MARKER}", "");
+    return { marked: true, text: norm(chosen.getAttribute("aria-label") || chosen.textContent || "").slice(0, 50) };
   })()`;
+    const markerSelector = `[${UPLOAD_AFFORDANCE_MARKER}]`;
     try {
-        const result = (await pollEnumerate(page, target, expr, (r) => r?.clicked === true)) ?? { clicked: false };
-        if (result.clicked) {
-            logger.info(`upload primitive: clicked upload affordance "${result.text ?? ""}"`);
-            return true;
+        const result = (await pollEnumerate(page, target, expr, (r) => r?.marked === true)) ?? { marked: false };
+        if (!result.marked) {
+            logger.info("upload primitive: no upload affordance button found in DOM");
+            return false;
         }
-        logger.info("upload primitive: no upload affordance button found in DOM");
-        return false;
+        // A trusted CDP click is required: an in-page el.click() never opens a file chooser.
+        try {
+            await (0, trusted_click_1.clickCentredTrusted)(target, markerSelector, { label: "upload affordance" });
+        }
+        finally {
+            await target
+                .evaluate(`document.querySelectorAll(${JSON.stringify(markerSelector)}).forEach((el) => el.removeAttribute("${UPLOAD_AFFORDANCE_MARKER}"))`)
+                .catch(() => { });
+        }
+        logger.info(`upload primitive: clicked upload affordance "${result.text ?? ""}"`);
+        return true;
     }
     catch (err) {
         logger.warn(`upload primitive: affordance click threw: ${(0, errors_1.toErrorMessage)(err)}`);
         return false;
     }
 }
+/**
+ * Push the fixture to Browserbase's session uploads endpoint, because a remote
+ * browser cannot read a path on this host. Returns the path the remote
+ * browser sees, or null when the upload is rejected.
+ */
+async function uploadFixtureToRemoteSession(sessionId, fixture, logger) {
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array(fixture.buffer)], { type: fixture.mimeType }), fixture.name);
+    try {
+        const res = await fetch(`${config_1.config.scraper.browserbaseBaseUrl}/v1/sessions/${sessionId}/uploads`, {
+            method: "POST",
+            headers: { "X-BB-API-Key": config_1.config.scraper.browserbaseApiKey ?? "" },
+            body: form,
+        });
+        const accepted = res.ok ?? (res.status >= 200 && res.status < 300);
+        if (!accepted) {
+            logger.warn(`upload primitive: remote session upload failed (status=${res.status})`);
+            return null;
+        }
+        return `/tmp/.uploads/${fixture.name}`;
+    }
+    catch (err) {
+        logger.warn(`upload primitive: remote session upload threw: ${(0, errors_1.toErrorMessage)(err)}`);
+        return null;
+    }
+}
 /**
  * Complete a native-chooser upload the recon intercepted via CDP. CDP's
  * `DOM.setFileInputFiles` takes filesystem PATHS (not buffers), so it uses the
@@ -4424,11 +4957,15 @@ async function clickUploadAffordance(page, target, logger) {
  * shared upload-network signal.
  */
 async function setFilesViaCdp(params) {
-    const { page, target, session, backendNodeId, fixture, logger, signalCounter, recentCaptureMeta, } = params;
+    const { page, target, session, backendNodeId, fixture, logger, signalCounter, recentCaptureMeta, browserbaseSessionId, } = params;
     // CDP needs a filesystem path; the fixture is an in-memory buffer. Write it
     // to a temp file (tiny — a few KB) so the path is always valid regardless of
     // where the recon loaded the fixture from.
-    const path = writeFixtureToTempFile(fixture);
+    const path = browserbaseSessionId
+        ? await uploadFixtureToRemoteSession(browserbaseSessionId, fixture, logger)
+        : writeFixtureToTempFile(fixture);
+    if (path === null)
+        return false;
     try {
         await session.send("DOM.setFileInputFiles", { files: [path], backendNodeId });
     }
@@ -4480,6 +5017,19 @@ async function setFilesViaCdp(params) {
 // 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;
+/**
+ * Matches `prefix` (which must end in a `(?=')` lookahead) and returns the
+ * contraction-aware quoted phrase that starts right after it, so anchored
+ * step parsers pair quotes the same way as {@link findQuotedSpans}.
+ */
+function matchQuotedAfter(instruction, prefix) {
+    const match = prefix.exec(instruction);
+    if (!match)
+        return null;
+    const at = match.index + match[0].length;
+    const phrase = (0, quoted_spans_1.findQuotedSpans)(instruction).find((p) => p.start === at);
+    return phrase ? { match, phrase } : null;
+}
 /**
  * Pick the QUESTION LABEL out of an instruction's quoted phrases, given the
  * already-extracted OPTION.
@@ -4497,21 +5047,17 @@ const WIDGET_NOUN_RE = /\b(prompt\s+selector|multiselect|typeahead|dropdown|fiel
  * 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);
+    const candidates = (0, quoted_spans_1.findQuotedSpans)(instruction).filter((s) => s.text.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);
+    const adjacentToWidgetNoun = candidates.find((s) => {
+        const before = instruction.slice(Math.max(0, s.start - 25), s.start);
+        const after = instruction.slice(s.end, s.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();
+    return picked.text.trim();
 }
 function parseSelectStep(instruction) {
     const lower = instruction.toLowerCase();
@@ -4524,8 +5070,7 @@ function parseSelectStep(instruction) {
     // Catch-all steps ("for any remaining…") have no concrete single target.
     if (/\bany\s+remaining\b/.test(lower))
         return null;
-    // biome-ignore lint/style/noNonNullAssertion: capture group 1 is required by the pattern, so it is present on every match
-    const quoted = [...instruction.matchAll(/'([^']+)'/g)].map((m) => m[1]);
+    const quoted = (0, quoted_spans_1.findQuotedSpans)(instruction).map((s) => s.text);
     if (quoted.length === 0)
         return null;
     // The OPTION is the quoted string following the word "select", allowing a
@@ -4533,11 +5078,10 @@ function parseSelectStep(instruction) {
     // 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);
+    const selMatch = matchQuotedAfter(instruction, /\bselect(?:\s+or\s+check)?\s+(?:the\s+\S+\s+)?(?=')/i)?.phrase;
     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();
+    const option = selMatch.text.trim();
     // The QUESTION LABEL, when present, is a DIFFERENT quoted string — the one
     // introduced by "for '…'" or adjacent to a widget noun like "'…' dropdown"
     // or "'…' prompt selector". See `pickQuestionLabel`.
@@ -4569,11 +5113,11 @@ function parseSelectStep(instruction) {
  * to the normal cascade unchanged.
  */
 function parseFillStep(instruction) {
-    const match = instruction.match(/\bfill(?:\s+in)?\s+(?:the\s+)?(.+?)\s+(?:field|input|textbox)\s+with\s+'([^']+)'/i);
-    if (!match)
+    const found = matchQuotedAfter(instruction, /\bfill(?:\s+in)?\s+(?:the\s+)?(.+?)\s+(?:field|input|textbox)\s+with\s+(?=')/i);
+    if (!found)
         return null;
-    const fieldLabel = match[1]?.trim();
-    const value = match[2]?.trim();
+    const fieldLabel = found.match[1]?.trim();
+    const value = found.phrase.text.trim();
     if (!fieldLabel || !value)
         return null;
     return { fieldLabel, value };
@@ -4601,14 +5145,458 @@ function parseFillValueIntent(instruction) {
     if (parseSelectStep(instruction))
         return null;
     if (/\bfill(?:\s+in)?\b/i.test(instruction)) {
-        const value = instruction.match(/\bwith\s+'([^']+)'/i)?.[1]?.trim();
+        const value = matchQuotedAfter(instruction, /\bwith\s+(?=')/i)?.phrase.text.trim();
         return value ? { value } : null;
     }
     if (/\btype\b/i.test(instruction)) {
-        const value = instruction.match(/\btype\s+'([^']+)'/i)?.[1]?.trim();
+        const value = matchQuotedAfter(instruction, /\btype\s+(?=')/i)?.phrase.text.trim();
         return value ? { value } : null;
     }
-    return null;
+    return null;
+}
+const SEGMENTED_DATE_VALUE_RE = /^[\d/.\s-]+$/;
+const SEGMENTED_DATE_MIN_DIGITS = 4;
+const SEGMENTED_DATE_MAX_DIGITS = 8;
+const SEGMENTED_DATE_KEY_DELAY_MS = 50;
+const SEGMENTED_DATE_FIELD_WORDS = new Set([
+    "from",
+    "to",
+    "start",
+    "end",
+    "since",
+    "until",
+    "through",
+    "begin",
+    "finish",
+]);
+const SEGMENTED_DATE_STOPWORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "at",
+    "date",
+    "enter",
+    "fill",
+    "for",
+    "in",
+    "into",
+    "of",
+    "on",
+    "the",
+    "then",
+    "to",
+    "type",
+    "with",
+]);
+/**
+ * Extract the digits a fill/type/enter step wants typed into a multi-segment
+ * date widget. Limited to 4-8 digits so phone numbers and other long numerics
+ * never trigger the segmented-date path. Reuses `parseFillValueIntent` and
+ * falls back to the last date-shaped quoted phrase for verbless steps such as
+ * "'From' date in Work Experience 1, '012020'".
+ */
+function parseSegmentedDateValue(instruction) {
+    const spans = (0, quoted_spans_1.findQuotedSpans)(instruction);
+    const intent = parseFillValueIntent(instruction)?.value;
+    const candidates = intent
+        ? [intent]
+        : spans
+            .map((s) => s.text.trim())
+            .filter((t) => SEGMENTED_DATE_VALUE_RE.test(t))
+            .reverse();
+    for (const raw of candidates) {
+        if (!SEGMENTED_DATE_VALUE_RE.test(raw))
+            continue;
+        const digits = raw.replace(/\D/g, "");
+        if (digits.length < SEGMENTED_DATE_MIN_DIGITS || digits.length > SEGMENTED_DATE_MAX_DIGITS) {
+            continue;
+        }
+        return { digits, valueSpan: raw };
+    }
+    if (spans.length > 0 && intent)
+        return null;
+    const bare = instruction
+        .split(/\s+/)
+        .map((t) => t.replace(/[.,;:]+$/, ""))
+        .filter((t) => /\d/.test(t) && SEGMENTED_DATE_VALUE_RE.test(t))
+        .reverse();
+    for (const raw of bare) {
+        const digits = raw.replace(/\D/g, "");
+        if (digits.length < SEGMENTED_DATE_MIN_DIGITS || digits.length > SEGMENTED_DATE_MAX_DIGITS) {
+            continue;
+        }
+        return { digits, valueSpan: raw };
+    }
+    return null;
+}
+/** Keeps a typed date's shape (segment count and widths) in logs without its digits. */
+function maskDateDigits(text) {
+    return text.replace(/\d/g, "9");
+}
+function segmentedDateTokens(text) {
+    return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+const SEGMENTED_DATE_PART_LABELS = new Set(["mm", "dd", "yyyy", "yy", "month", "day", "year"]);
+const SEGMENTED_DATE_FIELD_NOUNS = new Set([
+    "date",
+    "field",
+    "group",
+    "input",
+    "spinbutton",
+    "segment",
+    "value",
+    "part",
+]);
+const SEGMENTED_DATE_NAMING_DETERMINERS = new Set(["the", "its", "this", "that", "for", "of"]);
+/**
+ * Step tokens with the field words that are mere prose removed. "from"/"to"
+ * only name a date field when a determiner precedes them ("the To date"), a
+ * field noun follows ("From date"), or they are capitalised mid-sentence;
+ * "auto-advances from month to year" names nothing and must never select a
+ * group labelled "From".
+ */
+function segmentedDateStepTokens(text) {
+    const words = text.match(/[A-Za-z0-9]+/g) ?? [];
+    return words.flatMap((word, i) => {
+        const token = word.toLowerCase();
+        if (!SEGMENTED_DATE_FIELD_WORDS.has(token))
+            return [token];
+        const prev = (words[i - 1] ?? "").toLowerCase();
+        const next = (words[i + 1] ?? "").toLowerCase();
+        const named = SEGMENTED_DATE_NAMING_DETERMINERS.has(prev) ||
+            SEGMENTED_DATE_FIELD_NOUNS.has(next) ||
+            (i > 0 && /^[A-Z]/.test(word));
+        return named ? [token] : [];
+    });
+}
+/**
+ * Pick which spinbutton group a segmented-date step targets. Groups whose
+ * segment widths (digit count of `aria-valuemax`) don't sum to the value's
+ * digit count are dropped. A group is only eligible when a field the step names
+ * (quoted, e.g. 'From', or unquoted in field position, e.g. "the To date")
+ * matches its OWN label as whole words — a group with no `label` is judged by
+ * its whole `context`. The section the step names ("Work Experience 1") is
+ * then resolved: when a width-fitting group elsewhere matches the step's
+ * section words better than any eligible group does, the named section renders
+ * no such field and the step resolves to nothing rather than to another
+ * section's. Returns the index into `groups`, or `null` when nothing matches
+ * or the best match is tied — writing a date into a group that merely fits the
+ * width would corrupt another field.
+ */
+function resolveSegmentedDateGroup(instruction, groups) {
+    const value = parseSegmentedDateValue(instruction);
+    if (!value)
+        return null;
+    const valueTokens = segmentedDateTokens(value.valueSpan).join(" ");
+    const quoted = (0, quoted_spans_1.findQuotedSpans)(instruction)
+        .map((s) => segmentedDateTokens(s.text.trim()))
+        .filter((t) => t.length > 0 &&
+        t.join(" ") !== valueTokens &&
+        !(t.length === 1 && SEGMENTED_DATE_PART_LABELS.has(t[0] ?? "")));
+    const stepTokens = segmentedDateStepTokens(instruction.replace(value.valueSpan, " barnaclevalue "));
+    const targets = quoted.length > 0 ? quoted : [stepTokens];
+    const contains = (hay, needle) => {
+        for (let i = 0; i + needle.length <= hay.length; i++) {
+            if (needle.every((t, j) => hay[i + j] === t))
+                return true;
+        }
+        return false;
+    };
+    const compatible = (group) => group.segmentMaxes.map((max) => String(max).length).reduce((a, b) => a + b, 0) ===
+        value.digits.length;
+    const stepSet = new Set(stepTokens);
+    const sectionScore = (group) => {
+        const own = new Set(segmentedDateTokens(group.label ?? ""));
+        const sectionTokens = new Set(segmentedDateTokens(group.section ?? group.context));
+        return [...sectionTokens].filter((t) => stepSet.has(t) &&
+            !own.has(t) &&
+            !SEGMENTED_DATE_STOPWORDS.has(t) &&
+            !SEGMENTED_DATE_FIELD_WORDS.has(t)).length;
+    };
+    const bestSection = Math.max(0, ...groups.filter(compatible).map((group) => sectionScore(group)));
+    let best = -1;
+    let bestScore = -1;
+    let tied = false;
+    groups.forEach((group, index) => {
+        if (!compatible(group))
+            return;
+        const own = segmentedDateTokens(group.label ?? group.context);
+        if (own.length === 0)
+            return;
+        const namesOwnField = group.label === undefined &&
+            quoted.length === 0 &&
+            own.some((t) => SEGMENTED_DATE_FIELD_WORDS.has(t) && stepSet.has(t));
+        if (!namesOwnField &&
+            !targets.some((t) => contains(t, own) || (quoted.length > 0 && contains(own, t)))) {
+            return;
+        }
+        const score = sectionScore(group);
+        if (score < bestSection)
+            return;
+        if (score > bestScore) {
+            best = index;
+            bestScore = score;
+            tied = false;
+        }
+        else if (score === bestScore) {
+            tied = true;
+        }
+    });
+    if (best >= 0)
+        return tied ? null : best;
+    // A step that names no field at all can only mean the one date widget on the
+    // page; a named field that matched no label must never fall back to it.
+    if (quoted.length > 0 || stepTokens.some((t) => SEGMENTED_DATE_FIELD_WORDS.has(t)))
+        return null;
+    const only = groups.flatMap((g, i) => (compatible(g) && !g.nested ? [i] : []));
+    return only.length === 1 ? (only[0] ?? null) : null;
+}
+const SEGMENTED_DATE_MARKER_ATTR = "data-barnacle-segdate";
+/** Exported so tests can run the real DOM enumeration against markup. */
+exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
+  const attr = ${JSON.stringify(SEGMENTED_DATE_MARKER_ATTR)};
+  const stale = document.querySelectorAll("[" + attr + "]");
+  stale.forEach((el) => el.removeAttribute(attr));
+  const hiddenAttr = (node) => node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true";
+  const styleOf = (node) => {
+    try { return typeof getComputedStyle === "function" ? getComputedStyle(node) : window.getComputedStyle(node); } catch { return null; }
+  };
+  const isHidden = (el) => {
+    for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
+      if (hiddenAttr(node)) return true;
+      const style = styleOf(node);
+      if (style && (style.display === "none" || style.visibility === "hidden")) return true;
+    }
+    return false;
+  };
+  const spins = Array.from(document.querySelectorAll("input[role='spinbutton']")).filter((el) => !isHidden(el));
+  if (spins.length === 0) return { groups: [] };
+  const norm = (s) => (s || "").replace(/\\s+/g, " ").trim();
+  const byContainer = new Map();
+  for (const el of spins) {
+    const box = el.closest("fieldset,[role='group']") || el.parentElement;
+    if (!byContainer.has(box)) byContainer.set(box, []);
+    byContainer.get(box).push(el);
+  }
+  const idText = (ids) => (ids || "").split(/\\s+/).map((id) => {
+    const ref = id ? document.getElementById(id) : null;
+    return ref ? norm(ref.textContent) : "";
+  }).join(" ");
+  const headingSibling = (node) => {
+    let prevSib = node.previousElementSibling;
+    for (let hop = 0; hop < 3 && prevSib; hop++, prevSib = prevSib.previousElementSibling) {
+      if (prevSib.matches("h1,h2,h3,h4,h5,h6,legend,[role='heading']")) return norm(prevSib.textContent);
+    }
+    return "";
+  };
+  const legendOf = (node) => {
+    const legend = node.tagName === "FIELDSET" ? node.querySelector(":scope > legend") : null;
+    return legend ? norm(legend.textContent) : "";
+  };
+  const namedBy = (node) => [legendOf(node), norm(node.getAttribute("aria-label")), idText(node.getAttribute("aria-labelledby"))].filter(Boolean).join(" ");
+  const sectionOf = (box, includeSelf) => {
+    const parts = [includeSelf ? namedBy(box) : "", headingSibling(box)];
+    let node = box.parentElement;
+    for (let depth = 0; depth < 4 && node && node !== document.body; depth++, node = node.parentElement) {
+      parts.push(namedBy(node), headingSibling(node));
+    }
+    return Array.from(new Set(parts.filter(Boolean))).join(" ");
+  };
+  const ownCaption = (box) => {
+    const caption = Array.from(box.querySelectorAll("label,legend")).find((l) => !l.querySelector("input,[role='spinbutton']") && !(l.getAttribute("for") && box.querySelector("[id='" + l.getAttribute("for") + "']")));
+    if (caption) return norm(caption.textContent);
+    const prev = box.previousElementSibling;
+    return prev && prev.matches("label,legend") && !prev.querySelector("input,[role='spinbutton']") ? norm(prev.textContent) : "";
+  };
+  const formFieldOf = (box) => box.closest("[data-automation-id^='formField-']");
+  const formFieldLabel = (field) => {
+    const label = field.querySelector("label,legend");
+    return label ? norm(label.textContent) : "";
+  };
+  const labelText = (seg) => {
+    const parts = [idText(seg.getAttribute("aria-labelledby")), norm(seg.getAttribute("aria-label")), norm(seg.getAttribute("placeholder"))];
+    if (seg.id) {
+      document.querySelectorAll("label").forEach((l) => { if (l.getAttribute("for") === seg.id) parts.push(norm(l.textContent)); });
+    }
+    const wrap = seg.closest("label");
+    if (wrap) parts.push(norm(wrap.textContent));
+    return parts.filter(Boolean).join(" ");
+  };
+  const maxOf = (seg, si, count) => {
+    const declared = Number(seg.getAttribute("aria-valuemax"));
+    if (declared > 0) return declared;
+    const own = labelText(seg).toLowerCase();
+    if (/year|yyyy|\byy\b/.test(own)) return 9999;
+    if (/month|\bmm\b/.test(own)) return 12;
+    if (/day|\bdd\b/.test(own)) return 31;
+    const len = Number(seg.getAttribute("maxlength"));
+    if (len > 0) return Math.pow(10, len) - 1;
+    return count > 1 && si === count - 1 ? 9999 : 12;
+  };
+  const groups = [];
+  const mark = (seg, token) => {
+    const prior = seg.getAttribute(attr);
+    seg.setAttribute(attr, prior ? prior + " " + token : token);
+  };
+  const addGroup = (segs, box, nested) => {
+    const gi = groups.length;
+    segs.forEach((seg, si) => mark(seg, gi + ":" + si));
+    const field = formFieldOf(box) || segs[0].closest("[data-automation-id^='formField-']");
+    const innerField = field && field !== box && box.contains(field) && segs.every((seg) => field.contains(seg)) ? formFieldLabel(field) : "";
+    const own = innerField || namedBy(box) || (field ? formFieldLabel(field) : "") || ownCaption(box) || segs.map((seg) => idText(seg.getAttribute("aria-labelledby"))).filter(Boolean).join(" ");
+    const section = sectionOf(box, Boolean(innerField));
+    groups.push({
+      segmentMaxes: segs.map((seg, si) => maxOf(seg, si, segs.length)),
+      context: [section, own].filter(Boolean).join(" "),
+      label: own,
+      section,
+      nested,
+    });
+  };
+  const nestedCandidates = [];
+  byContainer.forEach((segs, box) => {
+    addGroup(segs, box, false);
+    const byParent = new Map();
+    for (const seg of segs) {
+      if (!byParent.has(seg.parentElement)) byParent.set(seg.parentElement, []);
+      byParent.get(seg.parentElement).push(seg);
+    }
+    // A shared fieldset can hold several independent dates (From and To year
+    // spinbuttons side by side); each wrapper is then its own candidate group.
+    if (byParent.size > 1) byParent.forEach((inner, parent) => nestedCandidates.push([inner, parent]));
+  });
+  nestedCandidates.forEach(([inner, parent]) => addGroup(inner, parent, true));
+  return { groups };
+})()`;
+const SEGMENTED_DATE_CLEAR_EXPR = `(() => {
+  document.querySelectorAll("[${SEGMENTED_DATE_MARKER_ATTR}]").forEach((el) => el.removeAttribute(${JSON.stringify(SEGMENTED_DATE_MARKER_ATTR)}));
+})()`;
+/**
+ * Type a date into a multi-segment `role=spinbutton` widget with real key
+ * events (raw CDP key events, `locator.type` with a delay as fallback), then
+ * verify every segment numerically.
+ *
+ * Why this exists: such widgets keep each segment's value in component state
+ * driven by `keydown`/`beforeinput`; `fill`/`insertText` bypasses that and
+ * garbles the segments. Returns a marker id on commit, or null on no
+ * spinbuttons, an unresolvable group, or any segment mismatch so the caller
+ * falls through to the cascade.
+ */
+async function trySegmentedDateSpinbuttonPrimitive(params) {
+    const { page, target, instruction, logger } = params;
+    const value = parseSegmentedDateValue(instruction);
+    if (!value)
+        return null;
+    const sendCDP = (method, args) => target.frame?.session ? target.frame.session.send(method, args) : page.sendCDP(method, args);
+    try {
+        const enumerated = (await target.evaluate(exports.SEGMENTED_DATE_ENUMERATE_EXPR));
+        if (!enumerated?.groups?.length)
+            return null;
+        const gi = resolveSegmentedDateGroup(instruction, enumerated.groups);
+        if (gi === null) {
+            logger.info("segmented date primitive: no unambiguous group; falling through");
+            await target.evaluate(SEGMENTED_DATE_CLEAR_EXPR);
+            return null;
+        }
+        const maxes = enumerated.groups[gi]?.segmentMaxes ?? [];
+        const widths = maxes.map((max) => String(max).length);
+        const expected = widths.map((w, i) => {
+            const start = widths.slice(0, i).reduce((a, b) => a + b, 0);
+            return Number(value.digits.slice(start, start + w));
+        });
+        const segmentSelector = (si) => `[${SEGMENTED_DATE_MARKER_ATTR}~="${gi}:${si}"]`;
+        const focusSegment = async (si) => {
+            const selector = segmentSelector(si);
+            // A below-the-fold segment would otherwise take the trusted click at an
+            // off-screen point; centre it first so the click and key events land on it.
+            try {
+                await target.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(selector)}); if (el && typeof el.scrollIntoView === "function") el.scrollIntoView({ block: "center", inline: "center" }); })()`);
+            }
+            catch {
+                // scrolling is best-effort; the key events only need the segment focused
+            }
+            try {
+                if (await (0, trusted_click_1.isClickPointUnobscured)(target, selector)) {
+                    await (0, trusted_click_1.clickCentredTrusted)(target, selector, { label: "date segment" });
+                }
+            }
+            catch {
+                // click unavailable; focus below is what the key events need
+            }
+            await target.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(selector)}); if (el && document.activeElement !== el) el.focus(); })()`);
+        };
+        const typeViaCdp = async (digits) => {
+            for (const digit of digits) {
+                const keyArgs = {
+                    key: digit,
+                    code: `Digit${digit}`,
+                    windowsVirtualKeyCode: 48 + Number(digit),
+                };
+                await sendCDP("Input.dispatchKeyEvent", { type: "keyDown", text: digit, ...keyArgs });
+                await sendCDP("Input.dispatchKeyEvent", { type: "keyUp", ...keyArgs });
+            }
+        };
+        const segmentDigits = widths.map((w, i) => {
+            const from = widths.slice(0, i).reduce((acc, n) => acc + n, 0);
+            return value.digits.slice(from, from + w);
+        });
+        const readSegments = async () => (await target.evaluate(`(() => {
+      const sels = ${JSON.stringify(widths.map((_, si) => segmentSelector(si)))};
+      return sels.map((sel) => {
+        const s = document.querySelector(sel);
+        if (!s) return NaN;
+        const now = s.getAttribute("aria-valuenow");
+        const raw = now !== null && now !== "" ? now : s.value;
+        return raw === undefined || raw === null || String(raw).trim() === "" ? NaN : Number(raw);
+      });
+    })()`));
+        const matches = (got) => Array.isArray(got) &&
+            got.length === expected.length &&
+            got.every((n, i) => n === expected[i]);
+        // Raw CDP key events go to the focused segment, so each segment is focused
+        // explicitly rather than trusting the widget to auto-advance. A delayed
+        // locator.type (per-character key events, never Input.insertText) covers a
+        // page whose CDP channel does not reach the widget.
+        const typeViaLocator = async () => {
+            for (const [si, digits] of segmentDigits.entries()) {
+                await target.locator(segmentSelector(si)).first().type(digits, {
+                    delay: SEGMENTED_DATE_KEY_DELAY_MS,
+                });
+            }
+        };
+        const typeViaKeyEvents = async () => {
+            for (const [si, digits] of segmentDigits.entries()) {
+                await focusSegment(si);
+                await typeViaCdp(digits);
+            }
+        };
+        let actual = [];
+        for (const type of [typeViaKeyEvents, typeViaLocator]) {
+            try {
+                await type();
+            }
+            catch (err) {
+                logger.info(`segmented date primitive: delivery attempt threw: ${(0, errors_1.toErrorMessage)(err)}`);
+                continue;
+            }
+            actual = await readSegments();
+            if (matches(actual))
+                break;
+        }
+        if (!matches(actual))
+            actual = await readSegments();
+        await target.evaluate(SEGMENTED_DATE_CLEAR_EXPR);
+        if (!matches(actual)) {
+            logger.info(`segmented date primitive: readback ${maskDateDigits(JSON.stringify(actual))} != ${maskDateDigits(JSON.stringify(expected))}; falling through`);
+            return null;
+        }
+        logger.info(`segmented date primitive: committed segments ${maskDateDigits(JSON.stringify(actual))}`);
+        return `segmented-date-${gi}`;
+    }
+    catch (err) {
+        logger.warn(`segmented date primitive: threw: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
+        return null;
+    }
 }
 /**
  * Parse a single-choice RADIO flow step into the option to click and (when
@@ -4645,16 +5633,14 @@ function parseRadioStep(instruction) {
     // Catch-all steps ("for any remaining…") have no concrete single target.
     if (/\bany\s+remaining\b/.test(lower))
         return null;
-    // biome-ignore lint/style/noNonNullAssertion: capture group 1 is required by the pattern, so it is present on every match
-    const quoted = [...instruction.matchAll(/'([^']+)'/g)].map((m) => m[1]);
+    const quoted = (0, quoted_spans_1.findQuotedSpans)(instruction).map((s) => s.text);
     if (quoted.length === 0)
         return null;
     // The OPTION is the quoted string immediately after "click the".
-    const optMatch = instruction.match(/\bclick\s+the\s+'([^']+)'/i);
+    const optMatch = matchQuotedAfter(instruction, /\bclick\s+the\s+(?=')/i)?.phrase;
     if (!optMatch)
         return null;
-    // biome-ignore lint/style/noNonNullAssertion: guarded by the !optMatch early-return; group 1 is required by the pattern
-    const option = optMatch[1].trim();
+    const option = optMatch.text.trim();
     // The QUESTION LABEL, when present, is a DIFFERENT quoted string — the one
     // introduced by "for the question '…'" / "for the '…' question". Some steps
     // phrase the question un-quoted ("…about requiring visa sponsorship"); in
@@ -4699,11 +5685,10 @@ function parseWidgetOptionClickStep(instruction) {
     // tolerant of a short qualifier ("top-level", "leaf") between the noun and
     // the quote — e.g. "click the top-level category 'Job Boards'" or "click
     // the leaf option 'Internet - Job Boards/Search Engines'".
-    const optMatch = instruction.match(/\bclick\s+the\s+(?:\S+\s+)?(?:category|option)\s+'([^']+)'/i);
+    const optMatch = matchQuotedAfter(instruction, /\bclick\s+the\s+(?:\S+\s+)?(?:category|option)\s+(?=')/i)?.phrase;
     if (!optMatch)
         return null;
-    // biome-ignore lint/style/noNonNullAssertion: guarded by the !optMatch early-return; group 1 is required by the pattern
-    const option = optMatch[1].trim();
+    const option = optMatch.text.trim();
     return { option };
 }
 /**
@@ -4724,10 +5709,31 @@ function parseCheckStep(instruction) {
     const lower = instruction.toLowerCase();
     if (/\bany\s+remaining\b/.test(lower))
         return null;
-    const match = instruction.match(/\b(?:check|click)\s+(?:the\s+)?'([^']+)'.*?\bcheckbox\b/i);
-    const label = match?.[1]?.trim();
+    const found = matchQuotedAfter(instruction, /\b(?:un)?check\s+(?:the\s+)?(?=')|\bclick\s+(?:the\s+)?(?=')/i);
+    const rest = found ? instruction.slice(found.phrase.end) : "";
+    const label = /^.*?\bcheckbox\b/i.test(rest) ? found?.phrase.text.trim() : undefined;
     return label ? { label } : null;
 }
+/**
+ * Parse a single-checkbox STATE step ("Check the 'X' checkbox" / "Uncheck the
+ * 'X' checkbox") into its label, desired state and trailing section words.
+ *
+ * Why this exists: "Click the … checkbox" is a toggle and stays with the
+ * cascade; only the explicit check/uncheck verbs name a target state the
+ * primitive can compare against what the page committed.
+ */
+function parseCheckStateStep(instruction) {
+    const parsed = parseCheckStep(instruction);
+    const found = matchQuotedAfter(instruction, /\b(un)?check\s+(?:the\s+)?(?=')/i);
+    if (!parsed || !found)
+        return null;
+    const outside = instruction.slice(0, found.match.index) +
+        " " +
+        instruction.slice(found.phrase.end).replace(/^.*?\bcheckbox\b/i, "");
+    const stop = new Set(["the", "for", "and", "section", "under", "this", "that", "with", "from"]);
+    const sectionWords = (outside.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter((w) => !stop.has(w) && (w.length >= 3 || /^\d+$/.test(w)));
+    return { label: parsed.label, desired: !found.match[1], sectionWords };
+}
 /** Strips wrapping single quotes a parser's capture group may include (e.g. when a flow author quotes the field name itself), so a probe label compares plain text against plain text. */
 function stripQuotedLabel(label) {
     return label.replace(/^'+|'+$/g, "").trim();
@@ -5262,13 +6268,16 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
         if (clickResult.clicked) {
             if (!pre || !verification)
                 return true;
+            if (verification.page)
+                await (0, click_settle_1.settleAfterClick)(verification.page, verification.signalCounter, pre.networkCount, true, async () => (await snapshotPage(target, verification.signalCounter)).visibleTextSignature, pre.visibleTextSignature);
             const post = await snapshotPage(target, verification.signalCounter, verification.page);
             const verdict = (0, phantom_click_1.classifyPhantomClick)({
                 actResultSuccess: true,
                 pre,
                 post,
                 isSubmitShapedStep: true,
-                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, post.url),
+                isMidFlowSubmitStep: verification.isMidFlowSubmitStep,
+                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, post.url, verification.isMidFlowSubmitStep ? pre.url : undefined),
             });
             if (verdict !== "phantom")
                 return true;
@@ -5282,13 +6291,16 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
                     throw err;
                 });
                 if (runnerUpClickResult.clicked) {
+                    if (verification.page)
+                        await (0, click_settle_1.settleAfterClick)(verification.page, verification.signalCounter, post.networkCount, true, async () => (await snapshotPage(target, verification.signalCounter)).visibleTextSignature, post.visibleTextSignature);
                     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),
+                        isMidFlowSubmitStep: verification.isMidFlowSubmitStep,
+                        destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, runnerUpPost.url, verification.isMidFlowSubmitStep ? post.url : undefined),
                     });
                     if (runnerUpVerdict !== "phantom")
                         return true;
@@ -5403,7 +6415,7 @@ async function trySelectPrimitive(params) {
     if (!parsed)
         return null;
     const { option, questionLabel } = parsed;
-    const optLabel = `option "${redactIfSensitive(option, redactValue).slice(0, 40)}"${questionLabel ? `, question "${questionLabel.slice(0, 40)}"` : ""}`;
+    const optLabel = primitiveOptionLabel(option, questionLabel, redactValue);
     // Phase 1 (browser, no mutation): find the target select — the one whose
     // nearby text matches the question label (or, when no label, any select).
     // Try a deterministic option match first; if it hits, apply immediately (no
@@ -5501,7 +6513,7 @@ async function trySelectPrimitive(params) {
         if (enumResult.detMatch) {
             const { ok, stillInvalid } = await applySelectValue(page, target, enumResult.detMatch.selIdx, enumResult.detMatch.value);
             if (ok && !stillInvalid) {
-                logger.info(`select primitive: set dropdown to "${enumResult.detMatch.text.trim().slice(0, 40)}" (${optLabel})`);
+                logger.info(`select primitive: set dropdown to "${(0, pii_redaction_1.maskValueShape)(enumResult.detMatch.text.trim())}" (${optLabel})`);
                 return enumResult.detMatch.id;
             }
             logger.info(`select primitive: dropdown value for ${optLabel} did not commit (ok=${ok} stillInvalid=${stillInvalid}); falling through to cascade`);
@@ -5538,7 +6550,7 @@ async function trySelectPrimitive(params) {
         // same as the fast path.
         const { ok, stillInvalid } = await applySelectValue(page, target, chosenCandidate.selIdx, chosenOption.value);
         if (ok && !stillInvalid) {
-            logger.info(`select primitive: LLM chose "${chosenOption.text.slice(0, 40)}" for ${optLabel} (${verdict.reason.slice(0, 60)})`);
+            logger.info(`select primitive: LLM chose "${(0, pii_redaction_1.maskValueShape)(chosenOption.text)}" for ${optLabel} (${verdict.reason.slice(0, 60)})`);
             return chosenCandidate.id;
         }
         logger.info(`select primitive: LLM-chosen value for ${optLabel} did not commit (ok=${ok} stillInvalid=${stillInvalid}); falling through`);
@@ -5694,7 +6706,7 @@ async function tryFillRequiredSelectsPrimitive(params) {
             }
             const { ok, stillInvalid } = await applySelectValue(page, target, cand.selIdx, chosen.value);
             if (ok && !stillInvalid) {
-                logger.info(`required-select primitive: filled "${cand.label.slice(0, 40)}" with "${chosen.text.slice(0, 40)}"`);
+                logger.info(`required-select primitive: filled "${cand.label.slice(0, 40)}" with "${(0, pii_redaction_1.maskValueShape)(chosen.text)}"`);
             }
             else {
                 allCommitted = false;
@@ -5708,6 +6720,161 @@ async function tryFillRequiredSelectsPrimitive(params) {
         return false;
     }
 }
+/** Marker stamped on the matched checkbox / its label so trusted clicks can address them. */
+const CHECKBOX_STATE_MARKER_ATTR = "data-barnacle-cbstate";
+const CHECKBOX_STATE_POLL_MS = 200;
+const CHECKBOX_STATE_POLL_ATTEMPTS = 8;
+/**
+ * Commits a single "Check/Uncheck the 'X' checkbox" step by comparing the
+ * box's committed state to the requested one, so a pre-ticked box is never
+ * toggled off by a blind click. Returns the box's DOM id (possibly empty) on
+ * success, or null when ambiguous, absent, obscured or unflipped so the
+ * caller falls through to the cascade.
+ */
+async function tryCheckboxStatePrimitive(params) {
+    const { page, target, instruction, logger } = params;
+    const parsed = parseCheckStateStep(instruction);
+    if (!parsed)
+        return null;
+    const attr = CHECKBOX_STATE_MARKER_ATTR;
+    const stampExpr = `((label, words) => {
+    const norm = (s) => (s || "").replace(/\\s+/g, " ").replace(/\\s*[*:]+$/, "").trim().toLowerCase();
+    const want = norm(label);
+    document.querySelectorAll("[${attr}]").forEach((e) => e.removeAttribute("${attr}"));
+    const visible = (e) => {
+      try { return !!e && e.getClientRects().length > 0 && getComputedStyle(e).visibility !== "hidden"; } catch { return !!e; }
+    };
+    const labelsOf = (cb) => {
+      const out = [];
+      if (cb.id) {
+        document.querySelectorAll("label").forEach((l) => { if (l.getAttribute("for") === cb.id) out.push(l); });
+      }
+      const w = cb.closest("label");
+      if (w && !out.includes(w)) out.push(w);
+      return out;
+    };
+    const isOn = (cb) => {
+      const a = cb.getAttribute("aria-checked");
+      return a === "true" ? true : a === "false" ? false : cb.checked === true;
+    };
+    const boxes = Array.from(document.querySelectorAll("input[type=checkbox],[role=checkbox]"));
+    let hits = [];
+    for (const cb of boxes) {
+      const ls = labelsOf(cb);
+      const names = ls.map((l) => norm(l.textContent));
+      const al = cb.getAttribute("aria-label");
+      if (al) names.push(norm(al));
+      const alb = cb.getAttribute("aria-labelledby");
+      if (alb) {
+        const refs = alb.split(/\\s+/).map((id) => document.getElementById(id)).filter(Boolean);
+        if (refs.length > 0) names.push(norm(refs.map((r) => r.textContent).join(" ")));
+      }
+      if (!names.includes(want)) continue;
+      if (!visible(cb) && !ls.some(visible)) continue;
+      hits.push({ cb, ls });
+    }
+    const sectionText = (cb) => {
+      const parts = [];
+      for (let n = cb.parentElement; n; n = n.parentElement) {
+        const lb = n.getAttribute("aria-labelledby");
+        if (lb) lb.split(/\\s+/).forEach((id) => { const el = document.getElementById(id); if (el) parts.push(el.textContent); });
+        const lg = n.querySelector(":scope > legend");
+        if (lg) parts.push(lg.textContent);
+        const hd = n.querySelector(":scope > h2, :scope > h3, :scope > h4");
+        if (hd) parts.push(hd.textContent);
+        let sib = n.previousElementSibling;
+        for (let hop = 0; hop < 3 && sib; hop++, sib = sib.previousElementSibling) {
+          if (!sib.matches("h1,h2,h3,h4,h5,h6,legend,[role='heading']")) continue;
+          parts.push(sib.textContent);
+          break;
+        }
+      }
+      return norm(parts.join(" "));
+    };
+    if (hits.length > 1 && words.length > 0) {
+      const scored = hits.map((h) => {
+        const tokens = new Set(sectionText(h.cb).match(/[a-z0-9]+/g) || []);
+        return { h, score: words.filter((w) => tokens.has(w)).length };
+      });
+      const top = Math.max(...scored.map((x) => x.score));
+      if (top > 0) hits = scored.filter((x) => x.score === top).map((x) => x.h);
+    }
+    if (hits.length === 0) return { status: "none" };
+    if (hits.length > 1) return { status: "ambiguous" };
+    const { cb, ls } = hits[0];
+    cb.setAttribute("${attr}", "box");
+    const lab = ls.find(visible);
+    if (lab) lab.setAttribute("${attr}", "label");
+    return { status: "ok", checked: isOn(cb), id: cb.id || "", hasLabel: !!lab };
+  })(${JSON.stringify(parsed.label.toLowerCase())}, ${JSON.stringify(parsed.sectionWords)})`;
+    const stateExpr = `(() => {
+    const cb = document.querySelector("[${attr}=box]");
+    if (!cb) return null;
+    const a = cb.getAttribute("aria-checked");
+    return a === "true" ? true : a === "false" ? false : cb.checked === true;
+  })()`;
+    const clearExpr = `document.querySelectorAll("[${attr}]").forEach((e) => e.removeAttribute("${attr}"))`;
+    try {
+        const stamped = (await target.evaluate(stampExpr));
+        if (stamped?.status !== "ok")
+            return null;
+        const id = stamped.id ?? "";
+        if (stamped.checked === parsed.desired) {
+            logger.info(`checkbox state primitive: "${parsed.label.slice(0, 40)}" already ${parsed.desired ? "checked" : "unchecked"}, no click`);
+            return id;
+        }
+        const clickSels = [...(stamped.hasLabel ? [`[${attr}="label"]`] : []), `[${attr}="box"]`];
+        const reachedDesired = async () => {
+            for (let i = 0; i < CHECKBOX_STATE_POLL_ATTEMPTS; i++) {
+                await page.waitForTimeout(CHECKBOX_STATE_POLL_MS).catch(() => undefined);
+                if ((await target.evaluate(stateExpr)) === parsed.desired)
+                    return true;
+            }
+            return false;
+        };
+        const succeed = () => {
+            logger.info(`checkbox state primitive: "${parsed.label.slice(0, 40)}" now ${parsed.desired ? "checked" : "unchecked"}`);
+            return id;
+        };
+        let overlaid = false;
+        let trustedDelivered = false;
+        for (const sel of clickSels) {
+            const probe = await (0, trusted_click_1.probeClickPoint)(target, sel);
+            if (probe?.state === "occluded" && probe.occluder !== "none") {
+                overlaid = true;
+                continue;
+            }
+            if (probe?.state !== "hit")
+                continue;
+            const delivered = await (0, trusted_click_1.clickCentredTrusted)(target, sel, { label: "checkbox" })
+                .then(() => true)
+                .catch(() => false);
+            trustedDelivered ||= delivered;
+            if (delivered && (await reachedDesired()))
+                return succeed();
+        }
+        // A hit test that cannot resolve a point at all (no layout) says nothing
+        // about whether a programmatic click toggles the box, so it is tried once;
+        // a named overlay or an already-delivered trusted click that did not flip the
+        // box is left to the cascade, since a second click could toggle it back.
+        if (!overlaid && !trustedDelivered) {
+            for (const sel of clickSels) {
+                await target.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(sel)}); if (el) el.click(); })()`);
+                if (await reachedDesired())
+                    return succeed();
+            }
+        }
+        logger.warn(`checkbox state primitive: "${parsed.label.slice(0, 40)}" did not reach desired state, falling through`);
+        return null;
+    }
+    catch (err) {
+        logger.warn(`checkbox state primitive failed: ${(0, errors_1.toErrorMessage)(err)}`);
+        return null;
+    }
+    finally {
+        await target.evaluate(clearExpr).catch(() => undefined);
+    }
+}
 /**
  * Site-agnostic checkbox primitive: answer a multi-select checkbox-group
  * question by directly checking the matching option in the DOM, bypassing
@@ -5742,7 +6909,7 @@ async function tryCheckboxPrimitive(params) {
     if (!parsed)
         return null;
     const { option, questionLabel } = parsed;
-    const optLabel = `option "${redactIfSensitive(option, redactValue).slice(0, 40)}"${questionLabel ? `, question "${questionLabel.slice(0, 40)}"` : ""}`;
+    const optLabel = primitiveOptionLabel(option, questionLabel, redactValue);
     // Phase 1 (browser, no mutation): find checkbox GROUPS and their options.
     // A group is a `c-MultiCheckboxInput` container or a `<fieldset>` containing
     // checkboxes. Question label = the group's legend / associated label; each
@@ -5873,7 +7040,7 @@ async function tryCheckboxPrimitive(params) {
     })(${JSON.stringify(chosenGroup.gi)}, ${JSON.stringify(chosenOption.bi)})`;
         const applyResult = (await target.evaluate(applyExpr));
         if (applyResult?.ok) {
-            logger.info(`checkbox primitive: LLM checked "${chosenOption.text.slice(0, 40)}" for ${optLabel} (${verdict.reason.slice(0, 60)})`);
+            logger.info(`checkbox primitive: LLM checked "${(0, pii_redaction_1.maskValueShape)(chosenOption.text)}" for ${optLabel} (${verdict.reason.slice(0, 60)})`);
             return applyResult.id;
         }
         logger.info(`checkbox primitive: LLM-chosen checkbox did not stick for ${optLabel}; falling through`);
@@ -6069,7 +7236,7 @@ async function tryRadioPrimitive(params) {
     if (!parsed)
         return null;
     const { option, questionLabel } = parsed;
-    const optLabel = `option "${redactIfSensitive(option, redactValue).slice(0, 40)}"${questionLabel ? `, question "${questionLabel.slice(0, 40)}"` : ""}`;
+    const optLabel = primitiveOptionLabel(option, questionLabel, redactValue);
     // Phase 1 (browser): find radio GROUPS and their options. A group is a
     // `<fieldset>` / `[role=radiogroup]` / `[role=group]` / `[class*='RadioGroup']`
     // container with radios. Question label = the group's legend / associated label; each option
@@ -6154,7 +7321,7 @@ async function tryRadioPrimitive(params) {
                 xpath: chosenOpt?.xpath ?? "",
             });
             if (applied) {
-                logger.info(`radio primitive: selected "${(chosenOpt?.text ?? "").trim().slice(0, 40)}" (${optLabel})`);
+                logger.info(`radio primitive: selected "${(0, pii_redaction_1.maskValueShape)((chosenOpt?.text ?? "").trim())}" (${optLabel})`);
                 return chosenOpt?.id ?? "";
             }
             logger.info(`radio primitive: chosen radio did not stick for ${optLabel}; falling through`);
@@ -6200,7 +7367,7 @@ async function tryRadioPrimitive(params) {
             }),
         };
         if (applyResult?.ok) {
-            logger.info(`radio primitive: LLM selected "${chosenOption.text.slice(0, 40)}" for ${optLabel} (${verdict.reason.slice(0, 60)})`);
+            logger.info(`radio primitive: LLM selected "${(0, pii_redaction_1.maskValueShape)(chosenOption.text)}" for ${optLabel} (${verdict.reason.slice(0, 60)})`);
             return chosenOption.id ?? "";
         }
         logger.info(`radio primitive: LLM-chosen radio did not stick for ${optLabel}; falling through`);
@@ -6252,7 +7419,7 @@ async function applyRadioSelection(target, gi, ri, hint) {
     const inputSel = hint.id ? buildRadioIdXPath(hint.id) : hint.xpath ? `xpath=${hint.xpath}` : null;
     if (inputSel) {
         try {
-            await target.locator(inputSel).first().click();
+            await (0, trusted_click_1.clickCentredTrusted)(target, inputSel, { label: "radio input" });
             if (await readback())
                 return true;
         }
@@ -6263,10 +7430,9 @@ async function applyRadioSelection(target, gi, ri, hint) {
     // Tier B — trusted click on the associated label (MUI hides the real input).
     if (hint.id) {
         try {
-            await target
-                .locator(`xpath=//label[@for=${JSON.stringify(hint.id)}]`)
-                .first()
-                .click();
+            await (0, trusted_click_1.clickCentredTrusted)(target, `xpath=//label[@for=${JSON.stringify(hint.id)}]`, {
+                label: "radio label",
+            });
             if (await readback())
                 return true;
         }
@@ -6299,6 +7465,29 @@ async function applyRadioSelection(target, gi, ri, hint) {
     await target.evaluate(applyExpr).catch(() => ({ ok: false }));
     return await readback();
 }
+/**
+ * Extracts the option a step wants committed into a prompt-selector widget,
+ * with the question label that scopes which widget. Flow/replan generation
+ * words this as a SELECT, a FILL of the widget's search box, a radio-style
+ * answer click, or a cascading-multiselect category/leaf click, so all four
+ * shapes resolve to one `{ option, questionLabel }` — shared by the picking
+ * primitive and the act-success committed-value guard so both compare the page
+ * against the same requested value.
+ */
+function parsePromptSelectorStep(instruction) {
+    const select = parseSelectStep(instruction);
+    if (select)
+        return { ...select, isFill: false };
+    const fill = parseFillStep(instruction);
+    if (fill) {
+        return { option: fill.value, questionLabel: stripQuotedLabel(fill.fieldLabel), isFill: true };
+    }
+    const answer = parseRadioStep(instruction);
+    if (answer)
+        return { ...answer, isFill: false };
+    const optionClick = parseWidgetOptionClickStep(instruction);
+    return optionClick ? { option: optionClick.option, questionLabel: null, isFill: false } : null;
+}
 /**
  * Answer a native-control-less popup-dropdown widget (a combobox that opens a
  * listbox popup and renders NO `<select>`/`<input>` a focused `<select>`/
@@ -6370,23 +7559,11 @@ async function tryPromptSelectorPrimitive(params) {
     // shape), then parseWidgetOptionClickStep (option only, no question
     // label) so the widget-matching/open/readback phases below run unchanged
     // regardless of which verb the instruction used.
-    const parsedSelect = parseSelectStep(instruction);
-    const parsedFill = parsedSelect ? null : parseFillStep(instruction);
-    const parsedAnswer = parsedSelect || parsedFill ? null : parseRadioStep(instruction);
-    const parsedOptionClick = parsedSelect || parsedFill || parsedAnswer ? null : parseWidgetOptionClickStep(instruction);
-    const parsed = parsedSelect
-        ? parsedSelect
-        : parsedFill
-            ? { option: parsedFill.value, questionLabel: stripQuotedLabel(parsedFill.fieldLabel) }
-            : parsedAnswer
-                ? parsedAnswer
-                : parsedOptionClick
-                    ? { option: parsedOptionClick.option, questionLabel: null }
-                    : null;
+    const parsed = parsePromptSelectorStep(instruction);
     if (!parsed)
         return null;
     const { option, questionLabel } = parsed;
-    const optLabel = `option "${redactIfSensitive(option, redactValue).slice(0, 40)}"${questionLabel ? `, question "${questionLabel.slice(0, 40)}"` : ""}`;
+    const optLabel = primitiveOptionLabel(option, questionLabel, redactValue, parsed.isFill);
     const norm = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
     // Phase 1 (browser, read-only except for the marker attribute stamped for
     // Phase 2's click addressing): find candidate widgets — popup-dropdown
@@ -6399,6 +7576,7 @@ async function tryPromptSelectorPrimitive(params) {
     const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
     const triggers = Array.from(document.querySelectorAll(triggerSel));
     if (triggers.length === 0) return { widgetPresent: false };
+    const containerOf = ${PROMPT_WIDGET_CONTAINER_EXPR};
     const seen = new Set();
     const resolved = [];
     for (const el of triggers) {
@@ -6408,18 +7586,7 @@ async function tryPromptSelectorPrimitive(params) {
       // interactive ancestor, else the OUTERMOST widget-kit container on the
       // ancestor chain (so the inner input and its container collapse to the
       // same node), else the element itself.
-      const interactive = el.closest("button,[role='button'],[role='combobox']");
-      let container = interactive || el;
-      if (!interactive) {
-        const kitSel = "[data-uxi-widget-type='selectinput'],[data-uxi-widget-type='multiselect'],[data-automation-id='multiSelectContainer']";
-        let node = el.closest(kitSel);
-        while (node) {
-          container = node;
-          const up = node.parentElement && node.parentElement.closest(kitSel);
-          if (!up || up === node) break;
-          node = up;
-        }
-      }
+      const container = containerOf(el);
       if (seen.has(container)) continue;
       seen.add(container);
       resolved.push(container);
@@ -6441,7 +7608,9 @@ async function tryPromptSelectorPrimitive(params) {
         if (parts.length) return parts.join(" ").replace(/\\s+/g, " ").trim().slice(0, 120);
       }
       const al = w.getAttribute("aria-label");
-      if (al) return al.replace(/\\s+/g, " ").trim().slice(0, 120);
+      // A trigger's aria-label can merely echo its placeholder ("Select One
+      // Required"), which names no question — defer to the <label>/group lookup.
+      if (al && !emptyRx.test(al.replace(/\\s*required\\s*$/i, ""))) return al.replace(/\\s+/g, " ").trim().slice(0, 120);
       const labelledIds = [w.id, ...Array.from(w.querySelectorAll("[id]")).map((e) => e.id)].filter(Boolean);
       for (const id of labelledIds) {
         const lab = document.querySelector("label[for='" + (window.CSS && CSS.escape ? CSS.escape(id) : id) + "']");
@@ -6517,7 +7686,7 @@ async function tryPromptSelectorPrimitive(params) {
             logger.info(`prompt-selector primitive: no unambiguous widget match for ${optLabel}; falling through to cascade`);
             return null;
         }
-        const enumerateOptionsExpr = `((widgetMarkAttr, wIdx, markAttr, optionSel, searchSel) => {
+        const enumerateOptionsExpr = `((widgetMarkAttr, wIdx, markAttr, optionSel, searchSel, triggerSel) => {
       const optionLabel = ${OPTION_ACCESSIBLE_LABEL_EXPR};
       const w = document.querySelector("[" + widgetMarkAttr + '="' + wIdx + '"]');
       if (!w) return { optionsPresent: false };
@@ -6535,12 +7704,35 @@ async function tryPromptSelectorPrimitive(params) {
       // inline subtree), so a sibling widget's options are never picked. Fall
       // back to document only when neither a portal nor an inline popup is found.
       const scope = ${PROMPT_SCOPE_ROOT_EXPR}(w);
-      const all = Array.from(scope.querySelectorAll(optionSel));
+      // Under the document fallback, ownership is structural: content is foreign
+      // when, climbing from it WITHOUT passing through this widget, some ancestor
+      // is or holds another widget's trigger — e.g. a committed sibling's chips,
+      // whatever markup wraps them. Resolved from the trigger union rather than
+      // the enumeration mark, because a COMMITTED sibling is never marked (only
+      // unfilled widgets are) yet its chips are the likeliest leak. An unlinked
+      // portal sits under no widget, so it stays readable.
+      const containerOf = ${PROMPT_WIDGET_CONTAINER_EXPR};
+      const foreignRoots = scope === document
+        ? Array.from(new Set(Array.from(document.querySelectorAll(triggerSel)).map(containerOf)))
+            .filter((o) => o !== w && !o.contains(w) && !w.contains(o))
+        : [];
+      const heldByOtherWidget = (el) => {
+        if (scope !== document || w.contains(el)) return false;
+        for (let a = el; a && a !== document.body && !a.contains(w); a = a.parentElement) {
+          if (a.matches(triggerSel) || a.querySelector(triggerSel)) return true;
+        }
+        return false;
+      };
+      const isOwned = (el) => !foreignRoots.some((o) => o.contains(el)) && !heldByOtherWidget(el);
+      const all = Array.from(scope.querySelectorAll(optionSel)).filter(isOwned);
       // A union hit may be an ancestor of another (e.g. role=listbox > li > p):
       // keep only leaf-most option nodes with their own text so we don't double
       // count or address a wrapper.
       const opts = all.filter((el) => !all.some((o) => o !== el && el.contains(o)));
-      const searchInput = scope.querySelector(searchSel);
+      const searchInput = scope === document
+        ? (w.matches(searchSel) || w.matches("input") ? w : w.querySelector(searchSel))
+        : (scope.matches && scope.matches(searchSel) ? scope : null)
+          || Array.from(scope.querySelectorAll(searchSel)).find(isOwned) || null;
       // Mark the scoped filter input so the Node-side fill addresses THIS
       // widget's input (Playwright's locator can't re-run the scope resolution).
       if (searchInput) searchInput.setAttribute(markAttr + "-search", "1");
@@ -6548,13 +7740,23 @@ async function tryPromptSelectorPrimitive(params) {
       // is typed into — report the popup as present (with searchable=true) so the
       // caller types the filter first, rather than falling through as "no popup".
       if (opts.length === 0) {
-        return searchInput ? { optionsPresent: true, searchable: true, options: [] } : { optionsPresent: false };
+        return searchInput ? { optionsPresent: true, searchable: true, options: [], scopeIsDocument: scope === document } : { optionsPresent: false };
       }
       const options = [];
       for (let i = 0; i < opts.length; i++) {
-        opts[i].setAttribute(markAttr, String(i));
         const label = optionLabel(opts[i]);
-        options.push({ oIdx: i, text: label });
+        const ids = window.__bclOptionNodeIds || (window.__bclOptionNodeIds = { map: new WeakMap(), next: 0 });
+        if (!ids.map.has(opts[i])) ids.map.set(opts[i], ids.next++);
+        // Stamped with the node's own identity, not its list position: a
+        // re-enumeration after a virtualized re-render or scroll can reorder
+        // positions, so a positional stamp would re-address a different item.
+        opts[i].setAttribute(markAttr, String(ids.map.get(opts[i])));
+        options.push({
+          oIdx: i,
+          text: label,
+          nodeId: ids.map.get(opts[i]),
+          domText: (opts[i].textContent || "").replace(/\\s+/g, " ").trim(),
+        });
       }
       // scopeIsDocument distinguishes a genuinely resolved (portal or inline)
       // popup from the document-wide last-resort fallback in
@@ -6564,7 +7766,7 @@ async function tryPromptSelectorPrimitive(params) {
       // that resolved to THIS widget's own inline subtree or its own
       // aria-controls/aria-owns target counts.
       return { optionsPresent: true, searchable: !!searchInput, options, scopeIsDocument: scope === document };
-    })(${JSON.stringify(PROMPT_WIDGET_MARK_ATTR)}, ${JSON.stringify(chosen.wIdx)}, ${JSON.stringify(PROMPT_OPTION_MARK_ATTR)}, ${JSON.stringify(PROMPT_OPTION_SELECTORS)}, ${JSON.stringify(PROMPT_SEARCH_SELECTORS)})`;
+    })(${JSON.stringify(PROMPT_WIDGET_MARK_ATTR)}, ${JSON.stringify(chosen.wIdx)}, ${JSON.stringify(PROMPT_OPTION_MARK_ATTR)}, ${JSON.stringify(PROMPT_OPTION_SELECTORS)}, ${JSON.stringify(PROMPT_SEARCH_SELECTORS)}, ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)})`;
         // Pre-check (single evaluate, no polling): a PRIOR primitive call on this
         // same unreloaded page may have already opened/drilled this exact widget's
         // popup (a two-level cascading multiselect authored as two flow steps —
@@ -6576,6 +7778,12 @@ async function tryPromptSelectorPrimitive(params) {
         // an unrelated widget's stale/leftover popup elsewhere on the page as
         // "already open"); a genuinely closed popup falls through to the normal
         // open-click + poll path below unchanged.
+        // A popup whose aria-controls link lands after the click is not yet
+        // resolvable; a document-scoped read would credit a sibling widget's
+        // content, so keep polling until a non-document scope resolves. The poll
+        // returns the last read when the budget runs out, so a popup that
+        // genuinely has no linkage still resolves through the document fallback.
+        const isOwnScopePopup = (r) => r?.optionsPresent === true && r.scopeIsDocument !== true;
         const precheck = (await target.evaluate(enumerateOptionsExpr));
         const alreadyOpen = precheck?.optionsPresent === true &&
             (precheck.options?.length ?? 0) > 0 &&
@@ -6601,7 +7809,7 @@ async function tryPromptSelectorPrimitive(params) {
                 // Fall back to the container selector.
             }
             try {
-                await target.locator(triggerSel).first().click();
+                await (0, trusted_click_1.clickCentredTrusted)(target, triggerSel, { label: "prompt-selector trigger" });
             }
             catch (err) {
                 logger.info(`prompt-selector primitive: trigger click failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
@@ -6614,7 +7822,7 @@ async function tryPromptSelectorPrimitive(params) {
         }
         const optionsInitial = alreadyOpen
             ? precheck
-            : await pollEnumerate(page, target, enumerateOptionsExpr, (r) => r?.optionsPresent === true);
+            : await pollEnumerate(page, target, enumerateOptionsExpr, isOwnScopePopup);
         if (!optionsInitial?.optionsPresent) {
             logger.info(`prompt-selector primitive: popup for ${optLabel} did not render options; falling through`);
             return null;
@@ -6645,19 +7853,61 @@ async function tryPromptSelectorPrimitive(params) {
             // to its popup), falling back to the union only if the mark is absent.
             const scopedSearchSel = `[${PROMPT_OPTION_MARK_ATTR}-search="1"]`;
             const marked = await target.locator(scopedSearchSel).count();
-            await target
-                .locator(marked > 0 ? scopedSearchSel : PROMPT_SEARCH_SELECTORS)
-                .first()
-                .fill(option);
+            if (marked === 0) {
+                logger.info(`prompt-selector primitive: no filter input owned by the widget for ${optLabel}; falling through`);
+                return null;
+            }
+            await target.locator(scopedSearchSel).first().fill(option);
         }
         catch (err) {
             logger.info(`prompt-selector primitive: filter-input type failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
             return null;
         }
         await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
-        const optionsFiltered = await pollEnumerate(page, target, enumerateOptionsExpr, (r) => r?.optionsPresent === true);
+        let optionsFiltered = await pollEnumerate(page, target, enumerateOptionsExpr, isOwnScopePopup);
+        // An as-you-type search may still be in flight; Enter now would re-query with
+        // an empty search and swap in the full list. Search-on-submit widgets never
+        // name the option unprompted, so the wait is bounded.
+        for (let wait = 0; wait < PROMPT_SELECTOR_MAX_SEARCH_WAITS &&
+            optionsFiltered?.optionsPresent &&
+            !promptOptionsNameOption(optionsFiltered, option); wait++) {
+            await page.waitForTimeout(PROMPT_SELECTOR_SEARCH_WAIT_MS);
+            optionsFiltered = (await target.evaluate(enumerateOptionsExpr));
+        }
+        // Search-on-submit widgets keep a placeholder (or unrelated chips) until an
+        // Enter keydown; filter-as-you-type widgets already name the option here.
+        // The list is settled BEFORE each submit decision, so a search-as-you-type
+        // list still re-rendering (stale rows from the prior query) never reads as
+        // "names nothing", and the precondition is re-read right before the key
+        // press so a list that loaded in the meantime is not submitted at.
+        for (let submit = 0;; submit++) {
+            optionsFiltered = optionsFiltered?.optionsPresent
+                ? await readStablePromptOptions(page, target, enumerateOptionsExpr, optionsFiltered)
+                : null;
+            if (!optionsFiltered ||
+                promptOptionsNameOption(optionsFiltered, option) ||
+                submit >= PROMPT_SELECTOR_MAX_ENTER_SUBMITS) {
+                break;
+            }
+            const live = (await target.evaluate(enumerateOptionsExpr));
+            if (promptOptionsNameOption(live, option)) {
+                optionsFiltered = live;
+                continue;
+            }
+            logger.info(`prompt-selector primitive: filtered list for ${optLabel} names no matching option; submitting with Enter`);
+            try {
+                await target.evaluate(`(() => { const el = document.querySelector('[${PROMPT_OPTION_MARK_ATTR}-search="1"]'); if (el) el.focus(); })()`);
+                await sendTrustedEnter(page);
+            }
+            catch (err) {
+                logger.info(`prompt-selector primitive: enter submit failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}`);
+                break;
+            }
+            await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
+            optionsFiltered = await pollEnumerate(page, target, enumerateOptionsExpr, (r) => isOwnScopePopup(r) && promptOptionsNameOption(r, option));
+        }
         if (!optionsFiltered?.optionsPresent) {
-            logger.info(`prompt-selector primitive: filtered popup for ${optLabel} rendered no options; falling through`);
+            logger.info(`prompt-selector primitive: filtered popup for ${optLabel} rendered no stable options; falling through`);
             return null;
         }
         return await commitPromptOption({
@@ -6679,6 +7929,138 @@ async function tryPromptSelectorPrimitive(params) {
         return null;
     }
 }
+/** Cap on re-reads while waiting for the filtered list to stop changing. */
+const PROMPT_SELECTOR_MAX_STABLE_READS = 5;
+/**
+ * Re-reads the filtered list until two consecutive reads carry identical
+ * ordered option text AND node identity, so a virtualized list that reuses
+ * nodes is never treated as settled. The last read is returned because each
+ * read re-marks the live nodes; an earlier read's marks may point at detached
+ * elements. Returns null when the list is still changing at the cap, so the
+ * committer is never handed an unsettled list.
+ */
+async function readStablePromptOptions(page, target, enumerateOptionsExpr, initial) {
+    const key = (r) => JSON.stringify((r?.options ?? []).map((o) => [o.text, o.nodeId ?? null]));
+    let current = initial;
+    for (let read = 0; read < PROMPT_SELECTOR_MAX_STABLE_READS; read++) {
+        await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
+        const next = (await target.evaluate(enumerateOptionsExpr));
+        const stable = key(next) === key(current);
+        current = next;
+        if (stable)
+            return current;
+    }
+    logger.info("prompt-selector primitive: filtered list still changing after stable-read cap");
+    return null;
+}
+/** Cap on click-time re-resolves when the stamped node is re-bound mid-scroll. */
+const PROMPT_SELECTOR_MAX_CLICK_RESOLVES = 3;
+/** Bounded wait for an in-flight as-you-type search before concluding it is search-on-submit. */
+const PROMPT_SELECTOR_MAX_SEARCH_WAITS = 6;
+const PROMPT_SELECTOR_SEARCH_WAIT_MS = 500;
+/** Cap on trusted Enter submits for a search-on-submit prompt selector. */
+const PROMPT_SELECTOR_MAX_ENTER_SUBMITS = 2;
+/** Shared option-text normalisation so submit detection and commit agree on a match. */
+function normPromptOptionText(s) {
+    return s.replace(/\s+/g, " ").trim().toLowerCase();
+}
+/** Entries a widget renders when it holds no results (e.g. "No Items.", "No results for x"). */
+const PROMPT_PLACEHOLDER_RE = /^(no\b|nothing\b|none$|loading|searching|type to search|press enter|hit enter|search for|\.\.\.)|\b(no (results?|items?|matches|options?|data|records)|not found|nothing found|0 results?)\b/;
+/**
+ * Detects whether the list already names the requested option, so the submit
+ * decision never fires Enter at a widget that searches as you type. Looser than
+ * commitPromptOption's exact detMatch on purpose: a rendered label that differs
+ * by a prefix or suffix still means the list answered the query. A shorter
+ * entry the request merely contains (a chip "Oslo" for "University of Oslo")
+ * names nothing requested. Placeholder entries never count, even when they
+ * echo the requested text.
+ */
+function promptOptionsNameOption(result, option) {
+    const want = normPromptOptionText(option);
+    if (want === "")
+        return true;
+    return (result?.options ?? []).some((o) => {
+        const text = normPromptOptionText(o.text);
+        if (text === "")
+            return false;
+        if (text === want)
+            return true;
+        if (PROMPT_PLACEHOLDER_RE.test(text))
+            return false;
+        return text.includes(want);
+    });
+}
+/** Dispatches a trusted Enter to the focused element (the filter input) via CDP. */
+async function sendTrustedEnter(page) {
+    const key = { key: "Enter", code: "Enter", windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 };
+    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyDown", text: "\r", ...key });
+    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyUp", ...key });
+}
+/** Dispatches a trusted Escape to the focused element via CDP, closing a popup left open. */
+async function sendTrustedEscape(page) {
+    const key = {
+        key: "Escape",
+        code: "Escape",
+        windowsVirtualKeyCode: 27,
+        nativeVirtualKeyCode: 27,
+    };
+    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyDown", ...key });
+    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyUp", ...key });
+}
+/**
+ * Counts rendered listbox / activeListContainer popups other than the chip
+ * list; an emptied ("No Items.") popup still counts because it paints over
+ * neighbouring fields just the same.
+ */
+const VISIBLE_LEFTOVER_POPUP_COUNT_EXPR = `(() => {
+  const visible = (el) => {
+    for (let n = el; n && n.nodeType === 1; n = n.parentElement) {
+      if (n.hidden || n.getAttribute("aria-hidden") === "true") return false;
+      let cs = null;
+      try { cs = getComputedStyle(n); } catch { cs = null; }
+      if (cs && (cs.display === "none" || cs.visibility === "hidden")) return false;
+    }
+    return true;
+  };
+  const sel = '[role="listbox"], [data-automation-id="activeListContainer"]';
+  return Array.from(document.querySelectorAll(sel)).filter(
+    (el) => !el.matches('[data-automation-id="selectedItemList"]') && !el.closest('[data-automation-id="selectedItemList"]') && visible(el)
+  ).length;
+})()`;
+/**
+ * Synthetic Escape for a page whose CDP channel is unavailable or whose popup
+ * ignored the trusted one: the popup's own keydown handler is what closes it.
+ */
+const IN_PAGE_ESCAPE_EXPR = `(() => {
+  const el = document.activeElement || document.body;
+  for (const type of ["keydown", "keyup"]) {
+    el.dispatchEvent(new KeyboardEvent(type, { key: "Escape", code: "Escape", keyCode: 27, bubbles: true, cancelable: true }));
+  }
+})()`;
+/**
+ * Closes any popup still painted after a verified commit so it cannot
+ * intercept the next field's click. Best-effort: a trusted Escape first, then
+ * a synthetic one when the trusted dispatch failed or left the popup painted.
+ */
+async function dismissLeftoverPromptPopups(page, target) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const count = (await target
+            .evaluate(VISIBLE_LEFTOVER_POPUP_COUNT_EXPR)
+            .catch(() => 0));
+        if (!count)
+            return;
+        logger.info(`prompt-selector primitive: dismissing ${count} leftover popup(s) via Escape`);
+        const trusted = await sendTrustedEscape(page)
+            .then(() => true)
+            .catch((err) => {
+            logger.info(`prompt-selector primitive: Escape dispatch failed: ${(0, errors_1.toErrorMessage)(err)}`);
+            return false;
+        });
+        if (!trusted || attempt > 0)
+            await target.evaluate(IN_PAGE_ESCAPE_EXPR).catch(() => undefined);
+        await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS).catch(() => undefined);
+    }
+}
 /**
  * Phase 3 of {@link tryPromptSelectorPrimitive}: given the popup's rendered
  * (possibly filtered) option list, match the requested option — deterministic
@@ -6701,7 +8083,7 @@ async function tryPromptSelectorPrimitive(params) {
  */
 async function commitPromptOption(params) {
     const { page, target, logger, anthropic, captureFn, optLabel, option, questionLabel, chosen, enumerateOptionsExpr, } = params;
-    const norm = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
+    const norm = normPromptOptionText;
     const wantOpt = norm(option);
     const optionSetKey = (opts) => opts
         .map((o) => norm(o.text))
@@ -6738,35 +8120,69 @@ async function commitPromptOption(params) {
             return null;
         }
         const matchReason = detMatch ? "deterministic" : `LLM: ${(verdict?.reason ?? "").slice(0, 60)}`;
-        const optionSel = `[${PROMPT_OPTION_MARK_ATTR}="${chosenOption.oIdx}"]`;
-        try {
-            await target.locator(optionSel).first().click();
+        // A virtualized list may reuse nodes between the read and the click, so the
+        // stamped index can point at a different item. Each attempt re-stamps and
+        // re-resolves the matched option by text, and the click itself asserts the
+        // node still carries that item's text after the centring scroll; a mismatch
+        // re-resolves instead of clicking.
+        const wantChosenText = norm(chosenOption.text);
+        let clicked = false;
+        for (let attempt = 0; attempt < PROMPT_SELECTOR_MAX_CLICK_RESOLVES && !clicked; attempt++) {
+            const fresh = (await target.evaluate(enumerateOptionsExpr).catch(() => null));
+            const freshMatches = (fresh?.options ?? []).filter((o) => norm(o.text) === wantChosenText);
+            const freshOption = freshMatches.find((o) => o.nodeId !== undefined && o.nodeId === chosenOption.nodeId) ??
+                freshMatches[0];
+            if (!freshOption) {
+                logger.info(`prompt-selector primitive: matched option no longer present for ${optLabel}; falling through`);
+                return null;
+            }
+            const optionSel = `[${PROMPT_OPTION_MARK_ATTR}="${freshOption.nodeId ?? freshOption.oIdx}"]`;
+            const markedLabel = (await target
+                .evaluate(`((sel, labelOf) => {
+            const el = document.querySelector(sel);
+            return el ? labelOf(el) : null;
+          })(${JSON.stringify(optionSel)}, ${OPTION_ACCESSIBLE_LABEL_EXPR})`)
+                .catch(() => null));
+            if (markedLabel === null || !norm(markedLabel).includes(wantChosenText)) {
+                logger.info(`prompt-selector primitive: marked option node for ${optLabel} no longer shows the matched option; re-resolving`);
+                continue;
+            }
+            try {
+                const expectedDomText = freshOption.domText ?? wantChosenText;
+                await (0, trusted_click_1.clickCentredTrusted)(target, optionSel, {
+                    label: "prompt-selector option",
+                    expectText: expectedDomText,
+                    verifyBeforeClick: async () => (await target
+                        .evaluate(`((sel, want) => {
+                  const el = document.querySelector(sel);
+                  if (!el || !el.isConnected) return false;
+                  return (el.textContent || "").replace(/\\s+/g, " ").trim() === want;
+                })(${JSON.stringify(optionSel)}, ${JSON.stringify(expectedDomText)})`)
+                        .catch(() => null)) !== false,
+                });
+                clicked = true;
+            }
+            catch (err) {
+                const mismatch = (0, errors_1.toErrorMessage)(err).includes("identity mismatch");
+                logger.info(`prompt-selector primitive: option click ${mismatch ? "withheld" : "failed"} for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; ${mismatch ? "re-resolving" : "falling through"}`);
+                if (!mismatch)
+                    return null;
+            }
         }
-        catch (err) {
-            logger.info(`prompt-selector primitive: option click failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
+        if (!clicked)
             return null;
-        }
         await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
-        const isRequestedLeaf = norm(chosenOption.text) === wantOpt;
+        const isRequestedOption = norm(chosenOption.text) === wantOpt;
         const readbackExpr = `((wIdx, markAttr, valueSel, emptyRxSrc, emptyRxFlags, wantText, isRequestedLeaf) => {
       const isInvalid = ${INVALID_MARKER_EL_EXPR};
       const isPairedHiddenSelect = ${exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR};
       const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
-      const buttonValue = ${BUTTON_VALUE_EXPR};
-      const optionLabel = ${OPTION_ACCESSIBLE_LABEL_EXPR};
       const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
+      const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
+      const announcedValue = ${PROMPT_ANNOUNCED_VALUE_EXPR};
       const w = document.querySelector("[" + markAttr + '="' + wIdx + '"]');
-      if (!w) return { ok: false, id: "" };
-      // Value via the union: aria-activedescendant, own input value, a <button>'s
-      // own value text (popup-pollution-safe, see BUTTON_VALUE_EXPR), or a
-      // selection-label node (empty-state phrase treated as no value).
-      const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
-      const adText = adid && document.getElementById(adid) ? norm(optionLabel(document.getElementById(adid))) : "";
-      const own = w.tagName === "INPUT" ? norm(w.value || "") : w.tagName === "BUTTON" ? norm(buttonValue(w)) : "";
-      const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
-      const lblRaw = lbl ? (lbl.textContent || "") : "";
-      const lblText = lblRaw.trim() && !emptyRx.test(lblRaw.trim()) ? norm(lblRaw) : "";
-      const text = adText || own || lblText;
+      if (!w) return { ok: false, id: "", stillInvalid: false };
+      const text = currentText(w, valueSel, emptyRx);
       const textMatches = wantText ? text.includes(wantText) : text !== "";
       let node = w;
       let stillInvalid = false;
@@ -6819,14 +8235,37 @@ async function commitPromptOption(params) {
           cnode = cnode.parentElement;
         }
       }
-      // A category click may leave the widget's aria-invalid unset until final
-      // submit, so !stillInvalid alone only counts as success when this click
-      // landed on the requested leaf option, not an intermediate category.
-      return { ok: textMatches || (isRequestedLeaf && !stillInvalid) || hiddenSelectMatches, id: w.id || "" };
-    })(${JSON.stringify(chosen.wIdx)}, ${JSON.stringify(PROMPT_WIDGET_MARK_ATTR)}, ${JSON.stringify(PROMPT_VALUE_SELECTORS)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_SRC)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_FLAGS)}, ${JSON.stringify(norm(chosenOption.text))}, ${JSON.stringify(isRequestedLeaf)})`;
-        const readback = (await target.evaluate(readbackExpr).catch(() => ({ ok: false, id: "" })));
+      // The widget's own announcement of what it committed is ground truth when readable.
+      const committed = announcedValue(w);
+      if (committed) {
+        return { ok: !!wantText && committed.includes(wantText), id: w.id || "", stillInvalid, committed };
+      }
+      // A wrong option leaves the widget valid, so !stillInvalid proves nothing
+      // once the widget's own value is readable: a readable value naming another
+      // option is a wrong commit. The "Expanded"/"Collapsed" state words are
+      // announcements, not values. Only a requested-leaf click is refused here —
+      // a category click that swapped the popup must still reach the drill check.
+      const stateOnly = /^(?:expanded|collapsed)\\.?$/.test(text);
+      if (isRequestedLeaf && text !== "" && !stateOnly && !textMatches && !hiddenSelectMatches) {
+        return { ok: false, id: w.id || "", stillInvalid, committed: text };
+      }
+      return { ok: textMatches || hiddenSelectMatches, id: w.id || "", stillInvalid };
+    })(${JSON.stringify(chosen.wIdx)}, ${JSON.stringify(PROMPT_WIDGET_MARK_ATTR)}, ${JSON.stringify(PROMPT_VALUE_SELECTORS)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_SRC)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_FLAGS)}, ${JSON.stringify(norm(chosenOption.text))}, ${JSON.stringify(isRequestedOption)})`;
+        const runReadback = async () => (await target
+            .evaluate(readbackExpr)
+            .catch(() => ({ ok: false, id: "", stillInvalid: true })));
+        let readback = await runReadback();
+        if (readback?.ok) {
+            await dismissLeftoverPromptPopups(page, target);
+            readback = await runReadback();
+        }
+        if (!readback?.ok && readback?.committed) {
+            await dismissLeftoverPromptPopups(page, target);
+            logger.info(`prompt-selector primitive: committed "${(0, pii_redaction_1.maskValueShape)(readback.committed)}" instead of "${(0, pii_redaction_1.maskValueShape)(chosenOption.text)}" for ${optLabel}; falling through`);
+            return null;
+        }
         if (readback?.ok) {
-            logger.info(`prompt-selector primitive: selected "${chosenOption.text.slice(0, 40)}" for ${optLabel} (${matchReason})`);
+            logger.info(`prompt-selector primitive: selected "${(0, pii_redaction_1.maskValueShape)(chosenOption.text)}" for ${optLabel} (${matchReason})`);
             return readback.id;
         }
         if (depth === PROMPT_SELECTOR_MAX_DRILL_DEPTH) {
@@ -6838,12 +8277,20 @@ async function commitPromptOption(params) {
         const reEnumerated = (await target
             .evaluate(enumerateOptionsExpr)
             .catch(() => ({ optionsPresent: false })));
-        const newOptions = reEnumerated?.optionsPresent ? (reEnumerated.options ?? []) : [];
+        const newOptions = reEnumerated?.optionsPresent && reEnumerated.scopeIsDocument !== true
+            ? (reEnumerated.options ?? [])
+            : [];
         const drilled = newOptions.length > 0 && optionSetKey(newOptions) !== optionSetKey(options);
         if (!drilled) {
             logger.info(`prompt-selector primitive: selection for ${optLabel} did not commit; falling through to cascade`);
             return null;
         }
+        // Category click on the requested option: the drill itself is the observed
+        // effect, and it never commits a value, so only a widget not flagged invalid counts.
+        if (isRequestedOption && !readback.stillInvalid) {
+            logger.info(`prompt-selector primitive: requested option "${(0, pii_redaction_1.maskValueShape)(chosenOption.text)}" for ${optLabel} opened a new option set (${matchReason})`);
+            return readback?.id ?? "";
+        }
         logger.info(`prompt-selector primitive: click for ${optLabel} drilled the popup to a new option set; re-matching at the new level`);
         optionsResult = { options: newOptions };
     }
@@ -6870,8 +8317,10 @@ async function hasUnfilledRequiredControlForStep(target, instruction) {
     const label = extractRequiredControlProbeLabel(instruction);
     if (!label)
         return false;
-    const expr = `((label, triggerSel) => {
+    const expr = `((label, triggerSel, valueSel, emptyRxSrc, emptyRxFlags) => {
     const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
+    const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
+    const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
     const want = norm(label);
     if (!want) return false;
     const isInvalid = ${INVALID_MARKER_EL_EXPR};
@@ -6890,6 +8339,7 @@ async function hasUnfilledRequiredControlForStep(target, instruction) {
       if (!el) return false;
       if (el.getAttribute && el.getAttribute("aria-invalid") === "true") return true;
       if (isInvalid(el)) return true;
+      if (el.matches && el.matches(triggerSel)) return currentText(el, valueSel, emptyRx) === "";
       const v = ("value" in el) ? el.value : "";
       return !v || String(v).trim() === "";
     };
@@ -6940,7 +8390,7 @@ async function hasUnfilledRequiredControlForStep(target, instruction) {
       if (txt && (txt.includes(want) || want.includes(txt))) return true;
     }
     return false;
-  })(${JSON.stringify(label)}, ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)})`;
+  })(${JSON.stringify(label)}, ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)}, ${JSON.stringify(PROMPT_VALUE_SELECTORS)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_SRC)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_FLAGS)})`;
     try {
         return (await target.evaluate(expr)) === true;
     }
@@ -6970,24 +8420,7 @@ async function simulateDragDropUpload(target, fixture, logger) {
     const fileName = ${JSON.stringify(fixture.name)};
     const fileType = ${JSON.stringify(fixture.mimeType)};
     const base64 = ${JSON.stringify(base64)};
-    const dropZoneSelectors = [
-      "uapp-upload",
-      "app-upload",
-      "uapp-resume-upload",
-      "[class*='dropzone']",
-      "[class*='drop-zone']",
-      "[class*='file-drop']",
-      "[class*='upload-zone']",
-      "[class*='uapp-upload']",
-      "[class*='ResumeUpload']",
-      "[class*='resumeUpload']",
-      "[class*='resume-upload']",
-    ];
-    let dropZone = null;
-    for (const sel of dropZoneSelectors) {
-      const el = document.querySelector(sel);
-      if (el) { dropZone = el; break; }
-    }
+    const dropZone = ${upload_affordance_expr_1.FIND_DROP_ZONE_EXPR}(document);
     if (!dropZone) return { ok: false, reason: "no drop zone found" };
     try {
       const binStr = atob(base64);
@@ -7102,6 +8535,12 @@ async function verifyDomEffect(target, action, preSelectionState = {}) {
                 const expected = action.arguments?.[0];
                 if (typeof expected !== "string" || expected.length === 0)
                     return false;
+                // A lone spinbutton segment holds one slice of a date, so a matching
+                // digit string proves nothing about the whole value, and the
+                // fill("")+type retype below would overwrite committed neighbours.
+                if ((await verifyFillReadback(target, selector, expected))?.outcome === "segment") {
+                    return false;
+                }
                 const current = await locator.inputValue();
                 // Masked/formatted inputs (e.g. a phone field displaying
                 // "(212) 555-0123" after typing "2125550123") reformat the typed
@@ -7340,6 +8779,13 @@ async function verifyDomEffect(target, action, preSelectionState = {}) {
                     // owned panel to now render option content before crediting it.
                     return await comboboxOpenerPanelOpened(target, xpath, preSelectionState);
                 }
+                // A control exposing aria-checked is framework-managed: its own
+                // aria-checked is the committed state, so a leftover invalid marker
+                // on an ancestor must not veto a genuinely ticked box.
+                const ariaCheckedExpr = `(() => { const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null); const el = r.singleNodeValue; return el ? ${ariaCheckedReadExpr("el")} : null; })()`;
+                const ariaChecked = await target.evaluate(ariaCheckedExpr).catch(() => null);
+                if (ariaChecked === "true" || ariaChecked === "false")
+                    return ariaChecked === "true";
                 const isCheckedNow = await locator.isChecked();
                 if (!isCheckedNow)
                     return false;
@@ -7959,20 +9405,32 @@ function extractCodeFromMessage(msg, pattern) {
  * know the value came from an inbox rather than the flow's payload.
  */
 function spliceEmailStepFillValue(step, code) {
-    return /with\s+'[^']*'/i.test(step)
-        ? step.replace(/with\s+'[^']*'/i, `with '${code}'`)
+    const match = (0, quoted_spans_1.matchAnchored)(step, /with\s+'[^']*'/i);
+    return match
+        ? `${step.slice(0, match.start)}with '${code}'${step.slice(match.end)}`
         : `${step} with '${code}'`;
 }
 /**
- * Masks `text` when it equals `sensitiveValue` (the emailStep-extracted code
- * spliced into the step's fill value, see {@link spliceEmailStepFillValue}).
- * The select/checkbox/radio/prompt-selector primitives all re-parse the
- * (possibly code-bearing) instruction independently of the fill primitive,
- * so each one's own "option"/diagnostic logging must redact it too — the
- * code is a single-use credential and must never reach the logs verbatim.
+ * Masks a typed/selected value for logs and attempt diagnostics. Values are
+ * caller-supplied answers (or the emailStep-extracted single-use code spliced into
+ * the step, see {@link spliceEmailStepFillValue}), so only their shape is
+ * kept — enough to debug format mismatches, never the value itself.
+ */
+function maskLoggedValue(text, sensitiveValue) {
+    return sensitiveValue && text === sensitiveValue ? "[redacted]" : (0, pii_redaction_1.maskValueShape)(text);
+}
+/**
+ * Builds the "option ..., question ..." log label shared by the select,
+ * checkbox, radio and prompt-selector primitives. A value parsed from a FILL
+ * step is typed user data (names, emails, passwords), so it is logged only as
+ * its length; other options are still caller answers, so they keep only
+ * their shape via {@link maskLoggedValue}.
  */
-function redactIfSensitive(text, sensitiveValue) {
-    return sensitiveValue && text === sensitiveValue ? "[redacted]" : text;
+function primitiveOptionLabel(option, questionLabel, redactValue, fromFill = false) {
+    const shown = fromFill
+        ? `[${option.length}-char typed value]`
+        : maskLoggedValue(option, redactValue).slice(0, 40);
+    return `option "${shown}"${questionLabel ? `, question "${questionLabel.slice(0, 40)}"` : ""}`;
 }
 /**
  * Last-resort escalation for the cascade-exhaustion path: when every
@@ -8006,7 +9464,7 @@ function redactIfSensitive(text, sensitiveValue) {
  * candidate was actually clickable, or every click phantomed.
  */
 async function probeChildFrameSubmitFallback(params) {
-    const { page, signalCounter, step } = params;
+    const { page, signalCounter, step, isMidFlowSubmitStep } = 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
@@ -8059,13 +9517,18 @@ async function probeChildFrameSubmitFallback(params) {
         const clickResult = (await Promise.resolve(target.evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(top.deepIndex))).catch(() => ({ clicked: false })));
         if (!clickResult.clicked)
             continue;
+        await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, true, async () => {
+            const snap = await snapshotPage(target, signalCounter);
+            return snap.visibleTextSignature;
+        }, pre.visibleTextSignature);
         const post = await snapshotPage(target, signalCounter, page);
         const verdict = (0, phantom_click_1.classifyPhantomClick)({
             actResultSuccess: true,
             pre,
             post,
             isSubmitShapedStep: true,
-            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, post.url),
+            isMidFlowSubmitStep,
+            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, post.url, isMidFlowSubmitStep ? pre.url : undefined),
         });
         if (verdict !== "phantom")
             return target;
@@ -8075,21 +9538,52 @@ async function probeChildFrameSubmitFallback(params) {
         const runnerUpClickResult = (await Promise.resolve(target.evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(runnerUp.deepIndex))).catch(() => ({ clicked: false })));
         if (!runnerUpClickResult.clicked)
             continue;
+        await (0, click_settle_1.settleAfterClick)(page, signalCounter, post.networkCount, true, async () => {
+            const snap = await snapshotPage(target, signalCounter);
+            return snap.visibleTextSignature;
+        }, post.visibleTextSignature);
         const runnerUpPost = await snapshotPage(target, signalCounter, page);
         const runnerUpVerdict = (0, phantom_click_1.classifyPhantomClick)({
             actResultSuccess: true,
             pre,
             post: runnerUpPost,
             isSubmitShapedStep: true,
-            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, runnerUpPost.url),
+            isMidFlowSubmitStep,
+            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, runnerUpPost.url, isMidFlowSubmitStep ? post.url : undefined),
         });
         if (runnerUpVerdict !== "phantom")
             return target;
     }
     return null;
 }
+/**
+ * Rejects with the signal's reason as soon as it aborts, so an in-step await
+ * on a torn-down session stops instead of waiting out its own timeout.
+ * Passes the promise through untouched when no signal is supplied.
+ */
+async function raceAbortSignal(work, signal) {
+    if (!signal)
+        return work;
+    if (signal.aborted) {
+        work.catch(() => undefined);
+        throw signal.reason;
+    }
+    let onAbort;
+    const aborted = new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([work, aborted]);
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+        work.catch(() => undefined);
+    }
+}
 async function executeStepWithHealing(params) {
-    const { stagehand, page, optional, upload, submitStep, captchaGated = false, emailStep = false, emailStepConfig, allocatedInbox = null, sessionProxy = null, 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, onStepHeal, } = params;
+    const { stagehand, optional, upload, submitStep, captchaGated = false, emailStep = false, emailStepConfig, allocatedInbox = null, sessionProxy = null, 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, onStepHeal, } = params;
     // Mutable: the `emailStep` code-extract path splices the extracted code
     // into this instruction (see the emailStep hook block below) so the
     // pre-existing fill cascade downstream picks it up as the value to type
@@ -8106,6 +9600,9 @@ async function executeStepWithHealing(params) {
     // function keeps reading `frameTarget` unchanged; only its declaration
     // moved so it can be reassigned.
     let frameTarget = params.frameTarget;
+    // Rebound when a click opens a new browsing context, so every later probe,
+    // verifier and key event in the cascade reads the page the click navigated to.
+    let page = params.page;
     let frameReresolveAttempted = false;
     // Emailed-verification hook. Runs FIRST — before upload/select/checkbox/
     // radio/prompt-selector/captcha or any other cascade primitive — so an
@@ -8263,7 +9760,11 @@ 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 = isStepDeclaredNonSubmit({ step, submitStep });
+    // Single final-step inference every submit-strictness gate below reads, so a
+    // declared non-submit veto cannot be honoured at one site and missed at another.
+    const inferredFinalSubmitStep = isFinalStep && !stepDeclaredNonSubmit;
+    const requireSubmitEndpoint = (inferredFinalSubmitStep || submitStep) && 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
@@ -8291,6 +9792,7 @@ async function executeStepWithHealing(params) {
         fixture: uploadFixture,
         logger,
         signalCounter,
+        browserbaseSessionId: stagehand.browserbaseSessionID,
         recentCaptureMeta,
     })) {
         logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by upload primitive`);
@@ -8341,6 +9843,17 @@ async function executeStepWithHealing(params) {
         trajectory?.push({ stepIndex, verifiedBy: "dom", targetId: checkboxTargetId });
         return "completed";
     }
+    const checkboxStateTargetId = await tryCheckboxStatePrimitive({
+        page,
+        target: selectFrameTarget,
+        instruction: step,
+        logger,
+    });
+    if (checkboxStateTargetId !== null) {
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by checkbox state primitive`);
+        trajectory?.push({ stepIndex, verifiedBy: "dom", targetId: checkboxStateTargetId });
+        return "completed";
+    }
     // When the step is a single-choice RADIO answer ("Click the 'Yes' answer for
     // the question '…'"), commit it directly in the DOM. Runs AFTER select/
     // checkbox (which own their verbs) and BEFORE the cascade, so radios never
@@ -8386,6 +9899,19 @@ async function executeStepWithHealing(params) {
         trajectory?.push({ stepIndex, verifiedBy: "dom", targetId: promptSelectorTargetId });
         return "completed";
     }
+    // Multi-segment date spinbuttons need real key events; the cascade's
+    // insertText would garble the segments. Falls through on null.
+    const segmentedDateTargetId = await trySegmentedDateSpinbuttonPrimitive({
+        page,
+        target: selectFrameTarget,
+        instruction: step,
+        logger,
+    });
+    if (segmentedDateTargetId !== null) {
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by segmented-date primitive`);
+        trajectory?.push({ stepIndex, verifiedBy: "dom", targetId: segmentedDateTargetId });
+        return "completed";
+    }
     // On a CATCH-ALL step ("for any remaining … question"), fill every
     // required-but-empty native <select> — including MuiNativeSelect dropdowns
     // (tabindex=-1) that Stagehand observe can't see and that no concrete flow
@@ -8415,7 +9941,13 @@ 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,
+    });
+    const isSettleWaitStep = isSubmitOrFinalStep || isAdvanceStep(step);
     if (captchaGated && isSubmitOrFinalStep) {
         let captchaTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
         const sitekeyProbeExpr = `(() => {
@@ -8559,6 +10091,12 @@ async function executeStepWithHealing(params) {
                             signalCounter,
                             page,
                             step,
+                            isMidFlowSubmitStep: isMidFlowSubmitShapedStep({
+                                step,
+                                submitStep,
+                                isFinalStep,
+                                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                            }),
                         });
                     }
                     catch (err) {
@@ -8703,7 +10241,8 @@ async function executeStepWithHealing(params) {
     // candidate matching the step's instruction we either skip cleanly
     // (optional) or escalate straight to replan (required) — far cheaper than
     // burning 4 attempts on a page that clearly isn't the right one.
-    const probeResult = await probeStepBeforeAttempts({
+    params.abortSignal?.throwIfAborted();
+    const probeResult = await raceAbortSignal(probeStepBeforeAttempts({
         stagehand,
         page,
         step,
@@ -8716,7 +10255,8 @@ async function executeStepWithHealing(params) {
             await reresolveFrameTargetIfLost();
             return frameTarget;
         },
-    });
+    }), params.abortSignal);
+    params.abortSignal?.throwIfAborted();
     if (probeResult === "absent") {
         if (optional) {
             // Don't fast-skip when the page plainly has a required, still-empty
@@ -8759,7 +10299,7 @@ async function executeStepWithHealing(params) {
         });
         if (backendErrorUrl !== null) {
             logger.error(`${formatStepPrefix(stepIndex, totalSteps)} backend error detected (submit endpoint returned 5xx: ${backendErrorUrl}); aborting cascade`);
-            throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) backend 5xx at ${backendErrorUrl} — unrecoverable`, "backend-error-unrecoverable");
+            throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactSecrets)(step).slice(0, 60)}) backend 5xx at ${backendErrorUrl} — unrecoverable`, "backend-error-unrecoverable");
         }
         // Bounded same-origin child-iframe fallback: the probe above only ever
         // looked at the resolved (declared-or-main) frame's own light+shadow DOM,
@@ -8772,8 +10312,23 @@ 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, step });
+            isStepSubmitShaped({
+                step,
+                submitStep,
+                isFinalStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            })) {
+            const fallbackTarget = await probeChildFrameSubmitFallback({
+                page,
+                signalCounter,
+                step,
+                isMidFlowSubmitStep: isMidFlowSubmitShapedStep({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                }),
+            });
             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" });
@@ -8796,6 +10351,7 @@ async function executeStepWithHealing(params) {
         const fieldValuesAtFailure = await (frameTarget ?? page)
             .evaluate(fieldValuesAtFailureExpr())
             .catch(() => null);
+        params.abortSignal?.throwIfAborted();
         const probeAbsentObservedUnfocused = await (0, stagehand_guard_1.guardedObserve)(stagehand, undefined, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
         // observe() is blind to a cross-origin OOPIF, so a frame-scoped empty
         // result degrades to the deep-locator resolver for dump evidence — this
@@ -8806,7 +10362,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?.({
@@ -8823,7 +10384,7 @@ async function executeStepWithHealing(params) {
             targetResolutionDiagnostic,
             fieldValuesAtFailure,
         }) ?? null;
-        throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
+        throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactSecrets)(step).slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
     }
     // Pre-submit form-validity probe. Fires on the canonical submit step
     // (either the final flow step OR a step explicitly flagged `submitStep:
@@ -9044,7 +10605,7 @@ async function executeStepWithHealing(params) {
             if (!frameTarget?.frame) {
                 const topWindowTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
                 try {
-                    await (0, watchdog_1.withWatchdog)(() => topWindowTarget.locator(selector).first().click(), {
+                    await (0, watchdog_1.withWatchdog)(() => (0, trusted_click_1.clickCentredTrusted)(topWindowTarget, selector), {
                         timeoutMs: N16_TRUSTED_CLICK_TIMEOUT_MS,
                         label: "n+16 fallback: trusted click delivery",
                     });
@@ -9082,6 +10643,26 @@ async function executeStepWithHealing(params) {
             return { delivered: false, reason: "threw", message: (0, errors_1.toErrorMessage)(err) };
         }
     };
+    // Baseline is per step, not per attempt, so a tab opened by a click whose
+    // attempt then failed is still new to the next attempt. Hand-built sessions in
+    // unit tests carry no browser context (or one without a page list); there is no
+    // tab to follow.
+    const followableContext = () => typeof stagehand.context?.pages === "function" ? stagehand.context : null;
+    let knownPages = followableContext()?.pages() ?? [];
+    const adoptOpenedPage = async (discoverWaitMs) => {
+        const context = followableContext();
+        if (!context)
+            return false;
+        const followed = await (0, active_page_1.followNewPage)(context, page, knownPages, discoverWaitMs);
+        if (followed === page)
+            return false;
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} click opened a new page; following it`);
+        page = followed;
+        frameTarget = undefined;
+        knownPages = context.pages();
+        params.onPageAdopted?.(followed);
+        return true;
+    };
     let phantomClickAfterAttempt1 = false;
     let attempt1UnreachableViaLightDom = false;
     // Last candidate list the deep-submit-locator itself ranked this step, if
@@ -9091,6 +10672,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.
@@ -9099,7 +10681,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"
@@ -9118,7 +10705,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}`);
@@ -9127,8 +10719,12 @@ async function executeStepWithHealing(params) {
             }
         }
         if (attempt > 1) {
-            await page.waitForTimeout(attempt * ATTEMPT_BACKOFF_MS);
+            await raceAbortSignal(page.waitForTimeout(attempt * ATTEMPT_BACKOFF_MS), params.abortSignal);
+            params.abortSignal?.throwIfAborted();
         }
+        // A click from an earlier attempt that errored after opening a tab leaves the
+        // run on the stale page; pick the tab up before measuring anything.
+        await adoptOpenedPage(0);
         const pre = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page, captureSelectionState);
         // Snapshot the meta-tail length so the final-step pattern gate can scope
         // its URL scan to captures added DURING this attempt (not historical
@@ -9164,6 +10760,23 @@ async function executeStepWithHealing(params) {
         // whether this attempt's signal should come from the network/URL pair or
         // from DOM re-read. Captured here so both branches of the cascade write to it.
         let resolvedAction = null;
+        // Stagehand resolves a natural-language act target internally, so for a
+        // click-intent instruction resolve it with observe first and centre it;
+        // a sticky bar otherwise swallows Stagehand's own click. Throws when the
+        // control stays covered so the attempt fails instead of clicking an overlay.
+        // Resolves true once the observe ran, so guardedAct skips its own pass.
+        const preCentreNaturalLanguageClick = async (instruction) => {
+            if (!stagehand_guard_1.CLICK_INTENT_RE.test(instruction))
+                return false;
+            const observed = await (0, stagehand_guard_1.guardedObserve)(stagehand, instruction, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
+            const first = observed[0];
+            if (first?.method !== "click" || !first.selector)
+                return true;
+            const failure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), first.selector, (msg) => logger.debug(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${msg}`), true);
+            if (failure)
+                throw new Error(failure);
+            return true;
+        };
         try {
             // Field-label-first routing: for a frame-scoped fill/select step,
             // Stagehand's own act()/observe() can resolve a real, in-DOM, plausible-
@@ -9194,7 +10807,7 @@ async function executeStepWithHealing(params) {
                 triedSelectors.push(fieldLabelOutcome.matched.selector);
                 record.triedSelectors = [fieldLabelOutcome.matched.selector];
                 record.actResultSuccess = true;
-                record.actResultDescription = `deepLocator ${fieldLabelOutcome.fieldTarget.kind === "fill" ? "filled" : "selected"} "${fieldLabelOutcome.matched.accessibleText || fieldLabelOutcome.matched.selector}" with "${fieldLabelOutcome.fieldTarget.value}"`;
+                record.actResultDescription = `deepLocator ${fieldLabelOutcome.fieldTarget.kind === "fill" ? "filled" : "selected"} "${fieldLabelOutcome.matched.accessibleText || fieldLabelOutcome.matched.selector}" with "${(0, pii_redaction_1.maskValueShape)(fieldLabelOutcome.fieldTarget.value)}"`;
                 // Same rationale as the pre-existing candidates===0 branch below:
                 // the write + read-back the actuation helper already performed IS
                 // the verification signal — no resolvedAction/network/url verifier
@@ -9227,7 +10840,9 @@ async function executeStepWithHealing(params) {
             if (attempt === 1) {
                 record.technique = "act-string";
                 record.instruction = step;
-                const result = await (0, stagehand_guard_1.guardedAct)(stagehand, step, { timeout: exports.STEP_WATCHDOG_MS }, captureFn);
+                params.abortSignal?.throwIfAborted();
+                const preCentred = await preCentreNaturalLanguageClick(step);
+                const result = await (0, stagehand_guard_1.guardedAct)(stagehand, step, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), preCentred);
                 record.actResultSuccess = result.success;
                 record.actResultDescription = result.actionDescription;
                 // Deny-list guard (post-hoc): attempt-1 act resolves internally, so we
@@ -9256,7 +10871,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
@@ -9331,6 +10951,10 @@ async function executeStepWithHealing(params) {
                         // burn the step budget probing all of them.
                         const runnerUp = ranked[1];
                         if (runnerUp) {
+                            await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, true, async () => {
+                                const snap = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter);
+                                return snap.visibleTextSignature;
+                            }, pre.visibleTextSignature);
                             const midPost = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
                             const topVerdict = (0, phantom_click_1.classifyPhantomClick)({
                                 actResultSuccess: true,
@@ -9340,7 +10964,20 @@ 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),
+                                isMidFlowSubmitStep: isMidFlowSubmitShapedStep({
+                                    step,
+                                    submitStep,
+                                    isFinalStep,
+                                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                                }),
+                                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, midPost.url, isMidFlowSubmitShapedStep({
+                                    step,
+                                    submitStep,
+                                    isFinalStep,
+                                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                                })
+                                    ? pre.url
+                                    : undefined),
                             });
                             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})`);
@@ -9383,7 +11020,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
@@ -9460,7 +11102,8 @@ async function executeStepWithHealing(params) {
                             : { found: false };
                         if (markResult.found) {
                             try {
-                                await topWindowTarget.locator(`[${markerAttr}="${markerValue}"]`).first().click();
+                                const markerSelector = `[${markerAttr}="${markerValue}"]`;
+                                await (0, trusted_click_1.clickAfterCentredHitTest)((0, trusted_click_1.firstMatchClickable)(topWindowTarget.locator(markerSelector)), () => topWindowTarget.evaluate(buildDeepMarkerCentreExpr(markerSelector)), { label: markerSelector });
                                 clickedShadowDescendant = true;
                             }
                             finally {
@@ -9470,7 +11113,7 @@ async function executeStepWithHealing(params) {
                             }
                         }
                         else {
-                            await topWindowTarget.locator(topWindowSelector).first().click();
+                            await (0, trusted_click_1.clickCentredTrusted)(topWindowTarget, topWindowSelector);
                         }
                     }
                     catch (err) {
@@ -9531,6 +11174,7 @@ async function executeStepWithHealing(params) {
                 const observeOptions = attempt === 4 && triedSelectors.length > 0
                     ? { ignoreSelectors: [...triedSelectors], timeout: exports.STEP_WATCHDOG_MS }
                     : { timeout: exports.STEP_WATCHDOG_MS };
+                params.abortSignal?.throwIfAborted();
                 const candidates = await (0, stagehand_guard_1.guardedObserve)(stagehand, step, observeOptions, captureFn, frameTarget);
                 // observe() is blind to a cross-origin OOPIF (see
                 // deep-locator-candidates.ts's module docblock) — when the step is
@@ -9666,8 +11310,18 @@ async function executeStepWithHealing(params) {
                     }
                 }
                 else {
-                    // biome-ignore lint/style/noNonNullAssertion: this else-branch runs only when candidates.length !== 0
-                    const target = candidates[0];
+                    const quotedPhrases = stepQuotesValueNotControlName(step)
+                        ? []
+                        : (0, deep_locator_candidates_1.extractTaggedPhrases)(step);
+                    const verdict = (0, deep_locator_candidates_1.vetObserveCandidates)(candidates, quotedPhrases);
+                    if (verdict.refuse || !verdict.candidate) {
+                        record.errorMessage = `observe candidate does not match the control named in the step: "${(verdict.candidate?.description ?? "").slice(0, 60)}" (refusing to act on an unscored guess)`;
+                        attempts.push(record);
+                        failureReasons.push(record.errorMessage);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${record.errorMessage}`);
+                        continue;
+                    }
+                    const target = verdict.candidate;
                     // Deny-list guard: never act on a wizard-exit control (save-and-exit,
                     // cancel, restart) for a click/advance step. Record it as tried (so a
                     // re-observe with ignoreSelectors surfaces a different candidate) and
@@ -9711,7 +11365,22 @@ async function executeStepWithHealing(params) {
                             };
                         }
                     }
-                    const result = await (0, stagehand_guard_1.guardedAct)(stagehand, overriddenTarget, { timeout: exports.STEP_WATCHDOG_MS }, captureFn);
+                    params.abortSignal?.throwIfAborted();
+                    // Stagehand's internal Locator.click() does not scroll past sticky
+                    // bars, so centre + hit-test the observed control first; an
+                    // unrecoverable occlusion fails the attempt instead of clicking an
+                    // overlay.
+                    if (overriddenTarget.method === "click") {
+                        const centreFailure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), overriddenTarget.selector, (msg) => logger.debug(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${msg}`));
+                        if (centreFailure) {
+                            record.errorMessage = centreFailure;
+                            attempts.push(record);
+                            failureReasons.push(record.errorMessage);
+                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${record.errorMessage}`);
+                            continue;
+                        }
+                    }
+                    const result = await (0, stagehand_guard_1.guardedAct)(stagehand, overriddenTarget, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page));
                     record.actResultSuccess = result.success;
                     record.actResultDescription = result.actionDescription;
                     // observe(...)[0] is what Stagehand acted on; use it directly when
@@ -9743,8 +11412,8 @@ async function executeStepWithHealing(params) {
                             const dateFill = await fillHtml5DateTimeInput(dateFillTarget, overriddenTarget.selector, fillValue);
                             if (dateFill !== null) {
                                 record.errorMessage = dateFill.filled
-                                    ? `html5-date-fallback: filled ${dateFill.inputType}="${redactIfSensitive(dateFill.postValue, emailStepCode)}"`
-                                    : `html5-date-fallback: failed to fill ${dateFill.inputType} (post=${redactIfSensitive(dateFill.postValue, emailStepCode)})`;
+                                    ? `html5-date-fallback: filled ${dateFill.inputType}="${maskLoggedValue(dateFill.postValue, emailStepCode)}"`
+                                    : `html5-date-fallback: failed to fill ${dateFill.inputType} (post=${maskLoggedValue(dateFill.postValue, emailStepCode)})`;
                                 // Override the act result based on the deterministic fill
                                 // outcome — the helper bypasses Stagehand's schema-error
                                 // failure mode by writing directly via the native setter.
@@ -9764,8 +11433,8 @@ async function executeStepWithHealing(params) {
                                 const datepickerFill = await fillTextDatepickerInput(dateFillTarget, overriddenTarget.selector, fillValue);
                                 if (datepickerFill !== null) {
                                     record.errorMessage = datepickerFill.filled
-                                        ? `text-datepicker-fill: filled via ${datepickerFill.strategy} "${redactIfSensitive(datepickerFill.postValue, emailStepCode)}"`
-                                        : `text-datepicker-fill: failed to commit "${redactIfSensitive(fillValue.slice(0, 60), emailStepCode)}" (post=${redactIfSensitive(datepickerFill.postValue, emailStepCode)})`;
+                                        ? `text-datepicker-fill: filled via ${datepickerFill.strategy} "${maskLoggedValue(datepickerFill.postValue, emailStepCode)}"`
+                                        : `text-datepicker-fill: failed to commit "${maskLoggedValue(fillValue.slice(0, 60), emailStepCode)}" (post=${maskLoggedValue(datepickerFill.postValue, emailStepCode)})`;
                                     if (datepickerFill.filled) {
                                         record.actResultSuccess = true;
                                         resolvedAction = overriddenTarget;
@@ -9783,12 +11452,16 @@ async function executeStepWithHealing(params) {
                                     // (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 "${redactIfSensitive(fillValue.slice(0, 60), emailStepCode)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                                        if (readback.outcome === "segment") {
+                                            record.errorMessage = `fill-value-rejected: tried "${maskLoggedValue(fillValue.slice(0, 60), emailStepCode)}" on a single spinbutton segment; a lone segment cannot hold the whole value`;
+                                            record.actResultSuccess = false;
+                                        }
+                                        else if (readback.outcome === "rejected") {
+                                            record.errorMessage = `fill-value-rejected: tried "${maskLoggedValue(fillValue.slice(0, 60), emailStepCode)}" 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 "${redactIfSensitive(fillValue.slice(0, 60), emailStepCode)}" got "${redactIfSensitive(readback.postValue.slice(0, 60), emailStepCode)}" (framework reformatted)`);
+                                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} fill-value-differs: tried "${maskLoggedValue(fillValue.slice(0, 60), emailStepCode)}" got "${maskLoggedValue(readback.postValue.slice(0, 60), emailStepCode)}" (framework reformatted)`);
                                         }
                                     }
                                 }
@@ -9951,6 +11624,7 @@ async function executeStepWithHealing(params) {
                         "anthropic billing exhausted (FATAL_BILLING already logged); skipping rephrase";
                 }
                 else {
+                    params.abortSignal?.throwIfAborted();
                     const observedCandidates = await (0, stagehand_guard_1.guardedObserve)(stagehand, step, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
                     // observe() is blind to a cross-origin OOPIF, so a frame-scoped
                     // empty result degrades to the deep-locator resolver for prompt
@@ -9975,6 +11649,7 @@ async function executeStepWithHealing(params) {
                     // frameTarget: for a frame-scoped flow the ambient UI that matters
                     // (the wizard's own Save/Close controls) lives inside the iframe
                     // alongside the failed step, not in the top document.
+                    params.abortSignal?.throwIfAborted();
                     const observedUnfocused = await (0, stagehand_guard_1.guardedObserve)(stagehand, undefined, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
                     const unfocused = observedUnfocused.length === 0 && frameTarget?.frame
                         ? await deepLocatorCandidatesAsActions(page, frameTarget)
@@ -9992,7 +11667,9 @@ async function executeStepWithHealing(params) {
                     }
                     else {
                         record.instruction = rephrased;
-                        const result = await (0, stagehand_guard_1.guardedAct)(stagehand, rephrased, { timeout: exports.STEP_WATCHDOG_MS }, captureFn);
+                        params.abortSignal?.throwIfAborted();
+                        const preCentred = await preCentreNaturalLanguageClick(rephrased);
+                        const result = await (0, stagehand_guard_1.guardedAct)(stagehand, rephrased, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), preCentred);
                         record.actResultSuccess = result.success;
                         record.actResultDescription = result.actionDescription;
                         for (const action of result.actions ?? []) {
@@ -10021,7 +11698,7 @@ async function executeStepWithHealing(params) {
         // cannot produce a positive signal: verified is forced false and the
         // cascade always falls through to attempt 2. Skip the wasted ~2-3s
         // of timeout + snapshot work and let the cascade try observe-act.
-        if (attempt === 1 && resolvedAction === null) {
+        if (attempt === 1 && resolvedAction === null && record.actResultSuccess !== true) {
             attempts.push(record);
             const reason = record.errorMessage
                 ? `attempt 1 fast-skipped (no resolved action): ${record.errorMessage}`
@@ -10029,7 +11706,21 @@ async function executeStepWithHealing(params) {
             failureReasons.push(reason);
             continue;
         }
+        // A fill/select/type action cannot open a tab, so skip the discovery wait for it.
+        await adoptOpenedPage(resolvedAction && STATE_CLASS_METHODS.has(resolvedAction.method ?? "") ? 0 : undefined);
         await page.waitForTimeout(STEP_PAUSE_MS);
+        // A successful act that reported no actions still ran a click-class action;
+        // judging it before its round-trip lands would cascade onto the advanced page.
+        const mayTriggerRoundTrip = resolvedAction === null
+            ? record.actResultSuccess === true
+            : !STATE_CLASS_METHODS.has(resolvedAction.method ?? "");
+        if (mayTriggerRoundTrip) {
+            const settleTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+            await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, isSettleWaitStep, async () => {
+                const snap = await snapshotPage(settleTarget, signalCounter);
+                return snap.visibleTextSignature;
+            }, pre.visibleTextSignature);
+        }
         const post = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
         record.post = post;
         if (resolvedAction) {
@@ -10039,7 +11730,13 @@ async function executeStepWithHealing(params) {
         const networkFired = post.networkCount > pre.networkCount;
         // 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 stepIsMidFlowSubmit = isMidFlowSubmitShapedStep({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        });
+        const destinationPlausible = (0, phantom_click_1.isPlausibleStepDestination)(step, post.url, stepIsMidFlowSubmit ? pre.url : undefined);
         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";
@@ -10103,7 +11800,12 @@ 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 && destinationPlausible,
             networkIsRealAdvance,
@@ -10127,16 +11829,17 @@ async function executeStepWithHealing(params) {
         // Zero-signal reset veto input for the view-swap gate below. Read only
         // for a resolved click with a usable selector — a page reset that reverts
         // to an earlier screen (recon-viewswap-false-pass-on-zero-signal-click.md)
-        // replaces the clicked control along with everything else, while a
-        // genuine same-page toggle (a settings-page tab switcher) leaves it in
-        // place. See isClickViewSwapVerified's doc comment.
+        // replaces the clicked control along with everything else and shrinks
+        // the DOM, while a genuine same-page toggle leaves it in place and a
+        // view swap removes it but grows the DOM (absence vetoes only when
+        // bytesDelta <= 0). See isClickViewSwapVerified's doc comment.
         const clickedElementStillPresent = isClick && resolvedAction?.selector
             ? await resolvedClickTargetStillPresent(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector)
             : true;
         // 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
@@ -10148,6 +11851,17 @@ async function executeStepWithHealing(params) {
         // cascade to a 5-attempt failure and global replan. Vetoed when the click's
         // ng-invalid marker count grew, or when the landed destination is implausible
         // for the step (see isClickViewSwapVerified's doc comment).
+        const midFlowSubmit = isMidFlowSubmitShapedStep({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            elementSubmitShaped: resolvedElementIsSubmitShaped,
+        });
+        // An element-inferred mid-flow submit joins the exemption the step-derived
+        // one already got: a click that never left its URL did not bounce to a gate.
+        const midFlowDestinationPlausible = destinationPlausible ||
+            (midFlowSubmit && (0, phantom_click_1.isPlausibleStepDestination)(step, post.url, pre.url));
         const clickViewSwapVerified = isClickViewSwapVerified({
             resolvedAction,
             submitStep,
@@ -10158,7 +11872,10 @@ async function executeStepWithHealing(params) {
             invalidMarkerDelta: postInvalidMarkerCount - preInvalidMarkerCount,
             clickedElementStillPresent,
             resolvedElementIsSubmitShaped,
-            destinationPlausible,
+            destinationPlausible: midFlowDestinationPlausible,
+            midFlowSubmit,
+            pageAdvanced: (0, phantom_click_1.hasPageAdvanced)(pre, post),
+            actSucceeded: record.actResultSuccess === true,
         });
         if (clickViewSwapVerified === false &&
             isClick &&
@@ -10191,10 +11908,12 @@ 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 &&
@@ -10223,7 +11942,12 @@ async function executeStepWithHealing(params) {
             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") {
+                if (readback?.outcome === "segment") {
+                    datepickerRejected = true;
+                    record.actResultSuccess = false;
+                    record.errorMessage = `fill-value-rejected: tried "${maskLoggedValue(fillIntent.value.slice(0, 60), emailStepCode)}" on a single spinbutton segment; a lone segment cannot hold the whole value`;
+                }
+                else 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
@@ -10232,7 +11956,7 @@ async function executeStepWithHealing(params) {
                     if (datepickerFill !== null) {
                         if (datepickerFill.filled) {
                             datepickerCommitted = true;
-                            record.errorMessage = `text-datepicker-fill: filled via ${datepickerFill.strategy} "${redactIfSensitive(datepickerFill.postValue, emailStepCode)}"`;
+                            record.errorMessage = `text-datepicker-fill: filled via ${datepickerFill.strategy} "${maskLoggedValue(datepickerFill.postValue, emailStepCode)}"`;
                         }
                         else {
                             // A gated-in datepicker that neither gesture commits is a real fill
@@ -10240,7 +11964,7 @@ async function executeStepWithHealing(params) {
                             // so suppress the weak view-swap/form-value acceptance and escalate.
                             datepickerRejected = true;
                             record.actResultSuccess = false;
-                            record.errorMessage = `text-datepicker-fill: failed to commit "${redactIfSensitive(fillIntent.value.slice(0, 60), emailStepCode)}" (post=${redactIfSensitive(datepickerFill.postValue, emailStepCode)})`;
+                            record.errorMessage = `text-datepicker-fill: failed to commit "${maskLoggedValue(fillIntent.value.slice(0, 60), emailStepCode)}" (post=${maskLoggedValue(datepickerFill.postValue, emailStepCode)})`;
                         }
                     }
                     else {
@@ -10249,7 +11973,7 @@ async function executeStepWithHealing(params) {
                         // failure dump reads identically regardless of which path caught it.
                         datepickerRejected = true;
                         record.actResultSuccess = false;
-                        record.errorMessage = `fill-value-rejected: tried "${redactIfSensitive(fillIntent.value.slice(0, 60), emailStepCode)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
+                        record.errorMessage = `fill-value-rejected: tried "${maskLoggedValue(fillIntent.value.slice(0, 60), emailStepCode)}" on <${readback.tag}>; element value remains empty (silent rejection — HTML5 type validation, framework controlled-component, or masked-input library)`;
                     }
                 }
             }
@@ -10277,7 +12001,7 @@ async function executeStepWithHealing(params) {
             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);
+                const promptReadback = await verifyPromptSelectorCommitted(readbackTarget, readbackSelector, parsePromptSelectorStep(step)?.option);
                 if (promptReadback?.isPromptWidget === true && promptReadback.committed === false) {
                     promptSelectorRejected = true;
                     record.actResultSuccess = false;
@@ -10301,8 +12025,15 @@ async function executeStepWithHealing(params) {
             pre,
             post,
             elementStateChanged: domVerified && destinationPlausible,
-            isSubmitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag) || isSubmitIntentStep(step),
-            destinationPlausible,
+            isSubmitShapedStep: midFlowSubmit ||
+                isStepSubmitShaped({
+                    step,
+                    submitStep,
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                }),
+            isMidFlowSubmitStep: midFlowSubmit,
+            destinationPlausible: midFlowDestinationPlausible,
         });
         // An `"effective"` verdict driven purely by the page-wide byte-delta
         // floor (`TRIVIAL_DOM_DELTA_BYTES`, 500B) is intentionally NOT trusted
@@ -10323,8 +12054,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 ||
@@ -10391,6 +12126,7 @@ async function executeStepWithHealing(params) {
             }
             // Build the unfocused-observe evidence list. Used by the judge to
             // assess whether the page transitioned to a success state.
+            params.abortSignal?.throwIfAborted();
             const unfocusedForJudge = await (0, stagehand_guard_1.guardedObserve)(stagehand, undefined, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
             // Quick invalid-marker count (deterministic DOM querying — counting
             // structural ng-invalid containers is not fuzzy matching, just
@@ -10401,9 +12137,17 @@ async function executeStepWithHealing(params) {
                 label: "flow-runner: submit-verification page title probe",
             }).catch(() => "");
             const matchedSubmittedSelectors = domSubmittedMatch !== null ? [domSubmittedMatch] : [];
-            const judgeVerdict = await (0, verify_submit_1.verifySubmitWithLLM)({
+            const judgeVerdict = await judgeStepOutcome({
                 client: anthropic,
-                input: {
+                captureFn,
+                step,
+                isFinalStep,
+                page,
+                target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
+                signalCounter,
+                preNetworkCount: pre.networkCount,
+                preVisibleTextSignature: pre.visibleTextSignature,
+                submitInput: {
                     pageUrl: post.url,
                     pageTitle,
                     unfocusedObserve: unfocusedForJudge.map((a) => ({
@@ -10417,9 +12161,22 @@ async function executeStepWithHealing(params) {
                     successPageTitleHints,
                     submittedStateSelectors: matchedSubmittedSelectors,
                 },
-                captureFn,
             });
-            if (judgeVerdict === null) {
+            // A mid-flow transition is credited on the page's own demonstrable
+            // advance (visible text swapped); the judge's final-submit-flavoured
+            // view of a stale title or missing network must not undo it.
+            const midFlowAdvanceCredited = (midFlowSubmit && clickViewSwapVerified) ||
+                isNullVerdictAdvanceCredited({
+                    midFlowSubmit,
+                    judgeUnavailable: judgeVerdict === null,
+                    networkAdvanced: networkIsRealAdvance,
+                    pageAdvanced: (0, phantom_click_1.hasPageAdvanced)(pre, post),
+                    invalidMarkerCount,
+                });
+            if (midFlowAdvanceCredited && judgeVerdict?.verified !== true) {
+                logger.info(`mid-flow submit credited on demonstrable page advance (judge ${judgeVerdict === null ? "unavailable" : `rejected: ${judgeVerdict.reason}`})`);
+            }
+            else if (judgeVerdict === null) {
                 // Bedrock-only deployment or judge call failed entirely. Fall back
                 // to the DOM-state probe + requireSubmitEndpointMatch policy: if a
                 // submitted-state selector matched and the site didn't require
@@ -10539,11 +12296,16 @@ 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 tailPhrases = tailRetargetPhrasesForStep(step);
+                    const retryResolvedElementIsSubmitShaped = stepDeclaredNonSubmit
+                        ? false
+                        : await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector, xpathTail, tailPhrases);
                     // 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, tailPhrases);
                     // Trusted-click delivery for the plain-click branch: attempted
                     // BEFORE the resolve/activate expression below (so a successful
                     // delivery can suppress the synthetic `clickActivationExpr`
@@ -10575,10 +12337,12 @@ 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)}, ${JSON.stringify(tailPhrases)}); if (!el && ${JSON.stringify(tailPhrases.length > 0)} && ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)}, ${JSON.stringify(false)}, []) !== null) return { fired: false, phraseMismatch: true }; } 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") { const __ac = ${ariaCheckedReadExpr("el")}; if (__ac === "true" || __ac === "false") return { fired: true, kind: "checkbox", checked: __ac === "true", ariaManaged: true }; 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;
+                    if (fired)
+                        await adoptOpenedPage();
                     // Vacuous-click guard for the n+16 fallback. Same rationale as
                     // verifyDomEffect's click case: a checkbox/radio input's .checked
                     // property can flip true via CDP click even when the input lives on
@@ -10588,13 +12352,15 @@ async function executeStepWithHealing(params) {
                     // ancestor-invalid signal through prevents the cascade from
                     // advancing past a vacuous click.
                     let ancestorStillInvalid = false;
-                    if (probeResult.kind === "checkbox" && probeResult.checked === true) {
+                    if (probeResult.kind === "checkbox" &&
+                        probeResult.checked === true &&
+                        probeResult.ariaManaged !== true) {
                         const ancestorInvalidExpr = `(() => {
               const isInvalid = ${INVALID_MARKER_EL_EXPR};
               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)}, ${JSON.stringify(tailPhrases)});
               }
               if (!node) return false;
               for (let depth = 0; depth < 6 && node; depth++) {
@@ -10603,18 +12369,35 @@ async function executeStepWithHealing(params) {
               }
               return false;
             })()`;
-                        ancestorStillInvalid = (await n16FallbackTarget
+                        ancestorStillInvalid = (await (frameTarget ?? (0, frame_target_1.mainFrameTarget)(page))
                             .evaluate(ancestorInvalidExpr)
                             .catch(() => false));
                     }
+                    // An aria-managed box is never forced, so the framework's own
+                    // aria-checked decides; a stale invalid ancestor is not consulted.
+                    const forcedCheckboxRejected = probeResult.kind === "checkbox" &&
+                        (probeResult.ariaManaged === true
+                            ? probeResult.checked !== true
+                            : ancestorStillInvalid);
                     const checkboxStateVerified = probeResult.kind === "checkbox" &&
                         probeResult.checked === true &&
-                        !ancestorStillInvalid;
+                        (probeResult.ariaManaged === true || !ancestorStillInvalid);
                     await page.waitForTimeout(STEP_PAUSE_MS);
+                    await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, isSettleWaitStep, async () => {
+                        const snap = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter);
+                        return snap.visibleTextSignature;
+                    }, pre.visibleTextSignature);
                     const retryPost = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
                     const retryNetworkFired = retryPost.networkCount > pre.networkCount;
+                    const retryMidFlowSubmit = isMidFlowSubmitShapedStep({
+                        step,
+                        submitStep,
+                        isFinalStep,
+                        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                        elementSubmitShaped: retryResolvedElementIsSubmitShaped,
+                    });
                     const retryUrlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, retryPost.url) &&
-                        (0, phantom_click_1.isPlausibleStepDestination)(step, retryPost.url);
+                        (0, phantom_click_1.isPlausibleStepDestination)(step, retryPost.url, retryMidFlowSubmit ? pre.url : undefined);
                     const retryHtmlDelta = retryPost.bodyHtmlLength - pre.bodyHtmlLength;
                     const retryTextChanged = retryPost.visibleTextSignature !== pre.visibleTextSignature;
                     const retryFormValueChanged = retryPost.formValueSignature !== pre.formValueSignature;
@@ -10678,7 +12461,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)}, ${JSON.stringify(tailPhrases)});
                 }
                 return el ? isDisabled(el) : false;
               })()`;
@@ -10709,6 +12492,12 @@ async function executeStepWithHealing(params) {
                     // 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);
+                    // Only the verdict sees the pre.url exemption, and only for a demonstrable
+                    // page advance: bare network/DOM signals stay gated on the landed URL.
+                    const retryMidFlowDestinationPlausible = retryDestinationPlausible ||
+                        (retryMidFlowSubmit &&
+                            (0, phantom_click_1.hasPageAdvanced)(pre, retryPost) &&
+                            (0, phantom_click_1.isPlausibleStepDestination)(step, retryPost.url, pre.url));
                     const retryNetworkIsRealAdvance = retryNetworkFired &&
                         retryDestinationPlausible &&
                         (await waitForTransitionBody({
@@ -10722,7 +12511,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,
@@ -10781,11 +12575,13 @@ 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 = ((!inferredFinalSubmitStep && !submitStep && !retryResolvedElementIsSubmitShaped) ||
                         requireSubmitEndpoint) &&
                         !isCheckboxOrRadioIntentStep(step) &&
                         !clickTargetIsSelectionMarker;
@@ -10807,8 +12603,9 @@ async function executeStepWithHealing(params) {
                         pre,
                         post: retryPost,
                         elementStateChanged: retrySelectionStateChanged,
-                        isSubmitShapedStep: retrySubmitShaped,
-                        destinationPlausible: retryDestinationPlausible,
+                        isSubmitShapedStep: retryMidFlowSubmit || retrySubmitShaped,
+                        isMidFlowSubmitStep: retryMidFlowSubmit,
+                        destinationPlausible: retryMidFlowDestinationPlausible,
                     });
                     // Destination-plausibility audit of every remaining disjunct in
                     // this OR (the recon report's closing instruction, see
@@ -10824,15 +12621,28 @@ async function executeStepWithHealing(params) {
                     // three get the same `isPlausibleStepDestination` gate
                     // `weakDomSignalsAllowed` already has (bugfix-002) — `retryUrlChanged`
                     // already folds the same check in at its own computation above.
+                    // An unfired probe with no trusted delivery clicked nothing, so DOM
+                    // movement is ambient settling, not this step's effect.
+                    const n16ClickDelivered = fired === true || n16TrustedDelivered;
+                    const retryShowsErrorSummary = exports.ADVANCE_CLICK_RX.test(step)
+                        ? (await (frameTarget ?? (0, frame_target_1.mainFrameTarget)(page))
+                            .evaluate(exports.ERROR_SUMMARY_EXPR)
+                            .catch(() => false))
+                        : false;
                     let retryVerified = !clickBlockedByDisabled &&
+                        !retryShowsErrorSummary &&
                         !clickBlockedByInvalid &&
                         !fallbackDomOnlyAdvance &&
-                        ((retryNetworkFired && retryDestinationPlausible) ||
-                            retryUrlChanged ||
+                        !forcedCheckboxRejected &&
+                        ((n16ClickDelivered && retryNetworkFired && retryDestinationPlausible) ||
+                            (n16ClickDelivered && retryUrlChanged) ||
                             (checkboxStateVerified && retryDestinationPlausible) ||
                             (retrySelectionStateChanged && retryDestinationPlausible) ||
-                            (!retrySubmitShaped && retryVerdict === "effective") ||
-                            (weakDomSignalsAllowed &&
+                            (n16ClickDelivered &&
+                                (!retrySubmitShaped || retryMidFlowSubmit) &&
+                                retryVerdict === "effective") ||
+                            (n16ClickDelivered &&
+                                weakDomSignalsAllowed &&
                                 retryDestinationPlausible &&
                                 (retryHtmlDelta !== 0 || retryTextChanged || retryFormValueChanged)));
                     if (retryVerified) {
@@ -10876,7 +12686,10 @@ 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 = inferredFinalSubmitStep &&
+                        !submitStep &&
+                        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
@@ -10920,9 +12733,17 @@ async function executeStepWithHealing(params) {
                             label: "flow-runner: submit-verification retry page title probe",
                         }).catch(() => "");
                         const matchedSubmittedSelectors = domSubmittedMatch !== null ? [domSubmittedMatch] : [];
-                        const judgeVerdict = await (0, verify_submit_1.verifySubmitWithLLM)({
+                        const judgeVerdict = await judgeStepOutcome({
                             client: anthropic,
-                            input: {
+                            captureFn,
+                            step,
+                            isFinalStep,
+                            page,
+                            target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
+                            signalCounter,
+                            preNetworkCount: pre.networkCount,
+                            preVisibleTextSignature: pre.visibleTextSignature,
+                            submitInput: {
                                 pageUrl: retryPost.url,
                                 pageTitle,
                                 unfocusedObserve: unfocusedForJudge.map((a) => ({
@@ -10936,9 +12757,21 @@ async function executeStepWithHealing(params) {
                                 successPageTitleHints,
                                 submittedStateSelectors: matchedSubmittedSelectors,
                             },
-                            captureFn,
                         });
-                        if (judgeVerdict === null) {
+                        const retryMidFlowAdvanceCredited = (retryMidFlowSubmit &&
+                            retryVerdict === "effective" &&
+                            (0, phantom_click_1.hasPageAdvanced)(pre, retryPost)) ||
+                            isNullVerdictAdvanceCredited({
+                                midFlowSubmit: retryMidFlowSubmit,
+                                judgeUnavailable: judgeVerdict === null,
+                                networkAdvanced: retryNetworkFired && retryDestinationPlausible,
+                                pageAdvanced: (0, phantom_click_1.hasPageAdvanced)(pre, retryPost),
+                                invalidMarkerCount,
+                            });
+                        if (retryMidFlowAdvanceCredited && judgeVerdict?.verified !== true) {
+                            logger.info(`n+16 fallback mid-flow submit credited on demonstrable page advance (judge ${judgeVerdict === null ? "unavailable" : `rejected: ${judgeVerdict.reason}`})`);
+                        }
+                        else if (judgeVerdict === null) {
                             // Bedrock-only or judge failed; fall back to DOM-state + policy.
                             if (!requireSubmitEndpointMatch && domSubmittedMatch !== null) {
                                 logger.info(`n+16 fallback submit verified via submitted-state DOM selector '${domSubmittedMatch}' (judge unavailable)`);
@@ -11047,7 +12880,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,
@@ -11108,7 +12946,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)"
@@ -11120,7 +12963,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,
@@ -11140,7 +12988,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,
@@ -11167,8 +13020,23 @@ 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, step });
+        isStepSubmitShaped({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        })) {
+        const fallbackTarget = await probeChildFrameSubmitFallback({
+            page,
+            signalCounter,
+            step,
+            isMidFlowSubmitStep: isMidFlowSubmitShapedStep({
+                step,
+                submitStep,
+                isFinalStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            }),
+        });
         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" });
@@ -11200,7 +13068,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?.({
@@ -11220,7 +13093,7 @@ async function executeStepWithHealing(params) {
     if (dumpPath !== null) {
         logger.error(`${formatStepPrefix(stepIndex, totalSteps)} failed after ${MAX_STEP_ATTEMPTS} attempts; diagnostic bundle: ${dumpPath}`);
     }
-    throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) failed verification after ${MAX_STEP_ATTEMPTS} attempts${dumpPath ? `; see ${dumpPath}` : ""}`, phantomClickAfterAttempt1 ? "phantom-click-exhausted" : "cascade-exhausted");
+    throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactSecrets)(step).slice(0, 60)}) failed verification after ${MAX_STEP_ATTEMPTS} attempts${dumpPath ? `; see ${dumpPath}` : ""}`, phantomClickAfterAttempt1 ? "phantom-click-exhausted" : "cascade-exhausted");
 }
 /**
  * Navigates `page` directly to `url` and waits for the SPA to hydrate,
@@ -11266,7 +13139,11 @@ async function executeNavigateStep(params) {
  */
 async function runHealingFlow(deps) {
     const { stagehand, page, steps, logger, anthropic, rephraseModel, uploadFixture, maxFlowMs } = deps;
+    for (const secret of deps.secrets ?? [])
+        (0, pii_redaction_1.registerSecretValue)(secret);
     const counter = { n: 0 };
+    // Rebound when a step's click opens a new tab, so later steps drive that page.
+    let activePage = page;
     const signalCounter = { n: 0 };
     const recentCaptures = [];
     const recentCaptureMeta = [];
@@ -11274,7 +13151,17 @@ async function runHealingFlow(deps) {
     let submitVerified = false;
     let submitStepSkipped = false;
     let lastStepIndex = -1;
-    const stopCapture = wireSignalCapture(page, {
+    const liveOriginOf = (target) => {
+        try {
+            return new URL(target.url()).origin;
+        }
+        catch {
+            return "";
+        }
+    };
+    // Seeded so the first step does not re-gate; the initial gate lives with the caller's goto.
+    let lastOrigin = liveOriginOf(activePage);
+    const wireCapture = (target) => wireSignalCapture(target, {
         counter,
         signalCounter,
         recentCaptures,
@@ -11282,13 +13169,15 @@ async function runHealingFlow(deps) {
         getCurrentPhase: () => "flow",
         getCurrentPageOrigin: () => {
             try {
-                return new URL(page.url()).origin;
+                return new URL(activePage.url()).origin;
             }
             catch {
                 return "";
             }
         },
     });
+    // Listeners on earlier pages stay wired (a prior tab can still emit) and all stop on exit.
+    const stopFns = [wireCapture(page)];
     const flowHasSubmitSemanticsFlag = flowHasSubmitSemantics({
         steps,
         submitEndpointPattern: deps.submitEndpointPattern ?? null,
@@ -11315,19 +13204,27 @@ async function runHealingFlow(deps) {
             // legitimately-absent optional step, and the flow's own step count
             // never quietly reaches `steps.length` past the point of death.
             try {
-                page.url();
+                activePage.url();
             }
             catch (err) {
                 throw new errors_2.SessionTimeoutError(`${formatStepPrefix(i, () => steps.length)} session appears closed/dead (page.url() threw: ${(0, errors_1.toErrorMessage)(err)}) — aborting after ${i} of ${steps.length} steps completed`);
             }
             lastStepIndex = i;
+            // A cross-origin hop (redirect, new tab, navigateTo) lands on a SPA the initial
+            // readiness gate never covered; wait for hydration before the step probes a shell.
+            const currentOrigin = liveOriginOf(activePage);
+            if (currentOrigin !== "" && currentOrigin !== lastOrigin) {
+                logger.info(`origin changed ${lastOrigin || "(none)"} → ${currentOrigin}; re-gating on SPA hydration`);
+                await (0, spa_readiness_1.regateSpaAfterOriginChange)(activePage, logger);
+                lastOrigin = currentOrigin;
+            }
             // A navigateTo step is a direct page.goto, not an act/observe against
             // the current DOM, so it has no target frame to resolve and skips
             // straight to executeNavigateStep instead of the self-heal cascade.
             let stepPromise;
             if (s.navigateTo !== undefined) {
                 stepPromise = executeNavigateStep({
-                    page,
+                    page: activePage,
                     url: s.navigateTo,
                     optional: s.optional,
                     logger,
@@ -11340,11 +13237,18 @@ async function runHealingFlow(deps) {
                 // reachable, paralleling the recon CLI's per-step resolution. `resolveFrameTarget`
                 // falls back to the main-frame target when `frameSelector` is null/unresolvable,
                 // so this is a no-op for every flow that doesn't declare one.
-                const frameTarget = await (0, frame_target_1.resolveFrameTarget)(page, deps.frameSelector);
+                const frameTarget = await (0, frame_target_1.resolveFrameTarget)(activePage, deps.frameSelector);
                 await (0, frame_target_1.waitForChildFrameReady)(frameTarget);
                 stepPromise = executeStepWithHealing({
                     stagehand,
-                    page,
+                    page: activePage,
+                    onPageAdopted: (adopted) => {
+                        if (adopted === activePage)
+                            return;
+                        activePage = adopted;
+                        stopFns.push(wireCapture(adopted));
+                    },
+                    abortSignal: deps.abortSignal,
                     step: s.instruction,
                     optional: s.optional,
                     upload: s.upload,
@@ -11389,7 +13293,7 @@ async function runHealingFlow(deps) {
             // runHealingFlow resolve as if the flow succeeded. Mirrors the same
             // gate in recon-browser.ts's step loop.
             try {
-                page.url();
+                activePage.url();
             }
             catch (err) {
                 throw new errors_2.SessionTimeoutError(`${formatStepPrefix(i, () => steps.length)} session appears closed/dead (page.url() threw: ${(0, errors_1.toErrorMessage)(err)}) after step ${i} of ${steps.length} resolved`);
@@ -11404,7 +13308,8 @@ async function runHealingFlow(deps) {
         }
     }
     finally {
-        stopCapture();
+        for (const stop of stopFns)
+            stop();
     }
     return { submitVerified, submitStepSkipped, lastStepIndex };
 }