@enricai/barnacle 1.6.1 → 1.6.3

package/dist/scraper/flow-runner.js

@@ -60,6 +60,7 @@ exports.chooseRequiredSelectOption = chooseRequiredSelectOption;
 exports.buildRadioIdXPath = buildRadioIdXPath;
 exports.selectRadioGroupOption = selectRadioGroupOption;
 exports.narrowInvalidFormControl = narrowInvalidFormControl;
+exports.formatStepPrefix = formatStepPrefix;
 exports.probeStepBeforeAttempts = probeStepBeforeAttempts;
 exports.executeStepWithHealing = executeStepWithHealing;
 exports.waitForSpaReady = waitForSpaReady;
@@ -81,7 +82,9 @@ const logging_1 = require("../lib/logging");
 const call_capture_1 = require("../lib/telemetry/call-capture");
 const call_types_1 = require("../lib/telemetry/call-types");
 const errors_2 = require("../scraper/errors");
+const phantom_click_1 = require("../scraper/phantom-click");
 const stagehand_guard_1 = require("../scraper/stagehand-guard");
+const submit_control_1 = require("../scraper/submit-control");
 const recon_shared_1 = require("../scripts/recon-shared");
 const logger = (0, logging_1.getLogger)({ name: "scraper/flow-runner" });
 /** Cap on the rolling capture-filename window held in memory for failure dumps. */
@@ -352,7 +355,7 @@ const SELECT_SETTLE_MS = 400;
 /**
  * Extra bounded poll window for a network-only advance whose real
  * `TransitionWorklet(type="next")` POST lands AFTER the `STEP_PAUSE_MS`
- * snapshot. HCA/Talemetry's "Next" click fires a fast `WorkletPayload` autosave
+ * snapshot. The wizard ATS's "Next" click fires a fast `WorkletPayload` autosave
  * first, then the actual transition ~0.6-2s+ later — so a one-shot check
  * false-negatives the advance, retries the click, and the stale retry fires a
  * `back` that bounces the wizard. Additive to `STEP_PAUSE_MS`; only spent on an
@@ -426,7 +429,7 @@ exports.STEP_WATCHDOG_MS = 120_000;
  * browser-context `page.evaluate` expression string, where a Node RegExp can't
  * cross the boundary.
  *
- * Why the additions beyond the original Angular/Bootstrap set: HCA's Talemetry
+ * Why the additions beyond the original Angular/Bootstrap set: the Angular/MUI
  * wizard mixes Angular pages AND Material-UI (React) pages (Review, self-ID,
  * COMPENSATION). MUI marks invalid controls with `Mui-error` (class) +
  * `aria-invalid="true"` (attribute), NONE of which the ng-only regex matched —
@@ -493,11 +496,11 @@ async function snapshotPage(page, signalCounter) {
 /**
  * Detect whether a 2xx response body indicates the server REJECTED the
  * application despite returning a 2xx HTTP status. Many ATSs use a "200 OK
- * with rejection envelope" pattern instead of a 4xx: AppCast returns
+ * with rejection envelope" pattern instead of a 4xx: one JSON-envelope ATS returns
  * `{not_qualified: true, error: "Not qualified reason: <field>"}`,
  * Greenhouse uses `{rejected: true, reason: "..."}`, Lever uses
  * `{qualified: false, reason: "..."}`, Workday uses
- * `{status: "rejected"}`. Empirically verified on AppCast: 4/6 historical
+ * `{status: "rejected"}`. Empirically verified on a JSON-envelope ATS: 4/6 historical
  * /integrated_apply 200s on this codebase had `not_qualified: true` and
  * we treated them as wins because the audit only checked HTTP status.
  *
@@ -685,7 +688,7 @@ function latestCaptureIndex(recentCaptures) {
  * read straight from `capturesDir` — NOT from the in-memory `recentCaptures`
  * array, which is front-evicted to `RECENT_CAPTURES_WINDOW` and therefore drops
  * a step's transition when >20 captures flood during the step (measured 43
- * across one HCA cascade). Scanning disk by filename index is eviction-proof:
+ * across one wizard-ATS cascade). Scanning disk by filename index is eviction-proof:
  * the transition file is always on disk regardless of array churn. `.decoded.json`
  * sidecars are excluded (the raw file carries `requestPostData`). Sorted by index
  * so callers scan in capture order. Returns [] when the dir is unreadable.
@@ -709,7 +712,7 @@ function capturesAfterIndex(preIdx, capturesDir) {
  * Detects a multi-page-wizard RESTART / backward navigation by scanning the
  * captures written during this step for a configured restart-signal pattern
  * (e.g. `init-apply`, `application_canceled=true`). The restart signal is often
- * a plain GET (Talemetry's `GET .../init-apply?...&application_canceled=true`),
+ * a plain GET (the wizard ATS's `GET .../init-apply?...&application_canceled=true`),
  * so it scans the raw capture files' `url` field (GETs are written to disk even
  * though they're dropped from `recentCaptureMeta`). Window scoped by
  * `preIdx` via {@link capturesAfterIndex} (eviction-proof). Returns the matching
@@ -719,7 +722,7 @@ function capturesAfterIndex(preIdx, capturesDir) {
  * Does any same-window network capture's REQUEST BODY match the configured
  * transition pattern? Proves an interior "advance"/"Next" step really moved the
  * wizard forward when advance and non-advance mutations share one endpoint URL
- * (e.g. Talemetry `/gq`: a real advance is a `TransitionWorklet` mutation, a
+ * (e.g. the wizard ATS's `/gq`: a real advance is a `TransitionWorklet` mutation, a
  * field edit is `EditQuestionItem` — same URL, only the body differs, so a
  * URL/meta-based check can't tell them apart). Window scoped by `preIdx` via
  * {@link capturesAfterIndex} (disk-scan by filename index — eviction-proof, so a
@@ -730,7 +733,7 @@ function windowHasTransitionBody(params) {
     const { preIdx, advanceTransitionBodyPattern } = params;
     if (!advanceTransitionBodyPattern)
         return false;
-    const capturesDir = params.capturesDir ?? recon_shared_1.CAPTURES_DIR;
+    const capturesDir = params.capturesDir ?? (0, recon_shared_1.resolveReconRunDir)().graphqlDir;
     let rx;
     try {
         rx = new RegExp(advanceTransitionBodyPattern);
@@ -758,7 +761,7 @@ function windowHasTransitionBody(params) {
  * Stricter sibling of {@link windowHasTransitionBody}: a same-window capture
  * whose request body matches the transition pattern AND whose parsed
  * `variables.input.type === "next"`. The mutation NAME alone is a weak
- * distinguisher — on Talemetry a `back` bounce is ALSO a `TransitionWorklet`
+ * distinguisher — on the wizard ATS a `back` bounce is ALSO a `TransitionWorklet`
  * mutation (its body contains the pattern too) and would wrongly count as an
  * advance; and the fast `WorkletPayload` autosave that precedes the real
  * transition is a different mutation with no `input.type`. Requiring the parsed
@@ -772,7 +775,7 @@ function windowHasAdvanceTransition(params) {
     const { preIdx, advanceTransitionBodyPattern } = params;
     if (!advanceTransitionBodyPattern)
         return false;
-    const capturesDir = params.capturesDir ?? recon_shared_1.CAPTURES_DIR;
+    const capturesDir = params.capturesDir ?? (0, recon_shared_1.resolveReconRunDir)().graphqlDir;
     let rx;
     try {
         rx = new RegExp(advanceTransitionBodyPattern);
@@ -805,7 +808,7 @@ function windowHasAdvanceTransition(params) {
  * the RC2 gate is unit-testable.
  *
  * An interior "Next" on an SPA where an advance and a mere field-edit share one
- * endpoint (Talemetry `/gq`: TransitionWorklet vs EditQuestionItem — same URL,
+ * endpoint (the wizard ATS's `/gq`: TransitionWorklet vs EditQuestionItem — same URL,
  * different body) can fire a network POST that is NOT a real advance; the
  * fallback's htmlDelta/textChanged/checked-radio signals are then validation
  * re-renders / field toggles that don't move the wizard. So for an opted-in
@@ -830,7 +833,7 @@ function shouldVetoFallbackAdvance(params) {
  * transition fired — a URL change OR a real `type=next` (`networkIsRealAdvance`).
  * A DOM change alone is a validation re-render / field toggle that never moves
  * the wizard. Crucially this must veto even when a NON-advancing network POST
- * fired (Talemetry's `WorkletPayload` autosave): keying the veto on "no network
+ * fired (the wizard ATS's `WorkletPayload` autosave): keying the veto on "no network
  * at all" let a rephrase that triggered an autosave + DOM reflow false-verify an
  * advance, desyncing the flow from the wizard. Returns whether the DOM signal is
  * ALLOWED to verify: false = veto it. Non-advance/field steps, sites without the
@@ -921,7 +924,7 @@ function describeAttemptEffectSignals(pre, post, recentCaptureMeta, preMetaLengt
  * keeps healing opportunistically.
  */
 function shouldSkipTechnique(params) {
-    const { technique, priorAttempts, advanceUnmovedAfterAttempt1 } = params;
+    const { technique, priorAttempts, advanceUnmovedAfterAttempt1, phantomClickAfterAttempt1, submitShapedStep, } = params;
     // Unmoved-advance short-circuit (measured: attempts 2-4 recovered a stuck
     // advance 0 times in 289 steps). When attempt-1's act-string clicked the Next
     // and the wizard did NOT move forward (non-advancing POST, or no effect),
@@ -942,6 +945,31 @@ function shouldSkipTechnique(params) {
             reason: "advance step did not move the wizard on attempt 1; re-observe/re-click cannot advance it — skipping to rephrase/replan",
         };
     }
