@enricai/barnacle 1.12.54 → 1.12.55

package/dist/scraper/flow-runner.js

@@ -1207,29 +1207,42 @@ function isCheckboxOrRadioIntentStep(instruction) {
  * Whether `snapshotPage` should build the per-element selection baseline
  * (`StepSnapshot.selectionStateByXpath`) for this step — i.e. whether
  * `verifyDomEffect`'s element-scoped click read-back is allowed to credit it.
- * True ONLY for a field-answer/selection step: a submit, a final, or an advance
- * step must be verified by a real network/URL transition, so its own
+ * True ONLY for a field-answer/selection step: a submit or an advance step
+ * must be verified by a real network/URL transition, so its own
  * self-toggling button (a submit flipping to a loading/pressed class, a "Next"
  * flipping `aria-pressed`) must never earn an element-scoped credit — matching
- * the `!submit`/`!final`/`!advance` exclusions the former
- * `isClickStateToggleVerified` gate enforced. Pure + exported so the gate the
+ * the `!submit`/`!advance` exclusions the former `isClickStateToggleVerified`
+ * gate enforced. A benign final step (one that is NOT itself the flagged
+ * submit step) still captures — `flowHasSubmitSemantics` describes the FLOW,
+ * not this step, so it must not veto capture on its own; `submitStep` alone
+ * (authoritative per {@link flowHasSubmitSemantics}) identifies the step that
+ * actually needs network/URL verification. Pure + exported so the gate the
  * cascade depends on is unit-testable, not buried in `executeStepWithHealing`.
  */
 function shouldCaptureSelectionState(params) {
-    const { step, isFinalStep, submitStep, flowHasSubmitSemantics } = params;
-    return !(submitStep || (isFinalStep && flowHasSubmitSemantics) || isAdvanceStep(step));
-}
-/**
- * Whether a flow has ANY submit semantics at all — a step flagged
- * `submitStep: true`, a `submitEndpointPattern`, or `requireSubmitEndpointMatch`.
- * A read-only flow (none of the three) has no submit shape anywhere, so its
- * final step is an ordinary read/click, not a submit. Pure + exported so
- * callers can stop inferring submit-shape from `isFinalStep` alone on flows
- * that never declared a submit.
+    const { step, submitStep } = params;
+    return !(submitStep || isAdvanceStep(step));
+}
+/**
+ * Whether the flow's FINAL step carries submit semantics. A read-only flow
+ * (no step flagged `submitStep: true`, no `submitEndpointPattern`, no
+ * `requireSubmitEndpointMatch`) has no submit shape anywhere, so its final
+ * step is an ordinary read/click. When some step IS explicitly flagged
+ * `submitStep: true`, that flag is authoritative over inference — the final
+ * step only counts as submit-shaped if it is itself the flagged step, not
+ * merely because an earlier, unrelated step claims the submit role. Only
+ * when NO step carries an explicit flag do we fall back to inferring
+ * submit-shape onto the final step from `submitEndpointPattern` /
+ * `requireSubmitEndpointMatch` (the documented fallback for self-heal-
+ * appended final steps that never got the flag set). Pure + exported so
+ * callers can stop inferring submit-shape from `isFinalStep` alone.
  */
 function flowHasSubmitSemantics(params) {
     const { steps, submitEndpointPattern, requireSubmitEndpointMatch } = params;
-    return (steps.some((s) => s.submitStep) || submitEndpointPattern !== null || requireSubmitEndpointMatch);
+    const hasExplicitSubmitStep = steps.some((s) => s.submitStep);
+    return hasExplicitSubmitStep
+        ? (steps[steps.length - 1]?.submitStep ?? false)
+        : submitEndpointPattern !== null || requireSubmitEndpointMatch;
 }
 /**
  * Whether a flow should be WARNed that its DOM-only advance guard is disarmed.
@@ -1471,10 +1484,13 @@ function isDomOnlyAdvanceVerified(params) {
  * (`VIEW_SWAP_MIN_BYTES` env var) lets a deployment lower the threshold
  * without regressing the shared default for other sites.
  *
- * **Scope guards:** Excludes final/submit steps (those require real network
- * per isSubmitRevealedInvalid + LLM submit judge) and advance-pattern steps
- * (those require real transition per isDomOnlyAdvanceVerified/isAdvanceStalled
- * to avoid wizard-ATS autosave-vs-transition ambiguity).
+ * **Scope guards:** Excludes steps explicitly flagged `submitStep: true`
+ * (those require real network per isSubmitRevealedInvalid + LLM submit
+ * judge — trusting only the step's own explicit flag, never the flow-level
+ * `flowHasSubmitSemantics` inference: an unflagged final step may genuinely
+ * be a legitimate client-side view swap) and advance-pattern steps (those
+ * require real transition per isDomOnlyAdvanceVerified/isAdvanceStalled to
+ * avoid wizard-ATS autosave-vs-transition ambiguity).
  *
  * **Small-delta reveal credit:** a sub-section unhiding within an
  * already-loaded page (e.g. a validation-triggered "Work History requirement"
@@ -1505,10 +1521,16 @@ function isDomOnlyAdvanceVerified(params) {
 function isClickViewSwapVerified(params) {
     const VIEW_SWAP_MIN_BYTES = config_1.config.scraper.viewSwapMinBytesThreshold;
     const VIEW_SWAP_REVEAL_MIN_BYTES = config_1.config.scraper.viewSwapRevealMinBytesThreshold;
-    const { resolvedAction, isFinalStep, submitStep, flowHasSubmitSemantics, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, } = params;
+    const { resolvedAction, submitStep, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, } = params;
     if (resolvedAction?.method !== "click")
         return false;
-    if (submitStep || (isFinalStep && flowHasSubmitSemantics))
+    // Only the step's own explicit submitStep flag identifies the step that
+    // actually needs network/URL verification — mirrors the submit-judge
+    // gate's hasSubmitTransitionSignal discipline (see 5763ac2). Inferring
+    // submit-shape from isFinalStep && flowHasSubmitSemantics falsely vetoes
+    // an inferred final same-page toggle step that was never going to receive
+    // a real network/URL transition, leaving it structurally unverifiable.
+    if (submitStep)
         return false;
     if (isAdvanceWithPattern)
         return false;
@@ -1516,9 +1538,9 @@ function isClickViewSwapVerified(params) {
         return false;
     if (invalidMarkerDelta > 0)
         return false;
-    if (bytesDelta >= VIEW_SWAP_MIN_BYTES)
+    if (Math.abs(bytesDelta) >= VIEW_SWAP_MIN_BYTES)
         return true;
-    return textChanged && bytesDelta >= VIEW_SWAP_REVEAL_MIN_BYTES;
+    return textChanged && Math.abs(bytesDelta) >= VIEW_SWAP_REVEAL_MIN_BYTES;
 }
 /**
  * Reads the "N settings/items selected" running count that multi-select wizard
@@ -4564,6 +4586,28 @@ async function waitForCaptchaNavigation(params) {
     }
     return false;
 }
+/**
+ * Distinguishes a navigating evaluate's expected context-teardown rejection
+ * (the callback/submit dispatch it wraps synchronously navigated the frame,
+ * tearing down the execution context before a return value marshals) from a
+ * genuine in-page exception — a thrown `TypeError`, a rejected fetch, or any
+ * other real failure inside the site's own callback/submit logic. Both are
+ * indistinguishable to a blanket `.catch(() => undefined)`, which is exactly
+ * why a genuinely thrown-and-swallowed exception during the callback invoke
+ * used to log `callbackDiscovered=true`/`injected=true` (both computed
+ * BEFORE the invoke) while never actually dispatching anything. Only a
+ * context-teardown rejection is safe to discard silently; this is what lets
+ * callers keep doing that for the first case while surfacing the second.
+ */
+function isNavigatingEvaluateRejection(error) {
+    const message = (0, errors_1.toErrorMessage)(error).toLowerCase();
+    return (message.includes("execution context was destroyed") ||
+        message.includes("execution context is not available") ||
+        message.includes("cannot find context with specified id") ||
+        message.includes("target closed") ||
+        message.includes("frame was detached") ||
+        message.includes("no frame for given id found"));
+}
 /**
  * Shared in-page discovery of the widget's callback, used identically by
  * `injectCaptchaTokenAndSubmit`'s precheck (to decide the branch) and its
@@ -4616,6 +4660,10 @@ function setResponseFieldAndInvokeCallbackExprSrc(responseField, token) {
     } else if (field) {
       field.value = token;
     }
+    if (field) {
+      field.dispatchEvent(new Event("input", { bubbles: true }));
+      field.dispatchEvent(new Event("change", { bubbles: true }));
+    }
     found.invoke(token);
   `;
 }
@@ -4707,8 +4755,8 @@ async function injectCaptchaTokenAndSubmit(target, token, responseField = "h-cap
         // case: it's an anonymous closure living in the registry, not a named
         // `window` global, so it cannot be marshalled back from the precheck's
         // evaluate call.
-        await target.evaluate(invokeCallbackExpr).catch(() => undefined);
-        return { injected, hasForm, callbackDiscovered };
+        const callbackInvokeError = await target.evaluate(invokeCallbackExpr).then(() => undefined, (err) => (isNavigatingEvaluateRejection(err) ? undefined : (0, errors_1.toErrorMessage)(err)));
+        return { injected, hasForm, callbackDiscovered, callbackInvokeError };
     }
     // Belt-and-suspenders: this frame missed session.ts's page-init-script
     // install and bugfix-001's per-frame attach install (it either attached
@@ -4739,8 +4787,8 @@ async function injectCaptchaTokenAndSubmit(target, token, responseField = "h-cap
         // the non-late invoke above: the callback is free to submit the form
         // synchronously off the field value that's now present, tearing down the
         // execution context before a return value marshals.
-        await target.evaluate(invokeLateCallbackExpr).catch(() => undefined);
-        return { injected, hasForm, callbackDiscovered: true };
+        const callbackInvokeError = await target.evaluate(invokeLateCallbackExpr).then(() => undefined, (err) => (isNavigatingEvaluateRejection(err) ? undefined : (0, errors_1.toErrorMessage)(err)));
+        return { injected, hasForm, callbackDiscovered: true, callbackInvokeError };
     }
     const setValueExpr = `(() => {
     const responseField = ${JSON.stringify(responseField)};
@@ -4773,7 +4821,10 @@ async function injectCaptchaTokenAndSubmit(target, token, responseField = "h-cap
     const dispatchChangeExpr = `(() => {
     const responseField = ${JSON.stringify(responseField)};
     const field = document.querySelector('[name="' + responseField + '"]');
-    if (field) field.dispatchEvent(new Event("change", { bubbles: true }));
+    if (field) {
+      field.dispatchEvent(new Event("input", { bubbles: true }));
+      field.dispatchEvent(new Event("change", { bubbles: true }));
+    }
   })()`;
     // Dispatching "change" can trigger a page's own submit-on-token callback,
     // which navigates the frame synchronously from within this call and tears
@@ -4788,24 +4839,123 @@ async function injectCaptchaTokenAndSubmit(target, token, responseField = "h-cap
  * used only when the caller's own transition poll observed no advance after
  * the inject, so the widget's callback (if any) evidently didn't submit for
  * us. Kept separate from the inject primitive so the caller can gate its use
- * on an observed transition rather than firing it unconditionally. Prefers
- * `form.requestSubmit()` so any submit-event listener (including one that
- * calls `preventDefault()` and drives its own submit logic) and native form
- * validation still run, matching real-browser submit semantics; falls back
- * to the bare `form.submit()` only when `requestSubmit` isn't available.
- */
-async function submitCaptchaGatedForm(target, responseField = "h-captcha-response") {
+ * on an observed transition rather than firing it unconditionally.
+ *
+ * Dispatches a real, framework-observed click via the same
+ * {@link buildRankSubmitCandidatesExpr}/{@link buildClickByDeepIndexExpr}
+ * primitives the phantom-click cascade uses, rather than a synthetic
+ * `form.requestSubmit()`/`form.submit()` call: on a React/SPA site the
+ * submit button's `onClick` handler owns the actual submission (validation,
+ * XHR/fetch dispatch, etc.), and `<form>`-level APIs never fire it, so
+ * "success" here would silently produce zero site-host HTTP traffic for
+ * {@link waitForCaptchaNavigation} to observe. Only when no submit-shaped
+ * control can be found or clicked does this fall back to the form-level API
+ * — a plain server-rendered form with no button-bound JS handler still needs
+ * `requestSubmit()`/`submit()` to actually navigate.
+ *
+ * Resolves the form to submit by name first (the response field's own
+ * closest form), then falls back to the sitekey-anchored form (or the sole
+ * form on the page) the same way {@link injectCaptchaTokenAndSubmit} resolves
+ * its target: an invisible/callback-only widget never creates a named
+ * response field, so a named-field-only lookup here would silently no-op and
+ * no site-host traffic would ever follow the clean callback. Resolves to
+ * whether a form was actually found and acted on; a true no-op is reported
+ * only when the page has no form at all to resolve.
+ *
+ * The click-dispatch and form-level submit evals both tolerate the expected
+ * context-teardown rejection of a click/submit that navigated the frame —
+ * see {@link isNavigatingEvaluateRejection} — but rethrow anything else, so a
+ * genuine in-page exception during the dispatch propagates to the caller
+ * instead of silently resolving as a successful submit.
+ *
+ * The ranked-candidate click is verified the same way the main cascade's
+ * `deep-submit-locator` verifies its top pick (see `executeStepWithHealing`
+ * at flow-runner.ts:10374-10428): a shadow-root/web-component control can
+ * report `clicked: true` while wiring no real handler, so a bare
+ * `clicked: true` here would let a phantom click masquerade as a resolved
+ * submit and this fallback would return `true` with zero site-host traffic
+ * ever following. When `verification` is supplied, snapshots pre/post via
+ * `snapshotPage` and classifies with `classifyPhantomClick({isSubmitShapedStep:
+ * true})`; a `phantom` verdict retries the runner-up candidate once (mirroring
+ * the cascade's single runner-up retry) before falling through to the
+ * form-level submit below. `verification` is optional so callers that only
+ * need the non-polling, non-verifying original contract (and existing tests
+ * exercising the rank/click primitives directly) are unaffected.
+ */
+async function submitCaptchaGatedForm(target, responseField = "h-captcha-response", verification) {
+    const findFormExpr = `(() => {
+    const responseField = ${JSON.stringify(responseField)};
+    const field = document.querySelector('[name="' + responseField + '"]');
+    const fieldForm = field ? field.closest("form") : null;
+    if (fieldForm) return true;
+    const forms = Array.from(document.querySelectorAll("form"));
+    const sitekeyForm = forms.find((candidate) => candidate.querySelector("[data-sitekey]")) ?? forms[0];
+    return Boolean(sitekeyForm);
+  })()`;
+    const found = await target.evaluate(findFormExpr).catch(() => false);
+    if (!found)
+        return false;
+    const rankResult = await target
+        .evaluate((0, submit_control_1.buildRankSubmitCandidatesExpr)())
+        .catch(() => []);
+    const ranked = Array.isArray(rankResult) ? rankResult : [];
+    // biome-ignore lint/style/noNonNullAssertion: guarded by the length check
+    const top = ranked.length > 0 ? ranked[0] : null;
+    if (top) {
+        const pre = verification
+            ? await snapshotPage(target, verification.signalCounter, verification.page)
+            : null;
+        const clickResult = await target
+            .evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(top.deepIndex))
+            .catch((err) => {
+            if (isNavigatingEvaluateRejection(err))
+                return { clicked: false };
+            throw err;
+        });
+        if (clickResult.clicked) {
+            if (!pre || !verification)
+                return true;
+            const post = await snapshotPage(target, verification.signalCounter, verification.page);
+            const verdict = (0, phantom_click_1.classifyPhantomClick)({
+                actResultSuccess: true,
+                pre,
+                post,
+                isSubmitShapedStep: true,
+            });
+            if (verdict !== "phantom")
+                return true;
+            const runnerUp = ranked[1];
+            if (runnerUp) {
+                const runnerUpClickResult = await target
+                    .evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(runnerUp.deepIndex))
+                    .catch((err) => {
+                    if (isNavigatingEvaluateRejection(err))
+                        return { clicked: false };
+                    throw err;
+                });
+                if (runnerUpClickResult.clicked)
+                    return true;
+            }
+        }
+    }
     const submitExpr = `(() => {
     const responseField = ${JSON.stringify(responseField)};
     const field = document.querySelector('[name="' + responseField + '"]');
-    const form = field ? field.closest("form") : null;
+    const fieldForm = field ? field.closest("form") : null;
+    const forms = Array.from(document.querySelectorAll("form"));
+    const form = fieldForm ?? forms.find((candidate) => candidate.querySelector("[data-sitekey]")) ?? forms[0];
     if (form) (form.requestSubmit ? form.requestSubmit() : form.submit());
   })()`;
     // form.submit() navigates the frame synchronously, tearing down the execution
     // context before Runtime.evaluate can marshal a return value for this call —
     // that rejection is the expected outcome of a navigating evaluate, not a
     // real failure, so it's discarded here rather than awaited for a result.
-    await target.evaluate(submitExpr).catch(() => undefined);
+    await target.evaluate(submitExpr).catch((err) => {
+        if (isNavigatingEvaluateRejection(err))
+            return undefined;
+        throw err;
+    });
+    return true;
 }
 /**
  * Site-agnostic select primitive: answer a native `<select>` dropdown by
@@ -7759,7 +7909,7 @@ async function executeStepWithHealing(params) {
     // instead of silently falling through as if unverified-but-passing.
     const isSubmitOrFinalStep = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag);
     if (captchaGated && isSubmitOrFinalStep) {
-        const captchaTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+        let captchaTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
         const sitekeyProbeExpr = `(() => {
       const el = document.querySelector("[data-sitekey]");
       if (!el) return { siteKey: null, isInvisible: false };
@@ -7787,26 +7937,56 @@ async function executeStepWithHealing(params) {
             // no-nav case is the same underlying race from the other side.
             for (let captchaAttempt = 1; captchaAttempt <= CAPTCHA_REGISTRY_RETRY_ATTEMPTS; captchaAttempt++) {
                 if (captchaAttempt > 1) {
+                    // Re-resolve the target frame before every retry, mirroring the
+                    // main step loop's per-step `resolveFrameTarget` call: a
+                    // navigation or detach triggered by the prior attempt (its solve's
+                    // ~120s wait, its inject, or its submit) can leave `captchaTarget`
+                    // bound to a torn-down frame, and every evaluate below would
+                    // otherwise silently keep operating on that stale target for the
+                    // rest of the retries. A target with no declared frame selector
+                    // (main-frame flows) resolves this immediately with zero polling.
+                    captchaTarget = await (0, frame_target_1.resolveFrameTarget)(page, captchaTarget.frameSelector ?? captchaTarget.declaredFrameSelector ?? null);
                     // Re-assert the capture install in the target frame before
                     // retrying: a late-attaching registry may not exist yet on the
                     // first attempt, and re-running this idempotent install gives a
                     // widget that renders on demand another chance to be caught.
                     await captchaTarget.evaluate((0, captcha_callback_capture_1.buildHcaptchaCallbackCaptureScript)()).catch(() => undefined);
                 }
-                const solved = await (0, captcha_solver_1.solveCaptcha)({
+                const solveResult = await (0, captcha_solver_1.solveCaptcha)({
                     type: "hcaptcha",
                     siteKey,
                     pageUrl,
                     isInvisible,
                     userAgent,
                     proxy: sessionProxy ?? undefined,
-                }).catch((err) => {
-                    logger.error(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: solve failed (${(0, errors_1.toErrorMessage)(err)}); failing the step rather than silently proceeding`);
-                    throw err;
-                });
+                })
+                    .then((solved) => ({ ok: true, solved }))
+                    .catch((err) => ({ ok: false, err }));
+                if (!solveResult.ok) {
+                    const attemptsRemain = captchaAttempt < CAPTCHA_REGISTRY_RETRY_ATTEMPTS;
+                    logger.error(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: solve failed on attempt ${captchaAttempt}/${CAPTCHA_REGISTRY_RETRY_ATTEMPTS} (${(0, errors_1.toErrorMessage)(solveResult.err)}); ${attemptsRemain ? "retrying" : "failing the step rather than silently proceeding"}`);
+                    if (attemptsRemain)
+                        continue;
+                    throw solveResult.err;
+                }
+                const solved = solveResult.solved;
                 const preCaptchaCaptureIdx = latestCaptureIndex(recentCaptures);
-                const injectResult = await injectCaptchaTokenAndSubmit(captchaTarget, solved.token);
-                const registryState = await captchaTarget.evaluate(`(() => {
+                const preCaptchaMetaLength = recentCaptureMeta.length;
+                // Both the inject-and-submit primitive and the registry-state probe
+                // below evaluate against `captchaTarget` after the solve's ~120s poll
+                // has already elapsed, so a page navigation or frame detach that
+                // happened during that wait can leave the frame stale/wedged and
+                // make either evaluate throw via `withWatchdog` — a possibility
+                // distinct from (and unguarded by) the solveCaptcha rejection handled
+                // above. Fold that into the same attempts-remaining tolerance rather
+                // than letting it escape the loop uncaught on every attempt: retry
+                // when attempts remain, still throw on the final attempt so a
+                // genuine failure fails the step per the comment below.
+                let injectResult;
+                let registryState;
+                try {
+                    injectResult = await injectCaptchaTokenAndSubmit(captchaTarget, solved.token);
+                    registryState = await captchaTarget.evaluate(`(() => {
           const sitekey = ${JSON.stringify(siteKey)};
           const findSitekeyEl = function () {
             return Array.prototype.find.call(
@@ -7832,6 +8012,14 @@ async function executeStepWithHealing(params) {
           if (hcaptchaLoaded && widgetRendered) return "renderedUnmatched";
           return "empty";
         })()`);
+                }
+                catch (err) {
+                    const attemptsRemain = captchaAttempt < CAPTCHA_REGISTRY_RETRY_ATTEMPTS;
+                    logger.error(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: token inject/registry-probe threw on attempt ${captchaAttempt}/${CAPTCHA_REGISTRY_RETRY_ATTEMPTS} (${(0, errors_1.toErrorMessage)(err)}); ${attemptsRemain ? "retrying" : "failing the step rather than silently proceeding"}`);
+                    if (attemptsRemain)
+                        continue;
+                    throw err;
+                }
                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: attempt=${captchaAttempt}/${CAPTCHA_REGISTRY_RETRY_ATTEMPTS} token injected=${injectResult.injected} hasForm=${injectResult.hasForm} callbackDiscovered=${injectResult.callbackDiscovered} registryState=${registryState}`);
                 // Reuse the EXISTING waitForTransitionBody poll (no new captcha-specific
                 // poll loop), just with a widened budget so the solve+submit round trip
@@ -7856,9 +8044,32 @@ async function executeStepWithHealing(params) {
                 // only issue an explicit submit when no transition was observed AND a
                 // form is known to exist to submit — otherwise this would double-submit
                 // a form the widget's own callback already advanced.
+                let fallbackSubmitted = false;
                 if (!confirmed && injectResult.hasForm) {
-                    await submitCaptchaGatedForm(captchaTarget);
-                    if (advanceTransitionBodyPattern) {
+                    try {
+                        fallbackSubmitted = await submitCaptchaGatedForm(captchaTarget, "h-captcha-response", {
+                            signalCounter,
+                            page,
+                        });
+                    }
+                    catch (err) {
+                        // A genuine in-page exception from the click/submit dispatch
+                        // (classified via `isNavigatingEvaluateRejection` inside
+                        // `submitCaptchaGatedForm`) — not the expected context-teardown
+                        // rejection of a submit that navigated the frame. Fold into the
+                        // same attempts-remaining tolerance as the inject/registry-probe
+                        // catch above rather than letting it silently resolve as a
+                        // no-op fallback.
+                        const attemptsRemain = captchaAttempt < CAPTCHA_REGISTRY_RETRY_ATTEMPTS;
+                        logger.error(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: explicit submit fallback threw a genuine in-page exception on attempt ${captchaAttempt}/${CAPTCHA_REGISTRY_RETRY_ATTEMPTS} (${(0, errors_1.toErrorMessage)(err)}); ${attemptsRemain ? "retrying" : "failing the step rather than silently proceeding"}`);
+                        if (attemptsRemain)
+                            continue;
+                        throw err;
+                    }
+                    if (!fallbackSubmitted) {
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: explicit submit fallback found no field/form to act on (widget likely tore down or replaced it after the callback fired); nothing was submitted`);
+                    }
+                    else if (advanceTransitionBodyPattern) {
                         confirmed = await waitForTransitionBody({
                             page,
                             preIdx: preCaptchaCaptureIdx,
@@ -7891,13 +8102,53 @@ async function executeStepWithHealing(params) {
                     trajectory?.push({ stepIndex, verifiedBy: "url" });
                     return "completed";
                 }
+                // Neither transition poll above can see a same-origin submit whose
+                // response never changes the page's URL (an XHR/fetch-driven submit
+                // with no client-side redirect). `findRecentPageTransition` is the
+                // SAME network-capture detector the probe-absent path below already
+                // relies on for exactly this case — reusing it here, scoped to the
+                // captures landed since this attempt's solve, catches the submit a
+                // clean callback dispatches even when the URL/origin never moves.
+                const networkTransitionUrl = findRecentPageTransition({
+                    recentCaptureMeta,
+                    preMetaLength: preCaptchaMetaLength,
+                });
+                if (networkTransitionUrl !== null) {
+                    logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: post-submit network response confirmed the advance (${networkTransitionUrl})`);
+                    trajectory?.push({ stepIndex, verifiedBy: "network" });
+                    return "completed";
+                }
+                // The discovered callback threw a genuine in-page exception during
+                // its invoke (classified via `isNavigatingEvaluateRejection`), and
+                // none of the transition detectors above confirmed an advance
+                // either. Checked BEFORE `shouldRetryCaptchaRegistry` below so the
+                // swallowed exception is always logged and threaded into the retry
+                // decision — never silently absorbed into that check's generic
+                // "callback fired but no nav" retry reasoning, which says nothing
+                // about a real thrown error having occurred. A thrown exception is
+                // direct evidence the token was never actually delivered, not merely
+                // an absence of a poll result, so it must never be folded into the
+                // "clean callback, no evidence either way" fallthrough further below
+                // either. Retry while attempts remain (the exception may be
+                // transient, e.g. a stale frame on this attempt — re-resolved at the
+                // top of the next iteration), else fail loudly naming the real cause
+                // instead of silently reporting `callbackDiscovered=true`/
+                // `injected=true` and falling through to the phantom-click cascade
+                // with no trace of it.
+                if (injectResult.callbackInvokeError) {
+                    const attemptsRemain = captchaAttempt < CAPTCHA_REGISTRY_RETRY_ATTEMPTS;
+                    logger.error(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: the discovered callback threw a genuine in-page exception on attempt ${captchaAttempt}/${CAPTCHA_REGISTRY_RETRY_ATTEMPTS} (${injectResult.callbackInvokeError}); ${attemptsRemain ? "retrying" : "failing the step rather than silently falling through to the cascade"}`);
+                    if (attemptsRemain)
+                        continue;
+                    throw new errors_2.CaptchaError(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: the discovered callback threw a genuine in-page exception (${injectResult.callbackInvokeError}) instead of delivering the token, and no transition was confirmed after the solve`);
+                }
                 // The intermittent race this loop exists for: a still-empty/absent
                 // registry means the callback attach hadn't landed when this attempt
                 // solved+injected, and a discovered-but-unconfirmed callback means it
                 // fired without a poll seeing the resulting transition. Both are
                 // worth another attempt within budget rather than an immediate throw.
                 if (shouldRetryCaptchaRegistry(captchaAttempt, CAPTCHA_REGISTRY_RETRY_ATTEMPTS, registryState, injectResult.callbackDiscovered, confirmed)) {
-                    logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: registryState=${registryState} callbackDiscovered=${injectResult.callbackDiscovered} with no confirmed transition on attempt ${captchaAttempt}; retrying`);
+                    logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: registryState=${registryState} callbackDiscovered=${injectResult.callbackDiscovered} fallbackSubmitted=${fallbackSubmitted} with no confirmed transition on attempt ${captchaAttempt}; retrying`);
                     continue;
                 }
                 // No render-config callback was discoverable AND neither the inject's
@@ -7911,9 +8162,25 @@ async function executeStepWithHealing(params) {
                 // none configured, no network poll ever ran, so there's nothing here
                 // to contradict the normal cascade/verifier.
                 if (advanceTransitionBodyPattern && !injectResult.callbackDiscovered) {
-                    throw new errors_2.CaptchaError(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: no render-config callback could be found and delivered, and no transition was confirmed after the solve`);
+                    const fallbackDetail = injectResult.hasForm && !fallbackSubmitted
+                        ? " and the explicit submit fallback found no field/form to act on"
+                        : "";
+                    throw new errors_2.CaptchaError(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: no render-config callback could be found and delivered, and no transition was confirmed after the solve${fallbackDetail}`);
                 }
-                break;
+                // The remaining shape: a render-config callback WAS cleanly
+                // discovered and invoked on every attempt (or no pattern was
+                // configured to distinguish that from the branch above), yet
+                // neither the navigation poll nor the network-capture scan ever
+                // confirmed an advance on any attempt. `shouldRetryCaptchaRegistry`
+                // above already exhausted every attempt worth retrying, so this is
+                // not a registry race — the token was solved and handed to the
+                // widget's own callback, but nothing observable ever moved. Fail
+                // loudly here too instead of `break`-ing into the normal
+                // phantom-click cascade as if the solve had worked; that fallthrough
+                // is the exact misleading "callbackDiscovered=true" silent no-op
+                // this hook must never produce, pattern-configured or not.
+                logger.error(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: registryState=${registryState} callbackDiscovered=${injectResult.callbackDiscovered} produced no confirmed transition after exhausting all ${CAPTCHA_REGISTRY_RETRY_ATTEMPTS} attempts; failing the step rather than silently falling through to the cascade`);
+                throw new errors_2.CaptchaError(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: registryState=${registryState} callbackDiscovered=${injectResult.callbackDiscovered} produced no confirmed transition after exhausting all attempts`);
             }
         }
     }
@@ -9210,9 +9477,7 @@ async function executeStepWithHealing(params) {
         // ng-invalid marker count grew (see isClickViewSwapVerified's doc comment).
         const clickViewSwapVerified = isClickViewSwapVerified({
             resolvedAction,
-            isFinalStep,
             submitStep,
-            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
             isAdvanceWithPattern: isAdvanceStep(step) && advanceTransitionBodyPattern !== null,
             networkDelta: post.networkCount - pre.networkCount,
             bytesDelta: post.bodyHtmlLength - pre.bodyHtmlLength,
@@ -9330,10 +9595,49 @@ async function executeStepWithHealing(params) {
                 }
             }
         }
+        // Phantom-click verdict, computed from the same pre/post pair the
+        // signals above were derived from. Read HERE — at the point the retry
+        // loop decides whether to keep going — rather than only after the
+        // `verified` gate has already failed the attempt: an `"effective"`
+        // verdict (a real, observable change) must end the attempt loop
+        // immediately regardless of step shape (final, submit, or ordinary
+        // interior toggle), the same as the narrower `verified` boolean does.
+        // Previously the verdict was computed only for post-failure diagnostics/
+        // escalation, so an attempt explicitly classified `"effective"` could
+        // still be followed by wasted further attempts (see
+        // recon-browser-1.12.54-phantom-click-verdict-inconsistent-blocks-terminal-tab-toggle-steps-from-ever-completing.md).
+        record.phantomClickVerdict = (0, phantom_click_1.classifyPhantomClick)({
+            actResultSuccess: record.actResultSuccess,
+            pre,
+            post,
+            elementStateChanged: domVerified,
+            isSubmitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
+        });
+        // An `"effective"` verdict driven purely by the page-wide byte-delta
+        // floor (`TRIVIAL_DOM_DELTA_BYTES`, 500B) is intentionally NOT trusted
+        // here: `clickViewSwapVerified`/`formValueVerified` already own that
+        // signal with the correct, much higher view-swap thresholds (5000B, or
+        // 500B+textChanged for a reveal) — see
+        // flow-runner.client-side-view-swap-cascade.test.ts's <5KB fixture,
+        // which must stay unverified so the cascade keeps excluding candidates.
+        // The one verdict-driven signal genuinely missing from `verified` is the
+        // element-scoped selection-state change (`domVerified`): a same-page
+        // toggle whose own committed state flips (Base Web `kind`/class, ARIA,
+        // native `checked`) with no network/URL/advance-pattern match had NO
+        // credit path at all outside the n+16 fallback's own checkbox-specific
+        // check, even though `classifyPhantomClick` already classifies it
+        // `"effective"` (excluded only on submit-shaped steps, to keep a stray
+        // self-toggle from defeating the submit escalation). Gated through
+        // `domVerifiedForStep` (not raw `domVerified`) so this credit path
+        // respects the SAME DOM-only-advance veto as the block above: a wizard
+        // "Next" step on a pattern-configured site whose only signal is a field
+        // toggle must stay unverified, not get waved through by the verdict.
+        const domEffectiveVerdict = !(submitStep || (isFinalStep && flowHasSubmitSemanticsFlag)) && domVerifiedForStep;
         let verified = networkIsRealAdvance ||
             urlChanged ||
             domVerifiedForStep ||
             datepickerCommitted ||
+            domEffectiveVerdict ||
             (!datepickerRejected &&
                 !promptSelectorRejected &&
                 (clickViewSwapVerified || formValueVerified));
@@ -9351,7 +9655,20 @@ async function executeStepWithHealing(params) {
         // state. A 2xx network response alone is insufficient (could be
         // telemetry). The Haiku judge defaults to verified=false when
         // ambiguous — strong evidence, not lax permission.
-        if (verified && requireSubmitEndpoint) {
+        //
+        // Only re-litigate an already-`verified` step through the judge when
+        // the step is EXPLICITLY the submit (`submitStep: true`) or a genuine
+        // transition fired (`networkIsRealAdvance` / `urlChanged`). A step that
+        // reached `verified` purely via the element-scoped selection-state
+        // credit (`domVerifiedForStep`) with no explicit `submitStep` flag is
+        // the inferred-final-step case — a same-page toggle the recon slice
+        // happened to end on, not the flow's real submit action (see
+        // flow-runner.final-step-toggle-not-submit-shaped-acceptance.test.ts).
+        // Forcing that toggle through the submit judge (which requires a DOM/
+        // URL/title post-submit signal it will never produce) false-negatives
+        // an already-genuine credit.
+        const hasSubmitTransitionSignal = submitStep || networkIsRealAdvance || urlChanged;
+        if (verified && requireSubmitEndpoint && hasSubmitTransitionSignal) {
             // Cap the scan from preMetaLength so we don't accept a historical
             // submit-shaped capture from an earlier step as proof for this one.
             const tail = recentCaptureMeta.slice(preMetaLength);
@@ -9698,6 +10015,36 @@ async function executeStepWithHealing(params) {
                     const weakDomSignalsAllowed = ((!isFinalStep && !submitStep) || requireSubmitEndpoint) &&
                         !isCheckboxOrRadioIntentStep(step) &&
                         !clickTargetIsSelectionMarker;
+                    // Same effective-verdict credit the primary attempt's completion
+                    // gate uses (see the `record.phantomClickVerdict` computation
+                    // above), re-run against THIS fallback click's own pre/post pair
+                    // (`pre`/`retryPost`) rather than the stale pre/post the primary
+                    // technique captured — the primary technique's own act() call may
+                    // not have produced any DOM effect at all, with the fallback's
+                    // `el.click()` being the click that actually landed. Still subject
+                    // to the `clickBlockedByDisabled`/`clickBlockedByInvalid`/
+                    // `fallbackDomOnlyAdvance` vetoes below, same as every other
+                    // fallback signal. `classifyPhantomClick` can still classify a
+                    // submit-shaped step "effective" purely off the page-wide
+                    // `TRIVIAL_DOM_DELTA_BYTES` floor (elementStateChanged is already
+                    // excluded on submit-shaped steps below via `isSubmitShapedStep`),
+                    // so the byte-delta-only branch of that verdict must not bypass
+                    // the submit-endpoint corroboration gate any more than the raw
+                    // `retryHtmlDelta`/`retryTextChanged` signals below may — same
+                    // `retrySubmitShaped` exclusion the primary gate's
+                    // `domEffectiveVerdict` applies. See
+                    // flow-runner.viewswap-blocked-submit-acceptance.test.ts (must stay
+                    // gated) and flow-runner.pricing-tab-symmetric-swap-verdict-
+                    // acceptance.test.ts (a non-submit-shaped final step must still get
+                    // credit here).
+                    const retrySubmitShaped = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag);
+                    const retryVerdict = (0, phantom_click_1.classifyPhantomClick)({
+                        actResultSuccess: record.actResultSuccess,
+                        pre,
+                        post: retryPost,
+                        elementStateChanged: retrySelectionStateChanged,
+                        isSubmitShapedStep: retrySubmitShaped,
+                    });
                     let retryVerified = !clickBlockedByDisabled &&
                         !clickBlockedByInvalid &&
                         !fallbackDomOnlyAdvance &&
@@ -9705,14 +10052,25 @@ async function executeStepWithHealing(params) {
                             retryUrlChanged ||
                             checkboxStateVerified ||
                             retrySelectionStateChanged ||
+                            (!retrySubmitShaped && retryVerdict === "effective") ||
                             (weakDomSignalsAllowed &&
                                 (retryHtmlDelta !== 0 || retryTextChanged || retryFormValueChanged)));
+                    if (retryVerified) {
+                        record.phantomClickVerdict = retryVerdict;
+                    }
                     // Apply the same submit-endpoint gate the primary verifier uses.
                     // Without this, the n+16 fallback would still ride past a
                     // tracking-pixel-only click on the final step. Same Haiku LLM
                     // judgment as the primary verifier — multi-signal corroboration
-                    // replaces deterministic URL regex matching.
-                    if (retryVerified && requireSubmitEndpoint) {
+                    // replaces deterministic URL regex matching. Same
+                    // hasSubmitTransitionSignal carve-out as the primary verifier: an
+                    // inferred (non-explicit-submitStep) final step whose n+16 credit
+                    // came only from the element-scoped `retrySelectionStateChanged`
+                    // signal is the same ordinary-toggle shape, not a real submit —
+                    // don't force it through a judge that requires evidence it can
+                    // never produce.
+                    const retryHasSubmitTransitionSignal = submitStep || retryNetworkIsRealAdvance || retryUrlChanged;
+                    if (retryVerified && requireSubmitEndpoint && retryHasSubmitTransitionSignal) {
                         const tail = recentCaptureMeta.slice(preMetaLength);
                         // DOM-state probe (deterministic).
                         let domSubmittedMatch = null;
@@ -9820,22 +10178,10 @@ async function executeStepWithHealing(params) {
             return "completed";
         }
         const effectSignals = describeAttemptEffectSignals(pre, post, recentCaptureMeta, preMetaLength);
-        // Phantom-click verdict, computed from the SAME pre/post pair
-        // describeAttemptEffectSignals just rendered — not recomputed deltas.
-        // Recorded on every unverified attempt (not just attempt 1) so the
-        // failure dump's attempts[] always carries the classification; only
-        // attempt 1's verdict drives the escalation flag below.
-        record.phantomClickVerdict = (0, phantom_click_1.classifyPhantomClick)({
-            actResultSuccess: record.actResultSuccess,
-            pre,
-            post,
-            // Authoritative element-scoped signal: `verifyDomEffect` read the resolved
-            // element's own committed-state delta (Base Web `kind`/class, ARIA, native
-            // checked) into `domVerified`. A registered selection toggle no longer
-            // reads as a phantom just because it moved no network/URL/bytes.
-            elementStateChanged: domVerified,
-            isSubmitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
-        });
+        // record.phantomClickVerdict was already computed above, before the
+        // `verified` gate — reaching this point means it is NOT `"effective"`
+        // (an effective verdict would have short-circuited to "completed"
+        // above), so it is either `"phantom"` or `"unresolved"` here.
         const reason = record.errorMessage
             ? effectSignals
                 ? `${record.errorMessage}; ${effectSignals}`