@enricai/barnacle 1.12.42 → 1.12.44

package/dist/scripts/recon-generate.js

@@ -38,6 +38,7 @@ exports.gatherResponseBodySamples = gatherResponseBodySamples;
 exports.selectPrimaryGraphQLOperation = selectPrimaryGraphQLOperation;
 exports.firstEndpointCapture = firstEndpointCapture;
 exports.firstEndpointPath = firstEndpointPath;
+exports.truncateActionSequenceAtSubmitPattern = truncateActionSequenceAtSubmitPattern;
 exports.resolveManifestActionSequence = resolveManifestActionSequence;
 exports.extractActionSequence = extractActionSequence;
 exports.extractGraphQLActionSequence = extractGraphQLActionSequence;
@@ -1050,7 +1051,7 @@ const IGNORE_REQUEST_HEADERS = new Set([
  * headers (a `X-CSRF-Token`, a `Job-Boards-API-Token`, an `API-ShortName`,
  * etc.) without the generator needing to know about any particular site.
  */
-function deriveRequestHeaders(captures, replays, baseUrl, submitPatterns = null) {
+function deriveRequestHeaders(captures, replays, baseUrl, submitPatterns = null, ownBackendHostnames = [], fallbackDomain = null) {
     const successfulUrls = new Set(replays.filter((r) => r.success).map((r) => endpointKey(r.url)));
     // Prefer ACTION captures (non-GET 2xx, non-noise) as the authoritative
     // header source. Replay-matched static-asset GETs lack the API-specific
@@ -1059,7 +1060,7 @@ function deriveRequestHeaders(captures, replays, baseUrl, submitPatterns = null)
     // (multi-step submission flows), use them. For sites where the flow is a
     // single REST call (no detectable action sequence), fall back to the
     // replay-matched captures.
-    const actionCaptures = extractActionSequence(captures, submitPatterns).map((a) => a.capture);
+    const actionCaptures = extractActionSequence(captures, submitPatterns, null, ownBackendHostnames, fallbackDomain).map((a) => a.capture);
     const replayMatchedCaptures = captures.filter((c) => successfulUrls.has(endpointKey(c.url)));
     const relevantCaptures = actionCaptures.length > 0 ? actionCaptures : replayMatchedCaptures;
     const counts = new Map();
@@ -1102,12 +1103,31 @@ function isGraphQL(captures) {
  * `selectPrimaryGraphQLOperation` winner) resolves its query, endpoint, and
  * operationName from — all three MUST trace back to this same capture, not
  * three independent array scans that could each land on a different one.
- */
-function firstGraphQLCapture(captures, ownBackendHostnames = [], fallbackDomain = null) {
+ *
+ * `submitPatterns` (declared after this function so the types can appear
+ * before the interface they use) restricts the search to non-mutation
+ * (query) captures matching the pattern when the flow declares one AND at
+ * least one own-backend query capture matches it — mirroring
+ * {@link truncateActionSequenceAtSubmitPattern}'s never-hard-fail fallback
+ * to the unfiltered pool. The restriction only ever narrows within the
+ * query captures, never promotes a mutation over them: this fallback exists
+ * specifically for the read op a bypassed {@link selectPrimaryGraphQLOperation}
+ * would have picked, and a declared pattern that happens to match the
+ * flow's own mutation capture (its real submission step, resolved
+ * elsewhere) must not hijack this read-op resolution.
+ */
+function firstGraphQLCapture(captures, ownBackendHostnames = [], fallbackDomain = null, submitPatterns = null) {
     const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
-    return (captures.find((c) => c.query &&
+    const ownBackendCandidates = captures.filter((c) => c.query &&
         (!hasHostProvenance ||
-            (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain))) ?? null);
+            (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain)));
+    if (submitPatterns === null ||
+        (submitPatterns.endpoint === null && submitPatterns.body === null)) {
+        return ownBackendCandidates[0] ?? null;
+    }
+    const nonMutationCandidates = ownBackendCandidates.filter((c) => !/^\s*mutation\b/.test(c.query ?? ""));
+    const pool = nonMutationCandidates.length > 0 ? nonMutationCandidates : ownBackendCandidates;
+    return restrictToSubmitPattern(pool, submitPatterns)[0] ?? null;
 }
 /**
  * Strips leading blank lines and `#`-comment lines (GraphQL comments run
@@ -1216,19 +1236,24 @@ function isPopulatedVariableValue(value) {
  * Select answer (e.g. a device-type dropdown) never contributes a spurious
  * facet match to the ranking.
  */
-function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = process.env, ownBackendHostnames = [], fallbackDomain = null) {
+function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = process.env, ownBackendHostnames = [], fallbackDomain = null, submitPatterns = null) {
     // Callers with no host-provenance data (the exported function's unit
     // tests) pass neither ownBackendHostnames nor fallbackDomain — in that
     // case isAllowedFixtureHost would reject every candidate, so the gate
     // only applies once the caller has actually resolved a notion of "own
     // backend" to check against.
     const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
-    const candidates = captures.filter((c) => c.status >= 200 &&
+    const ownBackendCandidates = captures.filter((c) => c.status >= 200 &&
         c.status < 300 &&
         c.query !== null &&
         !/^\s*mutation\b/.test(c.query) &&
         (!hasHostProvenance ||
             (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain)));
+    // A declared submitEndpointPattern is authoritative for single-endpoint
+    // primary selection too: it must not be silently ignored just because
+    // this scoring path (not the multi-step submission path) is the one that
+    // ends up resolving the flow's single action.
+    const candidates = restrictToSubmitPattern(ownBackendCandidates, submitPatterns);
     if (candidates.length === 0)
         return null;
     const knownFieldValues = buildKnownFieldValues(flowSteps, vocabulary, env);
@@ -1322,7 +1347,7 @@ function selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, env = pr
  * derives a path string from, so non-GraphQL flows can also read that
  * capture's own `.responseBody` instead of an array-order-first replay.
  */
-function firstEndpointCapture(captures, ownBackendHostnames = [], fallbackDomain = null) {
+function firstEndpointCapture(captures, ownBackendHostnames = [], fallbackDomain = null, submitPatterns = null) {
     // Callers with no host-provenance data (unit tests exercising the
     // chronological-first fallback in isolation) pass neither argument -- in
     // that case isAllowedFixtureHost would reject every candidate, so the
@@ -1331,7 +1356,7 @@ function firstEndpointCapture(captures, ownBackendHostnames = [], fallbackDomain
     const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
     const allowed = (c) => !hasHostProvenance ||
         (0, capture_filters_1.isAllowedFixtureHost)(captureHostname(c.url), ownBackendHostnames, fallbackDomain);
-    const nonGetCaptures = captures.filter((c) => c.method !== "GET" && allowed(c));
+    const nonGetCaptures = restrictToSubmitPattern(captures.filter((c) => c.method !== "GET" && allowed(c)), submitPatterns);
     for (const c of nonGetCaptures) {
         try {
             new URL(c.url);
@@ -1341,7 +1366,7 @@ function firstEndpointCapture(captures, ownBackendHostnames = [], fallbackDomain
             // skip
         }
     }
-    for (const c of captures.filter(allowed)) {
+    for (const c of restrictToSubmitPattern(captures.filter(allowed), submitPatterns)) {
         try {
             new URL(c.url);
             return c;
@@ -1360,9 +1385,9 @@ function safeUrlPathname(url) {
         return "/api/search";
     }
 }
-function firstEndpointPath(captures, ownBackendHostnames = [], fallbackDomain = null) {
+function firstEndpointPath(captures, ownBackendHostnames = [], fallbackDomain = null, submitPatterns = null) {
     try {
-        const capture = firstEndpointCapture(captures, ownBackendHostnames, fallbackDomain);
+        const capture = firstEndpointCapture(captures, ownBackendHostnames, fallbackDomain, submitPatterns);
         return capture ? new URL(capture.url).pathname : "/api/search";
     }
     catch {
@@ -1390,6 +1415,39 @@ function compileSubmitMatcher(patterns) {
         return true;
     };
 }
+/**
+ * Restricts a single-endpoint primary-capture candidate pool to captures
+ * matching the flow's declared submit pattern, when one is declared AND at
+ * least one candidate in the pool matches it. A pattern that matches nothing
+ * among the candidates falls back to the unfiltered pool — mirroring
+ * {@link truncateActionSequenceAtSubmitPattern}'s never-hard-fail philosophy
+ * — so `firstEndpointCapture`/`firstEndpointPath`/`firstGraphQLCapture`/
+ * `selectPrimaryGraphQLOperation` never lose a winner over a pattern that
+ * simply doesn't apply to this candidate pool.
+ */
+function restrictToSubmitPattern(pool, submitPatterns) {
+    const matchesSubmit = compileSubmitMatcher(submitPatterns);
+    const matching = pool.filter((c) => matchesSubmit(c));
+    return matching.length > 0 ? matching : pool;
+}
+/**
+ * Truncates a host-gated action sequence at the LAST capture matching the
+ * flow's declared submit pattern, keeping every capture up to and including
+ * it. A pattern that names only the wizard's final step must not collapse a
+ * multi-step chain (auth mint, paged listing, terminal submit) down to the
+ * bare matching capture(s) — a hard filter would drop the earlier steps the
+ * fold plan and state-threading depend on. When nothing matches, the result
+ * is empty, matching what a hard filter would have produced.
+ */
+function truncateActionSequenceAtSubmitPattern(sequence, submitPatterns) {
+    const matchesSubmit = compileSubmitMatcher(submitPatterns);
+    let lastMatchIndex = -1;
+    for (let i = 0; i < sequence.length; i++) {
+        if (matchesSubmit(sequence[i].capture))
+            lastMatchIndex = i;
+    }
+    return sequence.slice(0, lastMatchIndex + 1);
+}
 /**
  * Reads `submit-manifest.json` (written by recon-browser) and resolves it to the
  * authoritative submission action sequence. This is the deepest submit-selection
@@ -1426,11 +1484,11 @@ function resolveManifestActionSequence(runRoot, captures) {
 /**
  * Extracts the ordered sequence of meaningful POSTs that represent the
  * transactional flow: non-noise 2xx POSTs, minus telemetry and error-reporting
- * sinks. Assets need no filter of their own — they arrive as GETs. Host is
- * NOT a filter criterion — a multi-step submission routinely bounces to a
- * different host mid-flow (an account-creation redirect, a tenant API
- * subdomain distinct from the landing page's host), so `isNoiseUrl` alone
- * decides what counts as site traffic vs. third-party noise.
+ * sinks. Assets need no filter of their own — they arrive as GETs. When the
+ * caller has host-provenance data (`ownBackendHostnames`/`fallbackDomain`),
+ * a capture whose host fails {@link isAllowedFixtureHost} is dropped too —
+ * `isNoiseUrl` alone lets a third-party telemetry/beacon POST masquerade as
+ * a submission step, since it can look identical in shape to a real one.
  *
  * When the flow declares submit patterns, only POSTs matching them survive —
  * this isolates the submission from same-origin page chrome (bootstrap, chatbot,
@@ -1448,9 +1506,15 @@ function resolveManifestActionSequence(runRoot, captures) {
  * at a live site, and it is the only gate between a browser's incidental
  * chatter and the emitted hot path.
  */
-function extractActionSequence(captures, submitPatterns = null, foldReturnSpec = null) {
+function extractActionSequence(captures, submitPatterns = null, foldReturnSpec = null, ownBackendHostnames = [], fallbackDomain = null) {
     const matchesSubmit = compileSubmitMatcher(submitPatterns);
     const matchesFoldReturn = compileFoldReturnEndpointMatcher(foldReturnSpec);
+    // Callers with no host-provenance data (the exported function's unit
+    // tests) pass neither ownBackendHostnames nor fallbackDomain — in that
+    // case isAllowedFixtureHost would reject every candidate, so the gate
+    // only applies once the caller has actually resolved a notion of "own
+    // backend" to check against.
+    const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
     return captures
         .map((capture, index) => ({ capture, index }))
         .filter(({ capture }) => {
@@ -1462,6 +1526,9 @@ function extractActionSequence(captures, submitPatterns = null, foldReturnSpec =
             return false;
         if (!matchesSubmit(capture))
             return false;
+        if (hasHostProvenance &&
+            !(0, capture_filters_1.isAllowedFixtureHost)(captureHostname(capture.url), ownBackendHostnames, fallbackDomain))
+            return false;
         return true;
     });
 }
@@ -1473,8 +1540,10 @@ function extractActionSequence(captures, submitPatterns = null, foldReturnSpec =
  * make up a transactional flow (`UpsertSavedApplication`, `SubmitForm`, ...)
  * — and drops `query` operations, which are read/bootstrap calls (e.g. a
  * page-load `ListForms`) that carry no state-threading value and are exactly
- * what let a chronologically-first fallback pick an unrelated query. Host is
- * NOT a filter criterion, matching {@link extractActionSequence}.
+ * what let a chronologically-first fallback pick an unrelated query. When
+ * the caller has host-provenance data (`ownBackendHostnames`/`fallbackDomain`),
+ * a capture whose host fails {@link isAllowedFixtureHost} is dropped too,
+ * matching {@link extractActionSequence}.
  *
  * When the flow declares a `foldReturnSpec`, a non-mutation capture whose
  * URL matches its `endpointPattern` is admitted despite the query drop
@@ -1489,10 +1558,16 @@ function extractActionSequence(captures, submitPatterns = null, foldReturnSpec =
  * Exported for tests: this predicate decides what a generated GraphQL plugin
  * will send at a live site.
  */
-function extractGraphQLActionSequence(captures, submitPatterns = null, foldReturnSpec = null) {
+function extractGraphQLActionSequence(captures, submitPatterns = null, foldReturnSpec = null, ownBackendHostnames = [], fallbackDomain = null) {
     const matchesSubmit = compileSubmitMatcher(submitPatterns);
     const matchesFoldReturn = compileFoldReturnEndpointMatcher(foldReturnSpec);
     const matchesFoldReturnResults = compileFoldReturnResultsMatcher(foldReturnSpec);
+    // Callers with no host-provenance data (the exported function's unit
+    // tests) pass neither ownBackendHostnames nor fallbackDomain — in that
+    // case isAllowedFixtureHost would reject every candidate, so the gate
+    // only applies once the caller has actually resolved a notion of "own
+    // backend" to check against.
+    const hasHostProvenance = ownBackendHostnames.length > 0 || fallbackDomain !== null;
     return captures
         .map((capture, index) => ({ capture, index }))
         .filter(({ capture }) => {
@@ -1502,6 +1577,9 @@ function extractGraphQLActionSequence(captures, submitPatterns = null, foldRetur
             return false;
         if (!matchesSubmit(capture))
             return false;
+        if (hasHostProvenance &&
+            !(0, capture_filters_1.isAllowedFixtureHost)(captureHostname(capture.url), ownBackendHostnames, fallbackDomain))
+            return false;
         if (capture.query !== null && /^\s*mutation\b/.test(capture.query))
             return true;
         return matchesFoldReturn(capture) || matchesFoldReturnResults(capture);
@@ -7714,7 +7792,7 @@ ${executeHttpMethodBlock}
     session: BrowserSession,
     context: SitePluginContext
   ): Promise<SitePluginResult<${pascal}Response>> {
-    const raw = await run${pascal}BrowserFlow(session.stagehand, ${inputBody ? "payload.ClickUrl" : "context.baseUrl"}, payload);
+    const raw = await run${pascal}BrowserFlow(session.stagehand, ${inputBody ? "payload.ClickUrl" : "context.baseUrl"}, payload, session.sessionProxy ?? null);
     return { data: raw as ${pascal}Response };
   },
 };
@@ -8100,6 +8178,7 @@ import { getLogger } from "${ENGINE_PKG}/lib/logging";${usesThrowawayPassword ?
 import { type HealingFlowStep, runHealingFlow } from "${ENGINE_PKG}/scraper/flow-runner";
 import { waitForSpaReady } from "${ENGINE_PKG}/scraper/spa-readiness";
 import { guardedExtract } from "${ENGINE_PKG}/scraper/stagehand-guard";${usesEmailStep ? `\nimport { testmailInboxFromAddress } from "${ENGINE_PKG}/testmail/client";` : ""}
+import type { SessionProxyTuple } from "${ENGINE_PKG}/types/session-proxy";
 import ${isSubmissionFlow
         ? `type { ${pascal}Payload, ${pascal}Response }`
         : `{ type ${pascal}Payload, type ${pascal}Response, ${pascal}ResponseSchema }`} from "@/sites/${siteId}/contract";
@@ -8122,7 +8201,8 @@ const ${pascal}BrowserSchema = z.object({
 export async function run${pascal}BrowserFlow(
   stagehand: Stagehand,
   ${isSubmissionFlow ? "entryUrl" : "baseUrl"}: string,
-  payload: ${pascal}Payload
+  payload: ${pascal}Payload,
+  sessionProxy: SessionProxyTuple | null
 ): Promise<${pascal}Response> {
   const page = await stagehand.context.awaitActivePage();
 
@@ -8147,6 +8227,7 @@ ${flowStepsBlock}
     anthropic: buildAnthropicClient(),
     rephraseModel: buildRephraseModel(),
     uploadFixture: ${uploadFixtureExpr},${frameSelector !== undefined ? `\n    frameSelector: ${JSON.stringify(frameSelector)},` : ""}${usesEmailStep ? "\n    allocatedInbox: allocatedInbox," : ""}
+    sessionProxy,
   });
 
   // Schema-enforced extract via guardedExtract: Stagehand 3.4.0 accepts
@@ -8318,7 +8399,7 @@ async function main() {
             return [];
         }
     })();
-    const { flowSteps, frameSelector, submitEndpointPattern, submitBodyPattern, displayName, foldReturnSpec, } = (() => {
+    const { flowSteps, frameSelector, submitEndpointPattern, submitBodyPattern, requireSubmitEndpointMatch, displayName, foldReturnSpec, } = (() => {
         const flowFileContents = (() => {
             try {
                 return (0, node_fs_1.readFileSync)(flowFile, "utf8");
@@ -8339,6 +8420,7 @@ async function main() {
                     frameSelector: undefined,
                     submitEndpointPattern: null,
                     submitBodyPattern: null,
+                    requireSubmitEndpointMatch: false,
                     displayName: undefined,
                     foldReturnSpec,
                 };
@@ -8352,6 +8434,7 @@ async function main() {
                     frameSelector: obj.frameSelector,
                     submitEndpointPattern: obj.submitEndpointPattern ?? null,
                     submitBodyPattern: obj.submitBodyPattern ?? null,
+                    requireSubmitEndpointMatch: obj.requireSubmitEndpointMatch ?? false,
                     displayName: obj.displayName,
                     foldReturnSpec,
                 };
@@ -8361,6 +8444,7 @@ async function main() {
                 frameSelector: undefined,
                 submitEndpointPattern: null,
                 submitBodyPattern: null,
+                requireSubmitEndpointMatch: false,
                 displayName: undefined,
                 foldReturnSpec,
             };
@@ -8371,6 +8455,7 @@ async function main() {
                 frameSelector: undefined,
                 submitEndpointPattern: null,
                 submitBodyPattern: null,
+                requireSubmitEndpointMatch: false,
                 displayName: undefined,
                 foldReturnSpec,
             };
@@ -8433,16 +8518,18 @@ async function main() {
     for (const f of unmanifestedFiles) {
         logger.warn(`excluding aux fixture '${f}' — no aux-manifest.json entry, provenance unverifiable`);
     }
-    const baseHeaders = deriveRequestHeaders(captures, replays, baseUrl, submitPatterns);
+    const baseHeaders = deriveRequestHeaders(captures, replays, baseUrl, submitPatterns, ownBackendHostnames, fallbackDomain);
     const minTime = deriveMinTime(rateLimits);
     const hasRateLimitProbeData = rateLimits.some((f) => f.safeRps !== null);
     const safeRps = rateLimits.find((f) => f.safeRps !== null)?.safeRps ?? Math.floor(1000 / minTime);
     const gql = isGraphQL(captures);
     // Hoisted so both the primary-operation gate below and rawActionCaptures
     // (further down) read the same computed sequence instead of calling the
-    // extractor twice.
+    // extractor twice. Computed unfiltered (submitPatterns: null) — a
+    // flow-declared submit pattern must truncate this sequence, not filter
+    // it, so every gate reading it sees the full host-gated chain.
     const graphqlActionSequence = gql
-        ? extractGraphQLActionSequence(captures, submitPatterns, foldReturnSpec)
+        ? extractGraphQLActionSequence(captures, null, foldReturnSpec, ownBackendHostnames, fallbackDomain)
         : [];
     // A foldReturn-admitted read/drill capture (see extractGraphQLActionSequence's
     // doc comment) can put 2+ entries in graphqlActionSequence with none of them
@@ -8452,7 +8539,7 @@ async function main() {
     // out primaryGraphQLOperation below or flip isSubmissionFlow further down.
     const graphqlActionSequenceHasMutation = graphqlActionSequence.some((a) => a.capture.query !== null && /^\s*mutation\b/.test(a.capture.query));
     const primaryGraphQLOperation = gql && !graphqlActionSequenceHasMutation
-        ? selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, process.env, ownBackendHostnames, fallbackDomain)
+        ? selectPrimaryGraphQLOperation(captures, flowSteps, vocabulary, process.env, ownBackendHostnames, fallbackDomain, submitPatterns)
         : null;
     if (primaryGraphQLOperation && primaryGraphQLOperation.unpopulatedDeclaredVariables.length > 0) {
         const operationLabel = primaryGraphQLOperation.capture.operationName ?? "(anonymous)";
@@ -8465,20 +8552,20 @@ async function main() {
     // capture could otherwise win the endpoint/body fallback while an
     // unrelated capture supplies the query text.
     const fallbackGraphQLCapture = gql
-        ? firstGraphQLCapture(captures, ownBackendHostnames, fallbackDomain)
+        ? firstGraphQLCapture(captures, ownBackendHostnames, fallbackDomain, submitPatterns)
         : null;
     const gqlQuery = primaryGraphQLOperation?.capture.query ?? fallbackGraphQLCapture?.query ?? null;
     const endpointPath = primaryGraphQLOperation?.endpointPath ??
         (fallbackGraphQLCapture
             ? safeUrlPathname(fallbackGraphQLCapture.url)
-            : firstEndpointPath(captures, ownBackendHostnames, fallbackDomain));
+            : firstEndpointPath(captures, ownBackendHostnames, fallbackDomain, submitPatterns));
     // Derived from the primary operation's own Phase-1 capture, never from
     // replay array order -- a replay's body reflects whichever endpoint fired
     // first, not necessarily the primary operation, and only exists once
     // recon:http has run.
     const winningCapture = primaryGraphQLOperation?.capture ??
         fallbackGraphQLCapture ??
-        firstEndpointCapture(captures, ownBackendHostnames, fallbackDomain);
+        firstEndpointCapture(captures, ownBackendHostnames, fallbackDomain, submitPatterns);
     const responseBody = winningCapture?.responseBody ?? null;
     // Every 2xx capture sharing the winning capture's operation identity, not
     // just the one that happened to win selection -- a paginated/re-filtered
@@ -8499,30 +8586,33 @@ async function main() {
     // a wizard whose every section saves independently, so it is only trusted
     // when it isn't a strict undercount of what the same captures' own
     // heuristic extraction finds.
-    const patternedHeuristicActionCaptures = gql
+    const unfilteredHeuristicActionCaptures = gql
         ? dedupRedundantSameOperationCaptures(graphqlActionSequence, primaryGraphQLOperation)
-        : collapseRedundantPatches(extractActionSequence(captures, submitPatterns, foldReturnSpec));
-    // The same undercount hazard applies one layer below the manifest: a
-    // flow-declared submitEndpointPattern that matches only one section's URL
-    // (the natural way to describe "the button that finishes the wizard")
-    // filters the heuristic sequence down to that one capture even though the
-    // same captures, read without the pattern, show every section saving
-    // independently. A pattern that undercounts what the unfiltered heuristic
-    // finds is therefore not trusted either — it falls back to the richer,
-    // unfiltered sequence instead of collapsing a real multi-call flow into
-    // the generic single-endpoint fallback.
-    const unfilteredHeuristicActionCaptures = submitPatterns.endpoint === null && submitPatterns.body === null
-        ? patternedHeuristicActionCaptures
-        : gql
-            ? dedupRedundantSameOperationCaptures(extractGraphQLActionSequence(captures, null, foldReturnSpec), primaryGraphQLOperation)
-            : collapseRedundantPatches(extractActionSequence(captures, null, foldReturnSpec));
+        : collapseRedundantPatches(extractActionSequence(captures, null, foldReturnSpec, ownBackendHostnames, fallbackDomain));
+    // A flow-declared submitEndpointPattern is authoritative: it may match only
+    // the final step's URL (the natural way to describe "the button that
+    // finishes the wizard") even though the earlier steps of the same chain
+    // (auth mint, paged listing, ...) are what state-threading depends on.
+    // Truncating at the last match — instead of filtering to matches only —
+    // keeps that whole chain; the gap between this and the unfiltered
+    // sequence is logged below for visibility, but the declared pattern is
+    // never overridden by the richer unfiltered sequence.
+    const patternedHeuristicActionCaptures = submitPatterns.endpoint === null && submitPatterns.body === null
+        ? unfilteredHeuristicActionCaptures
+        : truncateActionSequenceAtSubmitPattern(unfilteredHeuristicActionCaptures, submitPatterns);
     const patternUndercounts = patternedHeuristicActionCaptures.length < unfilteredHeuristicActionCaptures.length;
-    if (patternUndercounts) {
+    if (patternUndercounts && requireSubmitEndpointMatch) {
+        // Distinct wording from the non-required case below: this pattern is never
+        // discarded, so a message that says "ignoring"/"undercount" would misstate
+        // what happened. The disagreement is still worth a warn-level surface —
+        // the flow author should know the declared pattern covers fewer captures
+        // than the unfiltered heuristic sequence finds.
+        logger.warn(`submission selection: declared submitEndpointPattern/submitBodyPattern (${patternedHeuristicActionCaptures.length} capture(s)) disagrees with the unfiltered heuristic action sequence (${unfilteredHeuristicActionCaptures.length} capture(s)); using the declared pattern because requireSubmitEndpointMatch is set`);
+    }
+    else if (patternUndercounts) {
         logger.info(`submission selection: ignoring submitEndpointPattern/submitBodyPattern (${patternedHeuristicActionCaptures.length} capture(s)) as an undercount of the unfiltered heuristic action sequence (${unfilteredHeuristicActionCaptures.length} capture(s))`);
     }
-    const heuristicActionCaptures = patternUndercounts
-        ? unfilteredHeuristicActionCaptures
-        : patternedHeuristicActionCaptures;
+    const heuristicActionCaptures = patternedHeuristicActionCaptures;
     const manifestActionCaptures = resolveManifestActionSequence(runRoot, captures);
     const manifestUndercounts = manifestActionCaptures !== null &&
         manifestActionCaptures.length < heuristicActionCaptures.length;
@@ -8535,19 +8625,6 @@ async function main() {
     const rawActionCaptures = manifestActionCaptures !== null && !manifestUndercounts
         ? manifestActionCaptures
         : heuristicActionCaptures;
-    // The declared submitEndpointPattern's own under-match: unlike manifestUndercounts
-    // (which compares an authoritative submit-manifest.json against the heuristic
-    // sequence), this compares the pattern-filtered heuristic sequence against the SAME
-    // captures with no submitPatterns filter at all — the true raw non-GET 2xx non-noise
-    // action set. A pattern that matches conspicuously fewer calls than that raw set is a
-    // detection failure (the pattern is too narrow), not evidence the flow is read-only,
-    // and per the no-silent-fallback rule must not be allowed to quietly collapse into the
-    // generic single-endpoint {query} template below.
-    const rawUnfilteredActionCaptures = submitEndpointPattern === null
-        ? null
-        : gql
-            ? dedupRedundantSameOperationCaptures(extractGraphQLActionSequence(captures, null, foldReturnSpec), primaryGraphQLOperation)
-            : collapseRedundantPatches(extractActionSequence(captures, null, foldReturnSpec));
     // Form-schema detection runs BEFORE state-indexing so the field-id/option-id
     // UUIDs can be shielded from indexing — those UUIDs are stable schema
     // anchors that T2/T3 substitution depends on remaining literal in body
@@ -8608,19 +8685,6 @@ async function main() {
         : new Map();
     const actionSteps = actionCaptures.length > 1 ? compileActionSteps(actionCaptures, stateIndex) : [];
     const isSubmissionFlow = actionSteps.length > 1 && (!gql || graphqlActionSequenceHasMutation);
-    // Loud failure for a submitEndpointPattern that under-matches the raw traffic badly
-    // enough to collapse the flow to the single-endpoint fallback: heuristicActionCaptures
-    // is the pattern-filtered sequence (used both directly and as rawActionCaptures' floor
-    // via manifestUndercounts above), so if it's this thin ONLY because the pattern itself
-    // excluded real action captures the unfiltered raw set still has, emitting the generic
-    // {query} template would misrepresent a genuine multi-call flow as read-only. Exit
-    // rather than degrade quietly, per the no-defensive/no-silent-fallback rule.
-    if (rawUnfilteredActionCaptures !== null &&
-        !isSubmissionFlow &&
-        rawUnfilteredActionCaptures.length > heuristicActionCaptures.length) {
-        logger.error(`ERROR declared submitEndpointPattern ${JSON.stringify(submitEndpointPattern)} matched only ${heuristicActionCaptures.length} of ${rawUnfilteredActionCaptures.length} raw non-GET 2xx non-noise action capture(s) — this under-match looks like a detection failure, not a read-only flow; refusing to fall back to the generic single-endpoint {query} template. Fix submitEndpointPattern in recon-flow.json to cover the real submission calls.`);
-        process.exit(1);
-    }
     // Diagnostic for the FAILURE-3 shape (a flowless recon capture): a "submission flow"
     // whose every action capture is landing-phase is almost certainly page-chrome
     // bootstrap (e.g. page-chrome `POST /widgets`) misread as an apply flow, not a walked