+    // Phantom-click short-circuit: attempt 1 clicked something Stagehand
+    // believes exists, but pre/post shows zero network, zero URL change, and
+    // no real DOM growth — the click almost certainly landed on nothing (the
+    // recon-submit-phantom-click bug report's light-DOM resolver can't see
+    // into a shadow root / web component). Repeating observe-act /
+    // structured-click / observe-act-exclude re-resolves the SAME
+    // light-DOM-only view of the page and would no-op identically, so skip
+    // straight to deep-submit-locator (attempt 2) instead. llm-rephrase
+    // (attempt 5) is never skipped — a differently-worded instruction is still
+    // a distinct attempt worth trying if the deep locator also fails. Gated on
+    // submitShapedStep: the deep submit-control locator ranks submit-shaped
+    // candidates only, so on a non-submit control (e.g. a radio/checkbox) it
+    // is a guaranteed no-op — leave the normal ladder intact so
+    // structured-click / observe-act-exclude, the techniques that can
+    // actually click it, still run.
+    if (phantomClickAfterAttempt1 === true &&
+        submitShapedStep === true &&
+        (technique === "observe-act" ||
+            technique === "structured-click" ||
+            technique === "observe-act-exclude")) {
+        return {
+            skip: true,
+            reason: "attempt 1 was a phantom click (reported success, zero observable effect) on a submit-shaped step; re-observe/re-click cannot reach a target the light-DOM resolver can't see — escalating to the deep submit-control locator",
+        };
+    }
     if (technique === "structured-click") {
         const anyXpathResolved = priorAttempts.some((a) => a.triedSelectors.length > 0);
         if (!anyXpathResolved) {
@@ -1013,7 +1041,7 @@ function isSubmitRevealedInvalid(params) {
  * landed within the poll window (`networkIsRealAdvance` false), the button works
  * but the wizard is refusing to advance (a precondition isn't met, e.g. a
  * required field the flow answers on a LATER step). Re-clicking the same button
- * only re-fires the autosave / a `back` bounce — measured across HCA runs as the
+ * only re-fires the autosave / a `back` bounce — measured across wizard-ATS runs as the
  * next→back oscillation. Break to replan instead, which can reorder a later step
  * forward. Conservative: any condition unmet → run the full cascade as before.
  * Never fires on final/submit steps (they own `isSubmitRevealedInvalid`) or on
@@ -1066,7 +1094,7 @@ async function rephraseWithLLM(client, originalStep, triedSelectors, observeCand
  * invalid form fields and visible error messages so the rephrase LLM can
  * propose corrective fills instead of
  * just "click harder" — the previous limitation observed in the
- * telemetry of the appcast Encompass run (every rephrase converged on
+ * telemetry of the JSON-envelope ATS run (every rephrase converged on
  * "Click Submit Application using JavaScript" because the prompt had no
  * signal that the form was invalid).
  */
@@ -1411,8 +1439,8 @@ const BODY_EXCERPT_FORM_WINDOW = 16_000;
  * Default: first 8KB. That window held for tenants whose form was at the
  * top of the page (early sweeps in 2026-06).
  *
- * For pages where the form HTML lives below 8KB (verified on AppCast's
- * applyboard SPA: ng-invalid first appears at byte ~15,500 after a header
+ * For pages where the form HTML lives below 8KB (verified on an Angular
+ * apply SPA: ng-invalid first appears at byte ~15,500 after a header
  * of Angular hydration JS + chrome), the 8KB cap silently produced
  * "FORM FIELDS CURRENTLY MARKED INVALID: (none)" in the replan prompt,
  * leaving the LLM with no evidence and causing it to hallucinate steps
@@ -1423,7 +1451,7 @@ const BODY_EXCERPT_FORM_WINDOW = 16_000;
  *
  * Site-agnostic: the markers we look for (ng-invalid, mat-form-field-
  * invalid, is-invalid, <form) are framework-level CSS-class conventions
- * used across countless SPAs, not AppCast-specific.
+ * used across countless SPAs, not specific to any one ATS.
  */
 function selectBodyExcerpt(body) {
     if (body.length <= BODY_EXCERPT_DEFAULT_CAP)
@@ -1454,7 +1482,7 @@ async function extractLivePageFormEvidence(page, options) {
     }
     // Pick a body excerpt that's likely to contain the form's invalid-field
     // markers. Default 8KB cap unless the body has ng-invalid / <form past
-    // the cap (typical of AppCast applyboard SPA, where the form starts
+    // the cap (typical of an Angular apply SPA, where the form starts
     // ~15KB into a page of Angular hydration scaffolding). See
     // selectBodyExcerpt for details.
     const bodyExcerpt = selectBodyExcerpt(body);
@@ -1520,7 +1548,7 @@ async function extractLivePageFormEvidence(page, options) {
  * matches `ng-invalid` because of bubbling, but its child `<app-input
  * class="ng-invalid">` ALSO matches; `:not(:has(...))` filters out the parent.
  *
- * Today's Encompass-Fitchburg smoke (run 1781478440322) showed E1's prompt
+ * A JSON-envelope ATS tenant's smoke (run 1781478440322) showed E1's prompt
  * instruction ("prefer the leaf, not the bubbled parent") only got Haiku from
  * 5 wrong fields → 1 wrong field — still surfaced `(unlabeled) <ol>` instead
  * of `<app-input autocomplete="zip-code">` at byte 95,033. All 3 replans + 4
@@ -1710,8 +1738,9 @@ async function extractInteractiveTargetsNearInvalid(page) {
 /**
  * Scan recent capture files for failed submit-endpoint requests and pull
  * out structured field-level errors from the response body. The cascade
- * already saves every captured request to `CAPTURES_DIR` with its parsed
- * `responseBody`; this helper reads those files back, filters to captures
+ * already saves every captured request to the run's graphql capture dir
+ * (see {@link resolveReconRunDir}) with its parsed `responseBody`; this
+ * helper reads those files back, filters to captures
  * matching the configured submit pattern with status >= 400, and walks
  * common error-shape conventions (`{ errors: [{ field, message }] }`,
  * `{ validation/fieldErrors: { … } }`, `{ message }`).
@@ -1728,7 +1757,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 = recon_shared_1.CAPTURES_DIR, mode = "strict") {
+ownBackendHostnames, capturesDir = (0, recon_shared_1.resolveReconRunDir)().graphqlDir, mode = "strict") {
     if (recentCaptureFilenames.length === 0)
         return "";
     if (mode === "strict" && ownBackendHostnames.length === 0)
@@ -1805,7 +1834,7 @@ ownBackendHostnames, capturesDir = recon_shared_1.CAPTURES_DIR, mode = "strict")
 }
 /**
  * Surface Google Analytics Measurement Protocol events captured during a
- * step's attempt window. AppCast (and most GA4-instrumented SPAs) emit
+ * step's attempt window. A JSON-envelope ATS (and most GA4-instrumented SPAs) emits
  * `view_secondPage`, `view_thankYouPage`, `form_submit` and similar events
  * via `https://www.google-analytics.com/g/collect` — the engine already
  * stores these in `recentCaptures[]` but no code reads them. Without
@@ -1819,7 +1848,7 @@ ownBackendHostnames, capturesDir = recon_shared_1.CAPTURES_DIR, mode = "strict")
  * Returns a numbered evidence list. Empty string when no GA collect
  * captures are present. Advisory — never load-bearing.
  */
-function extractGaEventEvidence(recentCaptureFilenames, capturesDir = recon_shared_1.CAPTURES_DIR) {
+function extractGaEventEvidence(recentCaptureFilenames, capturesDir = (0, recon_shared_1.resolveReconRunDir)().graphqlDir) {
     if (recentCaptureFilenames.length === 0)
         return "";
     const records = [];
@@ -2078,9 +2107,9 @@ function harvestFieldErrors(body) {
         return [];
     const out = [];
     const rec = body;
-    // Singular `{error: "message"}` shape used by AppCast, Lever, Greenhouse,
+    // Singular `{error: "message"}` shape used by JSON-envelope ATSs, Lever, Greenhouse,
     // and any REST API following the {error:string} terse-error convention.
-    // Verified on AppCast Encompass-Fitchburg: /integrated_apply 422 body is
+    // Verified on a JSON-envelope ATS tenant: /integrated_apply 422 body is
     // exactly {"error":"Resume is blank"} — no `errors`, no `message`. Before
     // J', this was caught by neither the array branch below nor the
     // extractSubmitFailureEvidence fallback at line 2028, resulting in
@@ -2157,7 +2186,7 @@ const UPLOAD_NETWORK_POLL_INTERVAL_MS = 250;
 /**
  * How long the upload primitive waits for the async ResumeUpload widget (and its
  * lazily-mounted `<input type=file>`) to render before deciding the input is
- * absent. HCA/Talemetry mounts the MUI/react-dropzone widget ~5s after the
+ * absent. The wizard ATS mounts the MUI/react-dropzone widget ~5s after the
  * wizard lands on the Apply page, so a single probe races that mount and the
  * primitive wrongly falls into the click-to-surface path (or skips). Only
  * reached on `upload:true` steps, so it never slows a page with no upload step.
@@ -2167,7 +2196,7 @@ const UPLOAD_WIDGET_RENDER_ATTEMPTS = 17;
 /**
  * URL substrings that mark a POST as an actual resume/attachment upload rather
  * than coincidental traffic (analytics beacons, `/interruption_check`,
- * geocoders). Talemetry posts the resume to an `attachment_upload_url` that
+ * geocoders). The wizard ATS posts the resume to an `attachment_upload_url` that
  * matches `/attachment`; the others cover the other ATS upload sinks. Module-
  * level so both the raw-input path and the click-to-surface path share one list.
  */
@@ -2206,7 +2235,7 @@ async function waitForUploadNetworkSignal(params) {
  * True when a control's text/aria-label denotes a resume-upload affordance
  * (the button that surfaces a hidden `<input type=file>` or opens a chooser).
  * Pure + exported for unit tests; the vocabulary is intentionally generic so it
- * benefits any MUI/React/dropzone ATS, not just Talemetry. Rejects negative
+ * benefits any MUI/React/dropzone ATS, not just the wizard ATS. Rejects negative
  * lookalikes ("upload later", "no file", a bare "submit") so the click-to-
  * surface path never fires a skip/decline/submit control.
  */
@@ -2280,7 +2309,7 @@ async function tryUploadPrimitive(params) {
         return false;
     }
     if ((inputCount ?? 0) === 0) {
-        // Talemetry/MUI and other react-dropzone widgets can render NO <input type=file>
+        // MUI wizard and other react-dropzone widgets can render NO <input type=file>
         // at all (a click surfaces it, or a native chooser opens). Try to surface it
         // (click-to-mount or CDP native-chooser interception) before giving up.
         logger.info("upload primitive: no <input type=file> after render wait; attempting click-to-surface");
@@ -2322,7 +2351,7 @@ async function attachToSurfacedInput(params) {
         // ControlValueAccessor binds at the wrapper level — and the wrapper's
         // change handler doesn't observe input.files mutations directly.
         //
-        // Verified on AppCast Encompass-Fitchburg today: setInputFiles
+        // Verified on a JSON-envelope ATS tenant: setInputFiles
         // populated input.files but the subsequent /integrated_apply submit
         // had no `apply[resume]` multipart field — the framework wrapper
         // never registered the file in its internal state. Server returned
@@ -2385,7 +2414,7 @@ async function attachToSurfacedInput(params) {
 }
 /**
  * Recover an upload for widgets that mount NO `<input type=file>` until a button
- * is clicked (Talemetry/MUI `ResumeUpload`, react-dropzone). Ordered cheapest-
+ * is clicked (the MUI wizard's `ResumeUpload`, react-dropzone). Ordered cheapest-
  * first: (DZ) a synthetic drag-drop on the dropzone; then, arming CDP native-
  * chooser interception BEFORE any click (a chooser-opening click with no
  * interception blocks the run — the single biggest risk), click the upload
@@ -2572,7 +2601,7 @@ async function setFilesViaCdp(params) {
  * Parse a select/dropdown flow step into the option to choose and (when
  * present) the question label that scopes which dropdown it targets.
  *
- * Why: HCA/Talemetry render dropdowns as `MuiNativeSelect` native `<select>`
+ * Why: the Angular/MUI wizard ATS renders dropdowns as `MuiNativeSelect` native `<select>`
  * with `tabindex="-1"` — removed from the accessibility tree, so Stagehand
  * observe returns `[]` and the cascade can never select an option. The select
  * primitive answers these directly from the DOM, but needs the target option
@@ -2621,7 +2650,7 @@ function parseSelectStep(instruction) {
  * Why this exists (sibling of `parseSelectStep`): `parseSelectStep`
  * deliberately excludes bare radio steps ("a bare 'click the Yes answer' is a
  * radio"), leaving radios with no DOM-direct primitive — they fall to the
- * observe cascade, which on HCA/Talemetry's MUI radio markup resolves the step
+ * observe cascade, which on the wizard ATS's MUI radio markup resolves the step
  * to a wrapper `<div>`/`<span>` (not the `<input type=radio>`) and commits via
  * a bare `el.click()` that never triggers React's controlled-state `onChange`.
  * The field stays `Mui-error` "required", Next no-ops, and the wizard walls at
@@ -2673,7 +2702,7 @@ const PRIMITIVE_ENUMERATE_ATTEMPTS = 5;
 const PRIMITIVE_ENUMERATE_RETRY_MS = 600;
 /**
  * Run a primitive's read-only DOM enumerate with a bounded settle-retry. SPA
- * wizards (Talemetry) frequently render the target widget a beat AFTER the flow
+ * wizards frequently render the target widget a beat AFTER the flow
  * step fires — the first evaluate sees an empty page, so the primitive would
  * give up even though the widget appears moments later. Re-run the enumerate up
  * to `PRIMITIVE_ENUMERATE_ATTEMPTS` times, waiting `PRIMITIVE_ENUMERATE_RETRY_MS`
@@ -2700,7 +2729,7 @@ async function pollEnumerate(page, expr, isPresent, opts) {
  * Bounded poll for the real advance-transition POST to appear in this step's
  * capture window. The verifiers snapshot once after `STEP_PAUSE_MS`, but the
  * genuine `TransitionWorklet(type="next")` POST can land hundreds of ms to 2s+
- * AFTER that snapshot (HCA fires a fast `WorkletPayload` autosave first). A
+ * AFTER that snapshot (the wizard ATS fires a fast `WorkletPayload` autosave first). A
  * one-shot check false-negatives the advance, retries the click, and the stale
  * retry fires a `back` — a next→back oscillation that never leaves the page.
  * Re-check {@link windowHasAdvanceTransition} every `intervalMs` until it matches
@@ -2734,7 +2763,7 @@ async function waitForTransitionBody(params) {
  * Site-agnostic select primitive: answer a native `<select>` dropdown by
  * directly setting its value in the DOM, bypassing Stagehand observe/act.
  *
- * Why this exists (parallels `tryUploadPrimitive`): Talemetry/MUI dropdowns are
+ * Why this exists (parallels `tryUploadPrimitive`): MUI wizard dropdowns are
  * `MuiNativeSelect` native `<select>` elements carrying `tabindex="-1"`, which
  * removes them from the accessibility tree. Stagehand observe returns `[]` for
  * them, so the cascade's `selectOption` (which needs a resolved locator) never
@@ -2764,7 +2793,7 @@ async function waitForTransitionBody(params) {
  * validation tick can be awaited: MUI `NativeSelect` re-runs required-validation
  * a beat after the synthetic `change`, so an immediate `sel.value === value`
  * readback passes even when the FormControl still flags the field required (and
- * a later worklet re-render then wipes the DOM-only value — the exact HCA
+ * a later worklet re-render then wipes the DOM-only value — the exact wizard-ATS
  * Job-Related failure). Returns `stillInvalid` so {@link trySelectPrimitive} can
  * refuse to claim success on an uncommitted select, routing to the cascade/replan
  * instead of silently advancing. Walks ≤6 ancestors for the invalid marker, same
@@ -2963,7 +2992,7 @@ const DECLINE_OPTION_MARKERS = [
  * Pick an option to satisfy a REQUIRED select on a catch-all step, from the
  * select's option TEXTS (placeholder already excluded upstream). Policy: take
  * the first non-decline option (a plausible substantive answer — the operator
- * accepts LLM-plausible answers reaching HCA prod); fall back to the first
+ * accepts LLM-plausible answers reaching ATS prod); fall back to the first
  * option only if every option is a decline/placeholder. Returns null when there
  * is nothing selectable. Pure + exported so the policy is unit-testable; the LLM
  * path ({@link judgeSelectOptionWithLLM}) is preferred when a client is present,
@@ -3110,7 +3139,7 @@ async function tryFillRequiredSelectsPrimitive(params) {
  * question by directly checking the matching option in the DOM, bypassing
  * Stagehand observe/act.
  *
- * Why this exists (parallels `trySelectPrimitive`): HCA/Talemetry render
+ * Why this exists (parallels `trySelectPrimitive`): the Angular/MUI wizard ATS renders
  * multi-select screening questions ("In which settings have you worked…",
  * certifications) as `c-MultiCheckboxInput` groups — a `<fieldset>`/`<legend>`
  * question with `<input type=checkbox>` options, each tied to its text by a
@@ -3278,7 +3307,7 @@ async function tryCheckboxPrimitive(params) {
 }
 /**
  * Build an XPath predicate that matches an `<input>` by its `id`, safe for any
- * id value. MUI/Talemetry radio ids are base64-ish (no double-quote), so a plain
+ * id value. MUI wizard radio ids are base64-ish (no double-quote), so a plain
  * quoted literal suffices — but if an id ever contains a `"`, fall back to
  * `concat(...)` so the XPath stays valid. Pure + exported for unit tests.
  */
@@ -3293,7 +3322,7 @@ function buildRadioIdXPath(id) {
  * positionally. Pure (no DOM/LLM) so it is unit-testable — the crux of the
  * unlabeled-radio disambiguation.
  *
- * Why this exists: HCA/Talemetry Basic Info has multiple UNLABELED yes/no groups
+ * Why this exists: the wizard ATS's Basic Info has multiple UNLABELED yes/no groups
  * (visa-sponsorship, common-domicile), answered by consecutive flow steps. The
  * old in-browser matcher treated an unlabeled group (`label===""`) as matching
  * ANY question (`"".includes(q)`/`q.includes("")===0`), so two unlabeled "No"
@@ -3435,12 +3464,12 @@ function selectRadioGroupOption(params) {
  * observe/act.
  *
  * Why this exists (parallels `trySelectPrimitive`/`tryCheckboxPrimitive`):
- * HCA/Talemetry render eligibility/screening questions as MUI radio groups.
+ * The Angular/MUI wizard ATS renders eligibility/screening questions as MUI radio groups.
  * Stagehand observe resolves the step to a wrapper `<div>`/`<span>`, not the
  * `<input type=radio>`, so the cascade's `el.click()` fallback fires on the
  * wrapper (or sets `.checked` without triggering React's `onChange`) and the
  * controlled value never commits — the field stays `Mui-error` "required", Next
- * no-ops, and the wizard walls (measured on HCA: the "Are you at least 18?"
+ * no-ops, and the wizard walls (measured on the wizard ATS: the "Are you at least 18?"
  * radio was the sole unfilled field blocking Basic Information → Step 2 of 10).
  * This primitive finds the radio group by raw DOM, matches the requested option
  * by its `<label for>` text, and commits via the React-safe native `checked`
@@ -4123,7 +4152,7 @@ const FORM_VALIDITY_PROBE_EXPR = `(() => {
     const leafInvalid = INVALID_CLASS_RX.test(ctrlClass);
     // A <select> whose currently-selected option is .disabled is the
     // Angular "Please select..." placeholder state. Some custom-element
-    // dropdowns (e.g. AppCast's app-dropdown) bind a truthy sentinel value
+    // dropdowns (e.g. an Angular apply SPA's app-dropdown) bind a truthy sentinel value
     // like "0: null" to the disabled placeholder, so ctrl.value !== ""
     // even though no real option is chosen. Without this branch the empty
     // check below silently drops every such wrapper and the pre-submit
@@ -4284,8 +4313,23 @@ function narrowInvalidFormControl(entry) {
         autoFilled: narrowedAutoFilled,
     };
 }
+/**
+ * Single source of truth for step-line prefixes. Exists because the cascade
+ * here has only ever received `stepIndex`, while the orchestrator loop in
+ * recon-browser owns the plan array — so half the step lines in a run printed
+ * a `N/total` denominator and half printed a bare `N`.
+ *
+ * Takes a getter rather than a number: a global replan splices new steps into
+ * the live plan array mid-run, so the total must be read when the line is
+ * emitted, not when the step started. Callers with no total omit it and get
+ * the bare form.
+ */
+function formatStepPrefix(stepIndex, totalSteps) {
+    const total = totalSteps?.();
+    return total === undefined ? `step ${stepIndex + 1}` : `step ${stepIndex + 1}/${total}`;
+}
 async function probeFormValidityBeforeSubmit(params) {
-    const { page, stepIndex, logger } = params;
+    const { page, stepIndex, totalSteps, logger } = params;
     try {
         const raw = await page.evaluate(FORM_VALIDITY_PROBE_EXPR);
         if (!Array.isArray(raw))
@@ -4299,15 +4343,15 @@ async function probeFormValidityBeforeSubmit(params) {
         }
         const autoCount = out.filter((e) => e.autoFilled !== null).length;
         if (out.length > 0) {
-            logger.info(`step ${stepIndex + 1} pre-submit probe: ${out.length} ng-invalid form control(s) detected; empty=${out.filter((e) => e.emptyOrUnchecked).length}; auto-picked=${autoCount}`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} pre-submit probe: ${out.length} ng-invalid form control(s) detected; empty=${out.filter((e) => e.emptyOrUnchecked).length}; auto-picked=${autoCount}`);
         }
         else {
-            logger.info(`step ${stepIndex + 1} pre-submit probe: no ng-invalid form controls detected`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} pre-submit probe: no ng-invalid form controls detected`);
         }
         return out;
     }
     catch (err) {
-        logger.warn(`step ${stepIndex + 1} pre-submit probe threw: ${(0, errors_1.toErrorMessage)(err)} — proceeding without pre-flight evidence`);
+        logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} pre-submit probe threw: ${(0, errors_1.toErrorMessage)(err)} — proceeding without pre-flight evidence`);
         return [];
     }
 }
@@ -4321,14 +4365,14 @@ async function probeFormValidityBeforeSubmit(params) {
  * step is declared "absent". Exported for tests.
  */
 async function probeStepBeforeAttempts(params) {
-    const { stagehand, step, stepIndex, logger, captureFn } = params;
+    const { stagehand, step, stepIndex, totalSteps, logger, captureFn } = params;
     try {
         const candidates = await (0, stagehand_guard_1.guardedObserve)(stagehand, step, { timeout: exports.STEP_WATCHDOG_MS }, captureFn);
         if (candidates.length === 0) {
             // Focused observe under-returns on some controlled-component forms:
             // Stagehand's instruction-scoped observe can resolve zero candidates for a
             // declarative "Fill in the X field with 'Y'" step even when the field is
-            // present and actionable (confirmed on HCA's MUI/React Talemetry form — an
+            // present and actionable (confirmed on the MUI/React wizard ATS's form — an
             // unfocused observe enumerated every field and a direct act filled them).
             // Treating focused-empty as hard "absent" skips the whole cascade and burns
             // a global replan per step. Fall back to an UNFOCUSED observe as a
@@ -4338,24 +4382,24 @@ async function probeStepBeforeAttempts(params) {
             // where the unfocused observe is also empty — stay "absent".
             const unfocused = await (0, stagehand_guard_1.guardedObserve)(stagehand, undefined, { timeout: exports.STEP_WATCHDOG_MS }, captureFn);
             if (unfocused.length > 0) {
-                logger.info(`step ${stepIndex + 1}: focused probe found 0 candidates but unfocused observe found ${unfocused.length} — treating as present (let cascade resolve)`);
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)}: focused probe found 0 candidates but unfocused observe found ${unfocused.length} — treating as present (let cascade resolve)`);
                 return "present";
             }
-            logger.info(`step ${stepIndex + 1}: probe found 0 candidates (focused and unfocused) — treating as absent (skip cascade, route to replan if required)`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)}: probe found 0 candidates (focused and unfocused) — treating as absent (skip cascade, route to replan if required)`);
             return "absent";
         }
-        logger.info(`step ${stepIndex + 1}: probe found ${candidates.length} candidate(s)`);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)}: probe found ${candidates.length} candidate(s)`);
         return "present";
     }
     catch (err) {
         // Bias toward the existing behavior on errors: don't trigger a spurious
         // replan when the probe itself is the broken thing.
-        logger.warn(`step ${stepIndex + 1}: probe threw ${(0, errors_1.toErrorMessage)(err)} — treating as present (cascade will run)`);
+        logger.warn(`${formatStepPrefix(stepIndex, totalSteps)}: probe threw ${(0, errors_1.toErrorMessage)(err)} — treating as present (cascade will run)`);
         return "present";
     }
 }
 async function executeStepWithHealing(params) {
-    const { stagehand, page, step, optional, upload, submitStep, stepIndex, phase, signalCounter, recentCaptures, recentCaptureMeta, anthropic, logger, captureFn, resumeFixture, isFinalStep, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, trajectory, onStepFailure, } = params;
+    const { stagehand, page, step, optional, upload, submitStep, stepIndex, totalSteps, phase, signalCounter, recentCaptures, recentCaptureMeta, anthropic, logger, captureFn, resumeFixture, isFinalStep, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, getSuppressedAisdkElementIdErrorCount, trajectory, onStepFailure, } = params;
     // Read-once to suppress "unused" — knownErrorClassPrefixes is threaded
     // through executeStepWithHealing's signature so the cascade has it in
     // scope when the invalid-fields judge migration (Task #43) lands. The
@@ -4371,12 +4415,12 @@ async function executeStepWithHealing(params) {
     // multi-signal evidence with strict prompting instead.
     //
     // Gate accepts (isFinalStep || submitStep): flows whose canonical Submit
-    // click lives mid-list (e.g. AppCast's flow has Submit at step 55/328 with
+    // click lives mid-list (e.g. one JSON-envelope ATS flow has Submit at step 55/328 with
     // 273 post-submit verification steps) opt in via the per-step
     // `submitStep: true` flag in the flow file. Without this opt-in, the pre-
     // submit DOM probe gated solely on `isFinalStep` never fires on the real
     // Submit, and unfilled required fields produce silent submit failures
-    // (verified 2026-06-15 on UVA Verona telemetry). Site-agnostic: any flow
+    // (verified 2026-06-15 on one measured tenant's telemetry). Site-agnostic: any flow
     // whose submit is mid-list can mark its submit step explicitly.
     const requireSubmitEndpoint = (isFinalStep || submitStep) && submitEndpointPattern !== null;
     const attempts = [];
@@ -4395,28 +4439,28 @@ async function executeStepWithHealing(params) {
         signalCounter,
         recentCaptureMeta,
     })) {
-        logger.info(`step ${stepIndex + 1} resolved by upload primitive`);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by upload primitive`);
         trajectory?.push({ stepIndex, verifiedBy: "network" });
         return "completed";
     }
     // When the step is a native-<select> dropdown selection, answer it directly
     // in the DOM ahead of the cascade. Critical for MuiNativeSelect/tabindex=-1
-    // dropdowns (HCA/Talemetry) that Stagehand observe can't surface — the
+    // dropdowns (the MUI wizard ATS) that Stagehand observe can't surface — the
     // cascade would otherwise skip them ("no candidates") and leave a required
     // question unanswered. No-op (returns false → falls through) when the step
     // isn't a single-dropdown select or no option matches.
     if (await trySelectPrimitive({ page, instruction: step, logger, anthropic, captureFn })) {
-        logger.info(`step ${stepIndex + 1} resolved by select primitive`);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by select primitive`);
         trajectory?.push({ stepIndex, verifiedBy: "dom" });
         return "completed";
     }
     // When the step is a "select 'X'" against a multi-select CHECKBOX group
-    // (c-MultiCheckboxInput) rather than a <select> — Talemetry renders some
+    // (c-MultiCheckboxInput) rather than a <select> — the wizard ATS renders some
     // screening questions this way — answer it directly in the DOM. Runs AFTER
     // trySelectPrimitive (which handles <select> and no-ops on checkbox-only
     // pages). No-op (falls through) when there's no checkbox group or no match.
     if (await tryCheckboxPrimitive({ page, instruction: step, logger, anthropic, captureFn })) {
-        logger.info(`step ${stepIndex + 1} resolved by checkbox primitive`);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by checkbox primitive`);
         trajectory?.push({ stepIndex, verifiedBy: "dom" });
         return "completed";
     }
@@ -4424,10 +4468,10 @@ async function executeStepWithHealing(params) {
     // the question '…'"), commit it directly in the DOM. Runs AFTER select/
     // checkbox (which own their verbs) and BEFORE the cascade, so radios never
     // reach the observe cascade's el.click() fallback that fails to commit MUI/
-    // React controlled state (the HCA Basic-Info Step-2 wall). No-op (falls
+    // React controlled state (the wizard ATS's Basic-Info Step-2 wall). No-op (falls
     // through) when there's no radio group or no confident option match.
     if (await tryRadioPrimitive({ page, instruction: step, logger, anthropic, captureFn })) {
-        logger.info(`step ${stepIndex + 1} resolved by radio primitive`);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by radio primitive`);
         trajectory?.push({ stepIndex, verifiedBy: "dom" });
         return "completed";
     }
@@ -4438,7 +4482,7 @@ async function executeStepWithHealing(params) {
     // catch-all (parseSelectStep returns null there, so trySelectPrimitive above
     // skipped it) and no-ops when the page has no required-empty select.
     if (await tryFillRequiredSelectsPrimitive({ page, instruction: step, logger, anthropic, captureFn })) {
-        logger.info(`step ${stepIndex + 1} resolved by required-select primitive`);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} resolved by required-select primitive`);
         trajectory?.push({ stepIndex, verifiedBy: "dom" });
         return "completed";
     }
@@ -4454,6 +4498,7 @@ async function executeStepWithHealing(params) {
         stagehand,
         step,
         stepIndex,
+        totalSteps,
         logger,
         captureFn,
     });
@@ -4464,10 +4509,10 @@ async function executeStepWithHealing(params) {
             // can't resolve the widget) — skipping would leave a required field empty
             // and silently doom the later submit. Fall through to the cascade instead.
             if (await hasUnfilledRequiredControlForStep(page, step)) {
-                logger.info(`step ${stepIndex + 1} probe-absent but a required unfilled control matches the question; NOT skipping (escalating to cascade)`);
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)} probe-absent but a required unfilled control matches the question; NOT skipping (escalating to cascade)`);
             }
             else {
-                logger.info(`step ${stepIndex + 1} skipped (optional, probe found no candidates)`);
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)} skipped (optional, probe found no candidates)`);
                 return "skipped";
             }
         }
@@ -4482,7 +4527,7 @@ async function executeStepWithHealing(params) {
             preMetaLength: stepStartMetaLength,
         });
         if (transitionUrl !== null) {
-            logger.info(`step ${stepIndex + 1} skipped (probe absent but recent transition detected: ${transitionUrl})`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} skipped (probe absent but recent transition detected: ${transitionUrl})`);
             trajectory?.push({ stepIndex, verifiedBy: "url" });
             return "completed";
         }
@@ -4497,8 +4542,8 @@ async function executeStepWithHealing(params) {
             ownBackendHostnames,
         });
         if (backendErrorUrl !== null) {
-            logger.error(`step ${stepIndex + 1} backend error detected (submit endpoint returned 5xx: ${backendErrorUrl}); aborting cascade`);
-            throw new errors_2.StepVerificationError(`step ${stepIndex + 1} (${step.slice(0, 60)}) backend 5xx at ${backendErrorUrl} — unrecoverable`, "backend-error-unrecoverable");
+            logger.error(`${formatStepPrefix(stepIndex, totalSteps)} backend error detected (submit endpoint returned 5xx: ${backendErrorUrl}); aborting cascade`);
+            throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) backend 5xx at ${backendErrorUrl} — unrecoverable`, "backend-error-unrecoverable");
         }
         // Capture diagnostics + write a failure dump BEFORE throwing so the
         // global replan path's `readFailureDumpEvidence` can populate the
@@ -4526,7 +4571,7 @@ async function executeStepWithHealing(params) {
             bodyOuterHtml,
             unfocusedObserve,
         }) ?? null;
-        throw new errors_2.StepVerificationError(`step ${stepIndex + 1} (${step.slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
+        throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
     }
     // Pre-submit form-validity probe. Fires on the canonical submit step
     // (either the final flow step OR a step explicitly flagged `submitStep:
@@ -4551,6 +4596,7 @@ async function executeStepWithHealing(params) {
         const invalidControls = await probeFormValidityBeforeSubmit({
             page,
             stepIndex,
+            totalSteps,
             logger,
         });
         for (const c of invalidControls) {
@@ -4592,6 +4638,7 @@ async function executeStepWithHealing(params) {
                 resolvedMethod: null,
                 resolvedArguments: null,
                 verifiedBy: null,
+                phantomClickVerdict: null,
             });
         }
         // Brief settle window after auto-picks so Angular's change-detection
@@ -4607,6 +4654,11 @@ async function executeStepWithHealing(params) {
     // NOT move the wizard forward. Read at the top of attempts 2-4 to skip the
     // proven-dead re-observe/re-click techniques (see shouldSkipTechnique).
     let advanceUnmovedAfterAttempt1 = false;
+    // Set after attempt 1: Stagehand reported success but pre/post shows zero
+    // observable effect (see classifyPhantomClick). Reroutes attempt 2 to
+    // deep-submit-locator instead of observe-act, since re-resolving via the
+    // same light-DOM view cannot reach a target the resolver can't see.
+    let phantomClickAfterAttempt1 = false;
     for (let attempt = 1; attempt <= MAX_STEP_ATTEMPTS; attempt++) {
         // Telemetry-driven technique-skip: when a cascade technique's
         // preconditions cannot be met by the prior attempts' state, running
@@ -4615,7 +4667,9 @@ async function executeStepWithHealing(params) {
         // techniques faster.
         if (attempt > 1) {
             const wouldBeTechnique = attempt === 2
-                ? "observe-act"
+                ? phantomClickAfterAttempt1 && (isFinalStep || submitStep)
+                    ? "deep-submit-locator"
+                    : "observe-act"
                 : attempt === 3
                     ? "structured-click"
                     : attempt === 4
@@ -4629,9 +4683,11 @@ async function executeStepWithHealing(params) {
                     errorMessage: a.errorMessage,
                 })),
                 advanceUnmovedAfterAttempt1,
+                phantomClickAfterAttempt1,
+                submitShapedStep: isFinalStep || submitStep,
             });
             if (decision.skip) {
-                logger.info(`step ${stepIndex + 1} attempt ${attempt} (${wouldBeTechnique}) skipped: ${decision.reason}`);
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt} (${wouldBeTechnique}) skipped: ${decision.reason}`);
                 failureReasons.push(`attempt ${attempt} skipped: ${decision.reason}`);
                 continue;
             }
@@ -4662,6 +4718,7 @@ async function executeStepWithHealing(params) {
             resolvedMethod: null,
             resolvedArguments: null,
             verifiedBy: null,
+            phantomClickVerdict: null,
         };
         // First resolved action from Stagehand's `act` result — used to decide
         // whether this attempt's signal should come from the network/URL pair or
@@ -4698,6 +4755,124 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
+            else if (attempt === 2 && phantomClickAfterAttempt1 && (isFinalStep || submitStep)) {
+                // Deep submit-control locator: attempt 1 phantom-clicked (Stagehand
+                // reported success but pre/post showed zero effect), so the target is
+                // almost certainly unreachable via document.querySelectorAll — most
+                // likely rendered inside an open shadow root by a web-component /
+                // framework-native submit control (see recon-submit-phantom-click bug
+                // report). Rank every submit-shaped candidate the deep traversal can
+                // reach and click the top-ranked one; the ranking already excludes
+                // Back/Cancel/Save-draft-shaped controls, so a false-positive submit
+                // click cannot fire.
+                //
+                // Rank and click are two separate page.evaluate round trips over a
+                // live Angular page, so any re-render between them shifts every
+                // deepIndex — the click then lands on nothing (`{clicked: false}`),
+                // not because the page is broken but because the snapshot the index
+                // was computed from is already gone. That's a transient, self-clearing
+                // condition, so re-rank against the CURRENT DOM and click once more
+                // before giving up. Capped at one retry (two rank+click rounds total)
+                // so a page re-rendering on every tick can't turn this into a loop.
+                record.technique = "deep-submit-locator";
+                for (let deepAttempt = 1; deepAttempt <= 2; deepAttempt++) {
+                    let ranked;
+                    try {
+                        ranked = (await page.evaluate((0, submit_control_1.buildRankSubmitCandidatesExpr)()));
+                    }
+                    catch (err) {
+                        // A thrown evaluate (page navigated away / frame detached) is not
+                        // a stale-index race — re-ranking a detached page will throw
+                        // again, so don't retry; record it and let the cascade move on.
+                        record.errorMessage = `deep-submit-locator: rank evaluate threw ${(0, errors_1.toErrorMessage)(err)}`;
+                        break;
+                    }
+                    if (ranked.length === 0) {
+                        record.errorMessage = "deep-submit-locator: no submit-shaped candidate found";
+                        break;
+                    }
+                    // biome-ignore lint/style/noNonNullAssertion: guarded by the length check above
+                    const top = ranked[0];
+                    record.instruction = `deep-submit-locator: ${top.tag} "${top.accessibleName}" (tier ${top.tier})`;
+                    record.triedSelectors = [`deep-index:${top.deepIndex}`];
+                    triedSelectors.push(`deep-index:${top.deepIndex}`);
+                    let clickResult;
+                    try {
+                        clickResult = (await page.evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(top.deepIndex)));
+                    }
+                    catch (err) {
+                        record.errorMessage = `deep-submit-locator: click evaluate threw ${(0, errors_1.toErrorMessage)(err)}`;
+                        break;
+                    }
+                    record.actResultSuccess = clickResult.clicked;
+                    record.actResultDescription = clickResult.clicked
+                        ? `deep-submit-locator clicked ${top.tag} "${top.accessibleName}"`
+                        : "deep-submit-locator: candidate vanished before click (deepIndex stale)";
+                    if (clickResult.clicked) {
+                        // Synthesize a click action so downstream verification (network /
+                        // url / dom) treats this exactly like any other resolved click.
+                        resolvedAction = {
+                            selector: `deep-index:${top.deepIndex}`,
+                            description: record.actResultDescription,
+                            method: "click",
+                        };
+                        // Runner-up retry: the top pick can itself phantom-click (a
+                        // second web-component / shadow-root control that LOOKS
+                        // submit-shaped but doesn't wire a real handler — see
+                        // submit-control.ts's module docblock). Re-snapshot right here
+                        // and re-classify with the same classifyPhantomClick primitive
+                        // that escalated attempt 1, so a phantom top pick doesn't fall
+                        // through to attempt 3's structured-click, which can't reach a
+                        // shadow-root control either. Cap at ranked[1] only (not the
+                        // full list) so a page with many submit-shaped candidates can't
+                        // burn the step budget probing all of them.
+                        const runnerUp = ranked[1];
+                        if (runnerUp) {
+                            const midPost = await snapshotPage(page, signalCounter);
+                            const topVerdict = (0, phantom_click_1.classifyPhantomClick)({
+                                actResultSuccess: true,
+                                pre,
+                                post: midPost,
+                            });
+                            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})`);
+                                record.instruction = `deep-submit-locator: ${runnerUp.tag} "${runnerUp.accessibleName}" (tier ${runnerUp.tier}), runner-up after top pick ${top.tag} "${top.accessibleName}" phantomed`;
+                                record.triedSelectors = [
+                                    `deep-index:${top.deepIndex}`,
+                                    `deep-index:${runnerUp.deepIndex}`,
+                                ];
+                                triedSelectors.push(`deep-index:${runnerUp.deepIndex}`);
+                                const runnerUpClickResult = (await page
+                                    .evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(runnerUp.deepIndex))
+                                    .catch(() => ({ clicked: false })));
+                                record.actResultSuccess = runnerUpClickResult.clicked;
+                                record.actResultDescription = runnerUpClickResult.clicked
+                                    ? `deep-submit-locator clicked runner-up ${runnerUp.tag} "${runnerUp.accessibleName}" after top pick phantomed`
+                                    : "deep-submit-locator: runner-up candidate vanished before click (deepIndex stale)";
+                                resolvedAction = runnerUpClickResult.clicked
+                                    ? {
+                                        selector: `deep-index:${runnerUp.deepIndex}`,
+                                        description: record.actResultDescription,
+                                        method: "click",
+                                    }
+                                    : null;
+                                if (!runnerUpClickResult.clicked) {
+                                    record.errorMessage = record.actResultDescription;
+                                }
+                            }
+                        }
+                        // The top pick (or its runner-up) was reached and clicked. A
+                        // runner-up that itself vanished is not the stale-index race the
+                        // re-rank exists for — the rank was fresh enough to click the top
+                        // pick — so exit either way and let the cascade classify.
+                        break;
+                    }
+                    record.errorMessage = record.actResultDescription;
+                    if (deepAttempt === 1) {
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} deep-submit-locator: deepIndex stale on first click, re-ranking once`);
+                    }
+                }
+            }
             else if (attempt === 2 || attempt === 4) {
                 record.technique = attempt === 2 ? "observe-act" : "observe-act-exclude";
                 const observeOptions = attempt === 4 && triedSelectors.length > 0
@@ -4725,12 +4900,12 @@ async function executeStepWithHealing(params) {
                         // don't fast-skip — let the healing cascade continue so the
                         // required field gets answered instead of silently doomed.
                         if (await hasUnfilledRequiredControlForStep(page, step)) {
-                            logger.info(`step ${stepIndex + 1} no candidates after act+observe but a required unfilled control matches; NOT skipping (continuing cascade)`);
+                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} no candidates after act+observe but a required unfilled control matches; NOT skipping (continuing cascade)`);
                         }
                         else {
                             record.verifiedBy = null;
                             attempts.push(record);
-                            logger.info(`step ${stepIndex + 1} skipped (optional, no candidates after act+observe)`);
+                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} skipped (optional, no candidates after act+observe)`);
                             return "skipped";
                         }
                     }
@@ -4748,7 +4923,7 @@ async function executeStepWithHealing(params) {
                         record.triedSelectors = [target.selector];
                         attempts.push(record);
                         failureReasons.push(record.errorMessage);
-                        logger.info(`step ${stepIndex + 1} attempt ${attempt}: ${record.errorMessage}`);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${record.errorMessage}`);
                         continue;
                     }
                     record.instruction = target.description;
