@enricai/barnacle 1.12.82 → 1.14.0

package/dist/scraper/flow-runner.js

@@ -34,6 +34,7 @@ exports.classifyStepSubmitIntent = classifyStepSubmitIntent;
 exports.isStepDeclaredNonSubmit = isStepDeclaredNonSubmit;
 exports.isStepSubmitShaped = isStepSubmitShaped;
 exports.isStepSettleWaitShaped = isStepSettleWaitShaped;
+exports.isGenuineFinalSubmit = isGenuineFinalSubmit;
 exports.isMidFlowSubmitShapedStep = isMidFlowSubmitShapedStep;
 exports.isCheckboxOrRadioIntentStep = isCheckboxOrRadioIntentStep;
 exports.shouldCaptureSelectionState = shouldCaptureSelectionState;
@@ -47,6 +48,7 @@ exports.windowHasAdvanceTransition = windowHasAdvanceTransition;
 exports.shouldVetoFallbackAdvance = shouldVetoFallbackAdvance;
 exports.isDomOnlyAdvanceVerified = isDomOnlyAdvanceVerified;
 exports.isNullVerdictAdvanceCredited = isNullVerdictAdvanceCredited;
+exports.isMidFlowAdvanceCredited = isMidFlowAdvanceCredited;
 exports.isClickViewSwapVerified = isClickViewSwapVerified;
 exports.selectionCountFromSignature = selectionCountFromSignature;
 exports.shouldReadbackFillOnActSuccess = shouldReadbackFillOnActSuccess;
@@ -74,6 +76,7 @@ exports.extractGaEventEvidence = extractGaEventEvidence;
 exports.normalizeDateValue = normalizeDateValue;
 exports.fillHtml5DateTimeInput = fillHtml5DateTimeInput;
 exports.fillTextDatepickerInput = fillTextDatepickerInput;
+exports.isDateSegmentAtSelector = isDateSegmentAtSelector;
 exports.verifyFillReadback = verifyFillReadback;
 exports.verifyPromptSelectorCommitted = verifyPromptSelectorCommitted;
 exports.tailRetargetPhrasesForStep = tailRetargetPhrasesForStep;
@@ -92,12 +95,15 @@ exports.parseSegmentedDateValue = parseSegmentedDateValue;
 exports.resolveSegmentedDateGroup = resolveSegmentedDateGroup;
 exports.parseSegmentedPartStep = parseSegmentedPartStep;
 exports.trySegmentedDateSpinbuttonPrimitive = trySegmentedDateSpinbuttonPrimitive;
+exports.runSegmentedDateSpinbuttonPrimitive = runSegmentedDateSpinbuttonPrimitive;
 exports.parseRadioStep = parseRadioStep;
 exports.parseWidgetOptionClickStep = parseWidgetOptionClickStep;
 exports.parseCheckStep = parseCheckStep;
 exports.parseCheckStateStep = parseCheckStateStep;
 exports.pollEnumerate = pollEnumerate;
 exports.waitForTransitionBody = waitForTransitionBody;
+exports.settleAndSnapshotPostClick = settleAndSnapshotPostClick;
+exports.readMidFlowPostClickAdvance = readMidFlowPostClickAdvance;
 exports.injectCaptchaTokenAndSubmit = injectCaptchaTokenAndSubmit;
 exports.submitCaptchaGatedForm = submitCaptchaGatedForm;
 exports.trySelectPrimitive = trySelectPrimitive;
@@ -158,6 +164,8 @@ 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 runtime_capture_store_1 = require("./runtime-capture-store");
+const segmented_date_spinbutton_1 = require("./segmented-date-spinbutton");
 const session_teardown_1 = require("./session-teardown");
 const spa_readiness_1 = require("./spa-readiness");
 const stagehand_guard_1 = require("./stagehand-guard");
@@ -166,7 +174,6 @@ 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");
 var spa_readiness_2 = require("./spa-readiness");
 Object.defineProperty(exports, "waitForSpaReady", { enumerable: true, get: function () { return spa_readiness_2.waitForSpaReady; } });
