@enricai/barnacle 1.9.2 → 1.9.4

package/dist/scripts/recon-browser.d.ts

@@ -94,6 +94,28 @@ export declare function detectRejectionInResponseBody(body: unknown): {
     rejected: boolean;
     reason: string | null;
 };
+/**
+ * Records which captured POSTs are the real submission — the authoritative
+ * signal `recon-generate` needs to emit only the submit calls, rather than
+ * re-guessing from raw same-origin traffic (which cannot separate the
+ * submission from page-chrome POSTs that share its URL). Selection is by the
+ * flow's declared submit patterns: `submitEndpointPattern` on the request URL
+ * AND, when declared, `submitBodyPattern` on the request body — the same
+ * site-agnostic signals the verifier already trusts. No-op (writes nothing)
+ * when no `submitEndpointPattern` is declared, so runs without submit signals
+ * fall through to generate's existing heuristic unchanged.
+ *
+ * Capture files are named `<NNN>-<phase>-...json` with a zero-padded index, so
+ * lexicographic order == numeric order; `recon-generate`'s `readJsonDir` sorts
+ * identically, making the recorded `index` a stable cross-tool key.
+ */
+declare function writeSubmitManifest(params: {
+    runRoot: string;
+    capturesDir: string;
+    submitEndpointPattern: string | null;
+    submitBodyPattern: string | null;
+    logger: Logger;
+}): void;
 export declare function findWizardRestartSignal(params: {
     preIdx: number;
     capturesDir?: string;
@@ -120,6 +142,19 @@ export declare function isReplanCycle(priorReplans: readonly ReplanEvent[], newS
     url: string;
     htmlLength: number;
 }): boolean;
+declare const RECON_FLOW_SCHEMA: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    step: z.ZodString;
+    optional: z.ZodDefault<z.ZodBoolean>;
+    upload: z.ZodDefault<z.ZodBoolean>;
+    submitStep: z.ZodDefault<z.ZodBoolean>;
+    payloadField: z.ZodOptional<z.ZodString>;
+    payloadFieldNone: z.ZodOptional<z.ZodBoolean>;
+    targetId: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        original: "original";
+        replan: "replan";
+    }>>;
+}, z.core.$strip>]>>;
 /**
  * Two on-disk shapes are accepted:
  *
@@ -152,6 +187,11 @@ export declare const RECON_FLOW_FILE_SCHEMA: z.ZodUnion<readonly [z.ZodArray<z.Z
     submitStep: z.ZodDefault<z.ZodBoolean>;
     payloadField: z.ZodOptional<z.ZodString>;
     payloadFieldNone: z.ZodOptional<z.ZodBoolean>;
+    targetId: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        original: "original";
+        replan: "replan";
+    }>>;
 }, z.core.$strip>]>>, z.ZodObject<{
     steps: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         step: z.ZodString;
@@ -160,9 +200,15 @@ export declare const RECON_FLOW_FILE_SCHEMA: z.ZodUnion<readonly [z.ZodArray<z.Z
         submitStep: z.ZodDefault<z.ZodBoolean>;
         payloadField: z.ZodOptional<z.ZodString>;
         payloadFieldNone: z.ZodOptional<z.ZodBoolean>;
+        targetId: z.ZodOptional<z.ZodString>;
+        origin: z.ZodOptional<z.ZodEnum<{
+            original: "original";
+            replan: "replan";
+        }>>;
     }, z.core.$strip>]>>;
     frameSelector: z.ZodOptional<z.ZodString>;
     submitEndpointPattern: z.ZodOptional<z.ZodString>;
+    submitBodyPattern: z.ZodOptional<z.ZodString>;
     submittedStateSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
     requireSubmitEndpointMatch: z.ZodOptional<z.ZodBoolean>;
     successUrlFragments: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -188,8 +234,10 @@ interface NormalizedStep {
     submitStep?: boolean;
     payloadField?: string;
     payloadFieldNone?: boolean;
+    targetId?: string;
     origin: "original" | "replan";
 }
+declare function normalizeFlow(steps: z.infer<typeof RECON_FLOW_SCHEMA>): NormalizedStep[];
 /**
  * Inverse of normalizeFlow: maps an internal `NormalizedStep` back to the
  * on-disk union shape. Bare string for the common case (required,
@@ -203,28 +251,37 @@ declare function denormalizeStep(step: NormalizedStep): string | {
     submitStep?: true;
     payloadField?: string;
     payloadFieldNone?: true;
+    targetId?: string;
+    origin?: "replan";
 };
 /**
- * Collapse any consecutive run of structurally-identical denormalized
- * steps into a single entry. Used by `persistReplannedFlow` before write-
- * back so cumulative-replan noise (each cascade-exhausted replan adds the
- * same recovery bridge to the tail; after 5 replans the persisted file
- * carries 5 stacked copies) doesn't pollute the on-disk flow.
- *
- * Comparison is structural via JSON-stringify equality:
- * - Two strings with the same value collapse.
- * - Two objects with the same {step, optional, upload} collapse.
- * - A string and an object with the same instruction do NOT collapse — they
- *   are semantically different (bare = required, object = could be optional
- *   or upload).
+ * Order-independent structural dedup: drops any item byte-identical to an
+ * earlier kept one, anywhere in the list (not just adjacent). The real
+ * cross-run accretion is identical recovery blocks stacked NON-adjacently
+ * (each cascade-exhausted replan re-appends its bridge to the tail, separated
+ * by other steps), which `dedupeConsecutiveIdentical` never compares. Keys on
+ * full JSON content, so two items collapse iff identical in every field — it
+ * can never merge two genuinely-different steps. First occurrence wins,
+ * preserving flow order.
+ */
+export declare function dedupeIdenticalSteps<T>(items: T[]): T[];
+/**
+ * Global, deterministic dedup on stable DOM target identity, applied at persist
+ * time. A wizard section the replanner re-discovers across runs is described in
+ * fresh prose each time (the replan prompt rewards structurally-different
+ * wording), so string/label dedup never collapses it and the persisted flow
+ * never converges. Because a step's `targetId` is the SAME DOM element
+ * regardless of wording, keying on it collapses those reworded duplicates
+ * deterministically.
  *
- * Only CONSECUTIVE duplicates collapse. A non-adjacent repeat is preserved
- * since flow authors sometimes intentionally re-fill a field after a
- * downstream interaction (e.g. re-fill First Name after the resume upload
- * triggers an Angular re-render). Adjacent duplicates are almost always
- * accumulation noise from successive replans converging on the same idea.
+ * Conservative by construction: only drops a `"replan"`-origin step whose
+ * `targetId` an EARLIER kept step already covers. Authored (`"original"`) steps
+ * are never dropped — that protects a legitimately-repeated authored action
+ * (e.g. re-fill after a re-render). Steps without a `targetId` are never
+ * dropped here; they fall through to the structural pass. First occurrence
+ * wins.
  */