@@ -4808,7 +4983,7 @@ async function executeStepWithHealing(params) {
                                         record.actResultSuccess = false;
                                     }
                                     else if (readback.outcome === "differs") {
-                                        logger.info(`step ${stepIndex + 1} fill-value-differs: tried "${fillValue.slice(0, 60)}" got "${readback.postValue.slice(0, 60)}" (framework reformatted)`);
+                                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} fill-value-differs: tried "${fillValue.slice(0, 60)}" got "${readback.postValue.slice(0, 60)}" (framework reformatted)`);
                                     }
                                 }
                             }
@@ -4824,7 +4999,7 @@ async function executeStepWithHealing(params) {
                 // browser's default label-click action does NOT toggle .checked for
                 // hidden inputs (Bootstrap, Tailwind, plain HTML labels-control,
                 // Angular Material's mat-radio-button, PrimeNG's p-radioButton, and
-                // custom Angular components like AppCast's app-radio-button all fit
+                // custom Angular components like an apply SPA's app-radio-button all fit
                 // this shape). The framework's FormControl/state listens on the
                 // input's `change` event, which never fires when the visible click
                 // never reaches a clickable input — so the form stays invalid even
@@ -5053,7 +5228,7 @@ async function executeStepWithHealing(params) {
             ? await verifyDomEffect(page, resolvedAction)
             : false;
         // Interior-advance transition gate (opt-in). On SPAs where a page advance
-        // and a mere field-edit share one endpoint URL (Talemetry `/gq`:
+        // and a mere field-edit share one endpoint URL (the wizard ATS's `/gq`:
         // TransitionWorklet vs EditQuestionItem — identical URLs, only the body
         // differs), a `networkFired` signal on an interior "Next" can be a
         // non-advancing POST. When the flow configures `advanceTransitionBodyPattern`
@@ -5080,7 +5255,7 @@ async function executeStepWithHealing(params) {
                 intervalMs: ADVANCE_TRANSITION_POLL_INTERVAL_MS,
             });
         if (advanceGateActive && !networkIsRealAdvance) {
-            logger.info(`step ${stepIndex + 1} network fired but no advance-transition (type=next) body matched within ${ADVANCE_TRANSITION_POLL_MS}ms poll (non-advancing POST); not treating as verified`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} network fired but no advance-transition (type=next) body matched within ${ADVANCE_TRANSITION_POLL_MS}ms poll (non-advancing POST); not treating as verified`);
         }
         // DOM-only-advance veto (opt-in). A rephrase can turn an advance/"Next" step
         // into a field click (e.g. "click the Yes radio for '18?' then Next"), which