@@ -1109,7 +1116,9 @@ function prepareFailureDumpBody(raw) {
 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 }; })()`;
+/** Bound on {@link StepSnapshot.visibleText}, keeping a pathological page from bloating snapshots. */
+const VISIBLE_TEXT_EXCERPT_CHARS = 3000;
+const DOM_SNAPSHOT_EXPR = `(() => { const b = document.body; if (!b) return { html: 0, text: "", values: "", state: "", full: "", digest: "" }; 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; const norm = t.replace(/\\s+/g, " ").trim(); let th = 2166136261; for (let tk = 0; tk < norm.length; tk++) { th ^= norm.charCodeAt(tk); th = Math.imul(th, 16777619); } return { html: (b.outerHTML || "").length, text: t.length + ":" + t.slice(0, 200), values, state, full: norm.slice(0, ${VISIBLE_TEXT_EXCERPT_CHARS}), digest: (th >>> 0).toString(36) + ":" + norm.length }; })()`;
 /** 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;
 const FIELD_VALUES_AT_FAILURE_MAX_VALUE_LENGTH = 500;
@@ -1175,7 +1184,15 @@ async function readPageQuiescence(target) {
         : idle;
 }
 /**
- * Reads only the visible-text signature settle polls on. Going through
+ * Installs the quiescence probe before a click, because it only starts counting
+ * requests and mutations from its first read and a post-click install would miss
+ * everything the click triggers immediately.
+ */
+async function armPageQuiescence(target) {
+    await readPageQuiescence(target);
+}
+/**
+ * Reads only the visible-text key settle polls on. Going through
  * {@link snapshotPage} also read the frame URL, which rejects once a submit
  * detaches the OOPIF and would abort the settle mid-poll; a failed read here
  * degrades to the empty signature like the snapshot's own text read does.
@@ -1184,35 +1201,16 @@ async function readSettleTextSignature(target) {
     const result = await Promise.resolve(target.evaluate(DOM_SNAPSHOT_EXPR)).catch(() => null);
     if (result === null || typeof result !== "object")
         return "";
-    const { text } = result;
-    return typeof text === "string" ? text : "";
+    const { text, digest } = result;
+    return (0, click_settle_1.settleTextKey)(typeof text === "string" ? text : "", typeof digest === "string" ? digest : undefined);
 }
 /**
  * Settles after a click using the target's own text signature and in-page
  * quiescence reader, so every post-click site decides from the same settle
  * signal instead of hand-building the readers.
  */
-async function settleWithPageQuiescence(page, target, signalCounter, preNetworkCount, submitShaped, preVisibleTextSignature, advanced) {
-    await (0, click_settle_1.settleAfterClick)(page, signalCounter, preNetworkCount, submitShaped, () => readSettleTextSignature(target), preVisibleTextSignature, () => readPageQuiescence(target), advanced);
-}
-/**
- * Builds the "has the page finished advancing" test a mid-flow submit settles
- * against. It is the body-swap half of the {@link hasPageAdvanced} the phantom
- * classifier credits with, so a header that flipped before its body re-rendered
- * keeps settle polling while the classifier still credits whatever is left once
- * the wait is spent.
- * Undefined for any other step, which keeps the plain quiet-window settle.
- */
-function pageAdvancedSince(preVisibleTextSignature, midFlowSubmit) {
-    if (!midFlowSubmit)
-        return undefined;
-    const pre = {
-        networkCount: 0,
-        url: "",
-        bodyHtmlLength: 0,
-        visibleTextSignature: preVisibleTextSignature,
-    };
-    return (visibleTextSignature) => (0, phantom_click_1.hasPageBodySwapped)(pre, { ...pre, visibleTextSignature });
+async function settleWithPageQuiescence(page, target, signalCounter, preNetworkCount, submitShaped, preVisibleTextSignature, preVisibleTextDigest) {
+    await (0, click_settle_1.settleAfterClick)(page, signalCounter, preNetworkCount, submitShaped, () => readSettleTextSignature(target), (0, click_settle_1.settleTextKey)(preVisibleTextSignature, preVisibleTextDigest), () => readPageQuiescence(target));
 }
 /**
  * Captures the pre/post signal triple the submit-verify cascade diffs.
@@ -1231,6 +1229,8 @@ function pageAdvancedSince(preVisibleTextSignature, midFlowSubmit) {
 async function snapshotPage(target, signalCounter, page, captureSelectionState = false) {
     let bodyHtmlLength = 0;
     let visibleTextSignature = "";
+    let visibleText = "";
+    let visibleTextDigest = "";
     let formValueSignature = "";
     let selectionStateSignature = "";
     try {
@@ -1243,6 +1243,10 @@ async function snapshotPage(target, signalCounter, page, captureSelectionState =
             typeof result.text === "string") {
             bodyHtmlLength = result.html;
             visibleTextSignature = result.text;
+            const rawFull = result.full;
+            visibleText = typeof rawFull === "string" ? rawFull : "";
+            const rawDigest = result.digest;
+            visibleTextDigest = typeof rawDigest === "string" ? rawDigest : "";
             const rawValues = result.values;
             formValueSignature = typeof rawValues === "string" ? rawValues : "";
             const rawState = result.state;
@@ -1285,6 +1289,8 @@ async function snapshotPage(target, signalCounter, page, captureSelectionState =
         url,
         bodyHtmlLength,
         visibleTextSignature,
+        visibleText,
+        visibleTextDigest: visibleTextDigest === "" ? undefined : visibleTextDigest,
         formValueSignature,
         selectionStateSignature,
         selectionStateByXpath,
@@ -1584,12 +1590,20 @@ function isStepSettleWaitShaped(params) {
     return isStepSubmitShaped(params) || isAdvanceStep(params.step);
 }
 /**
- * Submit-shaped but NOT the flow's final step: a mid-flow advancing submit
+ * The single definition of a genuine final submit: the last slot of a flow
+ * that has submit semantics. A final slot without them is mid-flow.
+ */
+function isGenuineFinalSubmit(params) {
+    return params.isFinalStep && params.flowHasSubmitSemantics;
+}
+/**
+ * Submit-shaped but NOT the flow's genuine final submit (a final slot without
+ * submit semantics, e.g. after a replan trims the tail, is still mid-flow): 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)
+    if (isGenuineFinalSubmit(params))
         return false;
     return isStepSubmitShaped(params) || params.elementSubmitShaped === true;
 }
@@ -1719,15 +1733,7 @@ function latestCaptureIndex(recentCaptures) {
  * so callers scan in capture order. Returns [] when the dir is unreadable.
  */
 function capturesAfterIndex(preIdx, capturesDir) {
-    let entries;
-    try {
-        entries = (0, node_fs_1.readdirSync)(capturesDir);
-    }
-    catch {
-        return [];
-    }
-    return entries
-        .filter((f) => f.endsWith(".json") && !f.endsWith(".decoded.json"))
+    return (0, runtime_capture_store_1.listCaptureFiles)(capturesDir)
         .map((f) => ({ f, idx: parseCaptureIndex(f) }))
         .filter((e) => e.idx !== null && e.idx > preIdx)
         .sort((a, b) => a.idx - b.idx)
@@ -1758,7 +1764,7 @@ function windowHasTransitionBody(params) {
     const { preIdx, advanceTransitionBodyPattern } = params;
     if (!advanceTransitionBodyPattern)
         return false;
-    const capturesDir = params.capturesDir ?? (0, recon_shared_1.resolveReconRunDir)().graphqlDir;
+    const capturesDir = params.capturesDir ?? (0, runtime_capture_store_1.defaultCapturesDir)();
     let rx;
     try {
         rx = new RegExp(advanceTransitionBodyPattern);
@@ -1768,8 +1774,9 @@ function windowHasTransitionBody(params) {
     }
     for (const filename of capturesAfterIndex(preIdx, capturesDir)) {
         try {
-            const raw = (0, node_fs_1.readFileSync)((0, node_path_1.join)(capturesDir, filename), "utf8");
-            const capture = JSON.parse(raw);
+            const capture = (0, runtime_capture_store_1.readCaptureFile)(capturesDir, filename);
+            if (!capture)
+                continue;
             const body = typeof capture.requestPostData === "string"
                 ? capture.requestPostData
                 : JSON.stringify(capture.requestPostData ?? "");
@@ -1800,7 +1807,7 @@ function windowHasAdvanceTransition(params) {
     const { preIdx, advanceTransitionBodyPattern } = params;
     if (!advanceTransitionBodyPattern)
         return false;
-    const capturesDir = params.capturesDir ?? (0, recon_shared_1.resolveReconRunDir)().graphqlDir;
+    const capturesDir = params.capturesDir ?? (0, runtime_capture_store_1.defaultCapturesDir)();
     let rx;
     try {
         rx = new RegExp(advanceTransitionBodyPattern);
@@ -1810,8 +1817,9 @@ function windowHasAdvanceTransition(params) {
     }
     for (const filename of capturesAfterIndex(preIdx, capturesDir)) {
         try {
-            const raw = (0, node_fs_1.readFileSync)((0, node_path_1.join)(capturesDir, filename), "utf8");
-            const capture = JSON.parse(raw);
+            const capture = (0, runtime_capture_store_1.readCaptureFile)(capturesDir, filename);
+            if (!capture)
+                continue;
             const body = typeof capture.requestPostData === "string"
                 ? capture.requestPostData
                 : JSON.stringify(capture.requestPostData ?? "");
@@ -1881,13 +1889,29 @@ function isDomOnlyAdvanceVerified(params) {
  * 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.
+ * false and keep the DOM-state fallback / failure path. Invalid markers
+ * describe the page the click landed on, so they only veto a network-only
+ * credit, never a settled page advance.
  */
 function isNullVerdictAdvanceCredited(params) {
-    if (!params.midFlowSubmit || !params.judgeUnavailable || params.invalidMarkerCount > 0) {
+    if (!params.midFlowSubmit || !params.judgeUnavailable)
         return false;
-    }
-    return params.networkAdvanced || params.pageAdvanced;
+    if (params.pageAdvanced)
+        return true;
+    return params.networkAdvanced && params.invalidMarkerCount <= 0;
+}
+/**
+ * Single decision both post-click judge sites use to credit a mid-flow submit
+ * on the page's own demonstrable advance, so a stale title or missing network
+ * the judge reads with final-submit eyes cannot undo it. `signalAdvanced` is the
+ * site's own settled-advance signal (the primary click's view-swap credit, the
+ * fallback click's effective verdict); the null-verdict path covers an
+ * unavailable judge.
+ */
+function isMidFlowAdvanceCredited(params) {
+    if (params.midFlowSubmit && params.signalAdvanced)
+        return true;
+    return isNullVerdictAdvanceCredited(params);
 }
 /**
  * Client-side view-swap verification gate. Credits a click that produces
@@ -1980,7 +2004,7 @@ function isNullVerdictAdvanceCredited(params) {
  *
  * **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
+ * shared {@link hasSettledPageAdvanced} 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
@@ -2003,7 +2027,6 @@ function isClickViewSwapVerified(params) {
         midFlowActRan &&
         destinationPlausible !== false &&
         !isAdvanceWithPattern &&
-        invalidMarkerDelta <= 0 &&
         textChanged &&
         pageAdvanced) {
         return true;
@@ -2121,7 +2144,7 @@ async function countNgInvalidContainers(target) {
 function describeAttemptEffectSignals(pre, post, recentCaptureMeta, preMetaLength) {
     const bytesDelta = post.bodyHtmlLength - pre.bodyHtmlLength;
     const networkDelta = post.networkCount - pre.networkCount;
-    const textChanged = post.visibleTextSignature !== pre.visibleTextSignature;
+    const textChanged = (0, phantom_click_1.hasVisibleTextChanged)(pre, post);
     const valueChanged = post.formValueSignature !== pre.formValueSignature;
     const selectionStateChanged = post.selectionStateSignature !== pre.selectionStateSignature;
     const windowCaptures = recentCaptureMeta.slice(preMetaLength);
@@ -2262,9 +2285,11 @@ function shouldSkipTechnique(params) {
  * navigations, partial DOM reflows, etc.).
  */
 function isSubmitRevealedInvalid(params) {
-    const { isFinalStep, requireSubmitEndpoint, resolvedMethod, effectSignals, preSubmitInvalidCount, postAttemptInvalidCount, } = params;
+    const { isFinalStep, requireSubmitEndpoint, resolvedMethod, effectSignals, preSubmitInvalidCount, postAttemptInvalidCount, midFlowAdvanced = false, } = params;
     if (!isFinalStep)
         return false;
+    if (midFlowAdvanced)
+        return false;
     if (!requireSubmitEndpoint)
         return false;
     if (resolvedMethod !== "click")
@@ -2955,32 +2980,36 @@ const STEP_REJUDGE_COMPARE_CHARS = 1200;
  */
 async function judgeStepOutcome(params) {
     const { client, captureFn, step, isFinalStep, target } = params;
-    if (isFinalStep) {
+    const genuineFinal = isGenuineFinalSubmit({
+        isFinalStep,
+        flowHasSubmitSemantics: params.flowHasSubmitSemantics,
+    });
+    if (genuineFinal) {
         return (0, verify_submit_1.verifySubmitWithLLM)({
             client,
             input: {
-                ...(await buildSubmitJudgeStepContext({ step, isFinalStep, target })),
+                ...(await buildSubmitJudgeStepContext({ step, isFinalStep: genuineFinal, target })),
                 ...params.submitInput,
             },
             captureFn,
         });
     }
-    await settleWithPageQuiescence(params.page, target, params.signalCounter, params.preNetworkCount, isStepSettleWaitShaped({
-        step,
-        submitStep: params.submitStep,
-        isFinalStep,
-        flowHasSubmitSemantics: params.flowHasSubmitSemantics,
-    }) || params.elementSubmitShaped === true, params.preVisibleTextSignature, pageAdvancedSince(params.preVisibleTextSignature, isMidFlowSubmitShapedStep({
-        step,
-        submitStep: params.submitStep,
-        isFinalStep,
-        flowHasSubmitSemantics: params.flowHasSubmitSemantics,
-        elementSubmitShaped: params.elementSubmitShaped,
-    })));
-    const colon = params.preVisibleTextSignature.indexOf(":");
-    const beforeText = (colon === -1 ? params.preVisibleTextSignature : params.preVisibleTextSignature.slice(colon + 1))
+    const hasSettledRead = params.settledPostVisibleText !== undefined;
+    if (!hasSettledRead) {
+        await settleWithPageQuiescence(params.page, target, params.signalCounter, params.preNetworkCount, isStepSettleWaitShaped({
+            step,
+            submitStep: params.submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: params.flowHasSubmitSemantics,
+        }) || params.elementSubmitShaped === true, params.preVisibleTextSignature, params.preVisibleTextDigest);
+    }
+    const signatureColon = params.preVisibleTextSignature.indexOf(":");
+    const signatureHead = (signatureColon === -1
+        ? params.preVisibleTextSignature
+        : params.preVisibleTextSignature.slice(signatureColon + 1))
         .replace(/\s+/g, " ")
         .trim();
+    const beforeText = params.preVisibleText ? params.preVisibleText : signatureHead;
     const judgeText = (afterText) => (0, verify_step_advanced_1.verifyStepAdvancedWithLLM)({
         client,
         input: {
@@ -2992,7 +3021,7 @@ async function judgeStepOutcome(params) {
         captureFn,
     });
     const rejudgeIfTextMoved = async (first, judgedText) => {
-        if (first === null || first.advanced)
+        if (first === null || first.advanced || hasSettledRead)
             return first;
         await params.page.waitForTimeout(STEP_REJUDGE_DELAY_MS);
         const laterText = await probeVisibleTextForJudge(target);
@@ -3002,7 +3031,9 @@ async function judgeStepOutcome(params) {
         }
         return (await judgeText(laterText)) ?? first;
     };
-    const afterText = await probeVisibleTextForJudge(target);
+    const afterText = hasSettledRead
+        ? (params.settledPostVisibleText ?? "")
+        : await probeVisibleTextForJudge(target);
     const firstVerdict = await judgeText(afterText);
     const verdict = await rejudgeIfTextMoved(firstVerdict, afterText);
     if (verdict === null)
@@ -3116,7 +3147,7 @@ function extractSubmitFailureEvidence(recentCaptureFilenames,
  * deterministic hostname equality. Empty list / "any-4xx" mode disables
  * the host filter and returns any 4xx in the window.
  */
-ownBackendHostnames, capturesDir = (0, recon_shared_1.resolveReconRunDir)().graphqlDir, mode = "strict") {
+ownBackendHostnames, capturesDir = (0, runtime_capture_store_1.defaultCapturesDir)(), mode = "strict") {
     if (recentCaptureFilenames.length === 0)
         return "";
     if (mode === "strict" && ownBackendHostnames.length === 0)
@@ -3128,9 +3159,9 @@ ownBackendHostnames, capturesDir = (0, recon_shared_1.resolveReconRunDir)().grap
             continue;
         seen.add(filename);
         try {
-            const path = (0, node_path_1.join)(capturesDir, filename);
-            const raw = (0, node_fs_1.readFileSync)(path, "utf8");
-            const capture = JSON.parse(raw);
+            const capture = (0, runtime_capture_store_1.readCaptureFile)(capturesDir, filename);
+            if (!capture)
+                continue;
             if (typeof capture.url !== "string")
                 continue;
             if (mode === "strict") {
@@ -3207,7 +3238,7 @@ ownBackendHostnames, capturesDir = (0, recon_shared_1.resolveReconRunDir)().grap
  * Returns a numbered evidence list. Empty string when no GA collect
  * captures are present. Advisory — never load-bearing.
  */
-function extractGaEventEvidence(recentCaptureFilenames, capturesDir = (0, recon_shared_1.resolveReconRunDir)().graphqlDir) {
+function extractGaEventEvidence(recentCaptureFilenames, capturesDir = (0, runtime_capture_store_1.defaultCapturesDir)()) {
     if (recentCaptureFilenames.length === 0)
         return "";
     const records = [];
@@ -3217,9 +3248,9 @@ function extractGaEventEvidence(recentCaptureFilenames, capturesDir = (0, recon_
             continue;
         seen.add(filename);
         try {
-            const path = (0, node_path_1.join)(capturesDir, filename);
-            const raw = (0, node_fs_1.readFileSync)(path, "utf8");
-            const capture = JSON.parse(raw);
+            const capture = (0, runtime_capture_store_1.readCaptureFile)(capturesDir, filename);
+            if (!capture)
+                continue;
             if (typeof capture.url !== "string")
                 continue;
             let url;
@@ -3591,6 +3622,25 @@ async function fillTextDatepickerInput(target, selector, value) {
         return { filled: false, postValue: "", strategy: "none" };
     }
 }
+/**
+ * Pre-write check for the observe-act fill override: a lone-segment write
+ * (insertText) cannot compose a date, so callers refuse before any write.
+ * An evaluate error propagates so the attempt fails rather than writing blind;
+ * only a selector form with no XPath body (nothing to resolve) answers false.
+ */
+async function isDateSegmentAtSelector(target, selector) {
+    const xpath = xpathBodyForEvaluate(selector);
+    if (xpath === null)
+        return false;
+    const expr = `(() => {
+    const result = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = result.singleNodeValue;
+    if (!el) return false;
+    ${segmented_date_spinbutton_1.SEGMENT_OWNER_JS}
+    return isDateSegment(el);
+  })()`;
+    return (await target.evaluate(expr)) === true;
+}
 /**
  * Read back an element's value after a fill action and compare to the
  * expected value. Catches silent-value-rejection cases that the verifier's
@@ -3628,7 +3678,7 @@ async function verifyFillReadback(target, selector, expectedValue) {
     if (!el) return null;
     const tag = el.tagName ? el.tagName.toLowerCase() : "";
     let actual = "";
-    ${SEGMENT_OWNER_JS}
+    ${segmented_date_spinbutton_1.SEGMENT_OWNER_JS}
     if (isDateSegment(el)) {
       return { outcome: "segment", postValue: el.value || el.getAttribute("aria-valuenow") || "", tag };
     }
@@ -4265,6 +4315,47 @@ async function resolvedClickTargetIsSubmitShaped(target, selector, xpathTail = n
         return false;
     }
 }
+/**
+ * Canonical key for an absolute xpath so Stagehand's `/html/body/div/button`
+ * (index omitted when sole of its tag) and this module's `/html[1]/body[1]/
+ * div[1]/button[1]` compare equal: a node's first-of-tag and sole-of-tag
+ * forms can never coexist under one parent, so dropping `[1]` is injective.
+ */
+function canonicalAbsoluteXpath(selector) {
+    const body = xpathBodyForEvaluate(selector);
+    return body?.startsWith("/") ? body.replace(/\[1\]/g, "").toLowerCase() : null;
+}
+/**
+ * Canonical xpaths of every control on the page that is submit-shaped right
+ * now, read before an act clicks anything. The act performs the click itself,
+ * and a view swap removes the control with the page, so the only read that
+ * cannot be blinded by the transition is one taken beforehand — and one that
+ * does not depend on observe having resolved the same control the act later
+ * clicks. Empty on any read failure: absence never manufactures a shape.
+ */
+async function readSubmitShapedControlXpaths(target) {
+    const expr = `(() => {
+    const xpathOf = ${XPATH_OF_FN_SRC};
+    const isSubmitShaped = ${submit_control_1.SUBMIT_SHAPE_EXPR};
+    const out = [];
+    for (const el of document.querySelectorAll("button, input, a, [role='button'], [type='submit'], [onclick], [tabindex]")) {
+      if (isSubmitShaped(el)) out.push(xpathOf(el));
+    }
+    return out;
+  })()`;
+    try {
+        const result = await target.evaluate(expr);
+        if (!Array.isArray(result))
+            return new Set();
+        return new Set(result
+            .filter((x) => typeof x === "string")
+            .map(canonicalAbsoluteXpath)
+            .filter((x) => x !== null));
+    }
+    catch {
+        return new Set();
+    }
+}
 /**
  * True when the primary (Stagehand-recorded) xpath is unresolvable and only
  * `xpathTailForRetarget`'s loose tag+same-tag-sibling-position re-anchor
@@ -5468,7 +5559,7 @@ function pickSegmentedDateGroup(instruction, groups, value, compatible) {
     // A group under another heading is not the field the step names, however
     // well its label matches: the step's own words must find the section.
     // A section that only repeats the group's own label is no heading at all
-    // (Workday enumerates "From*" as both), so it cannot name another section.
+    // (a widget may enumerate "From*" as both), so it cannot name another section.
     const namesOtherSection = (group) => {
         const section = segmentedDateTokens(group.section ?? "");
         const label = segmentedDateTokens(group.label ?? "");
@@ -5529,7 +5620,7 @@ function pickSegmentedDateGroup(instruction, groups, value, compatible) {
     if (leaders.length > 1) {
         // A nested group is one wrapper's slice of a larger date widget (e.g. the
         // Year half of "From MM/YYYY"), so it only ties with a standalone group of
-        // the same label when no section text separates them — Workday renders
+        // the same label when no section text separates them — a form may render
         // "Work Experience 1 From" and "Education 1 From" with no heading the
         // enumerator can see. The standalone group is the field the step names.
         const standalone = leaders.filter((i) => !groups[i]?.nested);
@@ -5542,71 +5633,13 @@ function pickSegmentedDateGroup(instruction, groups, value, compatible) {
     const only = groups.flatMap((g, i) => (compatible(g) && !g.nested ? [i] : []));
     return only.length === 1 ? (only[0] ?? null) : null;
 }
-/**
- * In-page helpers shared by the date-segment enumeration and the fill
- * readback so "is this spinbutton one segment of a multi-segment widget" has a
- * single definition; defines `spins`, `ownerOf` and `isDateSegment`.
- */
-const SEGMENT_OWNER_JS = `
-  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));
-  const norm = (s) => (s || "").replace(/\\s+/g, " ").trim();
-  const idText = (ids) => (ids || "").split(/\\s+/).map((id) => {
-    const ref = id ? document.getElementById(id) : null;
-    return ref ? norm(ref.textContent) : "";
-  }).join(" ");
-  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 tiedToSpin = (l) => l.querySelector("input,[role='spinbutton']") || (l.getAttribute("for") && spins.some((sp) => sp.id === l.getAttribute("for")));
-  const hasCaption = (node) => namedBy(node) !== "" || Array.from(node.querySelectorAll("label,legend")).some((l) => !tiedToSpin(l));
-  const captionOwnerOf = (el) => {
-    const explicit = el.closest("fieldset,[role='group']");
-    if (explicit) return explicit;
-    for (let node = el.parentElement; node && node !== document.body; node = node.parentElement) {
-      if (hasCaption(node)) return node;
-    }
-    return null;
-  };
-  const bareSpins = spins.filter((sp) => !captionOwnerOf(sp));
-  const hasOtherControl = (node) => Array.from(node.querySelectorAll("input,select,textarea")).some((c) => !spins.includes(c) && c.type !== "hidden");
-  // Segments that each sit in their own uncaptioned wrapper share no
-  // fieldset/caption, so the nearest ancestor holding several bare spinbuttons
-  // (and no other form control) is the widget they belong to.
-  const bareOwnerOf = (el) => {
-    for (let node = el.parentElement; node && node !== document.body; node = node.parentElement) {
-      if (hasOtherControl(node)) break;
-      if (bareSpins.filter((sp) => node.contains(sp)).length > 1) return node;
-    }
-    return el.parentElement;
-  };
-  const ownerOf = (el) => captionOwnerOf(el) || bareOwnerOf(el);
-  const isDateSegment = (el) => {
-    if (!el.getAttribute || el.getAttribute("role") !== "spinbutton" || !spins.includes(el)) return false;
-    const box = ownerOf(el);
-    return spins.filter((sp) => ownerOf(sp) === box).length > 1;
-  };
-`;
 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));
-  ${SEGMENT_OWNER_JS}
+  ${segmented_date_spinbutton_1.SEGMENT_OWNER_JS}
   if (spins.length === 0) return { groups: [] };
   const headingSibling = (node) => {
     let prevSib = node.previousElementSibling;
@@ -5660,15 +5693,21 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     const prior = seg.getAttribute(attr);
     seg.setAttribute(attr, prior ? prior + " " + token : token);
   };
-  const addGroup = (segs, box, nested) => {
+  const addGroup = (segs, box, nested, outer) => {
     const gi = groups.length;
     segs.forEach((seg, si) => mark(seg, gi + ":" + si));
     let inner = null;
-    for (let node = segs[0].parentElement; node && node !== box && box.contains(node) && !inner; node = node.parentElement) {
-      if (segs.every((seg) => node.contains(seg)) && hasCaption(node)) inner = node;
-    }
+    // A wrapper holding one segment is captioned by the nearest ancestor that
+    // holds that segment and no other: a caption over several segments names
+    // the whole date, never one slice of it.
+    const top = outer || box;
+    const soleOwner = (node) => !outer || spins.filter((sp) => node.contains(sp)).length === segs.length;
+    for (let node = segs[0].parentElement; node && node !== top && top.contains(node) && !inner; node = node.parentElement) {
+      if (segs.every((seg) => node.contains(seg)) && hasCaption(node) && soleOwner(node)) inner = node;
+    }
+    if (inner === box) inner = null;
     const labelBox = inner || box;
-    const own = namedBy(labelBox) || ownCaption(labelBox) || segs.map((seg) => idText(seg.getAttribute("aria-labelledby"))).filter(Boolean).join(" ");
+    const own = namedBy(labelBox) || ownCaption(labelBox) || segs.map((seg) => idText(seg.getAttribute("aria-labelledby"))).filter(Boolean).join(" ") || Array.from(new Set(segs.map((seg) => ownKey(seg)).filter(Boolean))).join(" ");
     const section = sectionOf(labelBox, Boolean(inner));
     groups.push({
       segmentMaxes: segs.map((seg, si) => maxOf(seg, si, segs.length)),
@@ -5691,7 +5730,7 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     }
     const wrap = seg.closest("label");
     if (wrap) parts.push(norm(wrap.textContent));
-    return keyOf(parts.filter(Boolean).join(" "));
+    return keyOf(Array.from(new Set(parts.filter(Boolean))).join(" "));
   };
   // A container's legend names the whole section; the field a segment belongs
   // to is the caption naming it, or the caption nearest before it with no other
@@ -5705,8 +5744,15 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
       if (el === boxLegend) return;
       if (el.matches("label,legend")) {
         const target = el.getAttribute("for");
-        if (isHidden(el) || el.querySelector("input,select,textarea,[role='spinbutton']") || (target && box.querySelector("[id='" + target + "']"))) return;
-        current = keyOf(el.textContent);
+        if (isHidden(el) || el.querySelector("input,select,textarea,[role='spinbutton']")) return;
+        const text = keyOf(el.textContent);
+        // A label tied to one of these segments names the field that segment
+        // opens; its text is only a part word ("Month") when it names nothing.
+        if (target && box.querySelector("[id='" + target + "']")) {
+          if (own.has(box.querySelector("[id='" + target + "']")) && text) current = text;
+          return;
+        }
+        current = text;
         return;
       }
       if (!own.has(el)) {
@@ -5729,10 +5775,8 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     }
     // 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]));
-      return;
-    }
+    const split = byParent.size > 1;
+    if (split) byParent.forEach((inner, parent) => nestedCandidates.push([inner, parent, box]));
     const keys = fieldKeys(segs, box);
     const runs = [];
     segs.forEach((seg, si) => {
@@ -5740,9 +5784,13 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
       if (last && last.key === keys[si]) last.segs.push(seg);
       else runs.push({ key: keys[si], segs: [seg] });
     });
-    runs.filter((run) => run.key).forEach((run) => captionRuns.push({ run, box, outerIndex, whole: run.segs.length === segs.length }));
+    // Segments that each sit in their own display wrapper still form one date
+    // when a shared caption names them, so the caption run is a candidate too;
+    // a run that is exactly one wrapper's segments is already that wrapper's group.
+    const isWrapperGroup = (run) => split && byParent.get(run.segs[0].parentElement).length === run.segs.length && run.segs.every((seg) => seg.parentElement === run.segs[0].parentElement);
+    runs.filter((run) => run.key && !isWrapperGroup(run)).forEach((run) => captionRuns.push({ run, box, outerIndex, whole: run.segs.length === segs.length }));
   });
-  nestedCandidates.forEach(([inner, parent]) => addGroup(inner, parent, true));
+  nestedCandidates.forEach(([inner, parent, outer]) => addGroup(inner, parent, true, outer));
   captionRuns.forEach(({ run, box, outerIndex, whole }) => {
     const outer = groups[outerIndex];
     const same = (a, b) => a.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() === b.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
@@ -5771,21 +5819,38 @@ const SEGMENTED_DATE_CLEAR_EXPR = `(() => {
  *
  * 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.
+ * garbles the segments. Returns a marker id on commit, or null on any
+ * non-commit. Callers that must tell "not applicable" from "refused" use
+ * `runSegmentedDateSpinbuttonPrimitive`.
  */
 async function trySegmentedDateSpinbuttonPrimitive(params) {
+    const outcome = await runSegmentedDateSpinbuttonPrimitive(params);
+    return outcome.kind === "committed" ? outcome.targetId : null;
+}
+/**
+ * Same as `trySegmentedDateSpinbuttonPrimitive` but distinguishes "this step
+ * is not a segmented date here" (fall through to the cascade) from "a
+ * width-compatible segment group exists and the primitive could not deliver"
+ * (refused: the cascade would write the value via insertText and garble the
+ * segments, so the caller must fail the step instead).
+ */
+async function runSegmentedDateSpinbuttonPrimitive(params) {
     const { page, target, instruction, logger } = params;
+    const notApplicable = { kind: "not-applicable" };
+    const refuse = (reason) => {
+        logger.warn(`segmented date primitive: refused: ${reason}`);
+        return { kind: "refused", reason };
+    };
+    let groupChosen = false;
     const whole = parseSegmentedDateValue(instruction);
     const part = parseSegmentedPartStep(instruction);
     if (!whole && !part)
-        return null;
+        return notApplicable;
     const sendCDP = frameCdpSender(page, target);
     try {
         const enumerated = (await target.evaluate(exports.SEGMENTED_DATE_ENUMERATE_EXPR));
         if (!enumerated?.groups?.length)
-            return null;
+            return notApplicable;
         const wholeGi = whole ? resolveSegmentedDateGroup(instruction, enumerated.groups) : null;
         const partStep = wholeGi === null ? part : null;
         const value = (wholeGi !== null ? whole : part);
@@ -5801,10 +5866,18 @@ async function trySegmentedDateSpinbuttonPrimitive(params) {
                 ? pickSegmentedDateGroup(instruction, enumerated.groups, partStep, partFits)
                 : null);
         if (gi === null) {
-            logger.info("segmented date primitive: no unambiguous group; falling through");
             await target.evaluate(SEGMENTED_DATE_CLEAR_EXPR);
-            return null;
+            const widthCompatible = enumerated.groups.some((group) => (whole !== null &&
+                group.segmentMaxes.reduce((sum, max) => sum + String(max).length, 0) ===
+                    whole.digits.length) ||
+                (partStep !== null && partFits(group)));
+            if (widthCompatible) {
+                return refuse("a width-compatible date group exists but the target group is ambiguous");
+            }
+            logger.info("segmented date primitive: no compatible group; falling through");
+            return notApplicable;
         }
+        groupChosen = true;
         const maxes = enumerated.groups[gi]?.segmentMaxes ?? [];
         const widths = maxes.map((max) => String(max).length);
         const onlySegment = partStep ? partOf(enumerated.groups[gi]) : null;
@@ -5901,15 +5974,16 @@ async function trySegmentedDateSpinbuttonPrimitive(params) {
             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;
+            return refuse(`readback ${maskDateDigits(JSON.stringify(actual))} != ${maskDateDigits(JSON.stringify(expected))}`);
         }
         logger.info(`segmented date primitive: committed segments ${maskDateDigits(JSON.stringify(actual))}`);
-        return `segmented-date-${gi}`;
+        return { kind: "committed", targetId: `segmented-date-${gi}` };
     }
     catch (err) {
+        if (groupChosen)
+            return refuse(`delivery threw: ${(0, errors_1.toErrorMessage)(err)}`);
         logger.warn(`segmented date primitive: threw: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
-        return null;
+        return notApplicable;
     }
 }
 /**
@@ -6275,15 +6349,103 @@ function isNavigatingEvaluateRejection(error) {
         message.includes("no frame for given id found") ||
         GENERIC_CONTENT_FREE_EVAL_REJECTION_MESSAGES.has(message.trim()));
 }
+const DEFAULT_POST_CLICK_SETTLE_IO = {
+    settle: settleWithPageQuiescence,
+    snapshot: snapshotPage,
+};
+/**
+ * Re-settle rounds granted to a post-click page whose header flipped but whose
+ * body has not re-rendered yet. Each round waits the settle's own idle
+ * allowance, so the rounds together span the settle's MAX_MS ceiling rather
+ * than a fixed guess; a held-still text ends the loop sooner.
+ */
+const HEADER_ONLY_RESETTLE_ROUNDS = Math.floor(click_settle_1.MAX_MS / click_settle_1.IDLE_GIVE_UP_MS);
+/**
+ * Re-reads the post-click page while only its header has flipped. One
+ * settle-then-snapshot moment can land between a header flip and the body
+ * re-render that follows it, so the verdict waits for the body or for the text
+ * to hold still through the whole re-settle budget, and only then reads the
+ * header flip as the page's final state (`settled`): a single quiet round
+ * cannot distinguish a finished page from a body that re-renders later. Each round settles against the
+ * pre-click text, so the header flip stays movement and the quiet window, not the silent no-op
+ * give-up, decides how long a body re-render is waited for. Bounded; a page whose body already swapped
+ * returns at once, and one showing no change gets a single probe round so a
+ * re-render that lands after the first snapshot is still seen.
+ */
+async function resettleThroughHeaderOnlyFlip(page, target, signalCounter, pre, post, io = DEFAULT_POST_CLICK_SETTLE_IO) {
+    let current = post;
+    for (let round = 0; round < HEADER_ONLY_RESETTLE_ROUNDS; round++) {
+        const moved = (0, phantom_click_1.hasVisibleTextChanged)(pre, current);
+        if (moved && (0, phantom_click_1.hasPageBodySwapped)(pre, current))
+            return round > 0 ? { ...current, settled: true } : current;
+        if (!moved) {
+            // A click unseen to move anything gets one settle-free re-read, so a genuine
+            // no-op adds no wait to its give-up bound.
+            if (round > 0)
+                return current;
+            const probe = await io.snapshot(target, signalCounter, page);
+            if (!(0, phantom_click_1.hasVisibleTextChanged)(pre, probe))
+                return current;
+            current = probe;
+            continue;
+        }
+        await io.settle(page, target, signalCounter, current.networkCount, true, pre.visibleTextSignature, pre.visibleTextDigest);
+        const next = await io.snapshot(target, signalCounter, page);
+        const heldStill = !(0, phantom_click_1.hasVisibleTextChanged)(current, next);
+        current = next;
+        if (heldStill && !(0, phantom_click_1.hasPageBodySwapped)(pre, current))
+            return { ...current, settled: true };
+    }
+    return current;
+}
+/**
+ * Text baseline of the step-start page with the attempt's own network count, so
+ * a late re-render an earlier attempt already absorbed into `pre` still reads as
+ * movement to the settle while only this click's requests count as its own.
+ */
+function withNetworkBaseline(baseline, pre) {
+    return { ...baseline, networkCount: pre.networkCount };
+}
+/**
+ * Single owner of the settle -> snapshot -> header-only resettle sequence, so
+ * every post-click site applies the same settled-ness rule. A click that cannot
+ * trigger a round-trip is snapshotted as-is. The resettle does not depend on
+ * `waitForMutations`, since an unflagged step can still advance a page whose
+ * body re-renders late.
+ */
+async function settleSnapshotAndResettle(target, signalCounter, page, pre, mayTriggerRoundTrip, waitForMutations, io) {
+    if (page && mayTriggerRoundTrip)
+        await io.settle(page, target, signalCounter, pre.networkCount, waitForMutations, pre.visibleTextSignature, pre.visibleTextDigest);
+    const post = await io.snapshot(target, signalCounter, page);
+    return page && mayTriggerRoundTrip
+        ? resettleThroughHeaderOnlyFlip(page, target, signalCounter, pre, post, io)
+        : post;
+}
 /**
  * Settles after a click and returns the post-click snapshot, so the settle
  * wait and the phantom classifier decide from the same reader and baseline.
  * Without a page there is nothing to wait on and the snapshot is taken as-is.
+ * `io` lets a caller that owns its own seam (recon-browser's pre-replan
+ * short-circuit) route the settle and the snapshot through the functions it
+ * already imports, so the settled read there is the same one every other site
+ * makes.
+ */
+async function settleAndSnapshotPostClick(target, signalCounter, page, pre, waitForMutations = true, io = DEFAULT_POST_CLICK_SETTLE_IO) {
+    return settleSnapshotAndResettle(target, signalCounter, page, pre, true, waitForMutations, io);
+}
+/**
+ * Single mid-flow post-click advance read: picks the advance baseline (the
+ * step-start snapshot for a mid-flow submit, `pre` otherwise), gives it the
+ * attempt's network count, settles, re-settles through a header-only flip and
+ * judges advance against that same baseline, so every site credits a page that
+ * advanced from step start once it is quiescent.
  */
-async function settleAndSnapshotPostClick(target, signalCounter, page, pre, midFlowSubmit = false) {
-    if (page)
-        await settleWithPageQuiescence(page, target, signalCounter, pre.networkCount, true, pre.visibleTextSignature, pageAdvancedSince(pre.visibleTextSignature, midFlowSubmit));
-    return snapshotPage(target, signalCounter, page);
+async function readMidFlowPostClickAdvance(args) {
+    const advanceBaseline = args.midFlowSubmit
+        ? withNetworkBaseline(args.stepStartSnapshot, args.pre)
+        : args.pre;
+    const post = await settleSnapshotAndResettle(args.target, args.signalCounter, args.page, advanceBaseline, args.mayTriggerRoundTrip ?? true, args.waitForMutations ?? true, args.io ?? DEFAULT_POST_CLICK_SETTLE_IO);
+    return { post, advanceBaseline, pageAdvanced: (0, phantom_click_1.hasSettledPageAdvanced)(advanceBaseline, post) };
 }
 /**
  * Shared in-page discovery of the widget's callback, used identically by
@@ -6511,6 +6673,38 @@ async function injectCaptchaTokenAndSubmit(target, token, responseField = "h-cap
     await target.evaluate(dispatchChangeExpr).catch(() => undefined);
     return { injected, hasForm, callbackDiscovered };
 }
+/**
+ * Single assembly point for the mid-flow half of a phantom-click verdict, so
+ * the primary attempt and every bypass/retry site extend the same
+ * pre-URL destination exemption for a mid-flow submit, granted only on a
+ * settled page advance, identically instead of each re-deriving it.
+ */
+function midFlowDestinationPlausible(params) {
+    const { step, post, midFlowSubmit } = params;
+    const baseline = params.advanceBaseline;
+    return ((params.destinationPlausible ?? (0, phantom_click_1.isPlausibleStepDestination)(step, post.url)) ||
+        (midFlowSubmit &&
+            (0, phantom_click_1.hasSettledPageAdvanced)(baseline, post) &&
+            (0, phantom_click_1.isPlausibleStepDestination)(step, post.url, baseline.url)));
+}
+/**
+ * Classifies a submit-shaped click through the shared mid-flow verdict
+ * assembly used by the primary path and the n+16 / deep-submit / captcha /
+ * child-frame bypass sites.
+ */
+function classifySubmitShapedClick(params) {
+    const { pre, post, midFlowSubmit } = params;
+    return (0, phantom_click_1.classifyPhantomClick)({
+        actResultSuccess: params.actResultSuccess ?? true,
+        pre,
+        post,
+        elementStateChanged: params.elementStateChanged,
+        isSubmitShapedStep: midFlowSubmit || (params.isSubmitShapedStep ?? true),
+        isMidFlowSubmitStep: midFlowSubmit,
+        advanceBaseline: params.advanceBaseline,
+        destinationPlausible: midFlowDestinationPlausible(params),
+    });
+}
 /**
  * Explicit submit fallback for {@link injectCaptchaTokenAndSubmit} callers:
  * used only when the caller's own transition poll observed no advance after
@@ -6582,6 +6776,8 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
         const pre = verification
             ? await snapshotPage(target, verification.signalCounter, verification.page)
             : null;
+        if (pre)
+            await armPageQuiescence(target);
         const clickResult = await target
             .evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(top.deepIndex))
             .catch((err) => {
@@ -6592,14 +6788,30 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
         if (clickResult.clicked) {
             if (!pre || !verification)
                 return true;
-            const post = await settleAndSnapshotPostClick(target, verification.signalCounter, verification.page, pre, verification.isMidFlowSubmitStep);
-            const verdict = (0, phantom_click_1.classifyPhantomClick)({
-                actResultSuccess: true,
+            // An omitted flag means the caller could not tell final from mid-flow;
+            // derive from the step like the in-cascade sites rather than going strict.
+            const midFlowSubmit = verification.isMidFlowSubmitStep ??
+                isMidFlowSubmitShapedStep({
+                    step: verification.step,
+                    submitStep: false,
+                    isFinalStep: false,
+                    flowHasSubmitSemantics: false,
+                    elementSubmitShaped: true,
+                });
+            const { post, advanceBaseline } = await readMidFlowPostClickAdvance({
+                target,
+                signalCounter: verification.signalCounter,
+                page: verification.page,
+                pre,
+                stepStartSnapshot: verification.stepStartSnapshot ?? pre,
+                midFlowSubmit,
+            });
+            const verdict = classifySubmitShapedClick({
+                step: verification.step,
                 pre,
                 post,
-                isSubmitShapedStep: true,
-                isMidFlowSubmitStep: verification.isMidFlowSubmitStep,
-                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, post.url, verification.isMidFlowSubmitStep ? pre.url : undefined),
+                midFlowSubmit,
+                advanceBaseline,
             });
             if (verdict !== "phantom")
                 return true;
@@ -6613,14 +6825,20 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
                     throw err;
                 });
                 if (runnerUpClickResult.clicked) {
-                    const runnerUpPost = await settleAndSnapshotPostClick(target, verification.signalCounter, verification.page, post, verification.isMidFlowSubmitStep);
-                    const runnerUpVerdict = (0, phantom_click_1.classifyPhantomClick)({
-                        actResultSuccess: true,
+                    const { post: runnerUpPost, advanceBaseline: runnerUpBaseline } = await readMidFlowPostClickAdvance({
+                        target,
+                        signalCounter: verification.signalCounter,
+                        page: verification.page,
+                        pre: post,
+                        stepStartSnapshot: verification.stepStartSnapshot ?? pre,
+                        midFlowSubmit,
+                    });
+                    const runnerUpVerdict = classifySubmitShapedClick({
+                        step: verification.step,
                         pre: post,
                         post: runnerUpPost,
-                        isSubmitShapedStep: true,
-                        isMidFlowSubmitStep: verification.isMidFlowSubmitStep,
-                        destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(verification.step, runnerUpPost.url, verification.isMidFlowSubmitStep ? post.url : undefined),
+                        midFlowSubmit,
+                        advanceBaseline: runnerUpBaseline,
                     });
                     if (runnerUpVerdict !== "phantom")
                         return true;
@@ -9884,6 +10102,7 @@ function primitiveOptionLabel(option, questionLabel, redactValue, fromFill = fal
  */
 async function probeChildFrameSubmitFallback(params) {
     const { page, signalCounter, step, isMidFlowSubmitStep } = params;
+    const midFlowSubmit = isMidFlowSubmitStep === true;
     // `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
@@ -9933,17 +10152,27 @@ async function probeChildFrameSubmitFallback(params) {
         // biome-ignore lint/style/noNonNullAssertion: guarded by the length check above
         const top = ranked[0];
         const pre = await snapshotPage(target, signalCounter, page);
+        await armPageQuiescence(target);
         const clickResult = (await Promise.resolve(target.evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(top.deepIndex))).catch(() => ({ clicked: false })));
         if (!clickResult.clicked)
             continue;
-        const post = await settleAndSnapshotPostClick(target, signalCounter, page, pre, isMidFlowSubmitStep);
-        const verdict = (0, phantom_click_1.classifyPhantomClick)({
-            actResultSuccess: true,
+        // The step-start snapshot describes the resolved frame, not this child
+        // frame, so the first click's own pre-click page is the baseline both
+        // the top pick and the runner-up are judged against.
+        const { post, advanceBaseline } = await readMidFlowPostClickAdvance({
+            target,
+            signalCounter,
+            page,
+            pre,
+            stepStartSnapshot: pre,
+            midFlowSubmit,
+        });
+        const verdict = classifySubmitShapedClick({
+            step,
             pre,
             post,
-            isSubmitShapedStep: true,
-            isMidFlowSubmitStep,
-            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, post.url, isMidFlowSubmitStep ? pre.url : undefined),
+            midFlowSubmit,
+            advanceBaseline,
         });
         if (verdict !== "phantom")
             return target;
@@ -9953,14 +10182,20 @@ 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;
-        const runnerUpPost = await settleAndSnapshotPostClick(target, signalCounter, page, post, isMidFlowSubmitStep);
-        const runnerUpVerdict = (0, phantom_click_1.classifyPhantomClick)({
-            actResultSuccess: true,
-            pre,
+        const { post: runnerUpPost } = await readMidFlowPostClickAdvance({
+            target,
+            signalCounter,
+            page,
+            pre: midFlowSubmit ? post : advanceBaseline,
+            stepStartSnapshot: advanceBaseline,
+            midFlowSubmit,
+        });
+        const runnerUpVerdict = classifySubmitShapedClick({
+            step,
+            pre: post,
             post: runnerUpPost,
-            isSubmitShapedStep: true,
-            isMidFlowSubmitStep,
-            destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, runnerUpPost.url, isMidFlowSubmitStep ? post.url : undefined),
+            midFlowSubmit,
+            advanceBaseline,
         });
         if (runnerUpVerdict !== "phantom")
             return target;
@@ -9994,7 +10229,14 @@ async function raceAbortSignal(work, signal) {
     }
 }
 async function executeStepWithHealing(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;
+    const { stagehand, optional, upload, submitStep, captchaGated = false, emailStep = false, emailStepConfig, allocatedInbox = null, sessionProxy = null, flowHasSubmitSemantics: flowHasSubmitSemanticsParam, 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, onElementStepStartBaseline, } = params;
+    // An explicitly flagged final step is the flow's submit by definition (see
+    // flowHasSubmitSemantics). An omitted flow-level flag is derived from the same
+    // evidence flowHasSubmitSemantics reads (a submit flag, an endpoint pattern or
+    // requirement), so a last slot with none of them is mid-flow rather than a
+    // final submit held to network/URL proof.
+    const flowSubmitEvidence = submitStep || submitEndpointPattern !== null || requireSubmitEndpointMatch;
+    const flowHasSubmitSemanticsFlag = (flowHasSubmitSemanticsParam ?? flowSubmitEvidence) || (isFinalStep && submitStep);
     // 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
@@ -10174,7 +10416,11 @@ async function executeStepWithHealing(params) {
     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;
+    // Finality goes through isGenuineFinalSubmit like the judge routing and
+    // isMidFlowSubmitShapedStep: a last slot without submit semantics is mid-flow
+    // and must not be held to final-submit proof here.
+    const inferredFinalSubmitStep = isGenuineFinalSubmit({ isFinalStep, flowHasSubmitSemantics: flowHasSubmitSemanticsFlag }) &&
+        !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
@@ -10312,15 +10558,18 @@ async function executeStepWithHealing(params) {
     }
     // Multi-segment date spinbuttons need real key events; the cascade's
     // insertText would garble the segments. Falls through on null.
-    const segmentedDateTargetId = await trySegmentedDateSpinbuttonPrimitive({
+    const segmentedDate = await runSegmentedDateSpinbuttonPrimitive({
         page,
         target: selectFrameTarget,
         instruction: step,
         logger,
     });
-    if (segmentedDateTargetId !== null) {
+    if (segmentedDate.kind === "refused") {
+        throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactPii)(step).slice(0, 60)}) segmented date could not be delivered: ${segmentedDate.reason}`, "cascade-exhausted");
+    }
+    if (segmentedDate.kind === "committed") {
         logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by segmented-date primitive`);
-        trajectory?.push({ stepIndex, verifiedBy: "dom", targetId: segmentedDateTargetId });
+        trajectory?.push({ stepIndex, verifiedBy: "dom", targetId: segmentedDate.targetId });
         return "completed";
     }
     // On a CATCH-ALL step ("for any remaining … question"), fill every
@@ -10361,6 +10610,9 @@ async function executeStepWithHealing(params) {
     const isSettleWaitStep = isSubmitOrFinalStep || isAdvanceStep(step);
     if (captchaGated && isSubmitOrFinalStep) {
         let captchaTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+        // The step-level baseline is declared after this block, so capture the
+        // step-start page here for the fallback submit to judge against.
+        const captchaStepStartSnapshot = await snapshotPage(captchaTarget, signalCounter, page);
         const sitekeyProbeExpr = `(() => {
       const el = document.querySelector("[data-sitekey]");
       if (!el) return { siteKey: null, isInvisible: false };
@@ -10502,11 +10754,13 @@ async function executeStepWithHealing(params) {
                             signalCounter,
                             page,
                             step,
+                            stepStartSnapshot: captchaStepStartSnapshot ?? undefined,
                             isMidFlowSubmitStep: isMidFlowSubmitShapedStep({
                                 step,
                                 submitStep,
                                 isFinalStep,
                                 flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                                elementSubmitShaped: !stepDeclaredNonSubmit,
                             }),
                         });
                     }
@@ -10648,6 +10902,66 @@ async function executeStepWithHealing(params) {
     // legitimate-transition check (below) scans captures landed during THIS
     // step's processing — earlier-step transitions don't count.
     const stepStartMetaLength = recentCaptureMeta.length;
+    let firstAttemptPre = null;
+    let stepStartSnapshot = isStepSubmitShaped({
+        step,
+        submitStep,
+        isFinalStep,
+        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+    })
+        ? await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page)
+        : null;
+    // A click on a disabled control can still grow the DOM (a validation
+    // re-render), which would read as a step-start advance — so the last
+    // resolved click's disabled veto must also gate the baseline credit.
+    let lastClickBlockedByDisabled = false;
+    // A step whose submit shape is only known from a resolved element got no
+    // step-level baseline; the first attempt's pre-click snapshot is the
+    // step-start page, so every later verdict site judges against it.
+    const adoptElementStepStartBaseline = () => {
+        if (stepStartSnapshot || !firstAttemptPre)
+            return;
+        stepStartSnapshot = firstAttemptPre;
+        onElementStepStartBaseline?.(firstAttemptPre);
+    };
+    // One derivation for every in-cascade verdict site, so the same click is
+    // judged under the same strictness class and baseline whichever site sees it.
+    const deriveMidFlowJudgement = (elementSubmitShaped, pre) => {
+        const midFlowSubmit = isMidFlowSubmitShapedStep({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            elementSubmitShaped,
+        });
+        if (elementSubmitShaped)
+            adoptElementStepStartBaseline();
+        return { midFlowSubmit, advanceBaseline: stepStartSnapshot ?? pre };
+    };
+    const creditStepStartAdvance = async (exit) => {
+        const genuineFinal = isGenuineFinalSubmit({
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        });
+        if (!stepStartSnapshot || genuineFinal || lastClickBlockedByDisabled)
+            return false;
+        const { post: settled, pageAdvanced } = await readMidFlowPostClickAdvance({
+            target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
+            signalCounter,
+            page,
+            pre: stepStartSnapshot,
+            stepStartSnapshot,
+            midFlowSubmit: true,
+        });
+        if (!pageAdvanced)
+            return false;
+        // A DOM change that came from bouncing to an auth gate is not an advance.
+        if (!(0, phantom_click_1.isPlausibleStepDestination)(step, settled.url, stepStartSnapshot.url))
+            return false;
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} ${exit}: settled page advanced from the step-start baseline; crediting the step`);
+        trajectory?.push({ stepIndex, verifiedBy: "dom" });
+        return true;
+    };
     // Page-state probe BEFORE the cascade. When the page doesn't have any
     // candidate matching the step's instruction we either skip cleanly
     // (optional) or escalate straight to replan (required) — far cheaper than
@@ -10738,6 +11052,7 @@ async function executeStepWithHealing(params) {
                     submitStep,
                     isFinalStep,
                     flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                    elementSubmitShaped: !stepDeclaredNonSubmit,
                 }),
             });
             if (fallbackTarget) {
@@ -10746,6 +11061,8 @@ async function executeStepWithHealing(params) {
                 return "completed";
             }
         }
+        if (await creditStepStartAdvance("probe-absent"))
+            return "completed";
         // Capture diagnostics + write a failure dump BEFORE throwing so the
         // global replan path's `readFailureDumpEvidence` can populate the
         // prompt's CURRENTLY VISIBLE / UNFOCUSED OBSERVE / PAGE BODY HTML
@@ -11076,6 +11393,21 @@ async function executeStepWithHealing(params) {
     };
     let phantomClickAfterAttempt1 = false;
     let attempt1UnreachableViaLightDom = false;
+    // Attempt 1 resolved no candidate at all and was skipped before any verdict,
+    // so it never reached the "unresolved" escalation a judged attempt 1 takes.
+    let attempt1FastSkipped = false;
+    // The deep submit-control locator takes attempt 2 when attempt 1 judged its
+    // target unreachable, and attempt 3 when attempt 1 was fast-skipped and the
+    // observe-act retry in attempt 2 did not verify, so a submit-shaped step with
+    // no resolvable light-DOM target is never left without it.
+    const deepSubmitLocatorSlot = (attemptNumber) => isStepSubmitShaped({
+        step,
+        submitStep,
+        isFinalStep,
+        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+    }) &&
+        ((attemptNumber === 2 && attempt1UnreachableViaLightDom) ||
+            (attemptNumber === 3 && attempt1FastSkipped));
     // Last candidate list the deep-submit-locator itself ranked this step, if
     // any — reused by the cascade-exhausted diagnostic snapshot below so it
     // doesn't re-run buildRankSubmitCandidatesExpr (and inflate the rank-call
@@ -11090,23 +11422,17 @@ async function executeStepWithHealing(params) {
         // Skip to the next iteration so the cascade reaches its higher-value
         // techniques faster.
         if (attempt > 1) {
-            const wouldBeTechnique = attempt === 2
-                ? attempt1UnreachableViaLightDom &&
-                    isStepSubmitShaped({
-                        step,
-                        submitStep,
-                        isFinalStep,
-                        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                    })
-                    ? "deep-submit-locator"
-                    : phantomClickAfterAttempt1
+            const wouldBeTechnique = deepSubmitLocatorSlot(attempt)
+                ? "deep-submit-locator"
+                : attempt === 2
+                    ? phantomClickAfterAttempt1
                         ? "trusted-click-retry"
                         : "observe-act"
-                : attempt === 3
-                    ? "structured-click"
-                    : attempt === 4
-                        ? "observe-act-exclude"
-                        : "llm-rephrase";
+                    : attempt === 3
+                        ? "structured-click"
+                        : attempt === 4
+                            ? "observe-act-exclude"
+                            : "llm-rephrase";
             const decision = shouldSkipTechnique({
                 technique: wouldBeTechnique,
                 priorAttempts: attempts.map((a) => ({
@@ -11136,7 +11462,15 @@ async function executeStepWithHealing(params) {
         // 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);
+        // A prior attempt's click may have advanced the page after its own verdict;
+        // judge against the step-start baseline before `pre` absorbs the advance.
+        if (attempt > 1 && (await creditStepStartAdvance(`attempt-${attempt}-entry`)))
+            return "completed";
         const pre = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page, captureSelectionState);
+        // Recorded before any fast-skip `continue`, so an attempt-1 act that threw
+        // after its click landed still leaves the step-start page behind.
+        firstAttemptPre ??= pre;
+        await armPageQuiescence(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page));
         // Snapshot the meta-tail length so the final-step pattern gate can scope
         // its URL scan to captures added DURING this attempt (not historical
         // tail from earlier steps).
@@ -11171,6 +11505,15 @@ 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;
+        // Submit shape of the control observe resolved BEFORE the act clicked it.
+        // The act performs the click itself, so a page that swaps at once has
+        // already removed the control by the time the post-act read runs; this is
+        // the only read that cannot be blinded by the transition it caused.
+        const submitShapeObservedBeforeClick = new Map();
+        // Every submit-shaped control on the page before the act, so the shape of
+        // the control the act clicked is known even when observe resolved nothing
+        // or a different node than the act did.
+        const submitShapedControlsBeforeClick = new Set();
         // 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
@@ -11179,10 +11522,17 @@ async function executeStepWithHealing(params) {
         const preCentreNaturalLanguageClick = async (instruction) => {
             if (!(0, stagehand_guard_1.hasClickIntent)(instruction))
                 return false;
+            if (!stepDeclaredNonSubmit) {
+                for (const xpath of await readSubmitShapedControlXpaths(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page))) {
+                    submitShapedControlsBeforeClick.add(xpath);
+                }
+            }
             const observed = await (0, stagehand_guard_1.guardedObserve)(stagehand, instruction, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget);
             const first = observed[0];
             if (!(0, stagehand_guard_1.isTrustedClickMethod)(first?.method) || !first?.selector)
                 return true;
+            submitShapeObservedBeforeClick.set(first.selector, !stepDeclaredNonSubmit &&
+                (await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), first.selector)));
             const failure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), first.selector);
             if (failure)
                 throw new Error(failure);
@@ -11280,14 +11630,7 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
-            else if (attempt === 2 &&
-                attempt1UnreachableViaLightDom &&
-                isStepSubmitShaped({
-                    step,
-                    submitStep,
-                    isFinalStep,
-                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                })) {
+            else if (deepSubmitLocatorSlot(attempt)) {
                 // 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
@@ -11363,24 +11706,26 @@ async function executeStepWithHealing(params) {
                         const runnerUp = ranked[1];
                         if (runnerUp) {
                             const midTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
-                            const deepMidFlowSubmit = isMidFlowSubmitShapedStep({
-                                step,
-                                submitStep,
-                                isFinalStep,
-                                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                                elementSubmitShaped: !stepDeclaredNonSubmit,
+                            // Ranked candidates are submit-shaped by construction, so the
+                            // resolved element's shape is the step's declared-non-submit gate.
+                            const { midFlowSubmit: deepMidFlowSubmit, advanceBaseline: deepStepBaseline } = deriveMidFlowJudgement(!stepDeclaredNonSubmit, pre);
+                            const { post: midPost, advanceBaseline: deepAdvanceBaseline } = await readMidFlowPostClickAdvance({
+                                target: midTarget,
+                                signalCounter,
+                                page,
+                                pre,
+                                stepStartSnapshot: deepStepBaseline,
+                                midFlowSubmit: deepMidFlowSubmit,
                             });
-                            const midPost = await settleAndSnapshotPostClick(midTarget, signalCounter, page, pre, deepMidFlowSubmit);
-                            const topVerdict = (0, phantom_click_1.classifyPhantomClick)({
-                                actResultSuccess: true,
+                            // The deep-submit-locator runs only on submit escalation, so a
+                            // stray selection flip must not mask a top-pick phantom and skip
+                            // the runner-up retry.
+                            const topVerdict = classifySubmitShapedClick({
+                                step,
                                 pre,
                                 post: midPost,
-                                // The deep-submit-locator runs only on submit escalation, so a
-                                // stray selection flip must not mask a top-pick phantom and skip
-                                // the runner-up retry.
-                                isSubmitShapedStep: true,
-                                isMidFlowSubmitStep: deepMidFlowSubmit,
-                                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, midPost.url, deepMidFlowSubmit ? pre.url : undefined),
+                                midFlowSubmit: deepMidFlowSubmit,
+                                advanceBaseline: deepAdvanceBaseline,
                             });
                             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})`);
@@ -11768,6 +12113,14 @@ async function executeStepWithHealing(params) {
                             };
                         }
                     }
+                    if (overriddenTarget.method === "fill" &&
+                        (await isDateSegmentAtSelector(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), overriddenTarget.selector))) {
+                        record.errorMessage = `refused fill on a date segment: "${target.description.slice(0, 60)}" (a lone-segment write cannot compose a date)`;
+                        attempts.push(record);
+                        failureReasons.push(record.errorMessage);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${record.errorMessage}`);
+                        continue;
+                    }
                     params.abortSignal?.throwIfAborted();
                     // Stagehand's internal Locator.click() does not scroll past sticky
                     // bars, so centre + hit-test the observed control first; an
@@ -12107,6 +12460,7 @@ async function executeStepWithHealing(params) {
                 ? `attempt 1 fast-skipped (no resolved action): ${record.errorMessage}`
                 : "attempt 1 fast-skipped (no resolved action; Stagehand returned no candidates)";
             failureReasons.push(reason);
+            attempt1FastSkipped = true;
             continue;
         }
         // A fill/select/type action cannot open a tab, so skip the discovery wait for it.
@@ -12117,9 +12471,19 @@ async function executeStepWithHealing(params) {
         // settle: a view swap removes the clicked control, so a post-swap read
         // would blind the mid-flow exemption on exactly the case it exists for.
         // See resolvedClickTargetIsSubmitShaped's doc comment.
+        // A successful act that listed no actions still clicked what observe
+        // resolved first, so that control's pre-click shape stands in for it.
         const resolvedElementIsSubmitShaped = isClick && !stepDeclaredNonSubmit && resolvedAction?.selector
-            ? await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector)
-            : false;
+            ? submitShapeObservedBeforeClick.get(resolvedAction.selector) === true ||
+                submitShapedControlsBeforeClick.has(canonicalAbsoluteXpath(resolvedAction.selector) ?? "") ||
+                (await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector))
+            : resolvedAction === null &&
+                record.actResultSuccess === true &&
+                !stepDeclaredNonSubmit &&
+                submitShapeObservedBeforeClick.values().next().value === true;
+        if (resolvedElementIsSubmitShaped)
+            adoptElementStepStartBaseline();
+        const advanceBaseline = stepStartSnapshot ?? pre;
         // Computed once: gates every credit signal that takes no post-click URL
         // (network, DOM read-back) and classifyPhantomClick's destinationPlausible.
         const stepIsMidFlowSubmit = isMidFlowSubmitShapedStep({
@@ -12135,11 +12499,19 @@ async function executeStepWithHealing(params) {
         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 settleWithPageQuiescence(page, settleTarget, signalCounter, pre.networkCount, isSettleWaitStep || resolvedElementIsSubmitShaped, pre.visibleTextSignature, pageAdvancedSince(pre.visibleTextSignature, stepIsMidFlowSubmit));
-        }
-        const post = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
+        // Re-settle is not gated on submit shape: an unflagged step or a no-action
+        // act can still advance a page whose body re-renders late. Credit stays
+        // gated on stepIsMidFlowSubmit, so the final step keeps its strictness.
+        const { post } = await readMidFlowPostClickAdvance({
+            target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
+            signalCounter,
+            page,
+            pre,
+            stepStartSnapshot: advanceBaseline,
+            midFlowSubmit: stepIsMidFlowSubmit,
+            mayTriggerRoundTrip,
+            waitForMutations: isSettleWaitStep || resolvedElementIsSubmitShaped,
+        });
         record.post = post;
         if (resolvedAction) {
             record.resolvedMethod = resolvedAction.method ?? null;
@@ -12261,23 +12633,42 @@ async function executeStepWithHealing(params) {
             flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
             elementSubmitShaped: resolvedElementIsSubmitShaped,
         });
+        // A submit-worded last slot without submit semantics is mid-flow
+        // (isGenuineFinalSubmit), so the sibling predicates below must not hold it
+        // to genuine-final strictness while the verdict gates already credit it on
+        // a settled advance.
+        const primarySubmitShaped = isStepSubmitShaped({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+        }) &&
+            (submitStep ||
+                isGenuineFinalSubmit({ isFinalStep, flowHasSubmitSemantics: flowHasSubmitSemanticsFlag }) ||
+                !isFinalStep);
         // 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 midFlowDestinationPlausibleForPost = midFlowDestinationPlausible({
+            step,
+            pre,
+            post,
+            midFlowSubmit,
+            advanceBaseline,
+            destinationPlausible,
+        });
         const clickViewSwapVerified = isClickViewSwapVerified({
             resolvedAction,
             submitStep,
             isAdvanceWithPattern: isAdvanceStep(step) && advanceTransitionBodyPattern !== null,
             networkDelta: post.networkCount - pre.networkCount,
             bytesDelta: post.bodyHtmlLength - pre.bodyHtmlLength,
-            textChanged: post.visibleTextSignature !== pre.visibleTextSignature,
+            textChanged: (0, phantom_click_1.hasVisibleTextChanged)(advanceBaseline, post),
             invalidMarkerDelta: postInvalidMarkerCount - preInvalidMarkerCount,
             clickedElementStillPresent,
             resolvedElementIsSubmitShaped,
-            destinationPlausible: midFlowDestinationPlausible,
+            destinationPlausible: midFlowDestinationPlausibleForPost,
             midFlowSubmit,
-            pageAdvanced: (0, phantom_click_1.hasPageAdvanced)(pre, post),
+            pageAdvanced: (0, phantom_click_1.hasSettledPageAdvanced)(advanceBaseline, post),
             actSucceeded: record.actResultSuccess === true,
         });
         if (clickViewSwapVerified === false &&
@@ -12311,12 +12702,7 @@ 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 = !(isStepSubmitShaped({
-            step,
-            submitStep,
-            isFinalStep,
-            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-        }) || resolvedElementIsSubmitShaped) || requireSubmitEndpoint;
+        const formValueWeakSignalAllowed = !(primarySubmitShaped || resolvedElementIsSubmitShaped) || requireSubmitEndpoint;
         const formValueVerified = isStateClass &&
             formValueWeakSignalAllowed &&
             destinationPlausible &&
@@ -12436,7 +12822,8 @@ async function executeStepWithHealing(params) {
                     flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
                 }),
             isMidFlowSubmitStep: midFlowSubmit,
-            destinationPlausible: midFlowDestinationPlausible,
+            advanceBaseline,
+            destinationPlausible: midFlowDestinationPlausibleForPost,
         });
         // An `"effective"` verdict driven purely by the page-wide byte-delta
         // floor (`TRIVIAL_DOM_DELTA_BYTES`, 500B) is intentionally NOT trusted
@@ -12457,12 +12844,7 @@ 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 = !isStepSubmitShaped({
-            step,
-            submitStep,
-            isFinalStep,
-            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-        }) && domVerifiedForStep;
+        const domEffectiveVerdict = !primarySubmitShaped && domVerifiedForStep;
         let verified = networkIsRealAdvance ||
             urlChanged ||
             domVerifiedForStep ||
@@ -12552,7 +12934,10 @@ async function executeStepWithHealing(params) {
                 target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
                 signalCounter,
                 preNetworkCount: pre.networkCount,
-                preVisibleTextSignature: pre.visibleTextSignature,
+                preVisibleTextSignature: advanceBaseline.visibleTextSignature,
+                preVisibleText: advanceBaseline.visibleText,
+                preVisibleTextDigest: advanceBaseline.visibleTextDigest,
+                settledPostVisibleText: post.visibleText,
                 submitInput: {
                     pageUrl: post.url,
                     pageTitle,
@@ -12571,14 +12956,14 @@ async function executeStepWithHealing(params) {
             // 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,
-                });
+            const midFlowAdvanceCredited = isMidFlowAdvanceCredited({
+                midFlowSubmit,
+                signalAdvanced: clickViewSwapVerified,
+                judgeUnavailable: judgeVerdict === null,
+                networkAdvanced: networkIsRealAdvance,
+                pageAdvanced: (0, phantom_click_1.hasSettledPageAdvanced)(advanceBaseline, post),
+                invalidMarkerCount,
+            });
             if (midFlowAdvanceCredited && judgeVerdict?.verified !== true) {
                 logger.info(`mid-flow submit credited on demonstrable page advance (judge ${judgeVerdict === null ? "unavailable" : `rejected: ${judgeVerdict.reason}`})`);
             }
@@ -12614,7 +12999,7 @@ async function executeStepWithHealing(params) {
                 // Any-4xx fallback. The judge said failed; surface any captured 4xx
                 // body's field-level error JSON for the rephrase prompt downstream
                 // — same role as before the migration.
-                const fallbackEvidence = extractSubmitFailureEvidence(recentCaptures.slice(-tail.length), [], (0, recon_shared_1.resolveReconRunDir)().graphqlDir, "any-4xx");
+                const fallbackEvidence = extractSubmitFailureEvidence(recentCaptures.slice(-tail.length), [], (0, runtime_capture_store_1.defaultCapturesDir)(), "any-4xx");
                 if (fallbackEvidence.length > 0) {
                     failureReasons.push(`any-4xx fallback: ${fallbackEvidence.split("\n")[0]}`.slice(0, 240));
                 }
@@ -12789,26 +13174,22 @@ async function executeStepWithHealing(params) {
                         probeResult.checked === true &&
                         (probeResult.ariaManaged === true || !ancestorStillInvalid);
                     await page.waitForTimeout(STEP_PAUSE_MS);
-                    await settleWithPageQuiescence(page, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, pre.networkCount, isSettleWaitStep || retryResolvedElementIsSubmitShaped, pre.visibleTextSignature, pageAdvancedSince(pre.visibleTextSignature, isMidFlowSubmitShapedStep({
-                        step,
-                        submitStep,
-                        isFinalStep,
-                        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                        elementSubmitShaped: retryResolvedElementIsSubmitShaped,
-                    })));
-                    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 { midFlowSubmit: retryMidFlowSubmit, advanceBaseline: retryAdvanceBaseline } = deriveMidFlowJudgement(retryResolvedElementIsSubmitShaped, pre);
+                    const { post: retryPost, pageAdvanced: retryPageAdvanced } = await readMidFlowPostClickAdvance({
+                        target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
+                        signalCounter,
+                        page,
+                        pre,
+                        stepStartSnapshot: retryAdvanceBaseline,
+                        midFlowSubmit: retryMidFlowSubmit,
+                        waitForMutations: isSettleWaitStep || retryResolvedElementIsSubmitShaped,
                     });
+                    const retryNetworkFired = retryPost.networkCount > pre.networkCount;
                     const retryUrlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, 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 retryDomBaseline = retryMidFlowSubmit ? retryAdvanceBaseline : pre;
+                    const retryHtmlDelta = retryPost.bodyHtmlLength - retryDomBaseline.bodyHtmlLength;
+                    const retryTextChanged = (0, phantom_click_1.hasVisibleTextChanged)(retryDomBaseline, retryPost);
                     const retryFormValueChanged = retryPost.formValueSignature !== pre.formValueSignature;
                     // Element-scoped selection read-back for the n+16 fallback — the same
                     // authoritative signal the primary verifier uses via `verifyDomEffect`,
@@ -12878,6 +13259,8 @@ async function executeStepWithHealing(params) {
                                 .evaluate(disabledExpr)
                                 .catch(() => false);
                         })());
+                    if (probeResult.kind === "click")
+                        lastClickBlockedByDisabled = clickBlockedByDisabled;
                     const clickWasDomOnly = probeResult.kind === "click" && !retryNetworkFired && !retryUrlChanged;
                     const clickBlockedByInvalid = clickWasDomOnly &&
                         (await countNgInvalidContainers(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page)).catch(() => 0)) >
@@ -12903,10 +13286,14 @@ async function executeStepWithHealing(params) {
                     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 retryMidFlowDestinationPlausible = midFlowDestinationPlausible({
+                        step,
+                        pre,
+                        post: retryPost,
+                        midFlowSubmit: retryMidFlowSubmit,
+                        advanceBaseline: retryAdvanceBaseline,
+                        destinationPlausible: retryDestinationPlausible,
+                    });
                     const retryNetworkIsRealAdvance = retryNetworkFired &&
                         retryDestinationPlausible &&
                         (await waitForTransitionBody({
@@ -13014,6 +13401,7 @@ async function executeStepWithHealing(params) {
                         elementStateChanged: retrySelectionStateChanged,
                         isSubmitShapedStep: retryMidFlowSubmit || retrySubmitShaped,
                         isMidFlowSubmitStep: retryMidFlowSubmit,
+                        advanceBaseline: retryAdvanceBaseline,
                         destinationPlausible: retryMidFlowDestinationPlausible,
                     });
                     // Destination-plausibility audit of every remaining disjunct in
@@ -13050,6 +13438,10 @@ async function executeStepWithHealing(params) {
                             (n16ClickDelivered &&
                                 (!retrySubmitShaped || retryMidFlowSubmit) &&
                                 retryVerdict === "effective") ||
+                            (n16ClickDelivered &&
+                                retryMidFlowSubmit &&
+                                retryPageAdvanced &&
+                                retryMidFlowDestinationPlausible) ||
                             (n16ClickDelivered &&
                                 weakDomSignalsAllowed &&
                                 retryDestinationPlausible &&
@@ -13149,12 +13541,15 @@ async function executeStepWithHealing(params) {
                             isFinalStep,
                             submitStep,
                             flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                            elementSubmitShaped: resolvedElementIsSubmitShaped,
+                            elementSubmitShaped: retryResolvedElementIsSubmitShaped,
                             page,
                             target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
                             signalCounter,
                             preNetworkCount: pre.networkCount,
-                            preVisibleTextSignature: pre.visibleTextSignature,
+                            preVisibleTextSignature: retryAdvanceBaseline.visibleTextSignature,
+                            preVisibleText: retryAdvanceBaseline.visibleText,
+                            preVisibleTextDigest: retryAdvanceBaseline.visibleTextDigest,
+                            settledPostVisibleText: retryPost.visibleText,
                             submitInput: {
                                 pageUrl: retryPost.url,
                                 pageTitle,
@@ -13170,16 +13565,14 @@ async function executeStepWithHealing(params) {
                                 submittedStateSelectors: matchedSubmittedSelectors,
                             },
                         });
-                        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,
-                            });
+                        const retryMidFlowAdvanceCredited = isMidFlowAdvanceCredited({
+                            midFlowSubmit: retryMidFlowSubmit,
+                            signalAdvanced: retryVerdict === "effective" && retryPageAdvanced,
+                            judgeUnavailable: judgeVerdict === null,
+                            networkAdvanced: retryNetworkFired && retryDestinationPlausible,
+                            pageAdvanced: retryPageAdvanced,
+                            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}`})`);
                         }
@@ -13358,12 +13751,7 @@ 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 = isStepSubmitShaped({
-                    step,
-                    submitStep,
-                    isFinalStep,
-                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                })
+                const escalationTarget = primarySubmitShaped
                     ? "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)"
@@ -13375,17 +13763,16 @@ 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: isStepSubmitShaped({
-                    step,
-                    submitStep,
-                    isFinalStep,
-                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                }),
+                isFinalStep: primarySubmitShaped,
                 requireSubmitEndpoint,
                 resolvedMethod: record.resolvedMethod,
                 effectSignals,
                 preSubmitInvalidCount,
                 postAttemptInvalidCount,
+                midFlowAdvanced: !isGenuineFinalSubmit({
+                    isFinalStep,
+                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                }) && (0, phantom_click_1.hasSettledPageAdvanced)(advanceBaseline, post),
             });
             if (earlyExit) {
                 const exitReason = `submit-revealed-invalid: click surfaced ${postAttemptInvalidCount - preSubmitInvalidCount} new ng-invalid container(s) (was ${preSubmitInvalidCount}, now ${postAttemptInvalidCount}); attempts 2-${MAX_STEP_ATTEMPTS} cannot heal a form that needs answers — routing to replan`;
@@ -13447,6 +13834,7 @@ async function executeStepWithHealing(params) {
                 submitStep,
                 isFinalStep,
                 flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                elementSubmitShaped: !stepDeclaredNonSubmit,
             }),
         });
         if (fallbackTarget) {
@@ -13455,6 +13843,8 @@ async function executeStepWithHealing(params) {
             return "completed";
         }
     }
+    if (await creditStepStartAdvance("cascade-exhausted"))
+        return "completed";
     const cascadeExhaustObservedFinal = 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 dump evidence — this
@@ -13550,6 +13940,9 @@ async function executeNavigateStep(params) {
  * than let the flow report phantom success.
  */
 async function runHealingFlow(deps) {
+    return (0, runtime_capture_store_1.withRuntimeCaptureStore)((store) => runHealingFlowScoped(deps, store));
+}
+async function runHealingFlowScoped(deps, store) {
     const { stagehand, page, steps, logger, anthropic, rephraseModel, uploadFixture, maxFlowMs } = deps;
     for (const secret of deps.secrets ?? [])
         (0, pii_redaction_1.registerSecretValue)(secret);
@@ -13579,6 +13972,7 @@ async function runHealingFlow(deps) {
         recentCaptures,
         recentCaptureMeta,
         getCurrentPhase: () => "flow",
+        onCapture: (capture, filename) => (0, runtime_capture_store_1.recordRuntimeCapture)(store, filename, capture),
         getCurrentPageOrigin: () => {
             try {
                 return new URL(activePage.url()).origin;