-declare function dedupeConsecutiveIdentical<T>(items: T[]): T[];
+export declare function dedupeReplanStepsByTarget(steps: NormalizedStep[]): NormalizedStep[];
 /**
  * Resume-from-failure filter for replan output. The global replanner should emit
  * only a recovery BRIDGE from the failure point (the original remaining tail is
@@ -421,8 +478,11 @@ declare function parseCli(): {
     advancedStealth: boolean;
     dumpDomBeforeStep: number | null;
     allocateEmailEnvVar: string | null;
+    maxCascadeReplans: number | null;
+    maxProbeReplans: number | null;
     frameSelector: string | null;
     submitEndpointPattern: string | null;
+    submitBodyPattern: string | null;
     submittedStateSelectors: string[];
     requireSubmitEndpointMatch: boolean;
     advanceTransitionBodyPattern: string | null;
@@ -439,5 +499,5 @@ declare function main(): Promise<void>;
 export type { Html5DateFillResult, InvalidFormControl, LeafInvalidField, RadioGroupCandidate, ValidationRejectionPair, VerifyFillReadbackResult, } from "../scraper/flow-runner";
 export { buildRadioIdXPath, capturesAfterIndex, chooseRequiredSelectOption, describeAttemptEffectSignals, extractGaEventEvidence, extractSubmitFailureEvidence, fillHtml5DateTimeInput, fillTextDatepickerInput, findRecentBackendError, findRecentPageTransition, formatValidationRejectedReason, hasBillingErrorBeenLogged, isAdvanceStalled, isAdvanceStep, isDomOnlyAdvanceVerified, isSubmitRevealedInvalid, isUploadAffordanceLabel, isWizardExitAction, latestCaptureIndex, logBillingErrorIfPresent, narrowInvalidFormControl, normalizeDateValue, pairInvalidWithErrors, parseCaptureIndex, parseRadioStep, parseSelectStep, pollEnumerate, probeLeafInvalidContainers, probeStepBeforeAttempts, renderLeafInvalidFields, renderUnfocusedObserve, rephraseWithLLM, resetBillingErrorFlagForTests, selectBodyExcerpt, selectRadioGroupOption, shouldSkipTechnique, shouldVetoFallbackAdvance, shouldWarnMissingAdvancePattern, verifyFillReadback, waitForTransitionBody, windowHasAdvanceTransition, windowHasTransitionBody, writeFixtureToTempFile, } from "../scraper/flow-runner";
 export type { NormalizedStep, ReplanEvent };
-export { dedupeConsecutiveIdentical, denormalizeStep, main, parseCli, persistReplannedFlow, readFailureDumpEvidence, replanRemainingFlow, snapshotAndPersistCookieJar, };
+export { denormalizeStep, main, normalizeFlow, parseCli, persistReplannedFlow, readFailureDumpEvidence, replanRemainingFlow, snapshotAndPersistCookieJar, writeSubmitManifest, };
 //# sourceMappingURL=recon-browser.d.ts.map

package/dist/scripts/recon-browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recon-browser.d.ts","sourceRoot":"","sources":["../../src/scripts/recon-browser.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recon-browser.d.ts","sourceRoot":"","sources":["../../src/scripts/recon-browser.ts"],"names":[],"mappings":"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"}

package/dist/scripts/recon-browser.js

@@ -54,19 +54,22 @@ exports.findWizardRestartSignal = findWizardRestartSignal;
 exports.isStructurallyBlocked = isStructurallyBlocked;
 exports.summarizeReplanFailureKinds = summarizeReplanFailureKinds;
 exports.isReplanCycle = isReplanCycle;
+exports.dedupeIdenticalSteps = dedupeIdenticalSteps;
+exports.dedupeReplanStepsByTarget = dedupeReplanStepsByTarget;
 exports.filterCompletedFromReplan = filterCompletedFromReplan;
 exports.filterReplanDuplicatingNextAuthored = filterReplanDuplicatingNextAuthored;
 exports.isReplanReproposingFailedStep = isReplanReproposingFailedStep;
 exports.renderStepWindow = renderStepWindow;
 exports.countSlugPrefixMatches = countSlugPrefixMatches;
-exports.dedupeConsecutiveIdentical = dedupeConsecutiveIdentical;
 exports.denormalizeStep = denormalizeStep;
 exports.main = main;
+exports.normalizeFlow = normalizeFlow;
 exports.parseCli = parseCli;
 exports.persistReplannedFlow = persistReplannedFlow;
 exports.readFailureDumpEvidence = readFailureDumpEvidence;
 exports.replanRemainingFlow = replanRemainingFlow;
 exports.snapshotAndPersistCookieJar = snapshotAndPersistCookieJar;
+exports.writeSubmitManifest = writeSubmitManifest;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -171,14 +174,6 @@ async function snapshotAndPersistCookieJar(page, counter, label, phase, stepInde
         logger.warn(`cookie-snapshot-write skipped for ${filename}: ${(0, errors_1.toErrorMessage)(err)}`);
     }
 }
-const MAX_PROBE_REPLANS = 5;
-/**
- * Replans triggered by the full self-healing cascade exhausting all 4
- * attempts (expensive: 4 attempts × backoff + LLM rephrase + observe
- * calls). Counted separately from probe replans so cheap recoveries don't
- * consume the budget reserved for expensive recoveries.
- */
-const MAX_CASCADE_REPLANS = 5;
 /**
  * Validates the RECON_GOTO_WAIT_UNTIL override before it reaches Stagehand,
  * which accepts a narrower set of load states than Playwright does — `commit`
@@ -344,6 +339,59 @@ function auditFinalSubmitMatch(params) {
     }
     return { auditFailed: true, rejectionReason: lastRejectionReason };
 }
+/**
+ * Records which captured POSTs are the real submission — the authoritative
+ * signal `recon-generate` needs to emit only the submit calls, rather than
+ * re-guessing from raw same-origin traffic (which cannot separate the
+ * submission from page-chrome POSTs that share its URL). Selection is by the
+ * flow's declared submit patterns: `submitEndpointPattern` on the request URL
+ * AND, when declared, `submitBodyPattern` on the request body — the same
+ * site-agnostic signals the verifier already trusts. No-op (writes nothing)
+ * when no `submitEndpointPattern` is declared, so runs without submit signals
+ * fall through to generate's existing heuristic unchanged.
+ *
+ * Capture files are named `<NNN>-<phase>-...json` with a zero-padded index, so
+ * lexicographic order == numeric order; `recon-generate`'s `readJsonDir` sorts
+ * identically, making the recorded `index` a stable cross-tool key.
+ */
+function writeSubmitManifest(params) {
+    const { runRoot, capturesDir, submitEndpointPattern, submitBodyPattern, logger } = params;
+    if (submitEndpointPattern === null)
+        return;
+    const endpointRx = new RegExp(submitEndpointPattern);
+    const bodyRx = submitBodyPattern === null ? null : new RegExp(submitBodyPattern);
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(capturesDir)
+            .filter((f) => f.endsWith(".json") && !f.endsWith(".decoded.json"))
+            .sort();
+    }
+    catch (err) {
+        logger.warn(`submit-manifest: could not read captures dir ${capturesDir}: ${(0, errors_1.toErrorMessage)(err)}`);
+        return;
+    }
+    const matched = [];
+    for (const [index, filename] of entries.entries()) {
+        try {
+            const data = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(capturesDir, filename), "utf8"));
+            if (data.method === "GET" || typeof data.url !== "string")
+                continue;
+            if (!endpointRx.test(data.url))
+                continue;
+            if (bodyRx !== null && !bodyRx.test(data.requestPostData ?? ""))
+                continue;
+            matched.push({ index, filename, url: data.url });
+        }
+        catch {
+            // Ignore unparseable/non-capture files, as the audit does.
+        }
+    }
+    if (matched.length === 0) {
+        logger.warn(`submit-manifest: no capture matched submitEndpointPattern${submitBodyPattern !== null ? " + submitBodyPattern" : ""} — writing empty manifest so generate reports the gap rather than silently re-guessing`);
+    }
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(runRoot, "submit-manifest.json"), `${JSON.stringify(matched, null, 2)}\n`);
+    logger.info(`submit-manifest: recorded ${matched.length} submission capture(s)`);
+}
 function findWizardRestartSignal(params) {
     const { preIdx, restartSignalUrlPatterns } = params;
     if (restartSignalUrlPatterns.length === 0)
@@ -460,6 +508,17 @@ exports.RECON_FLOW_FILE_SCHEMA = v4_1.z.union([
          */
         frameSelector: v4_1.z.string().min(1).optional(),
         submitEndpointPattern: v4_1.z.string().min(1).optional(),
+        /**
+         * Regex tested against a captured POST's request BODY to distinguish the
+         * real submission from page-chrome POSTs that share the submit URL. Some
+         * ATSes overload one endpoint by a body discriminator (e.g. a submit and a
+         * reference-lookup both POST the same path, separable only by a body key),
+         * so `submitEndpointPattern` (URL) alone keeps both. When set,
+         * `recon-generate` emits only POSTs whose body ALSO matches this pattern —
+         * isolating the submission. Opt-in: sites that don't set it keep URL-only
+         * selection, so no cross-site regression.
+         */
+        submitBodyPattern: v4_1.z.string().min(1).optional(),
         submittedStateSelectors: v4_1.z.array(v4_1.z.string().min(1)).optional(),
         /**
          * When true, the final-step verifier accepts ONLY a `submitEndpointPattern`
@@ -549,7 +608,9 @@ function normalizeFlow(steps) {
             submitStep: s.submitStep,
             payloadField: s.payloadField,
             payloadFieldNone: s.payloadFieldNone,
-            origin: "original",
+            targetId: s.targetId,
+            // Preserve a persisted replan marker across runs; absence = authored.
+            origin: s.origin ?? "original",
         });
 }
 /**
@@ -580,7 +641,12 @@ function substituteFlowEnvVars(steps) {
  */
 function denormalizeStep(step) {
     const hasSplicerHint = step.payloadField !== undefined || step.payloadFieldNone === true;
-    if (!step.optional && !step.upload && !step.submitStep && !hasSplicerHint) {
+    // targetId and a "replan" origin are load-bearing identity that must survive
+    // the round-trip, so a step carrying either is forced to object form even when
+    // it has no flags. Authored ("original") origin stays implicit — persisting it
+    // on every step would needlessly object-ify the whole flow file.
+    const hasIdentity = step.targetId !== undefined || step.origin === "replan";
+    if (!step.optional && !step.upload && !step.submitStep && !hasSplicerHint && !hasIdentity) {
         return step.instruction;
     }
     const out = {
@@ -596,37 +662,60 @@ function denormalizeStep(step) {
         out.payloadField = step.payloadField;
     if (step.payloadFieldNone === true)
         out.payloadFieldNone = true;
+    if (step.targetId !== undefined)
+        out.targetId = step.targetId;
+    if (step.origin === "replan")
+        out.origin = "replan";
     return out;
 }
 /**
- * Collapse any consecutive run of structurally-identical denormalized
- * steps into a single entry. Used by `persistReplannedFlow` before write-
- * back so cumulative-replan noise (each cascade-exhausted replan adds the
- * same recovery bridge to the tail; after 5 replans the persisted file
- * carries 5 stacked copies) doesn't pollute the on-disk flow.
- *
- * Comparison is structural via JSON-stringify equality:
- * - Two strings with the same value collapse.
- * - Two objects with the same {step, optional, upload} collapse.
- * - A string and an object with the same instruction do NOT collapse — they
- *   are semantically different (bare = required, object = could be optional
- *   or upload).
+ * Order-independent structural dedup: drops any item byte-identical to an
+ * earlier kept one, anywhere in the list (not just adjacent). The real
+ * cross-run accretion is identical recovery blocks stacked NON-adjacently
+ * (each cascade-exhausted replan re-appends its bridge to the tail, separated
+ * by other steps), which `dedupeConsecutiveIdentical` never compares. Keys on
+ * full JSON content, so two items collapse iff identical in every field — it
+ * can never merge two genuinely-different steps. First occurrence wins,
+ * preserving flow order.
+ */
+function dedupeIdenticalSteps(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const key = JSON.stringify(item);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+/**
+ * Global, deterministic dedup on stable DOM target identity, applied at persist
+ * time. A wizard section the replanner re-discovers across runs is described in
+ * fresh prose each time (the replan prompt rewards structurally-different
+ * wording), so string/label dedup never collapses it and the persisted flow
+ * never converges. Because a step's `targetId` is the SAME DOM element
+ * regardless of wording, keying on it collapses those reworded duplicates
+ * deterministically.
  *
- * Only CONSECUTIVE duplicates collapse. A non-adjacent repeat is preserved
- * since flow authors sometimes intentionally re-fill a field after a
- * downstream interaction (e.g. re-fill First Name after the resume upload
- * triggers an Angular re-render). Adjacent duplicates are almost always
- * accumulation noise from successive replans converging on the same idea.
+ * Conservative by construction: only drops a `"replan"`-origin step whose
+ * `targetId` an EARLIER kept step already covers. Authored (`"original"`) steps
+ * are never dropped — that protects a legitimately-repeated authored action
+ * (e.g. re-fill after a re-render). Steps without a `targetId` are never
+ * dropped here; they fall through to the structural pass. First occurrence
+ * wins.
  */
-function dedupeConsecutiveIdentical(items) {
-    if (items.length < 2)
-        return [...items];
-    const out = [items[0]];
-    for (let i = 1; i < items.length; i++) {
-        const prev = JSON.stringify(out[out.length - 1]);
-        const curr = JSON.stringify(items[i]);
-        if (prev !== curr)
-            out.push(items[i]);
+function dedupeReplanStepsByTarget(steps) {
+    const seenTargets = new Set();
+    const out = [];
+    for (const step of steps) {
+        if (step.origin === "replan" && step.targetId !== undefined && seenTargets.has(step.targetId)) {
+            continue;
+        }
+        if (step.targetId !== undefined)
+            seenTargets.add(step.targetId);
+        out.push(step);
     }
     return out;
 }
@@ -787,12 +876,19 @@ function persistReplannedFlow(params) {
     // cascade still fires for the original employer when the persisted flow
     // is replayed. Required to keep cross-employer sweeps from regressing
     // across runs.
-    const denormalizedSteps = finalPlan.map((step) => denormalizeStep(step.origin === "replan" && !step.optional ? { ...step, optional: true } : step));
-    // Cumulative-replan dedupe: each cascade-exhausted replan appends a
-    // recovery bridge to the tail; after several replans the persisted flow
-    // would carry stacked copies of the same bridge. Collapse them so the
-    // user reviewing the diff sees only the distinct LLM-discovered steps.
-    const dedupedSteps = dedupeConsecutiveIdentical(denormalizedSteps);
+    // Deterministic convergence: first drop replan-origin steps whose stable DOM
+    // targetId an earlier step already covers (collapses reworded re-discoveries
+    // of the same section across runs — the churn no string/label dedup catches).
+    // Runs on NormalizedStep[] because it needs `.origin`/`.targetId`, both erased
+    // by denormalizeStep.
+    const targetDeduped = dedupeReplanStepsByTarget(finalPlan);
+    const denormalizedSteps = targetDeduped.map((step) => denormalizeStep(step.origin === "replan" && !step.optional ? { ...step, optional: true } : step));
+    // Then a global structural pass for identical blocks that carry no targetId
+    // (e.g. label-less clickable bridges): each cascade-exhausted replan re-appends
+    // its bridge to the tail, and successive runs stack byte-identical copies at
+    // NON-adjacent positions. Global JSON-equality collapses them; it can never
+    // merge two genuinely-different steps.
+    const dedupedSteps = dedupeIdenticalSteps(denormalizedSteps);
     // 2-space indent + trailing newline matches the existing on-disk style
     // (verified against site recon-flow.json files).
     const payload = originalShape === "object"
@@ -1058,7 +1154,7 @@ ${errorTextList || "(none)"}
 STRUCTURED SERVER-SIDE VALIDATION ERRORS (parsed from captured 4xx responses to the submit endpoint — when populated, the form's submit DID fire and the server rejected it with specific feedback):
 ${submitFailureList || "(none)"}
 
-PRIOR REPLAN HISTORY (proposals from previous replans for this same failure; the cascade executed each one and verification still failed at the time it ran. Between replans, the page may have advanced — a step that failed earlier could potentially work now if intervening steps filled missing prerequisites or dismissed blockers. But re-proposing the EXACT same multi-step sequence that already failed is unlikely to produce a different outcome. Prefer structurally different recovery paths. If you re-use a prior step, pair it with new context that addresses why it failed before):
+PRIOR REPLAN HISTORY (proposals from previous replans for this same failure; the cascade executed each one and verification still failed at the time it ran. Between replans, the page may have advanced — a step that failed earlier could potentially work now if intervening steps filled missing prerequisites or dismissed blockers. But re-proposing the EXACT same multi-step sequence that already failed is unlikely to produce a different outcome. When a prior proposal targeted the WRONG control (misread the DOM), target the correct control instead. Do NOT, however, merely re-describe an action on a control that a completed step already handled — same control, fresh wording is not progress and only bloats the flow; advance to the next unhandled control instead. If you re-use a prior step, pair it with new context that addresses why it failed before):
 ${priorReplanList || "(none)"}
 
 PRIOR STEP TRAJECTORY (how the last few completed steps verified — url / submitted-state-dom signal pages that visibly transitioned; network / dom signal pages that stayed static. Use this to distinguish "page has been advancing through the flow" from "page has been static and the form is still in front of us"; avoid proposing regression-style steps if the trajectory shows recent transitions):
@@ -1280,6 +1376,8 @@ function parseCli() {
     let advancedStealth = false;
     let dumpDomBeforeStep = null;
     let allocateEmailEnvVar = null;
+    let maxCascadeReplans = null;
+    let maxProbeReplans = null;
     let allowEmptyFlow = false;
     for (let i = 0; i < args.length; i++) {
         if (args[i] === "--url" && args[i + 1]) {
@@ -1324,12 +1422,28 @@ function parseCli() {
             }
             allocateEmailEnvVar = name;
         }
+        else if (args[i] === "--max-cascade-replans" && args[i + 1]) {
+            const n = Number.parseInt(args[++i], 10);
+            if (!Number.isInteger(n) || n < 1) {
+                logger.error(`--max-cascade-replans must be a positive integer (got ${JSON.stringify(args[i])})`);
+                process.exit(1);
+            }
+            maxCascadeReplans = n;
+        }
+        else if (args[i] === "--max-probe-replans" && args[i + 1]) {
+            const n = Number.parseInt(args[++i], 10);
+            if (!Number.isInteger(n) || n < 1) {
+                logger.error(`--max-probe-replans must be a positive integer (got ${JSON.stringify(args[i])})`);
+                process.exit(1);
+            }
+            maxProbeReplans = n;
+        }
         else if (args[i] === "--allow-empty-flow") {
             allowEmptyFlow = true;
         }
     }
     if (!url) {
-        logger.error('usage: recon-browser.ts --url <url> [--flow \'["step1","step2"]\'] [--flow-file <path>] [--provider browserbase|steel] [--upload-fixture <path>] [--no-save-replan] [--advanced-stealth] [--dump-dom-before-step <N>] [--allocate-email <ENV_VAR_NAME>] [--allow-empty-flow]');
+        logger.error('usage: recon-browser.ts --url <url> [--flow \'["step1","step2"]\'] [--flow-file <path>] [--provider browserbase|steel] [--upload-fixture <path>] [--no-save-replan] [--advanced-stealth] [--dump-dom-before-step <N>] [--allocate-email <ENV_VAR_NAME>] [--max-cascade-replans <N>] [--max-probe-replans <N>] [--allow-empty-flow]');
         process.exit(1);
     }
     if (flowFile) {
@@ -1355,8 +1469,11 @@ function parseCli() {
             advancedStealth,
             dumpDomBeforeStep,
             allocateEmailEnvVar,
+            maxCascadeReplans,
+            maxProbeReplans,
             frameSelector: null,
             submitEndpointPattern: null,
+            submitBodyPattern: null,
             submittedStateSelectors: [],
             requireSubmitEndpointMatch: false,
             advanceTransitionBodyPattern: null,
@@ -1380,6 +1497,9 @@ function parseCli() {
     const submitEndpointPattern = Array.isArray(parsed.data)
         ? null
         : (parsed.data.submitEndpointPattern ?? null);
+    const submitBodyPattern = Array.isArray(parsed.data)
+        ? null
+        : (parsed.data.submitBodyPattern ?? null);
     const submittedStateSelectors = Array.isArray(parsed.data)
         ? []
         : (parsed.data.submittedStateSelectors ?? []);
@@ -1419,6 +1539,15 @@ function parseCli() {
             process.exit(1);
         }
     }
+    if (submitBodyPattern !== null) {
+        try {
+            new RegExp(submitBodyPattern);
+        }
+        catch (err) {
+            logger.error(`flow file: submitBodyPattern is not a valid regex: ${(0, errors_1.toErrorMessage)(err)}`);
+            process.exit(1);
+        }
+    }
     return {
         url,
         flow: normalizeFlow(stepsRaw),
@@ -1429,8 +1558,11 @@ function parseCli() {
         advancedStealth,
         dumpDomBeforeStep,
         allocateEmailEnvVar,
+        maxCascadeReplans,
+        maxProbeReplans,
         frameSelector,
         submitEndpointPattern,
+        submitBodyPattern,
         submittedStateSelectors,
         requireSubmitEndpointMatch,
         advanceTransitionBodyPattern,
@@ -1468,7 +1600,13 @@ function loadUploadFixture(path) {
     }
 }
 async function main() {
-    const { url, flow: rawFlow, flowFile, provider, uploadFixturePath, saveReplan, advancedStealth, dumpDomBeforeStep, allocateEmailEnvVar, frameSelector, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, restartSignalUrlPatterns, originalShape, allowEmptyFlow, } = parseCli();
+    const { url, flow: rawFlow, flowFile, provider, uploadFixturePath, saveReplan, advancedStealth, dumpDomBeforeStep, allocateEmailEnvVar, maxCascadeReplans, maxProbeReplans, frameSelector, submitEndpointPattern, submitBodyPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, restartSignalUrlPatterns, originalShape, allowEmptyFlow, } = parseCli();
+    // Replan-budget precedence: CLI flag > RECON_MAX_*_REPLANS env
+    // (config.scraper.max*Replans) > the built-in default constants. A known-deep
+    // wizard can raise its own ceiling per-run without a code change; nothing set
+    // preserves the historical budget of 5.
+    const resolvedCascadeBudget = maxCascadeReplans ?? config_1.config.scraper.maxCascadeReplans;
+    const resolvedProbeBudget = maxProbeReplans ?? config_1.config.scraper.maxProbeReplans;
     // Allocate a fresh testmail.app inbox + bind it to the requested env var
     // BEFORE substituting placeholders in the flow. Subsequent ${ENV_VAR}
     // tokens anywhere in the flow's instruction strings resolve to the
@@ -1726,6 +1864,17 @@ async function main() {
                     onStepFailure: dumpStepFailure,
                 });
                 await snapshotAndPersistCookieJar(page, jarCounter, "post-step", currentPhase, i);
+                // Stamp the step's stable DOM identity from the fast primitive that just
+                // resolved it (pushed onto trajectory), so persistReplannedFlow can dedup
+                // reworded re-discoveries of this field across runs on `targetId`. Only a
+                // non-empty id is load-bearing; an empty string (element had no id) is
+                // left off so the step falls back to structural dedup.
+                const lastTrajectory = trajectory[trajectory.length - 1];
+                if (lastTrajectory?.stepIndex === i &&
+                    lastTrajectory.targetId !== undefined &&
+                    lastTrajectory.targetId !== "") {
+                    plan[i] = { ...plan[i], targetId: lastTrajectory.targetId };
+                }
                 // Wizard-restart detection: if a configured restart-signal URL (e.g.
                 // a wizard ATS's `init-apply?...&application_canceled=true`) landed during
                 // this step, the multi-page wizard reset to page 1. Remaining steps now
@@ -1833,7 +1982,7 @@ async function main() {
                 // the step is unrecoverable). Separate budgets so cheap recoveries
                 // don't eat into the budget reserved for expensive ones.
                 const isProbe = err.kind === "probe-absent";
-                const budget = isProbe ? MAX_PROBE_REPLANS : MAX_CASCADE_REPLANS;
+                const budget = isProbe ? resolvedProbeBudget : resolvedCascadeBudget;
                 const usedSoFar = isProbe ? probeReplansUsed : cascadeReplansUsed;
                 if (usedSoFar >= budget) {
                     const kindsSummary = callsNdjsonPath !== null
@@ -1957,6 +2106,17 @@ async function main() {
             }
         }
         stopCapture();
+        // Authoritative submission record for recon-generate: which captured POSTs
+        // are the real submission, keyed on the flow's declared submit patterns.
+        // Runs whenever a pattern is declared (independent of the audit gate below),
+        // since generate consumes it even when requireSubmitEndpointMatch is off.
+        writeSubmitManifest({
+            runRoot: runDir.root,
+            capturesDir: runDir.graphqlDir,
+            submitEndpointPattern,
+            submitBodyPattern,
+            logger,
+        });
         // End-of-run audit: when the flow declared submitEndpointPattern AND
         // opted into requireSubmitEndpointMatch=true, scan ALL captures from
         // this run for a pattern-matching 200 before declaring success. If no