@@ -5089,7 +5264,7 @@ async function executeStepWithHealing(params) {
         // instruction) whose ONLY signal is that DOM state change, do NOT count it
         // verified: an advance requires a REAL transition (a `type=next` per
         // `networkIsRealAdvance`, or a URL change). Keyed on `networkIsRealAdvance`,
-        // NOT `!networkFired` — a non-advancing autosave POST (Talemetry
+        // NOT `!networkFired` — a non-advancing autosave POST (the wizard ATS's
         // `WorkletPayload`) fires network=true while the wizard doesn't move, and the
         // old `!networkFired` guard let a rephrase ride that autosave + a DOM reflow
         // to a FALSE advance, desyncing the flow from the wizard. Field-answer steps
@@ -5106,14 +5281,14 @@ async function executeStepWithHealing(params) {
             ? domVerified
             : false;
         if (domVerified && !domVerifiedForStep) {
-            logger.info(`step ${stepIndex + 1} advance step succeeded only via DOM state change (field toggle / non-advancing POST), not a real transition; not treating as verified`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} advance step succeeded only via DOM state change (field toggle / non-advancing POST), not a real transition; not treating as verified`);
         }
         let verified = networkIsRealAdvance || urlChanged || domVerifiedForStep;
         // Final-step submit-verification gate. Replaces the deterministic
         // submitEndpointPattern regex with a Haiku 4.5 LLM judgment over
         // multi-signal evidence (network captures, page URL/title, DOM
         // submitted-state probe, site-supplied criteria). The regex
-        // mislabeled successful submits as failures whenever AppCast used a
+        // mislabeled successful submits as failures whenever an ATS used a
         // POST URL outside the regex's narrow expectation — empirically
         // observed in last night's sweep and validated 2026-06-11 against
         // claude-haiku-4-5-20251001 with the SUBMIT_VERDICT_SCHEMA.
@@ -5208,7 +5383,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), [], recon_shared_1.CAPTURES_DIR, "any-4xx");
+                const fallbackEvidence = extractSubmitFailureEvidence(recentCaptures.slice(-tail.length), [], (0, recon_shared_1.resolveReconRunDir)().graphqlDir, "any-4xx");
                 if (fallbackEvidence.length > 0) {
                     failureReasons.push(`any-4xx fallback: ${fallbackEvidence.split("\n")[0]}`.slice(0, 240));
                 }
@@ -5312,7 +5487,7 @@ async function executeStepWithHealing(params) {
                     // change AND the page still has required-invalid controls (MUI-aware
                     // via countNgInvalidContainers), treat the DOM-only signal as NOT
                     // verifying so the cascade routes to the fill-invalid-fields replan.
-                    // Confirmed no-op signature on HCA COMPENSATION (network=false
+                    // Confirmed no-op signature on the wizard ATS's COMPENSATION page (network=false
                     // url=false htmlDelta>0 textChanged) mis-scored verified=true(dom).
                     const clickWasDomOnly = probeResult.kind === "click" && !retryNetworkFired && !retryUrlChanged;
                     const clickBlockedByInvalid = clickWasDomOnly && (await countNgInvalidContainers(page).catch(() => 0)) > 0;
@@ -5326,7 +5501,7 @@ async function executeStepWithHealing(params) {
                     // `advanceTransitionBodyPattern`. Without this, a non-advancing POST
                     // (retryNetworkFired=true) both satisfied retryVerified AND disarmed the
                     // old !retryNetworkFired-gated veto, so the fallback rode past a
-                    // validation-blocked Next while the page stayed put (HCA Basic Info
+                    // validation-blocked Next while the page stayed put (the wizard ATS's Basic Info
                     // stage1d). Only arms when the site opted into the pattern; field-answer
                     // (non-advance) steps keep their checkboxStateVerified/DOM path.
                     // Poll for the real TransitionWorklet(type="next") like the primary
@@ -5348,7 +5523,7 @@ async function executeStepWithHealing(params) {
                         retryNetworkIsRealAdvance,
                     });
                     if (fallbackDomOnlyAdvance) {
-                        logger.info(`step ${stepIndex + 1} n+16 fallback advanced but no real transition (non-advancing POST / field toggle); not treating as verified`);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} n+16 fallback advanced but no real transition (non-advancing POST / field toggle); not treating as verified`);
                     }
                     let retryVerified = !clickBlockedByInvalid &&
                         !fallbackDomOnlyAdvance &&
@@ -5426,7 +5601,7 @@ async function executeStepWithHealing(params) {
                             failureReasons.push(`n+16 fallback: submit-judge-rejected: ${judgeVerdict.reason}`);
                         }
                     }
-                    logger.info(`n+16 probe: step=${stepIndex + 1} attempt=${attempt} el.click() fallback fired=${fired === true} kind=${probeResult.kind ?? "none"} checkboxStateVerified=${checkboxStateVerified} ancestorStillInvalid=${ancestorStillInvalid}; network=${retryNetworkFired} url=${retryUrlChanged} htmlDelta=${retryHtmlDelta} textChanged=${retryTextChanged} verified=${retryVerified}`);
+                    logger.info(`n+16 probe: step=${stepIndex + 1}/${totalSteps?.() ?? "?"} attempt=${attempt} el.click() fallback fired=${fired === true} kind=${probeResult.kind ?? "none"} checkboxStateVerified=${checkboxStateVerified} ancestorStillInvalid=${ancestorStillInvalid}; network=${retryNetworkFired} url=${retryUrlChanged} htmlDelta=${retryHtmlDelta} textChanged=${retryTextChanged} verified=${retryVerified}`);
                     if (retryVerified) {
                         if (record.verifiedBy === null) {
                             record.verifiedBy = retryUrlChanged ? "url" : retryNetworkFired ? "network" : "dom";
@@ -5434,46 +5609,56 @@ async function executeStepWithHealing(params) {
                         record.post = retryPost;
                         attempts.push(record);
                         if (attempt > 1) {
-                            logger.info(`step ${stepIndex + 1} healed on attempt ${attempt} via ${record.technique} + el.click() fallback`);
+                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} healed on attempt ${attempt} via ${record.technique} + el.click() fallback`);
                         }
                         else {
-                            logger.info(`step ${stepIndex + 1} succeeded on attempt 1 via ${record.technique} + el.click() fallback`);
+                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} succeeded on attempt 1 via ${record.technique} + el.click() fallback`);
                         }
                         trajectory?.push({ stepIndex, verifiedBy: record.verifiedBy });
                         return "completed";
                     }
                 }
                 catch (probeErr) {
-                    logger.warn(`n+16 probe: step=${stepIndex + 1} attempt=${attempt} el.click() fallback threw: ${(0, errors_1.toErrorMessage)(probeErr)}`);
+                    logger.warn(`n+16 probe: step=${stepIndex + 1}/${totalSteps?.() ?? "?"} attempt=${attempt} el.click() fallback threw: ${(0, errors_1.toErrorMessage)(probeErr)}`);
                 }
             }
         }
         attempts.push(record);
         if (verified) {
             if (attempt > 1) {
-                logger.info(`step ${stepIndex + 1} healed on attempt ${attempt} via ${record.technique} (network=${networkFired} url=${urlChanged} dom=${domVerified})`);
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)} healed on attempt ${attempt} via ${record.technique} (network=${networkFired} url=${urlChanged} dom=${domVerified})`);
             }
             else {
                 // Why log first-try wins explicitly: prior to this change, attempt-1
                 // successes were silent — only attempts 2+ emitted "healed on attempt
                 // N" lines. That under-reporting caused a 2026-06-15 telemetry-vs-log
-                // contradiction where UVA Verona's run looked like a "cascade
+                // contradiction where one measured tenant's run looked like a "cascade
                 // collapse" (log showed 2 heals) but telemetry calls.ndjson showed
                 // 32 successful Stagehand acts. Surfacing attempt-1 wins lets the
                 // log match telemetry and prevents the same false alarm.
-                logger.info(`step ${stepIndex + 1} succeeded on attempt 1 via ${record.technique} (network=${networkFired} url=${urlChanged} dom=${domVerified})`);
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)} succeeded on attempt 1 via ${record.technique} (network=${networkFired} url=${urlChanged} dom=${domVerified})`);
             }
             trajectory?.push({ stepIndex, verifiedBy: record.verifiedBy });
             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,
+        });
         const reason = record.errorMessage
             ? effectSignals
                 ? `${record.errorMessage}; ${effectSignals}`
                 : record.errorMessage
             : effectSignals || "no observable effect (no network, url, or dom change)";
         failureReasons.push(reason);
-        logger.warn(`step ${stepIndex + 1} attempt ${attempt} (${record.technique}) produced no observable effect — ${reason}`);
+        logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt} (${record.technique}) produced no observable effect — ${reason}`);
         // One additive strategy among many: when a click on a final-step
         // submit/continue button fails AND the page surfaces a visible
         // <error> sibling next to a touched+dirty ng-invalid wrapper, surface
@@ -5481,7 +5666,7 @@ async function executeStepWithHealing(params) {
         // outcome="impossible" instead of looping on the same plan. Silent
         // no-op on sites where the DOM pattern doesn't match — the existing
         // failure-reason and replan/cycle-detection paths still fire.
-        // Empirically grounded: 22 of 22 AppCast Continue/Submit step-failure
+        // Empirically grounded: 22 of 22 JSON-envelope ATS Continue/Submit step-failure
         // dumps in a 2026-06-10 survey had the paired touched+dirty + visible
         // error text pattern with 3 distinct rejection messages.
         if (record.resolvedMethod === "click" && (isFinalStep || submitStep)) {
@@ -5498,7 +5683,7 @@ async function executeStepWithHealing(params) {
             for (const p of pairs) {
                 const validationReason = formatValidationRejectedReason(p);
                 failureReasons.push(validationReason);
-                logger.warn(`step ${stepIndex + 1} ${validationReason}`);
+                logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} ${validationReason}`);
             }
         }
         // Telemetry-driven early-exit: when attempt 1 on a final-Submit click
@@ -5520,6 +5705,20 @@ async function executeStepWithHealing(params) {
                     isAdvanceStep(step) &&
                     !urlChanged &&
                     !networkIsRealAdvance;
+            // Attempt 1 phantom-clicked: Stagehand reported success but pre/post
+            // shows zero observable effect. The zero-effect delta is the primary
+            // signal (classifyPhantomClick above); the live AISDK elementId
+            // suppression counter is corroborating evidence only — logged, never
+            // gating, since a nonzero count alone is too weak a signal on a run
+            // that sees dozens of suppressions across hundreds of unrelated steps.
+            phantomClickAfterAttempt1 = record.phantomClickVerdict === "phantom";
+            if (phantomClickAfterAttempt1) {
+                const suppressedCount = getSuppressedAisdkElementIdErrorCount?.();
+                const escalationTarget = isFinalStep || submitStep
+                    ? "escalating attempt 2 to deep-submit-locator"
+                    : "non-submit step — leaving the normal structured-click/observe-act-exclude ladder intact";
+                logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} phantom click detected on attempt 1 (${record.technique}): reported success with no network/url/dom change${suppressedCount !== undefined ? `; ${suppressedCount} AISDK elementId errors suppressed this session (corroborating, not causal)` : ""} — ${escalationTarget}`);
+            }
             const postAttemptInvalidCount = await countNgInvalidContainers(page);
             const earlyExit = isSubmitRevealedInvalid({
                 // Treat the canonical submit click as "final" for this predicate
@@ -5535,13 +5734,13 @@ async function executeStepWithHealing(params) {
             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`;
                 failureReasons.push(exitReason);
-                logger.warn(`step ${stepIndex + 1} ${exitReason}`);
+                logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} ${exitReason}`);
                 break;
             }
             // Telemetry-driven early-exit for interior ADVANCE steps: if the Next
             // click fired and hit the network but produced no real forward
             // transition, attempts 2-N only re-fire the autosave / bounce the wizard
-            // back (the measured HCA next→back oscillation). Route to replan — which
+            // back (the measured wizard-ATS next→back oscillation). Route to replan — which
             // can reorder a later step forward — instead of burning the cascade.
             const advanceStalled = isAdvanceStalled({
                 isAdvance: isAdvanceStep(step),
@@ -5555,7 +5754,7 @@ async function executeStepWithHealing(params) {
             if (advanceStalled) {
                 const exitReason = `advance-stalled: the Next click fired network but no real transition (type=next) landed within the poll window; attempts 2-${MAX_STEP_ATTEMPTS} would only re-bounce the wizard — routing to replan`;
                 failureReasons.push(exitReason);
-                logger.warn(`step ${stepIndex + 1} ${exitReason}`);
+                logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} ${exitReason}`);
                 break;
             }
         }
@@ -5583,9 +5782,9 @@ async function executeStepWithHealing(params) {
         unfocusedObserve,
     }) ?? null;
     if (dumpPath !== null) {
-        logger.error(`step ${stepIndex + 1} failed after ${MAX_STEP_ATTEMPTS} attempts; diagnostic bundle: ${dumpPath}`);
+        logger.error(`${formatStepPrefix(stepIndex, totalSteps)} failed after ${MAX_STEP_ATTEMPTS} attempts; diagnostic bundle: ${dumpPath}`);
     }
-    throw new errors_2.StepVerificationError(`step ${stepIndex + 1} (${step.slice(0, 60)}) failed verification after ${MAX_STEP_ATTEMPTS} attempts${dumpPath ? `; see ${dumpPath}` : ""}`, "cascade-exhausted");
+    throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) failed verification after ${MAX_STEP_ATTEMPTS} attempts${dumpPath ? `; see ${dumpPath}` : ""}`, phantomClickAfterAttempt1 ? "phantom-click-exhausted" : "cascade-exhausted");
 }
 /** SPA-readiness gate defaults — mirror the recon CLI's post-navigation wait. */
 const SPA_READINESS_TIMEOUT_MS = 15_000;
@@ -5667,6 +5866,7 @@ async function runHealingFlow(deps) {
                 upload: s.upload,
                 submitStep: s.submitStep,
                 stepIndex: i,
+                totalSteps: () => steps.length,
                 phase: "flow",
                 signalCounter,
                 recentCaptures,