scenescout 3.14.1 → 3.16.0

package/dist/engine/browser.js

@@ -1,38 +1,42 @@
 import { chromium, firefox, webkit, } from "playwright";
 import fs from "node:fs";
 import path from "node:path";
-import { elementKey, fingerprintState, isNonPageRoute, normalizePath } from "./fingerprint.js";
-import { AUTH_LOSS_PREFIX, JOURNEY_END, JOURNEY_START, MemoryStore, redactSecrets, TASK_SET } from "./memory.js";
+import { elementKey, fingerprintState, isNonPageRoute, keyAliases, normalizePath, ordinalKeys, refsSurviveUrlChange, routeBase, } from "./fingerprint.js";
+import { AUTH_LOSS_PREFIX, JOURNEY_END, JOURNEY_START, MemoryStore, reachedRoutes, redactSecrets, TASK_SET } from "./memory.js";
 import { normalizeTask } from "./task.js";
-import { CLAIM_SCAN_SCRIPT, findContradictions } from "./claims.js";
+import { ACTED_CONTROL_SRC, CLAIM_SCAN_SCRIPT, findContradictions, INFRASTRUCTURE_WRITE_RE, isBackgroundRequest, OPEN_DIALOGS_SCRIPT, quietAnswer, saidSince, } from "./claims.js";
 import { POSTMESSAGE_BINDING, describeTokenPost, postMessageCaptureScript, tokenHits, tokenPostKey } from "./postmessage.js";
 import { describeInjection, newInjections, probeQueries, probeScript, probeShape, rememberProbe } from "./injection.js";
 import { AuthLossTracker } from "./authloss.js";
-import { captureClip } from "./capture.js";
-import { COLLECT_INTERACTABLES_SCRIPT, VISIBLE_SRC, geometryIssues, BROKEN_IMAGES_SCRIPT, brokenImageIssues, frameLines, hasVisibleFrame, frameElementKey, frameLabel, masksForeignName, MASKED_NAME, capForeignName, stripForeignHref, frameToPageRect, displayName, missingName, placeholderOnly, placeholderEvidence, describeControl, labelFlag, } from "./collector.js";
-import { OracleMonitor, formatViolations, httpErrorDetail } from "./oracles.js";
+import { captureClip, cutByViewport } from "./capture.js";
+import { STOP_ANIMATIONS_SCRIPT } from "./baseline.js";
+import { COLLECT_INTERACTABLES_SCRIPT, COLLECTOR_CAP, NAME_SRC, POLICY_TEXT_SRC, VISIBLE_SRC, XPATH_OF_SRC, affordanceFlags, cutSummary, matchPrevious, geometryIssues, BROKEN_IMAGES_SCRIPT, brokenImageIssues, frameLines, hasVisibleFrame, frameElementKey, frameLabel, masksForeignName, MASKED_NAME, capForeignName, stripForeignHref, frameToPageRect, displayName, missingName, placeholderOnly, placeholderEvidence, describeControl, labelFlag, stateFlags, stateChange, trackedElements, inertKeys, MAIN_REGION_SCRIPT, mainRegionLine, mainRegionTag, mainState, describeCover, } from "./collector.js";
+import { OracleMonitor, formatViolations, httpErrorDetail, planStopsAt, requestKey } from "./oracles.js";
 import { extractCreatedIds, isOwnedResource, normalizeId } from "./ownership.js";
-import { formatJourney, measureJourney } from "./journey.js";
+import { formatJourney, journeyTime, measureJourney } from "./journey.js";
 import { describeStep, FLOW_AFTER_LAST_STEP_MS, isAction, matchRequest, parseTarget, splitRefusals, TARGET_HELP, urlMatches, } from "./flow.js";
 import { framePath, RECORD_MAX_FRAMES } from "./replay.js";
-import { keepWatchingUrl, normalizePace, SETTLE_TICK_MS, shouldKeepWaiting } from "./settle.js";
-import { buildRequestScript, formatReplay, replaySignature, requestHeaders, resolveMethod, resolveRequestUrl, toReplayResult } from "./request.js";
+import { InFlightRequests, keepWatchingUrl, normalizePace, SETTLE_TICK_MS, shouldKeepWaiting } from "./settle.js";
+import { crawledRoute, crawlLine, mainStateFlag } from "./crawl.js";
+import { authToRemember, BODY_FETCH_MAX, buildRequestScript, formatPageRequests, formatReplay, PageRequests, replaySignature, requestHeaders, resolveMethod, resolveRequestUrl, resolveTarget, staleCredentialNote, toReplayResult, wantsView, } from "./request.js";
 import { defaultEngine, focusAdvanceKey, REMOVE_SHARED_WORKER_SCRIPT, screencastSupport, serviceWorkerPolicy, sharedWorkersAllowed, unloadWriteInterception, closeWaitsForLeavingWrites, } from "../browsers.js";
 import { revealedLines } from "./hover.js";
-import { FORMS_INVENTORY_SCRIPT, FORM_PROBE_BODY, formProbeExpression, formIdentity, formStatus, FORMS_READ_FAILED, FORMS_SUBMIT_UNMATCHED, isEmptySubmit, sameControl, isNavigationTeardown, submits, tracksForm, } from "./forms.js";
+import { FORMS_INVENTORY_SCRIPT, FORM_PROBE_BODY, FORM_PROBE_OF_ACTIVE_ELEMENT, formIdentity, formStatus, FORMS_READ_FAILED, FORMS_SUBMIT_UNMATCHED, isEmptySubmit, isSubmitLike, sameControl, isNavigationTeardown, submits, tracksForm, APP_FILLED_TYPES, matchOption, normaliseDateValue, } from "./forms.js";
 import { explainLaunchFailure, isMissingBrowser } from "./launch.js";
-import { DEFAULT_TIME_LIMITS, explainTimeout, limitHint, resolveTimeLimits } from "./limits.js";
+import { DEFAULT_TIME_LIMITS, explainTimeout, firstLineOf, isTimeoutMessage, limitHint, resolveTimeLimits } from "./limits.js";
 import { performScroll, probeFocusIndicators, probeOverlays, scrollContainer } from "./probes.js";
 import { boundedTeardown } from "./teardown.js";
 import { BROWSER_MARKER, reapOrphanBrowsers } from "./reaper.js";
 import { planUploadOptions, resolveDiskUpload } from "./uploads.js";
-import { answersWithRefusal, destructiveRefusal, isDestructive, isDestructiveWire, allowsWrite, policyRefusal, foreignFrameOrigin, foreignWrite, withForeignFrameSandbox, offAppPageWrite, embedOfRequest, hostileForEmbed, trustedEmbedOrigins, MAX_TRUSTED_EMBEDS, trustsForeignWrite, embedProbeRefusal, EmbedMoveTracker, sandboxedRedirectPage, allowsForeignWriteOnSignIn, isAuthExempt, WriteRule, } from "./policy.js";
+import { answersWithRefusal, destructiveRefusal, destructiveLabelOf, pickIsDestructive, isDestructive, isDestructiveWire, blockSignature, BlockNotices, dialogNote, dialogResponse, ESCAPE_REFUSAL, allowsWrite, policyRefusal, foreignFrameOrigin, foreignWrite, withForeignFrameSandbox, offAppPageWrite, embedOfRequest, hostileForEmbed, trustedEmbedOrigins, MAX_TRUSTED_EMBEDS, MAX_READ_POSTS, READ_POSTS_ENV, readPostAllowed, matchReadPost, readPostEntries, readPostsSetting, trustsForeignWrite, embedProbeRefusal, EmbedMoveTracker, sandboxedRedirectPage, allowsForeignWriteOnSignIn, isAuthExempt, WriteRule, } from "./policy.js";
 import { scanProject } from "../scan.js";
 import { analyzeDesign, DESIGN_COLLECT_SCRIPT } from "./design.js";
 import { acceptMatches, generatedUpload } from "./fixtures.js";
 import { bodyDigest, headerOf, isReadMethod, judgeUnseenWrite, pausedRequestBytes, RoutedWrites, UnseenRefusals, unseenWriteSource, } from "./unload.js";
-import { loginCommand, permissionNote, resolveAttachAuth, roleLabel, sessionStorageInitScript, splitProfile, summarizeState, writeProfile, } from "./profiles.js";
-import { acquireLock, brokerEnabled, lockPathFor, planRefresh, presentedToken, profileAfterRotation, REFRESH_BROKER_ENV, refreshTokenSlots, rotatedFromResponse, rotationStored, swapProfileToken, swapRequest, } from "./refresh.js";
+import { reloginCommand, permissionNote, resolveAttachAuth, roleLabel, sessionStorageInitScript, splitProfile, summarizeState, writeProfile, } from "./profiles.js";
+import { acquireLock, brokerDecision, brokerEnabled, cookieMayCount, endpointKey, endpointsPathFor, headersForResend, isStaticAsset, learnableEndpoint, lockPathFor, planRefresh, profileAfterRotation, profileLoadWhileHeld, readLearnedEndpoints, REFRESH_BROKER_ENV, refreshNotice, refreshTokenSlots, rotatedCookies, rotatedFromResponse, rotationStored, swapProfileToken, swapRequest, swapToken, withLearnedEndpoint, writeBackStorageFrom, writeLearnedEndpoints, } from "./refresh.js";
+/** How many routes' last snapshots are kept for diffs. */
+const SNAPSHOTS_KEPT = 20;
 const SETTLE_MS = 400;
 /**
  * Request URL → pathname, falling back to the raw string for anything
@@ -59,8 +63,8 @@ const FORCED_CLICK_TIMEOUT_MS = 1500;
 const CHOOSER_GRACE_MS = 2000;
 /** How long a hover waits for delay-gated tooltips (component libraries warm up for as long as ~1500ms). */
 const HOVER_REVEAL_WINDOW_MS = 2500;
-/** Non-GET traffic that is auth/telemetry plumbing, not tester-caused state mutation. */
-const BENIGN_MUTATION_RE = /\/auth\/(refresh|token|session)|refresh[-_]?token|\/telemetry|\/analytics|\/heartbeat|\/sentry|\/collect\b|\/logs?\b|\/metrics\b/i;
+/** Non-GET traffic that is auth/telemetry plumbing, not tester-caused state mutation. One list, shared with the false-success rule. */
+const BENIGN_MUTATION_RE = INFRASTRUCTURE_WRITE_RE;
 /**
  * What the policy needs to know about where a request came from: the URLs of
  * the frame that sent it and of its parents, up to but not including the top
@@ -84,8 +88,6 @@ function requestSource(req) {
     }
     return { frameChain, frameUrl };
 }
-/** The `why` of a top-window navigation refused as a possible frame escape; the notice words it on its own. */
-const ESCAPE_REFUSAL = "a possible frame escape";
 /** The most frames a snapshot reads controls from. */
 const MAX_READ_FRAMES = 10;
 /** How long a snapshot waits for its frames' elements to answer. */
@@ -99,6 +101,15 @@ function submitControlIn(elements, probe) {
     const el = elements.find((e) => !e.frame && e.xpath === probe.submit);
     return el && sameControl(el, probe) ? el : null;
 }
+/** Page-side, built from constants only: an element's LiveFacts. */
+const LIVE_FACTS_BODY = `return { testid: node.getAttribute('data-testid'), ` +
+    `label: (node.getAttribute('aria-label') || node.innerText || node.textContent || node.getAttribute('placeholder') || '').trim().slice(0, 120), ` +
+    `name: (${NAME_SRC})(node).name, ...(${POLICY_TEXT_SRC})(node) };`;
+const liveFactsOf = new Function("node", LIVE_FACTS_BODY);
+/** Page-side: the one element carrying a test id, with its path and LiveFacts; null when none or several do. */
+const uniqueByTestid = new Function("testid", `const all = document.querySelectorAll('[data-testid="' + CSS.escape(testid) + '"]'); ` +
+    `if (all.length !== 1) return null; const node = all[0]; ` +
+    `return { xpath: (${XPATH_OF_SRC})(node), live: (function (node) { ${LIVE_FACTS_BODY} })(node) };`);
 /** Page-side: the form an element belongs to, and what its fields hold now (forms.ts). */
 const probeFormOf = new Function("node", FORM_PROBE_BODY);
 /**
@@ -113,10 +124,12 @@ function xpathLookup(xpath) {
 }
 /**
  * Runs in the page against one dropdown, BEFORE a choice: its options' values
- * and labels. Read first because a dropdown may reset itself (a bulk-action or
- * "jump to" menu) or remove itself on change. Skips disabled and hidden
- * options, and a placeholder or "all" option with an empty value — the state
- * the page loads in, which is not an option anyone owes a choice.
+ * and labels, and which are selected. Read first because a dropdown may reset
+ * itself (a bulk-action or "jump to" menu) or remove itself on change. Skips
+ * disabled and hidden options, and a placeholder or "all" option with an empty
+ * value — the state the page loads in, which is not an option anyone owes a
+ * choice. The option selected before the choice is the value the page already
+ * asked the server for, which is not owed one either.
  */
 function describeSelect(node) {
     // A plan may target the dropdown by its <label>; selectOption follows a label to its control, so this does too.
@@ -126,7 +139,7 @@ function describeSelect(node) {
         return null;
     return Array.from(select.options)
         .filter((o) => !o.disabled && !o.hidden && o.value !== "")
-        .map((o) => ({ value: o.value, label: (o.label || o.textContent || "").trim().slice(0, 80) }))
+        .map((o) => ({ value: o.value, label: (o.label || o.textContent || "").trim().slice(0, 80), selected: o.selected }))
         .filter((o) => o.label !== "");
 }
 /**
@@ -136,6 +149,68 @@ function describeSelect(node) {
 async function readSelectOptions(loc) {
     return loc.evaluate(describeSelect, undefined, { timeout: 1000 }).catch(() => null);
 }
+/**
+ * Runs in the page against one dropdown: every option, disabled and
+ * placeholder ones included, in document order, so a requested value can be
+ * matched (forms.ts matchOption) before anything is picked. Null when the node
+ * is not a select (or a label for one).
+ */
+function listSelectOptions(node) {
+    const target = node instanceof HTMLLabelElement ? (node.control ?? node.querySelector("select")) : node;
+    if (!(target instanceof HTMLSelectElement))
+        return null;
+    return Array.from(target.options).map((o) => ({
+        value: o.value,
+        // Whole, not cut short: an exact label has to match all of it.
+        label: (o.label || o.textContent || "").trim(),
+        disabled: o.disabled || (o.parentElement instanceof HTMLOptGroupElement && o.parentElement.disabled),
+    }));
+}
+/**
+ * Runs in the page against a click target, just before a forced click: what
+ * is on top of it at its centre, where the click aims. Null when nothing is
+ * (the target, something inside it, or one of its own labels is the top hit)
+ * or the centre is out of view. The hit is named by the nearest element at or
+ * above it with a role or a test id, never one that holds the target too.
+ */
+function readCoverAt(node) {
+    const r = node.getBoundingClientRect();
+    const x = r.left + r.width / 2;
+    const y = r.top + r.height / 2;
+    if (x < 0 || y < 0 || x >= window.innerWidth || y >= window.innerHeight)
+        return null;
+    const hit = document.elementFromPoint(x, y);
+    // A hit that holds the target (its wrapper, under a target with pointer-events: none) is not on top of it.
+    if (!hit || node.contains(hit) || hit.contains(node))
+        return null;
+    const labels = node.labels;
+    if (labels && Array.from(labels).some((l) => l.contains(hit)))
+        return null;
+    let named = hit;
+    for (let n = hit; n && n !== document.body && !n.contains(node); n = n.parentElement) {
+        if (n.getAttribute("role") || n.getAttribute("data-testid")) {
+            named = n;
+            break;
+        }
+    }
+    const tag = named.tagName.toLowerCase();
+    const implied = {
+        button: "button",
+        a: "link",
+        dialog: "dialog",
+        img: "image",
+        nav: "navigation",
+        header: "banner",
+        footer: "contentinfo",
+        aside: "complementary",
+    };
+    return {
+        role: named.getAttribute("role") || implied[tag] || null,
+        tag,
+        text: (named.innerText || named.textContent || "").trim().slice(0, 120),
+        testid: named.getAttribute("data-testid"),
+    };
+}
 /** Runs in the page against one file input (or the one a chooser belongs to). */
 function describeFileInput(node) {
     const input = node;
@@ -204,12 +279,25 @@ export class BrowserEngine {
     currentFingerprint = "";
     /** URL at the time of the last snapshot — refs are valid only while it matches. */
     snapshotUrl = "";
-    /** Last snapshot's identity map (per route) — enables stable refs + diff snapshots. */
-    lastSnap = null;
+    /** When the last snapshot was taken (0 before the first): what a forced click's covering element is compared against. */
+    snapshotAt = 0;
+    /**
+     * The last snapshot of each recent route, newest last (at most
+     * SNAPSHOTS_KEPT): a route snapshotted again keeps its refs and is shown as
+     * a diff, even after a visit elsewhere, and a tab of a screen diffs against
+     * the screen's last tab.
+     */
+    snaps = new Map();
+    /** The route of the latest snapshot, so a diff can say whether it is against that one. */
+    lastSnapRoute = "";
+    /** Why the refs of the latest snapshot were dropped since it was taken, or null when they were not. */
+    refsDropped = null;
     /** Non-parameterized routes discovered by the project scan — the objective completion contract. */
     knownRoutes = [];
     /** Real path of the attached project — the fence for scout_upload's filePath. */
     projectDir = "";
+    /** The folder a login command must name with --project (a folder SceneScout chose), else undefined. */
+    loginProject = { projectDir: "", projectChosen: false };
     /** Set when the project's real path could not be resolved — named in fence refusals, which it may then cause. */
     projectDirNote = "";
     memory = null;
@@ -223,6 +311,9 @@ export class BrowserEngine {
     /** Origins named as trusted embeds (policy.ts trustsEmbedWrite decides when that counts). */
     trustedEmbeds = new Set();
     trustNotice = "";
+    /** POST endpoints the user named as reads (policy.ts readPostAllowed decides when that counts). */
+    readPosts = [];
+    readPostNotice = "";
     /** Human label for the auth identity driving this session: the role, the storage-state file's name, or anonymous. Set by attach. */
     role = "anonymous";
     /** How the attached session signed in: a role profile, a storage-state file, or not at all. */
@@ -239,10 +330,14 @@ export class BrowserEngine {
      * profile holds no refresh token.
      */
     refresh = null;
+    /** Requests the broker took the lock for: their write-back is its own, so the rotation watcher leaves them alone. */
+    brokeredRequests = new WeakSet();
     /** Write-backs still waiting on a response, so close() lets them release their lock. */
     refreshTasks = new Set();
     /** What the broker did this session, for the lane report: counts only. */
-    refreshCounts = { refreshed: 0, swapped: 0, failed: 0 };
+    refreshCounts = { refreshed: 0, swapped: 0, failed: 0, learned: 0 };
+    /** What the broker did since the last action result, reported (and cleared) by drainRefresh. */
+    refreshEvents = [];
     /** UI-label blocking applies only in read-only mode (safe-write enforces at the network layer instead). */
     get readOnly() {
         // observe is read-only and then some: every UI-level refusal applies to it too.
@@ -255,6 +350,14 @@ export class BrowserEngine {
     }
     /** Requests blocked by the write policy since the last action (timestamped for attribution). */
     blockedRequests = [];
+    /** What this session has been told about blocked writes, so each endpoint is explained once. */
+    blockNotices = new BlockNotices();
+    /** Native dialogs the page opened since the last action's result, and how each was answered. */
+    dialogsSeen = [];
+    /** The caller's answer to a leave confirmation for the action in progress (dialogResponse); undefined lets the mode decide. */
+    leaveChoice = undefined;
+    /** Resolves the navigation in progress when the page's leave confirmation is answered "stay". */
+    onLeaveRefused = null;
     /**
      * WebSockets this session's pages opened. The write policy works on HTTP
      * requests; frames sent over a socket are not inspected. In observe mode that
@@ -316,6 +419,33 @@ export class BrowserEngine {
     }
     /** Design audits run by this session. The report gate counts the whole run's, on the shared store (MemoryStore.auditsThisRun). */
     designAuditCount = 0;
+    /** The data requests the driven page made since its document loaded (scout_network). */
+    pageRequests = new PageRequests();
+    /** Add a fetch/XHR to the page's request list when the driven page (any of its frames) sent it. */
+    notePageRequest(req) {
+        let fromPage = false;
+        try {
+            fromPage = !!this.page && req.frame().page() === this.page;
+        }
+        catch {
+            /* a service worker's request has no frame: not the page's */
+        }
+        if (!fromPage)
+            return;
+        let route = "";
+        try {
+            route = new URL(this.page.url()).pathname;
+        }
+        catch {
+            /* about:blank and the like have no route */
+        }
+        this.pageRequests.started(req, { method: req.method(), url: req.url(), route, at: Date.now() });
+    }
+    /** The data requests the page made since it loaded, as scout_network lists them. */
+    listPageRequests(opts = {}) {
+        this.requirePage();
+        return formatPageRequests(this.pageRequests.snapshot, { now: Date.now(), ...opts });
+    }
     /** Active task-efficiency measurement (scout_journey), if any. */
     journey = null;
     /** The session's objective: the whole remit the agent was given at scout_attach. Empty when none was given. */
@@ -332,17 +462,40 @@ export class BrowserEngine {
     /** How many frames could not be written. The first one says so in the log; the rest are counted. */
     framesFailed = 0;
     /**
-     * The Authorization header the app itself last sent, replayed by
-     * scout_request so a call with the UI bypassed carries the same credential
-     * as a click. Nothing here parses it: whatever scheme the app uses is
-     * whatever gets replayed.
+     * The Authorization header the app itself last sent to its own origin, on
+     * any request (authToRemember says which), replayed by scout_request so a
+     * call with the UI bypassed carries the same credential as a click. Nothing
+     * here parses it: whatever scheme the app uses is whatever gets replayed.
      */
     lastAuthHeader = null;
-    rememberAuthHeader(headers) {
-        const value = headers["authorization"] ?? headers["Authorization"];
-        if (value && value.trim())
+    /** The status of the page's latest authorised script request to its own origin, for staleCredentialNote. */
+    lastAuthAnswer = null;
+    rememberAuthHeader(req) {
+        const value = this.authOf(req);
+        if (value)
             this.lastAuthHeader = value;
     }
+    /** The Authorization header a request carries that counts as the app's own (authToRemember), or null. */
+    authOf(req) {
+        let frameUrl;
+        try {
+            frameUrl = req.frame().url();
+        }
+        catch {
+            /* a worker's request has no frame */
+        }
+        return authToRemember({ url: req.url(), baseUrl: this.baseUrl, headers: req.headers(), replay: this.replayRequests.has(req), frameUrl });
+    }
+    /** Note the status of the page's own authorised script request to its origin; a replay's is not the page's. */
+    noteAuthAnswer(res) {
+        const req = res.request();
+        const type = req.resourceType();
+        if (type !== "fetch" && type !== "xhr")
+            return;
+        if (this.authOf(req) === null)
+            return;
+        this.lastAuthAnswer = { status: res.status() };
+    }
     /**
      * Call the app's own API as this session, with the UI bypassed.
      *
@@ -360,16 +513,24 @@ export class BrowserEngine {
         const target = resolveRequestUrl(this.baseUrl, input.path);
         if ("problem" in target)
             return `REFUSED: ${target.problem}`;
+        const headers = requestHeaders({ given: input.headers, auth: this.lastAuthHeader, body: input.body });
+        // Whether the credential sent is the one replayed from the page, not one the caller chose.
+        const replayedAuth = this.lastAuthHeader !== null && headers["authorization"] === this.lastAuthHeader;
         const script = buildRequestScript({
             url: target.url,
             method: method.method,
             body: input.body,
-            headers: requestHeaders({ given: input.headers, auth: this.lastAuthHeader, body: input.body }),
+            headers,
+            ...(wantsView(input.view) ? { keep: BODY_FETCH_MAX } : {}),
         });
         let raw;
+        // Claimed by the first matching request the page sends (the request
+        // listener), so the oracles and the contradiction ledger know it is ours.
+        this.pendingReplay = { method: method.method, key: requestKey(target.url) };
+        this.oracles.replayStarted(target.url);
         try {
             raw = (await page.evaluate(script));
-            this.forgetReplay(method.method, target.url);
+            this.pageRequests.markReplay(method.method, target.url);
         }
         catch (err) {
             // The page could not run the fetch at all (a navigation mid-call, a
@@ -378,7 +539,13 @@ export class BrowserEngine {
             this.logAction({ action: "request", target: `${method.method} ${input.path}`, url: page.url(), result: `blocked: ${message.split("\n")[0]}` });
             return `${method.method} ${input.path} — the request did not complete: ${message.split("\n")[0]}`;
         }
-        const result = toReplayResult(raw);
+        finally {
+            this.pendingReplay = null;
+            this.oracles.replayEnded(target.url);
+            for (const hop of this.replayHops.splice(0))
+                this.oracles.replayEnded(hop);
+        }
+        const result = toReplayResult(raw, input.view);
         this.logAction({
             action: "request",
             target: `${method.method} ${input.path}`,
@@ -386,23 +553,36 @@ export class BrowserEngine {
             // Not a status signature: the trail must not record the stand-in as the server's answer.
             result: result.refusedByPolicy ? `blocked: write policy (${result.refusedByPolicy})` : replaySignature(method.method, result.url, result.status),
         });
-        return formatReplay(method.method, result);
+        return formatReplay(method.method, result) + (result.refusedByPolicy ? "" : staleCredentialNote(result.status, replayedAuth, this.lastAuthAnswer));
     }
+    /** The scout_request call in flight, until the page's request for it is seen. */
+    pendingReplay = null;
+    /** Addresses the call in flight was redirected to, ended with it. */
+    replayHops = [];
     /**
-     * Take the replayed request back out of the contradiction ledger. It was the
-     * agent's call, not the page's, so whatever the page says next is not its
-     * answer — and left in, a replay the policy refused was blamed on the next
-     * click as that click's false success, in place of the click's own request.
-     * Only this request: anything else the page fetched meanwhile stays.
+     * The requests scout_request sent, by identity (redirect hops included). They
+     * are the agent's calls, not the page's: their failures are not the page's
+     * violations, and whatever the page says next is not their answer. Left in
+     * the contradiction ledger, a replay the policy refused was blamed on the
+     * next click as that click's false success.
      */
-    forgetReplay(method, url) {
-        for (let i = this.watchedResponses.length - 1; i >= 0; i -= 1) {
-            const r = this.watchedResponses[i];
-            if (r.method === method && r.url === url) {
-                this.watchedResponses.splice(i, 1);
-                return;
-            }
+    replayRequests = new WeakSet();
+    /** When each request started, so the contradiction rules can tell the action's own writes from ones already in flight. */
+    requestStartedAt = new WeakMap();
+    /** Note whether a request the page is sending is this session's scout_request call. */
+    claimReplay(req) {
+        const from = req.redirectedFrom();
+        if (from && this.replayRequests.has(from)) {
+            this.replayRequests.add(req);
+            this.oracles.replayStarted(req.url());
+            this.replayHops.push(req.url());
+            return;
         }
+        const pending = this.pendingReplay;
+        if (!pending || req.method() !== pending.method || requestKey(req.url()) !== pending.key)
+            return;
+        this.replayRequests.add(req);
+        this.pendingReplay = null;
     }
     /**
      * The frame field for a log entry, or nothing. Spread into logAction so a
@@ -516,7 +696,7 @@ export class BrowserEngine {
         // role in a multi-role run, so a concurrent session navigating during this
         // journey would otherwise contaminate its path, screen count, and backtracks.
         const log = (this.memory?.actionLog ?? []).slice(j.fromLog).filter((e) => (e.session ?? this.sessionKey) === this.sessionKey);
-        const seconds = Math.round((Date.now() - j.startedAt) / 1000);
+        const time = journeyTime(j.startedAt, log.map((e) => Date.parse(e.at)), Date.now());
         const measured = measureJourney(log, completed);
         try {
             // Only a COMPLETED journey is a measurement of task ease. An abandoned
@@ -528,7 +708,7 @@ export class BrowserEngine {
             /* fact recording is best-effort */
         }
         this.logAction({ action: JOURNEY_END, target: j.goal, url: page.url(), result: completed ? "completed" : "abandoned" });
-        return formatJourney({ goal: j.goal, completed, seconds, note }, measured);
+        return formatJourney({ goal: j.goal, completed, time, note }, measured);
     }
     /** Whether the browser window is visible — headed hover results carry a physical-cursor caveat. */
     headed = false;
@@ -618,18 +798,101 @@ export class BrowserEngine {
      * element on the current page? Runs wherever violations are drained, so the
      * finding reaches the agent in the result of the action that revealed it.
      */
-    /** Record one answered request for the contradiction rules. Ones the policy stopped are marked, never dropped: the rules need to know they were ours. */
+    /**
+     * Record one answered request for the contradiction rules. Ones the policy
+     * stopped are marked, never dropped: the rules need to know they were ours.
+     * The agent's own scout_request calls are left out: the page did not send them.
+     */
     watchResponse(req, status) {
+        if (this.replayRequests.has(req))
+            return;
         if (this.watchedResponses.length >= BrowserEngine.MAX_WATCHED_RESPONSES)
             return;
+        const started = this.requestStartedAt.get(req) ?? 0;
+        let isDocumentLoad = false;
+        try {
+            isDocumentLoad = req.isNavigationRequest() && this.page !== null && req.frame() === this.page.mainFrame();
+        }
+        catch {
+            /* a worker's request: no frame, so not the page's navigation */
+        }
         this.watchedResponses.push({
             method: req.method(),
             url: req.url(),
             status,
             resourceType: req.resourceType(),
             blockedByPolicy: this.refusedByAnyPolicy(req),
+            // The current action is a user input only when it is the one that set the input mark (claims.ts isBackgroundRequest).
+            background: isBackgroundRequest({
+                started,
+                inputSince: this.inputSince,
+                actionStartedAt: this.actionStartedAt,
+                documentLoadSince: this.documentLoadSince,
+                isDocumentLoad,
+            }),
         });
     }
+    /**
+     * When the current user input (a click, a keypress, typing, a choice) began,
+     * or null before the first. An action that is not input (a navigation, a
+     * scroll, a crawl) moves actionStartedAt past it, which is how a request is
+     * known to have no input behind it.
+     */
+    inputSince = null;
+    /** What the page said as the current input began, for the contradiction rules; null when it could not be read. */
+    claimBaseline = null;
+    /** When the current input started loading a new main-frame document, or null while it has loaded none (claims.ts isBackgroundRequest). */
+    documentLoadSince = null;
+    /** The control the current click acted on, as the click found it, for the kept-change rule (claims.ts keptChange). */
+    actedControl = null;
+    /** When the write policy last refused a request, for the snapshot's "after a write-policy block" tag. */
+    lastBlockAt = 0;
+    /**
+     * Mark the start of a user input: read what the page says now, so a claim
+     * already on screen (a status badge, a heading) is not taken for the
+     * page's answer to this input's write. Never fails the action: with no
+     * baseline every text counts, as before.
+     */
+    async beginInput() {
+        this.inputSince = this.actionStartedAt;
+        this.claimBaseline = null;
+        this.documentLoadSince = null;
+        this.actedControl = null;
+        const page = this.page;
+        if (!page || page.isClosed())
+            return;
+        try {
+            this.claimBaseline = (await page.evaluate(CLAIM_SCAN_SCRIPT));
+        }
+        catch {
+            // A page mid-navigation has nothing on screen to excuse.
+        }
+    }
+    /** The page's claims as they stand (CLAIM_SCAN_SCRIPT), or null on a page that cannot be read. */
+    async readClaims(page) {
+        try {
+            return (await page.evaluate(CLAIM_SCAN_SCRIPT));
+        }
+        catch {
+            // A page mid-navigation has nothing to read.
+            return null;
+        }
+    }
+    /**
+     * Read the control a click is about to act on, so a refused write it sends
+     * can be judged by whether the control then shows the change as kept
+     * (claims.ts keptChange). Never fails the click: unread, the rule is skipped.
+     */
+    async readActedControl(el) {
+        const scope = this.scopeOf(el);
+        try {
+            const before = (await scope.evaluate(`(${ACTED_CONTROL_SRC})(${xpathLookup(el.xpath)})`));
+            this.actedControl = before ? { scope, xpath: el.xpath, before } : null;
+        }
+        catch {
+            this.actedControl = null;
+        }
+    }
     /**
      * Did the page agree with what the network just did? Runs in the same slot
      * as the injection scan, so it sees the DOM the action settled on.
@@ -641,6 +904,8 @@ export class BrowserEngine {
     async scanForContradictions() {
         const requests = this.watchedResponses;
         this.watchedResponses = [];
+        const acted = this.actedControl;
+        this.actedControl = null;
         const page = this.page;
         if (!page || page.isClosed() || requests.length === 0)
             return;
@@ -655,7 +920,19 @@ export class BrowserEngine {
             // A page mid-navigation has no DOM to ask.
             return;
         }
-        for (const found of findContradictions(requests, state)) {
+        // A baseline belongs to the input that took it, and to its page.
+        const before = this.inputSince !== null && this.inputSince >= this.actionStartedAt ? this.claimBaseline : null;
+        // The acted-on control as the click left it, read only when a refusal makes it matter.
+        let actedNow = null;
+        if (acted && before) {
+            try {
+                actedNow = (await acted.scope.evaluate(`(${ACTED_CONTROL_SRC})(${xpathLookup(acted.xpath)})`));
+            }
+            catch {
+                // The control's document went away: nothing left to show the change.
+            }
+        }
+        for (const found of findContradictions(requests, state, before, acted && actedNow ? { before: acted.before, after: actedNow } : null)) {
             if (this.contradictionsReported.has(found.evidence))
                 continue;
             this.contradictionsReported.add(found.evidence);
@@ -722,6 +999,10 @@ export class BrowserEngine {
     /** Write-policy blocks drained by the last action — counted, so an action can know a request fired even when the policy stopped it. */
     lastActionBlocked = 0;
     baseUrl = "";
+    /** The command that records `role` again so this session's next attach finds it (profiles.reloginCommand). */
+    reloginCommand(role) {
+        return reloginCommand({ role, url: this.baseUrl, ...this.loginProject });
+    }
     get attached() {
         return this.page !== null;
     }
@@ -729,7 +1010,13 @@ export class BrowserEngine {
         // Resolved before anything is closed, so a bad role, a missing profile or
         // a time limit out of bounds leaves a live session as it was.
         const limits = resolveTimeLimits(opts, process.env);
-        const auth = resolveAttachAuth({ projectDir: opts.projectDir, url: opts.url, role: opts.role, storageStatePath: opts.storageStatePath });
+        const auth = resolveAttachAuth({
+            projectDir: opts.projectDir,
+            url: opts.url,
+            role: opts.role,
+            storageStatePath: opts.storageStatePath,
+            projectChosen: opts.projectChosen,
+        });
         const brokered = brokerEnabled({ roleSession: auth.kind === "role", option: opts.refreshBroker, env: process.env[REFRESH_BROKER_ENV] });
         const storageStatePath = auth.kind === "none" ? undefined : auth.storageStatePath;
         if (storageStatePath && !fs.existsSync(storageStatePath)) {
@@ -754,7 +1041,12 @@ export class BrowserEngine {
         this.authLoss.beginSession(auth.kind, this.role);
         let profileNote = "";
         this.refresh = null;
-        this.refreshCounts = { refreshed: 0, swapped: 0, failed: 0 };
+        this.refreshCounts = { refreshed: 0, swapped: 0, failed: 0, learned: 0 };
+        this.refreshEvents = [];
+        this.brokeredRequests = new WeakSet();
+        // Another attach is another sign-in: the last one's credential is not this one's.
+        this.lastAuthHeader = null;
+        this.lastAuthAnswer = null;
         if (auth.kind === "role") {
             const note = permissionNote(auth.storageStatePath, fs.statSync(auth.storageStatePath).mode);
             if (note)
@@ -762,8 +1054,19 @@ export class BrowserEngine {
             if (brokered) {
                 const read = this.readRoleProfile();
                 const known = read.ok ? refreshTokenSlots(read.state) : [];
-                if (known.length > 0)
-                    this.refresh = { projectDir: opts.projectDir, role: auth.role, file: auth.storageStatePath, known, spent: [] };
+                if (known.length > 0) {
+                    this.refresh = {
+                        projectDir: opts.projectDir,
+                        role: auth.role,
+                        file: auth.storageStatePath,
+                        known,
+                        spent: [],
+                        learned: new Set(),
+                        learnedCheckedAt: 0,
+                        learnedMtimeMs: 0,
+                    };
+                    this.learnedEndpoints();
+                }
             }
         }
         this.currentMode = opts.mode ?? "read-only";
@@ -780,6 +1083,16 @@ export class BrowserEngine {
                 : "") +
                 (trust.rejected.length > 0 ? ` Not a plain http(s) origin, so not trusted: ${trust.rejected.join(", ")}.` : "") +
                 (trust.overflow.length > 0 ? ` More than ${MAX_TRUSTED_EMBEDS} trusted embeds; not trusted: ${trust.overflow.join(", ")}.` : "");
+        const reads = readPostEntries(readPostsSetting(opts.readPosts, process.env[READ_POSTS_ENV]));
+        this.readPosts = reads.entries;
+        this.readPostNotice =
+            (reads.entries.length > 0
+                ? this.mode === "observe"
+                    ? ` Read POSTs: ${reads.entries.map((e) => e.entry).join(", ")} — named as reads, so observe lets them out unless the path or body looks destructive or the body is a GraphQL mutation; each one is logged.`
+                    : ` Read POSTs (${reads.entries.map((e) => e.entry).join(", ")}) apply in observe mode only; ${this.mode} judges POSTs by its own rule.`
+                : "") +
+                (reads.rejected.length > 0 ? ` Not a "POST /path" or "POST https://host/path" entry, so not a read: ${reads.rejected.join(", ")}.` : "") +
+                (reads.overflow.length > 0 ? ` More than ${MAX_READ_POSTS} read POSTs; not reads: ${reads.overflow.join(", ")}.` : "");
         this.sessionObjective = (opts.objective ?? "").trim().replace(/\s+/g, " ").slice(0, 300);
         // An agent-supplied task counts as stated; the placeholder does not.
         this.setTask(opts.task ?? "Attaching and taking stock", opts.task !== undefined);
@@ -791,6 +1104,8 @@ export class BrowserEngine {
         this.framesFailed = 0;
         this.headed = opts.headed ?? false;
         this.blockedRequests = [];
+        this.blockNotices.reset();
+        this.dialogsSeen = [];
         this.watchedResponses = [];
         this.contradictionsReported = new Set();
         this.tokenPostsReported = new Set();
@@ -802,6 +1117,14 @@ export class BrowserEngine {
         // role must not discard what another role already created — otherwise
         // every multi-role handoff would be blocked as "not yours".
         this.memory = opts.memoryStore ?? new MemoryStore(opts.projectDir);
+        // A page refused before an endpoint was named as a read is no longer a gap for it.
+        if (this.readPosts.length > 0 && this.mode === "observe") {
+            const appOrigin = URL.canParse(this.baseUrl) ? new URL(this.baseUrl).origin : "";
+            this.memory.clearObserveRefusedPosts((endpoint) => {
+                const target = endpoint.replace(/^POST /, "");
+                return matchReadPost(this.readPosts, this.baseUrl, target.startsWith("/") ? appOrigin + target : target) !== null;
+            });
+        }
         // The REAL path, not merely the resolved one: on macOS the temp tree is a
         // symlink, and a fence comparing a real path against an unreal one would
         // refuse every upload from inside the project.
@@ -816,8 +1139,10 @@ export class BrowserEngine {
             this.projectDir = path.resolve(opts.projectDir);
             this.projectDirNote = ` (its real path could not be resolved: ${err instanceof Error ? err.message : String(err)} — a symlinked project path may be wrongly refused)`;
         }
+        this.loginProject = { projectDir: opts.projectDir, projectChosen: Boolean(opts.projectChosen) };
         this.oracles = new OracleMonitor();
         this.oracles.setPolicyRefusalCheck((req) => this.refusedByAnyPolicy(req));
+        this.oracles.setReplayCheck((req) => this.replayRequests.has(req));
         // A request an embed sends to the app is the app's to answer: only one headed outside the app is the embed's.
         this.oracles.setEmbedAttribution((req) => {
             let site = null;
@@ -830,7 +1155,7 @@ export class BrowserEngine {
             }
             return embedOfRequest(this.baseUrl, req.url(), site);
         });
-        this.lastSnap = null;
+        this.forgetSnapshots();
         this.designAuditCount = 0;
         // A new attach may be a restarted app: what failed to load before gets another try.
         this.loadFailedRoutes = new Set();
@@ -851,6 +1176,7 @@ export class BrowserEngine {
             this.context = await this.browser.newContext({
                 storageState: profile?.storageState,
                 viewport: opts.viewport ?? { width: 1280, height: 900 },
+                ...(opts.deviceScaleFactor !== undefined ? { deviceScaleFactor: opts.deviceScaleFactor } : {}),
                 serviceWorkers: serviceWorkerPolicy(this.engineName),
             });
             const restoreSession = sessionStorageInitScript(profile?.sessionStorage ?? []);
@@ -874,40 +1200,75 @@ export class BrowserEngine {
         this.openSockets.clear();
         this.socketsWarned = false;
         const watchSockets = (p) => void p.on("websocket", (ws) => this.openSockets.add(ws.url().slice(0, 120)));
+        // A request whose document goes away mid-body gets no finished or failed
+        // event, so a frame that commits a navigation, is removed, or closes with
+        // its page drops what it left in flight (the rule is in settle.ts).
+        const requests = (this.requests = new InFlightRequests());
+        const watchFrames = (p) => {
+            p.on("framenavigated", (frame) => requests.navigated(frame));
+            p.on("framedetached", (detached) => requests.gone((frame) => frame === detached));
+            p.on("close", () => requests.gone((frame) => frame.page() === p));
+        };
+        const watchPage = (p) => {
+            watchSockets(p);
+            watchFrames(p);
+        };
         // The first page already exists by now; later ones (popups) arrive as events.
         if (this.page)
-            watchSockets(this.page);
-        this.context.on("page", watchSockets);
-        this.context.on("requestfinished", () => {
-            this.inFlight = Math.max(0, this.inFlight - 1);
-        });
+            watchPage(this.page);
+        this.context.on("page", watchPage);
+        this.context.on("requestfinished", (req) => requests.ended(req));
         this.context.on("requestfailed", (req) => {
-            this.inFlight = Math.max(0, this.inFlight - 1);
+            requests.ended(req, true);
             this.watchResponse(req, null);
+            this.pageRequests.failed(req, req.failure()?.errorText ?? "", Date.now(), this.refusedByAnyPolicy(req));
         });
         this.context.on("response", (res) => {
+            this.noteAuthAnswer(res);
             this.watchResponse(res.request(), res.status());
+            this.pageRequests.answered(res.request(), res.status(), Date.now(), this.refusedByAnyPolicy(res.request()));
         });
         this.context.on("request", (req) => {
             // Who moved the driven page, decided on its navigation's first request
             // (this event fires before the route handler judges that page's writes).
             if (req.isNavigationRequest() && !req.redirectedFrom()) {
                 try {
-                    if (this.page && req.frame() === this.page.mainFrame())
+                    if (this.page && req.frame() === this.page.mainFrame()) {
                         this.embedMoves.navigationStarted(req.url(), req.headers()["referer"], this.embeddedSites());
+                        this.pageRequests.loaded(req.url(), Date.now());
+                        // The current input moved the page to a new document: what is sent from here on is not its own write.
+                        if (this.inputSince !== null && this.documentLoadSince === null && this.inputSince >= this.actionStartedAt)
+                            this.documentLoadSince = Date.now();
+                    }
                 }
                 catch {
                     /* no frame: not the driven page */
                 }
             }
-            this.inFlight += 1;
+            let sender;
+            try {
+                sender = req.frame();
+            }
+            catch {
+                /* a worker's request: no frame, so it ends only by finishing or failing */
+            }
+            requests.started(req, sender, req.isNavigationRequest());
             this.lastRequestStart = Date.now();
+            this.requestStartedAt.set(req, this.lastRequestStart);
+            this.claimReplay(req);
+            // After claimReplay, so a scout_request call's own header is not taken for the app's.
+            this.rememberAuthHeader(req);
             const type = req.resourceType();
-            if (type === "xhr" || type === "fetch")
+            if (type === "xhr" || type === "fetch") {
                 this.xhrCount += 1;
+                this.notePageRequest(req);
+            }
             const method = req.method();
             if (method === "GET" || method === "HEAD" || method === "OPTIONS")
                 return;
+            // A POST the user named as a read is not state the tester mutated, nor a form exercised.
+            if (this.readPostOf(this.writeRule.at(), method, req.url(), req.postData()))
+                return;
             // Infrastructure POSTs (token refresh, telemetry) are not state the
             // tester mutated — reporting them trains the driver to ignore the notice.
             if (BENIGN_MUTATION_RE.test(req.url()))
@@ -946,6 +1307,14 @@ export class BrowserEngine {
                 }
             }
         });
+        // The refresh broker. Registered before the write policy, so it runs after
+        // it: the policy judges each request as the page sent it and hands on
+        // (route.fallback) only what it lets out, and the broker sees only those.
+        // A refresh the policy refuses is never sent, so it needs no lock.
+        if (this.refresh) {
+            await this.context.route("**/*", (route) => this.brokerRefresh(route));
+            this.context.on("response", (res) => this.watchRotation(res));
+        }
         // Write policy — enforced on the wire, where the truth lives.
         if (this.mode !== "destructive") {
             const judge = async (route) => {
@@ -975,8 +1344,7 @@ export class BrowserEngine {
                 if (method === "GET" && req.resourceType() === "document" && this.embedEscapeNavigation(req)) {
                     const why = ESCAPE_REFUSAL;
                     // Reported like any refusal, so a click whose navigation this stopped does not read as a click that did nothing.
-                    if (this.blockedRequests.length < 20)
-                        this.blockedRequests.push({ at: Date.now(), sig: `navigation to ${req.url().slice(0, 140)}`, answered: false, why, type: req.resourceType() });
+                    this.noteBlocked({ at: Date.now(), sig: `navigation to ${req.url().slice(0, 140)}`, answered: false, why, type: req.resourceType() });
                     this.logAction({ action: "write-policy:blocked", target: `navigation to ${req.url().slice(0, 140)} (${why})`, url: this.page?.url() ?? "" });
                     this.refusedByPolicy.add(req);
                     this.oracles.notePolicyBlock();
@@ -1026,17 +1394,20 @@ export class BrowserEngine {
                     catch {
                         /* could not ask: load it as it would have loaded */
                     }
-                    await route.continue().catch(() => { });
+                    await route.fallback().catch(() => { });
                     return;
                 }
+                // What the policy lets out it hands on with route.fallback, never route.continue: the
+                // refresh broker, registered before this handler, runs next. With no broker it goes out.
                 if (method === "GET" || method === "HEAD" || method === "OPTIONS")
-                    return route.continue();
+                    return route.fallback();
                 const url = req.url();
                 const pathname = pathnameOf(url);
                 const refuse = (why) => {
                     const answered = answersWithRefusal(req.resourceType());
-                    if (this.blockedRequests.length < 20)
-                        this.blockedRequests.push({ at: Date.now(), sig: `${method} ${url.slice(0, 140)}`, answered, why, type: req.resourceType() });
+                    if (rule === "observe" && method === "POST" && !why && answered && !BENIGN_MUTATION_RE.test(url))
+                        this.noteObserveRefusedPost(url, req.postData());
+                    this.noteBlocked({ at: Date.now(), sig: `${method} ${url.slice(0, 140)}`, answered, why, type: req.resourceType() });
                     this.logAction({ action: "write-policy:blocked", target: `${method} ${pathname}${why ? ` (${why})` : ""}`, url: this.page?.url() ?? "" });
                     this.refusedByPolicy.add(req);
                     this.oracles.notePolicyBlock();
@@ -1052,7 +1423,6 @@ export class BrowserEngine {
                 const foreign = this.foreignWriteOf(req);
                 if (foreign)
                     return refuse(`sent from a frame of ${foreign}`);
-                this.rememberAuthHeader(req.headers());
                 const destructiveWire = isDestructiveWire(pathname, req.postData());
                 // An embed moved the session's page off the app: its writes out are not the app's, a sign-in excepted.
                 const offApp = offAppPageWrite(this.baseUrl, this.page?.url(), url, this.embedMoves.movedTo);
@@ -1062,7 +1432,19 @@ export class BrowserEngine {
                 // one, and in observe only the requests a login itself needs.
                 if (isAuthExempt(rule, method, pathname, destructiveWire)) {
                     this.routedWrites.note(rule, method, url, bodyDigest(req.postDataBuffer()));
-                    return route.continue();
+                    return route.fallback();
+                }
+                // A POST the user named as a read (observe only, never one that looks destructive): out, and logged.
+                const readPost = this.readPostOf(rule, method, url, req.postData(), destructiveWire);
+                if (readPost) {
+                    this.logAction({
+                        action: "write-policy:read-post",
+                        target: `${method} ${pathname} (named as a read: ${readPost.entry})`,
+                        url: this.page?.url() ?? "",
+                    });
+                    this.routedWrites.note(rule, method, url, bodyDigest(req.postDataBuffer()));
+                    this.clearRefusedPost(url);
+                    return route.fallback();
                 }
                 let owned = this.isOwnedResource(pathname);
                 // A single UI action commonly fires create-then-immediately-save
@@ -1098,7 +1480,9 @@ export class BrowserEngine {
                         this.pendingCreations.add(task);
                     }
                     this.routedWrites.note(rule, method, url, bodyDigest(req.postDataBuffer()));
-                    return route.continue();
+                    if (method === "POST")
+                        this.clearRefusedPost(url);
+                    return route.fallback();
                 }
                 return refuse();
             };
@@ -1115,11 +1499,6 @@ export class BrowserEngine {
                 }
             }
         }
-        // The refresh broker. Registered after the write policy so it runs first
-        // and hands every request on to it: a refresh it lets through is still
-        // judged by the policy like any other request.
-        if (this.refresh)
-            await this.context.route("**/*", (route) => this.brokerRefresh(route));
         // Popups / target=_blank: adopt same-origin pages as the active page (with
         // oracles attached); close foreign-origin popups so exploration cannot
         // silently escape the app under test.
@@ -1142,7 +1521,7 @@ export class BrowserEngine {
                     this.page = newPage;
                     this.refs.clear();
                     this.snapshotUrl = "";
-                    this.lastSnap = null;
+                    this.forgetSnapshots();
                 }
                 else {
                     void this.leaveAndClose(newPage);
@@ -1182,7 +1561,7 @@ export class BrowserEngine {
             ? `\n⚠ AUTH FAILED — the storage state at ${storageStatePath} did not produce a signed-in session: ` +
                 `attaching landed on ${landed}, a login page. ` +
                 (auth.kind === "role"
-                    ? `Record it again with \`${loginCommand(auth.role, this.baseUrl)}\` (its session has most likely expired) and re-attach. `
+                    ? `Record it again with \`${this.reloginCommand(auth.role)}\` (its session has most likely expired) and re-attach. `
                     : `Regenerate it (its token has most likely expired) and re-attach. `) +
                 `Continuing now tests a logged-out app.` +
                 (recipe.length > 0
@@ -1196,7 +1575,7 @@ export class BrowserEngine {
             `Memory: ${this.memory.dir}.${this.memory.loadWarning ? ` WARNING: ${this.memory.loadWarning}` : ""}` +
             (this.memory.prunedStates > 0 ? ` Trimmed ${this.memory.prunedStates} old page state(s) from the history; coverage is unchanged.` : "") +
             `${this.memory.legacyDirNote ? ` ${this.memory.legacyDirNote}` : ""}` +
-            `${this.memory.gitIgnoreNote ? ` ${this.memory.gitIgnoreNote}` : ""}${this.trustNotice} Call scout_snapshot to see the current state.` +
+            `${this.memory.gitIgnoreNote ? ` ${this.memory.gitIgnoreNote}` : ""}${this.trustNotice}${this.readPostNotice} Call scout_snapshot to see the current state.` +
             profileNote +
             authWarning);
     }
@@ -1242,18 +1621,50 @@ export class BrowserEngine {
                 this.foreignFrames.set(frame, origin);
         });
     }
-    /** Dialogs (confirm/alert): dismiss in read-only mode, accept otherwise. Must be wired on every page we drive, including adopted popups. */
+    /**
+     * Native dialogs, answered by policy.ts dialogResponse: alert, confirm and
+     * prompt dismissed in read-only and observe and accepted otherwise; a leave
+     * confirmation (beforeunload) by the caller's `leave`, else by the mode. Each
+     * is reported in the next action's result (dialogNote). Must be wired on
+     * every page we drive, including adopted popups.
+     */
     wireDialogHandler(page) {
         page.on("dialog", (dialog) => {
-            const action = this.readOnly ? "dismiss" : "accept";
+            this.nativeDialogAt = Date.now();
+            const type = dialog.type();
+            if (type !== "alert")
+                this.nativeQuestionAt = this.nativeDialogAt;
+            const leave = type === "beforeunload" ? this.leaveChoice : undefined;
+            const response = dialogResponse(type, this.readOnly, leave);
             this.logAction({
-                action: `dialog:${action}`,
+                action: `dialog:${type === "beforeunload" ? "leave-" : ""}${response}`,
                 target: dialog.message().slice(0, 120),
                 url: this.page?.url() ?? "",
             });
-            void (this.readOnly ? dialog.dismiss() : dialog.accept()).catch(() => { });
+            if (this.dialogsSeen.length < 10)
+                this.dialogsSeen.push({ type, message: dialog.message(), response, ...(leave !== undefined ? { leave } : {}) });
+            if (type === "beforeunload" && response === "dismiss" && page === this.page)
+                this.onLeaveRefused?.();
+            void (response === "dismiss" ? dialog.dismiss() : dialog.accept()).catch((err) => {
+                // A dialog already closed by the page or by the browser going away has nothing left to answer.
+                console.error(`[scenescout] could not answer a ${type} dialog: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
+            });
         });
     }
+    /** The lines for the native dialogs the page opened since the last result, cleared as they are read. */
+    drainDialogs() {
+        const notes = this.dialogsSeen.map((d) => dialogNote(d)).join("");
+        this.dialogsSeen = [];
+        return notes;
+    }
+    /** Whether the page asked to confirm leaving, since the `since`th dialog this action saw, and was answered "stay". */
+    leaveRefused(since) {
+        return this.dialogsSeen.slice(since).some((d) => d.type === "beforeunload" && d.response === "dismiss");
+    }
+    /** When the page last opened a native dialog (confirm, alert, prompt). */
+    nativeDialogAt = 0;
+    /** When a native dialog that asks something (confirm, prompt, a leave confirmation) last opened; an alert only tells. */
+    nativeQuestionAt = 0;
     requirePage() {
         if (!this.page || !this.memory) {
             throw new Error("Not attached. Call scout_attach first with the app URL and project path.");
@@ -1320,8 +1731,12 @@ export class BrowserEngine {
     }
     /** Set at attach: this session was given credentials, so a bounce to a login page is a verdict worth waiting for. */
     watchesForBounce = false;
-    /** Requests started and not yet finished or failed, from the context's own events. */
-    inFlight = 0;
+    /** Requests started and not yet finished, failed, or left behind by their frame. */
+    requests = new InFlightRequests();
+    /** How many are in flight. */
+    get inFlight() {
+        return this.requests.count;
+    }
     /** When the most recent request started, so a page that fires one late is not read too early. */
     lastRequestStart = 0;
     /**
@@ -1338,6 +1753,39 @@ export class BrowserEngine {
     get pace() {
         return this.paceMs;
     }
+    /** Forget every kept snapshot: the next one of any route is listed in full, with new refs. */
+    forgetSnapshots() {
+        this.snaps.clear();
+        this.lastSnapRoute = "";
+        this.refsDropped = null;
+    }
+    /** Drop the latest snapshot's refs, remembering why so the next diff does not call them stable. */
+    dropRefs(reason) {
+        this.refs.clear();
+        this.refsDropped ??= reason;
+    }
+    /**
+     * The kept snapshot a route's next snapshot is compared with: the route's
+     * own, else the latest of another tab of the same screen (routeBase).
+     */
+    prevSnapFor(route) {
+        const own = this.snaps.get(route);
+        if (own)
+            return { snap: own, how: route === this.lastSnapRoute ? "latest" : "revisited" };
+        const base = routeBase(route);
+        const tabs = [...this.snaps.values()].filter((s) => routeBase(s.route) === base);
+        const latest = tabs[tabs.length - 1];
+        return latest ? { snap: latest, how: "tab" } : null;
+    }
+    /** Keep a snapshot as its route's latest, dropping the least recent route past SNAPSHOTS_KEPT. */
+    keepSnapshot(snap) {
+        this.snaps.delete(snap.route);
+        this.snaps.set(snap.route, snap);
+        while (this.snaps.size > SNAPSHOTS_KEPT)
+            this.snaps.delete(this.snaps.keys().next().value);
+        this.lastSnapRoute = snap.route;
+        this.refsDropped = null;
+    }
     /** Collect the current page's interactables into SnapshotElements with stable refs. */
     async collect() {
         const page = this.requirePage();
@@ -1355,7 +1803,8 @@ export class BrowserEngine {
             if (stable)
                 break;
         }
-        const mainCount = rawElements.length;
+        const cut = rawElements.filter((r) => r.cut);
+        rawElements = rawElements.filter((r) => !r.cut);
         // The page's forms, read in the same settled page as its elements. The
         // page's own document only: an xpath names a node in one document.
         const rawForms = ((await this.formRead("form inventory", page.evaluate(FORMS_INVENTORY_SCRIPT))) ?? []);
@@ -1367,33 +1816,48 @@ export class BrowserEngine {
         // (and previously issued refs) survive re-snapshots. An element inside a
         // frame carries the frame in its key (collector.ts frameElementKey).
         const route = normalizePath(page.url());
-        const prevByKey = this.lastSnap?.route === route ? this.lastSnap.byKey : null;
+        const prev = this.prevSnapFor(route);
         this.refs.clear();
         this.refFrames.clear();
-        const keyCounts = new Map();
         const all = [
             ...rawElements.map((raw) => ({ raw })),
             ...framed.flatMap((g) => g.raws.map((raw) => ({ raw: raw, frame: g.frame, tag: g.tag }))),
         ];
-        const elements = all.map(({ raw: el, frame, tag }) => {
-            const baseKey = frameElementKey(elementKey(el), tag);
-            const count = keyCounts.get(baseKey) ?? 0;
-            keyCounts.set(baseKey, count + 1);
-            const key = count === 0 ? baseKey : `${baseKey}~${count}`;
-            const ref = prevByKey?.get(key)?.ref ?? `e${++this.refCounter}`;
+        // A live region listed for what it says is known by its role, not its
+        // text, so a new message reads as the same region saying something else.
+        const baseKeyOf = (el, name, tag) => frameElementKey(el.liveOnly ? `live:${el.role}` : elementKey({ ...el, name }), tag);
+        const bases = all.map(({ raw: el, tag }) => ({
+            base: baseKeyOf(el, el.name, tag),
+            prior: baseKeyOf(el, el.priorName ?? el.name, tag),
+            tracked: !el.liveOnly,
+        }));
+        const keys = ordinalKeys(bases.map((b) => b.base));
+        const aliases = keyAliases(bases);
+        const built = all.map(({ raw: el, frame, tag }, i) => {
+            const key = keys[i];
+            const { ownText: _ownText, centre: _centre, cut: _cut, priorName: _priorName, ...listed } = el;
             const full = {
-                ...el,
+                ...listed,
                 ...(tag ? { frame: tag } : {}),
                 // Judged on the real label, then masked: the policy must see what a click would press.
-                destructive: isDestructive(el.name, el.testid),
+                // A message is not a control: "Could not delete" in an alert is not a Delete button.
+                destructive: el.liveOnly ? false : destructiveLabelOf(el) !== null,
                 ...(tag?.foreign ? { name: masksForeignName(el.tag, el.role) ? MASKED_NAME : capForeignName(el.name) } : {}),
                 ...(tag?.foreign && el.href ? { href: stripForeignHref(el.href) } : {}),
-                ref,
+                ref: "",
                 key,
             };
-            this.refs.set(ref, full);
+            return { full, frame };
+        });
+        // An element keeps the ref it had in the snapshot it is matched to, so
+        // refs an agent holds survive a re-snapshot and the diff stays readable.
+        const matched = matchPrevious(prev?.snap.byKey ?? new Map(), built.map(({ full }) => ({ key: full.key, name: full.name, href: full.href, byPosition: full.liveOnly })));
+        const elements = built.map(({ full, frame }, i) => {
+            const was = matched[i];
+            full.ref = (was ? prev?.snap.byKey.get(was)?.ref : undefined) ?? `e${++this.refCounter}`;
+            this.refs.set(full.ref, full);
             if (frame)
-                this.refFrames.set(ref, frame);
+                this.refFrames.set(full.ref, frame);
             return full;
         });
         this.harvestRoutes(elements.filter((el) => !el.frame?.foreign));
@@ -1405,8 +1869,8 @@ export class BrowserEngine {
             const key = status === "untracked" ? null : (formIdentity(f.attrs) ?? keyAtXpath(elements, f.submit));
             return key ? [{ key, guarded: status === "guarded" }] : [];
         });
-        this.lastCollectTruncated = mainCount >= 150;
-        return { elements, truncated: mainCount >= 150, forms };
+        this.lastCollectTruncated = cut.length > 0;
+        return { elements, truncated: cut.length > 0, forms, cut, prev, matched, aliases };
     }
     /** Whether the latest collect stopped at the element cap, so some controls have no key at all. */
     lastCollectTruncated = false;
@@ -1435,7 +1899,9 @@ export class BrowserEngine {
                     return null;
                 const title = ((await el.getAttribute("title")) || (await el.getAttribute("name")) || "").trim();
                 const got = (await frame.evaluate(`(() => ({ els: ${COLLECT_INTERACTABLES_SCRIPT}, sx: window.scrollX, sy: window.scrollY }))()`));
-                const raws = got.els.map((r) => ({ ...r, rect: frameToPageRect(r.rect, box, { x: got.sx, y: got.sy }, pageScroll) }));
+                const raws = got.els
+                    .filter((r) => !r.cut)
+                    .map((r) => ({ ...r, rect: frameToPageRect(r.rect, box, { x: got.sx, y: got.sy }, pageScroll) }));
                 let origin = "";
                 try {
                     const u = new URL(frame.url());
@@ -1528,12 +1994,12 @@ export class BrowserEngine {
      */
     async captureCoverageState() {
         const page = this.requirePage();
-        const { elements, forms } = await this.collect();
+        const { elements, forms, aliases } = await this.collect();
         const url = page.url();
-        const fp = fingerprintState(url, elements);
-        this.memory?.visitState(fp, url, normalizePath(url), elements.map((el) => el.key));
+        const fp = fingerprintState(url, trackedElements(elements));
+        this.memory?.visitState(fp, url, normalizePath(url), trackedElements(elements).map((el) => el.key), inertKeys(elements), this.sessionKey, aliases);
         for (const f of forms)
-            this.memory?.recordForm(fp, f.key, f.guarded);
+            this.memory?.recordForm(fp, f.key, f.guarded, this.sessionKey);
         return { fp, elements, url };
     }
     /**
@@ -1575,6 +2041,16 @@ export class BrowserEngine {
         if (found.length > 0)
             this.memory.addDiscoveredRoutes(found);
     }
+    /** What the main region holds besides controls (MAIN_REGION_SCRIPT). A failed read is logged and gives no line, not "EMPTY". */
+    async readMainRegion(page) {
+        try {
+            return (await page.evaluate(MAIN_REGION_SCRIPT));
+        }
+        catch (err) {
+            console.error(`[scenescout] main-region read failed: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    }
     /** Every file input on the page. A failed probe is logged, not passed off as "none". */
     async listFileInputs(page) {
         try {
@@ -1605,15 +2081,16 @@ export class BrowserEngine {
         const page = this.requirePage();
         const memory = this.memory;
         await this.settle();
-        const { elements, truncated, forms } = await this.collect();
+        const { elements, truncated, forms, cut, prev: prevSnap, matched, aliases } = await this.collect();
         const url = page.url();
         this.snapshotUrl = url;
+        this.snapshotAt = Date.now();
         const route = normalizePath(url);
-        const fp = fingerprintState(url, elements);
+        const fp = fingerprintState(url, trackedElements(elements));
         this.currentFingerprint = fp;
-        const isNew = memory.visitState(fp, url, route, elements.map((el) => el.key));
+        const isNew = memory.visitState(fp, url, route, trackedElements(elements).map((el) => el.key), inertKeys(elements), this.sessionKey, aliases);
         for (const f of forms)
-            memory.recordForm(fp, f.key, f.guarded);
+            memory.recordForm(fp, f.key, f.guarded, this.sessionKey);
         memory.recordRoleAccess(this.role, route, "reached");
         // A snapshot is what an agent takes when it wants to LOOK at something, so
         // it is the frame a reader most wants beside the step. Recording only the
@@ -1622,30 +2099,53 @@ export class BrowserEngine {
         this.logAction({ action: "snapshot", url, result: fp, ...(await this.frameFor("snapshot")) });
         await this.scanForInjections();
         await this.scanForContradictions();
+        // An alert or live region that appeared after the write policy refused one of
+        // the current input's requests may be the page answering the engine's
+        // refusal, not a defect of its own: said beside it, so a reader of the
+        // snapshot alone does not file it (claims.ts saidSince).
+        const blockedThisInput = this.inputSince !== null && this.inputSince >= this.actionStartedAt && this.lastBlockAt >= this.inputSince;
+        const afterBlock = (el) => blockedThisInput && (el.liveOnly || el.role === "alert" || el.role === "status") && saidSince(el.name, this.claimBaseline)
+            ? " (after a write-policy block)"
+            : "";
         const line = (el) => {
             const dup = el.key.match(/~(\d+)$/);
             const flags = [
+                ...stateFlags(el.state),
                 el.testid ? `testid=${el.testid}` : null,
                 dup ? `copy#${Number(dup[1]) + 1}` : null,
                 el.disabled ? "disabled" : null,
                 el.destructive ? "DESTRUCTIVE" : null,
+                ...affordanceFlags(el),
                 labelFlag(el),
-                memory.wasExercised(fp, el.key) ? "done" : null,
+                // "exercised", not "done": it says an earlier action or run acted on it, and "done" read as the control's own state.
+                memory.wasExercised(fp, el.key) ? "exercised" : null,
                 el.href ? `href=${el.href.slice(0, 60)}` : null,
             ].filter(Boolean);
-            return `${el.ref} ${el.role} "${displayName(el)}"${flags.length ? ` [${flags.join(", ")}]` : ""}${el.frame ? ` ⟨in ${frameLabel(el.frame)}⟩` : ""}`;
+            return `${el.ref} ${el.role} "${displayName(el)}"${flags.length ? ` [${flags.join(", ")}]` : ""}${el.frame ? ` ⟨in ${frameLabel(el.frame)}⟩` : ""}${afterBlock(el)}`;
         };
-        // Diff mode: when re-snapshotting the same route, report only what
-        // changed — same idea as UI reconciliation, applied to agent context.
-        const prev = this.lastSnap?.route === route ? this.lastSnap : null;
-        this.lastSnap = { route, byKey: new Map(elements.map((el) => [el.key, { ref: el.ref, label: el.name, disabled: el.disabled }])) };
+        // Diff mode: when re-snapshotting a route (or another tab of the same
+        // screen), report only what changed — same idea as UI reconciliation,
+        // applied to agent context. Elements are paired with the kept snapshot's
+        // by matchPrevious, the same pairing that gave them their refs.
+        const prev = prevSnap?.snap ?? null;
+        const refsDropped = this.refsDropped;
+        this.keepSnapshot({
+            route,
+            byKey: new Map(elements.map((el) => [el.key, { ref: el.ref, label: el.name, href: el.href, disabled: el.disabled, state: stateFlags(el.state) }])),
+        });
+        const cutLine = truncated ? `TRUNCATED at ${COLLECTOR_CAP}, dense page — cut: ${cutSummary(cut)}` : "";
         let body;
-        if (!full && prev) {
-            const currentKeys = new Set(elements.map((el) => el.key));
-            const added = elements.filter((el) => !prev.byKey.has(el.key));
-            const removed = [...prev.byKey.entries()].filter(([key]) => !currentKeys.has(key));
+        if (!full && prev && prevSnap) {
+            const was = new Map(elements.map((el, i) => [el.key, matched[i]]));
+            const oldOf = (el) => {
+                const key = was.get(el.key);
+                return key ? prev.byKey.get(key) : undefined;
+            };
+            const pairedPrev = new Set(matched.filter((k) => k !== null));
+            const added = elements.filter((el) => !oldOf(el));
+            const removed = [...prev.byKey.entries()].filter(([key]) => !pairedPrev.has(key));
             const relabeled = elements.filter((el) => {
-                const old = prev.byKey.get(el.key);
+                const old = oldOf(el);
                 return old !== undefined && old.label !== el.name;
             });
             // An element can change WITHOUT being added, removed or relabeled: the
@@ -1657,29 +2157,52 @@ export class BrowserEngine {
             // to enabled "Save" changed BOTH ways, and reporting only the relabel
             // swallows the enable — the exact fact this line exists to surface.
             const retoggled = elements.filter((el) => {
-                const old = prev.byKey.get(el.key);
+                const old = oldOf(el);
                 return old !== undefined && old.disabled !== el.disabled;
             });
-            const changedKeys = new Set([...relabeled, ...retoggled].map((el) => el.key));
+            // A filter pill that became the active one, a tab now selected, a
+            // section now open: the same element, in a different state.
+            const restated = elements.flatMap((el) => {
+                const old = oldOf(el);
+                const change = old ? stateChange(old.state, stateFlags(el.state)) : null;
+                return change ? [{ el, change }] : [];
+            });
+            const changedKeys = new Set([...relabeled, ...retoggled, ...restated.map((r) => r.el)].map((el) => el.key));
             const unchanged = elements.length - added.length - changedKeys.size;
-            if (added.length === 0 && removed.length === 0 && relabeled.length === 0 && retoggled.length === 0) {
-                body = `No element changes since the last snapshot (${unchanged} interactables, refs unchanged).`;
+            // What the diff is against, and whether refs held from the latest snapshot still work.
+            const against = prevSnap.how === "latest"
+                ? "the last snapshot"
+                : prevSnap.how === "revisited"
+                    ? "this route's last snapshot"
+                    : `the last snapshot of ${prev.route} (tab changed)`;
+            const refNote = prevSnap.how === "latest" && !refsDropped
+                ? "refs stable"
+                : `refs from ${prevSnap.how === "latest" ? "it were dropped when " + refsDropped : "that snapshot"} are re-issued: an unchanged element has its old ref again`;
+            if (added.length === 0 && removed.length === 0 && relabeled.length === 0 && retoggled.length === 0 && restated.length === 0) {
+                body = `No element changes since ${against} (${unchanged} interactables, ${refNote === "refs stable" ? "refs unchanged" : refNote}).`;
             }
             else {
                 body =
-                    `DIFF vs last snapshot (${unchanged} unchanged, refs stable):\n` +
+                    `DIFF vs ${against} (${unchanged} unchanged, ${refNote}):\n` +
                         [
                             ...added.map((el) => `+ ${line(el)}`),
                             ...removed.map(([key, v]) => `- ${v.ref} "${v.label}" (gone: ${key})`),
-                            ...relabeled.map((el) => `~ ${el.ref} relabeled → "${el.name}"`),
+                            // A live region saying something new is the message itself, so it is shown in full like a new element.
+                            ...relabeled.map((el) => el.liveOnly
+                                ? `~ ${el.ref} ${el.role} "${displayName(el)}" (was ${oldOf(el)?.label ? `"${oldOf(el)?.label}"` : "empty"})${afterBlock(el)}`
+                                : `~ ${el.ref} relabeled → "${el.name}"`),
                             ...retoggled.map((el) => `~ ${el.ref} "${el.name}" is now ${el.disabled ? "DISABLED" : "ENABLED"}`),
+                            ...restated.map(({ el, change }) => `~ ${el.ref} "${displayName(el)}" ${change}`),
                         ].join("\n");
             }
+            if (cutLine)
+                body += `\n${cutLine}`;
         }
         else {
-            const missingTestids = elements.filter((el) => !el.testid && !el.disabled).length;
+            const missingTestids = trackedElements(elements).filter((el) => !el.testid && !el.disabled).length;
             body =
-                `Interactables (${elements.length}${truncated ? "+ — TRUNCATED at 150, dense page" : ""}${missingTestids ? `, ${missingTestids} missing data-testid` : ""}):\n` +
+                `Interactables (${elements.length}${truncated ? "+" : ""}${missingTestids ? `, ${missingTestids} missing data-testid` : ""}):\n` +
+                    (cutLine ? `${cutLine}\n` : "") +
                     elements.map(line).join("\n");
         }
         // Per document: the page's own controls together, and each frame's apart —
@@ -1690,10 +2213,12 @@ export class BrowserEngine {
         const cov = memory.coverage();
         const unvisited = this.unvisitedKnownRoutes();
         const title = await page.title();
+        const main = await this.readMainRegion(page);
         return (`URL: ${url}\nTitle: ${title}\nState: ${fp} ${isNew ? "(NEW state)" : "(revisited)"}\n` +
             `Coverage: ${cov.states} states known · ${cov.elementsExercised}/${cov.elementsTotal} elements exercised` +
             (this.allKnownRoutes().length > 0 ? ` · routes ${this.allKnownRoutes().length - unvisited.length}/${this.allKnownRoutes().length} visited` : "") +
             `\n` +
+            (main ? `${mainRegionLine(main)}\n` : "") +
             body +
             (geometry.length > 0 ? `\nGEOMETRY issues:\n` + geometry.map((g) => `  ⚠ ${g}`).join("\n") : "") +
             (brokenImages.length > 0 ? `\nBROKEN IMAGES:\n` + brokenImages.map((b) => `  ⚠ ${b}`).join("\n") : "") +
@@ -1712,7 +2237,7 @@ export class BrowserEngine {
                 : "") +
             this.socketNotice() +
             formatViolations(this.oracles.drain()) +
-            (elements.length === 0
+            (trackedElements(elements).length === 0
                 ? hasVisibleFrame(frames)
                     ? "\n⚠ No interactable elements in the page itself: what it shows is inside the frames listed above, which were not explored."
                     : "\n⚠ DEAD END: no interactable elements found on this page."
@@ -1720,38 +2245,112 @@ export class BrowserEngine {
     }
     /**
      * Resolve a ref and re-verify the live element at action time. Refs are
-     * trusted only while the page URL exactly matches the snapshot's, and even
-     * then the located element's live identity is re-read so the destructive
-     * policy applies to what is actually acted on — SPA re-renders can put a
-     * different element under a previously-safe XPath.
+     * trusted while the page is on the snapshot's URL, or one that differs from
+     * it only in what refsSurviveUrlChange allows (a search or filter query),
+     * and even then the located element's live identity is re-read so the
+     * destructive policy applies to what is actually acted on — SPA re-renders
+     * can put a different element under a previously-safe XPath. After a query
+     * change, the element must still carry its name as well as its test id.
+     *
+     * When the XPath finds nothing because the page re-rendered around the
+     * element (a footer that appears while typing shifts every path below it),
+     * an element with a test id that is unique on the page is found again by it,
+     * checked by name, and the ref is re-bound to it; the action's result says so (rebindNote).
      */
     async resolveForAction(ref) {
         this.actionStartedAt = Date.now();
+        this.rebindNote = "";
         const page = this.requirePage();
-        const el = this.refs.get(ref);
+        let el = this.refs.get(ref);
         if (!el) {
-            throw new Error(`Unknown ref "${ref}". Refs are only valid from the latest scout_snapshot — take a new snapshot.`);
+            throw new Error(`Unknown ref "${ref}". Refs are only valid from the latest scout_snapshot${this.refsDropped ? ` (they were dropped when ${this.refsDropped})` : ""} — take a new snapshot.`);
         }
-        if (page.url() !== this.snapshotUrl) {
-            this.refs.clear();
+        const urlMoved = page.url() !== this.snapshotUrl;
+        if (urlMoved && !refsSurviveUrlChange(this.snapshotUrl, page.url())) {
+            this.dropRefs(`the page moved to ${page.url()}`);
             throw new Error(`Page URL changed since the last snapshot (now ${page.url()}). Take a new scout_snapshot.`);
         }
-        // String EXPRESSION via page.evaluate (locator.evaluate treats a string as
-        // an expression, not a function — the element arg never binds).
-        const live = (await this.scopeOf(el)
-            .evaluate(`(() => { const node = ${xpathLookup(el.xpath)}; if (!node) return null; ` +
-            `return { testid: node.getAttribute('data-testid'), label: (node.getAttribute('aria-label') || node.innerText || node.textContent || node.getAttribute('placeholder') || '').trim().slice(0, 120) }; })()`)
-            .catch(() => null));
+        // The element and the test id are passed as arguments: no value of the
+        // page's is written into the code that runs there.
+        const scope = this.scopeOf(el);
+        const handle = await scope.$(`xpath=${el.xpath}`).catch(() => null);
+        let live = handle ? await handle.evaluate(liveFactsOf).catch(() => null) : null;
+        await handle?.dispose().catch(() => undefined);
+        if (!live && el.testid) {
+            // Found again only by a test id the page gives one element: two would leave it guessing.
+            const found = await scope.evaluate(uniqueByTestid, el.testid).catch(() => null);
+            if (found && found.live.name === el.name) {
+                el = { ...el, xpath: found.xpath };
+                this.refs.set(ref, el);
+                live = found.live;
+                this.rebindNote = `\nℹ ${ref} re-bound after a re-render: found again by its unique testid=${el.testid}.`;
+            }
+        }
         if (!live) {
             throw new Error(`Element ${ref} no longer exists in the DOM — take a new scout_snapshot.`);
         }
+        await this.beginInput();
         if (el.testid && live.testid !== el.testid) {
-            this.refs.clear();
+            this.dropRefs(`the element under ${ref} changed`);
             throw new Error(`Element under ${ref} changed (expected testid=${el.testid}, found ${live.testid ?? "none"}) — the DOM shifted; take a new scout_snapshot.`);
         }
-        return { el, liveLabel: live.label };
+        // After a query change a list may hold other rows under the same paths and
+        // the same shared test id, so the name must match too. Another site's frame
+        // shows a masked name (masksForeignName), so there is nothing to compare there.
+        if (urlMoved && !el.frame?.foreign && live.name !== el.name) {
+            this.dropRefs(`the element under ${ref} changed`);
+            throw new Error(`Element under ${ref} changed after the URL did (expected "${el.name}", found "${live.name}") — take a new scout_snapshot.`);
+        }
+        return { el, liveLabel: live.label, live: { ownText: live.ownText, centre: live.centre } };
+    }
+    /** Set when the action's ref had to be found again by its test id (resolveForAction); afterAction reports it once. */
+    rebindNote = "";
+    /** The read-POST entry that lets this request out under `rule`, or null (policy.ts readPostAllowed). */
+    readPostOf(rule, method, url, body, destructiveWire) {
+        if (this.readPosts.length === 0 || rule !== "observe" || method !== "POST")
+            return null;
+        const pathname = pathnameOf(url);
+        return readPostAllowed({
+            mode: rule,
+            method,
+            url,
+            appUrl: this.baseUrl,
+            body,
+            destructiveWire: destructiveWire ?? isDestructiveWire(pathname, body),
+            entries: this.readPosts,
+        });
     }
-    actionPolicyCheck(el, liveLabel) {
+    /** How the gap ledger names a POST's endpoint: "POST /path" on the app's origin, "POST https://host/path" elsewhere; null when unreadable. */
+    refusedPostEndpoint(url) {
+        try {
+            const u = new URL(url);
+            return `POST ${u.origin === new URL(this.baseUrl).origin ? "" : u.origin}${u.pathname}`;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Remember in project memory, for the gap ledger, a script's POST that
+     * observe refused on the page the session is on. Not one that looks
+     * destructive, nor one to an endpoint already named as a read (its body was
+     * a mutation): naming it would change nothing.
+     */
+    noteObserveRefusedPost(url, body) {
+        const pageUrl = this.page?.url();
+        if (!pageUrl || !this.memory || isDestructiveWire(pathnameOf(url), body) || matchReadPost(this.readPosts, this.baseUrl, url))
+            return;
+        const endpoint = this.refusedPostEndpoint(url);
+        if (endpoint)
+            this.memory.noteObserveRefusedPost(normalizePath(pageUrl), endpoint);
+    }
+    /** A POST to this endpoint went out, so the pages observe refused it on are no longer a gap for it. */
+    clearRefusedPost(url) {
+        const endpoint = this.refusedPostEndpoint(url);
+        if (endpoint && this.memory)
+            this.memory.clearObserveRefusedPosts((e) => e === endpoint);
+    }
+    actionPolicyCheck(el, liveLabel, live = {}) {
         if (!this.readOnly)
             return null;
         // Same-origin navigation links are exempt: navigation is non-destructive
@@ -1765,12 +2364,46 @@ export class BrowserEngine {
         // same holds for choosing a file: selection is not the send.
         if (el.role === "textbox" || el.role === "file")
             return null;
-        if (el.destructive || isDestructive(liveLabel)) {
-            return destructiveRefusal(liveLabel || el.name || el.testid || el.ref, this.mode);
+        // Judged as the snapshot judged it, and again on what is there now (policy.ts destructiveLabelOf).
+        const now = destructiveLabelOf({
+            tag: el.tag,
+            role: el.role,
+            name: liveLabel,
+            testid: el.testid,
+            ownText: live.ownText,
+            centre: live.centre,
+            interactive: el.interactive,
+        });
+        if (el.destructive || now !== null) {
+            return destructiveRefusal(now ?? (liveLabel || el.name || el.testid || el.ref), this.mode);
         }
         return null;
     }
-    async afterAction(action, target) {
+    /**
+     * Re-rank a page error this click raised when it reads as a router
+     * cancelling a route change (oracles.ts isRouteCancellation). The dialog
+     * count is read only when there is such an error to judge.
+     */
+    async rankRouteCancellations(click, url) {
+        const since = this.actionStartedAt;
+        if (!this.oracles.hasPageErrorSince(since))
+            return;
+        let dialogsNow = null;
+        try {
+            dialogsNow = (await this.requirePage().evaluate(OPEN_DIALOGS_SCRIPT));
+        }
+        catch {
+            // A page mid-navigation: only a native dialog can count.
+        }
+        const ariaDialogOpened = dialogsNow !== null && click.dialogsBefore !== null && dialogsNow > click.dialogsBefore;
+        this.oracles.downgradeRouteCancellations(since, {
+            byClick: true,
+            viaLink: click.viaLink,
+            urlChanged: url !== click.urlBefore,
+            dialogOpened: ariaDialogOpened || this.nativeDialogAt >= since,
+        });
+    }
+    async afterAction(action, target, click) {
         const page = this.requirePage();
         await this.settle();
         let url = page.url();
@@ -1785,27 +2418,39 @@ export class BrowserEngine {
             this.logAction({ action: policyAbortedNavigation ? "write-policy:navigation-blocked" : "origin-fence:bounced", target: url.slice(0, 200), url });
             await page.goBack({ waitUntil: "domcontentloaded", timeout: this.limits.backNavMs }).catch(() => { });
             url = page.url();
-            this.refs.clear();
-            const blocked = this.drainBlocked();
+            this.dropRefs("the page left the app's origin");
+            const blocked = this.drainBlocked() + this.drainRefresh();
             return ((policyAbortedNavigation
                 ? `OK: ${action} ${target}\nThe page tried to navigate with a request the write policy blocked, so the browser showed an error page; returned to ${url}.`
                 : `OK: ${action} ${target}\nNavigated off-origin and was bounced back to ${url}. Exploration is fenced to ${this.baseUrl}.`) +
                 blocked +
+                this.drainDialogs() +
                 formatViolations(this.oracles.drain()));
         }
         const frame = await this.recordFrame(action);
         this.logAction({ action, target, url, ...(frame ? { frame } : {}) });
         await this.scanForInjections();
         await this.scanForContradictions();
+        if (click)
+            await this.rankRouteCancellations(click, url);
         const violations = this.oracles.drain();
-        const mutations = this.drainMutations() + this.drainBlocked() + this.drainCreated();
-        const navigated = this.snapshotUrl !== "" && url !== this.snapshotUrl;
+        const mutations = this.drainMutations() + this.drainBlocked() + this.drainRefresh() + this.drainCreated();
+        const moved = this.snapshotUrl !== "" && url !== this.snapshotUrl;
+        // A query that is not UI state (a search, a filter) leaves the same screen: its refs still work.
+        const navigated = moved && !refsSurviveUrlChange(this.snapshotUrl, url);
         if (navigated) {
             // Refs point into the previous page's DOM; invalidate so a stale ref
             // errors ("take a new snapshot") instead of acting on the wrong element.
-            this.refs.clear();
+            this.dropRefs(`the page moved to ${url}`);
         }
-        return `OK: ${action} ${target}\nURL now: ${url}` + (navigated ? " (page changed — take a new snapshot)" : "") + mutations + formatViolations(violations);
+        const rebound = this.rebindNote;
+        this.rebindNote = "";
+        return (`OK: ${action} ${target}\nURL now: ${url}` +
+            (navigated ? " (page changed — take a new snapshot)" : moved ? " (same screen, query changed — refs still apply)" : "") +
+            rebound +
+            this.drainDialogs() +
+            mutations +
+            formatViolations(violations));
     }
     /** Does this request path address a record this run created? Rules live in ownership.ts. */
     isOwnedResource(pathname) {
@@ -2005,6 +2650,7 @@ export class BrowserEngine {
             let pathname = url;
             try {
                 pathname = pathnameOf(url);
+                const readPost = this.readPostOf(rule, method, url, bytes?.toString("utf8"));
                 const { foreign, offApp } = unseenWriteSource({
                     appUrl: this.baseUrl,
                     mode: rule,
@@ -2023,7 +2669,14 @@ export class BrowserEngine {
                     foreign,
                     offApp,
                     owned: this.isOwnedResource(pathname),
+                    readPost: readPost !== null,
                 });
+                if (readPost && verdict.allow)
+                    this.logAction({
+                        action: "write-policy:read-post",
+                        target: `${method} ${pathname} (named as a read: ${readPost.entry})`,
+                        url: this.page?.url() ?? "",
+                    });
             }
             catch (err) {
                 // Fail closed: a write that cannot be judged is refused, and reported as refused below.
@@ -2041,14 +2694,13 @@ export class BrowserEngine {
                 return;
             }
             // Refused and reported as any refusal is. Dropped rather than answered: the page that sent it is going or gone.
-            if (this.blockedRequests.length < 20)
-                this.blockedRequests.push({
-                    at: Date.now(),
-                    sig: `${method} ${url.slice(0, 140)}`,
-                    answered: false,
-                    why: verdict.why,
-                    type: (event.resourceType ?? "other").toLowerCase(),
-                });
+            this.noteBlocked({
+                at: Date.now(),
+                sig: `${method} ${url.slice(0, 140)}`,
+                answered: false,
+                why: verdict.why,
+                type: (event.resourceType ?? "other").toLowerCase(),
+            });
             this.logAction({ action: "write-policy:blocked", target: `${method} ${pathname}${verdict.why ? ` (${verdict.why})` : ""}`, url: this.page?.url() ?? "" });
             this.oracles.notePolicyBlock();
         }
@@ -2066,13 +2718,12 @@ export class BrowserEngine {
                 }
                 await answer(false);
                 try {
-                    if (this.blockedRequests.length < 20)
-                        this.blockedRequests.push({
-                            at: Date.now(),
-                            sig: `${method} ${url.slice(0, 140)}`,
-                            answered: false,
-                            type: (event.resourceType ?? "other").toLowerCase(),
-                        });
+                    this.noteBlocked({
+                        at: Date.now(),
+                        sig: `${method} ${url.slice(0, 140)}`,
+                        answered: false,
+                        type: (event.resourceType ?? "other").toLowerCase(),
+                    });
                     this.logAction({
                         action: "write-policy:blocked",
                         target: `${method} ${url.slice(0, 140)} (not judged: an error in the policy)`,
@@ -2086,39 +2737,26 @@ export class BrowserEngine {
             }
         }
     }
-    /** Report (and clear) write-policy blocks since the last action. */
+    /**
+     * Record a refused write for the next notice. Twenty are kept as they come;
+     * past that only an endpoint not already kept, up to sixty, so a page that
+     * beacons on every load cannot crowd out the block an action itself caused.
+     */
+    noteBlocked(entry) {
+        this.lastBlockAt = Math.max(this.lastBlockAt, entry.at);
+        const list = this.blockedRequests;
+        if (list.length < 20 || (list.length < 60 && !list.some((e) => blockSignature(e.sig) === blockSignature(entry.sig))))
+            list.push(entry);
+    }
+    /** Report (and clear) write-policy blocks since the last action: each endpoint in full once per session, then counted (BlockNotices). */
     drainBlocked() {
         this.lastActionBlocked = this.blockedRequests.length;
         if (this.blockedRequests.length === 0)
             return "";
-        const list = this.blockedRequests
-            .slice(0, 5)
-            .map((e) => this.lateMark(e))
-            .join("; ");
-        const extra = this.blockedRequests.length > 5 ? ` (+${this.blockedRequests.length - 5} more)` : "";
-        const answered = this.blockedRequests.some((e) => e.answered);
-        const reasons = new Set(this.blockedRequests.map((e) => e.why).filter((w) => !!w));
-        const escaped = reasons.delete(ESCAPE_REFUSAL);
-        const foreign = [...reasons];
+        const blocked = this.blockedRequests.map((e) => ({ sig: e.sig, late: e.at < this.actionStartedAt, answered: e.answered, why: e.why }));
         this.blockedRequests = [];
         // The rule that judged them, which just after a flow hands back is still the flow's (WriteRule).
-        const rule = this.writeRule.at();
-        return (`\n🛡 WRITE-POLICY blocked (${rule}): ${list}${extra}. ` +
-            `This is the tester's safety policy, NOT an app bug — do not file a finding for the resulting error UI. ` +
-            (foreign.length > 0
-                ? `Refused because it was ${foreign.join("; ")}: it would reach a site embedded in the page rather than the app, which no mode but destructive allows. `
-                : "") +
-            (escaped
-                ? `A move of the whole page off the app, with no Referer, was refused: a frame that held another site now sits on a data: or blob: URL, where WebKit drops the frame's sandbox, so the move may be that frame's. No mode but destructive allows it. `
-                : "") +
-            (answered
-                ? `The page's own requests were answered with a 403 in the server's place, so the page's handling of a refusal is real: an error message is correct, and a success message is a false_success violation. `
-                : "") +
-            (rule === "observe"
-                ? `observe mode blocks every request that is not a GET, so no form submission reaches the server. Re-attach with mode="read-only" ONLY if the user confirms that ordinary form submissions are acceptable on this target.`
-                : rule === "read-only"
-                    ? `Re-attach with mode="safe-write" to test create/edit flows, or "destructive" (user-approved disposable env only).`
-                    : `In safe-write, updates/deletes are only allowed on resources this session created (${this.createdResources.length} so far).`));
+        return this.blockNotices.notice(this.writeRule.at(), blocked, this.createdResources.length);
     }
     /** Once per session, in observe mode only: say that socket frames are outside the policy. */
     socketNotice() {
@@ -2198,7 +2836,7 @@ export class BrowserEngine {
         const clickCount = Math.max(1, Math.min(3, clicks));
         try {
             await locator.click({ timeout, clickCount });
-            return { forced: false };
+            return { forced: false, cover: null, coverReadAt: 0 };
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -2207,12 +2845,27 @@ export class BrowserEngine {
             const diagnostic = actionabilityDiagnostic(msg);
             if (!diagnostic || !/intercepts pointer events|is not stable/i.test(diagnostic))
                 throw err;
+            // What is on top at the click point, read before the forced click can
+            // change it (a toast the click dismisses). Only a name for the note: a
+            // read that fails leaves the note unnamed, never the click undone.
+            const cover = await locator.evaluate(readCoverAt, undefined, { timeout: FORCED_CLICK_TIMEOUT_MS }).catch(() => null);
+            // A block the forced click itself causes comes after the cover was there, so it cannot explain it.
+            const coverReadAt = Date.now();
             // A shorter budget here: the forced click skips the wait that
             // consumed the first `timeout`, so it needs very little of its own.
             await locator.click({ timeout: Math.min(timeout, FORCED_CLICK_TIMEOUT_MS), force: true, clickCount });
-            return { forced: true };
+            return { forced: true, cover, coverReadAt };
         }
     }
+    /**
+     * Whether the write policy refused a request between `since` and `until`
+     * (timestamps). Only the latest block is kept, so a later block outside the
+     * window hides an earlier one inside it: the note then stays unsuffixed.
+     */
+    blockedBetween(since, until) {
+        const at = this.lastBlockAt;
+        return at > 0 && at >= since && at <= until;
+    }
     /**
      * A form read (the inventory, or the probe before a submit), bounded by
      * FORM_READ_MS. This bookkeeping must never fail or stall the action, so a
@@ -2247,7 +2900,7 @@ export class BrowserEngine {
     }
     /** The form the focused element belongs to, for a key press that may submit through it. */
     probeFocusedForm() {
-        return this.formRead("form probe", this.requirePage().evaluate(formProbeExpression("document.activeElement")));
+        return this.formRead("form probe", this.requirePage().evaluate(FORM_PROBE_OF_ACTIVE_ELEMENT));
     }
     /**
      * A plan's pre-action state, fit to record a submit of this form against.
@@ -2295,13 +2948,20 @@ export class BrowserEngine {
             url: this.page?.url() ?? "",
         });
     }
-    async click(ref, clicks = 1) {
-        return this.withinLimit("action", () => this.clickNow(ref, clicks));
+    /** `leave` answers a leave confirmation the click raises (policy.ts dialogResponse); undefined lets the mode decide. */
+    async click(ref, clicks = 1, leave) {
+        this.leaveChoice = leave;
+        try {
+            return await this.withinLimit("action", () => this.clickNow(ref, clicks));
+        }
+        finally {
+            this.leaveChoice = undefined;
+        }
     }
     async clickNow(ref, clicks = 1) {
         const page = this.requirePage();
-        const { el, liveLabel } = await this.resolveForAction(ref);
-        const refusal = this.actionPolicyCheck(el, liveLabel);
+        const { el, liveLabel, live } = await this.resolveForAction(ref);
+        const refusal = this.actionPolicyCheck(el, liveLabel, live);
         if (refusal) {
             this.logAction({ action: "click:refused", target: liveLabel || el.name, url: page.url() });
             return refusal;
@@ -2314,16 +2974,24 @@ export class BrowserEngine {
         // Submit-shaped clicks that fire zero network requests are a smell
         // (silent no-op forms): capture the count before to compare after.
         const xhrBefore = this.xhrCount;
-        const submitLike = el.role === "button" && /submit|send|save|create|apply|subscribe|register|sign|post|add\b/i.test(el.name + " " + (el.testid ?? ""));
+        const submitLike = isSubmitLike(el.role, el.name, el.testid);
+        const clickContext = {
+            viaLink: el.role === "link",
+            urlBefore: page.url(),
+            dialogsBefore: this.claimBaseline?.dialogs ?? null,
+            claimsBefore: this.claimBaseline,
+        };
         const clickTarget = this.scopeOf(el).locator(`xpath=${el.xpath}`);
         // Read before the click: what the form's fields hold when it goes. Only a
         // button or an input can submit a form; nothing else is asked.
         const form = !el.frame && (el.tag === "button" || el.tag === "input") ? await this.probeForm(clickTarget) : null;
         const formState = { fp: this.currentFingerprint, elements: [...this.refs.values()] };
-        const { forced } = await this.resilientClick(clickTarget, this.limits.actionMs, clicks);
+        await this.readActedControl(el);
+        const { forced, cover, coverReadAt } = await this.resilientClick(clickTarget, this.limits.actionMs, clicks);
+        const coverNote = cover ? describeCover(cover, this.blockedBetween(this.snapshotAt, coverReadAt)) : null;
         this.memory.markExercised(this.currentFingerprint, el.key, clicks > 1 ? `click×${clicks}` : "click");
         this.noteFormSubmit(formState, "click", form);
-        const result = await this.afterAction(clicks > 1 ? `click×${clicks}` : "click", `${el.role} "${el.name}"`);
+        const result = await this.afterAction(clicks > 1 ? `click×${clicks}` : "click", `${el.role} "${el.name}"`, clickContext);
         // Impatient-user probe: a rapid multi-click that fires the SAME
         // state-changing request more than once means the action is not guarded
         // against double submission (button not disabled during flight, endpoint
@@ -2341,12 +3009,30 @@ export class BrowserEngine {
             return result + `\nℹ ${clicks}× rapid click fired no duplicate state-changing requests — double-submit appears guarded on this control.`;
         }
         const forcedNote = forced
-            ? `\nℹ NOTE: the strict click timed out waiting for this element to be the stable, unobstructed top hit at its coordinates, so a forced click was used instead (which still landed — this succeeded). Something is likely rendered on top of it (an icon, a decorative layer, an animating wrapper) or it delegates via a label; cross-check against any GEOMETRY overlap on this element before treating that as a real bug.`
+            ? `\nℹ NOTE: the strict click timed out waiting for this element to be the stable, unobstructed top hit at its coordinates, so a forced click was used instead (which still landed — this succeeded). ` +
+                (coverNote
+                    ? `At its centre it is ${coverNote}; look at that element before treating this as a layout bug.`
+                    : `Something is likely rendered on top of it (an icon, a decorative layer, an animating wrapper) or it delegates via a label; cross-check against any GEOMETRY overlap on this element before treating that as a real bug.`)
             : "";
         // Not when the write policy blocked the submission: a native form POST or a
         // beacon is not counted as xhr/fetch, so an aborted one looks exactly like
         // "fired nothing" — and the note would blame the app for the tool's block.
-        if (submitLike && this.xhrCount === xhrBefore && this.lastActionBlocked === 0 && page.url() === this.snapshotUrl) {
+        if (submitLike && this.xhrCount === xhrBefore && this.lastActionBlocked === 0 && page.url() === clickContext.urlBefore) {
+            // A client-side router can move the page just after the request-based
+            // settle, with no request for it to wait on: watch the URL before
+            // calling the click silent, and look at the requests again after.
+            const landed = await this.stableUrl();
+            if (landed !== clickContext.urlBefore)
+                return result + `\nℹ The page then moved client-side to ${landed} (take a new snapshot).` + forcedNote;
+            if (this.xhrCount !== xhrBefore)
+                return result + forcedNote;
+            // The page may have answered without a request: a dialog, or validation saying what is missing (claims.ts quietAnswer).
+            // A native alert is not a step: alert("Saved!") with nothing sent is the very case the note is for.
+            const answer = this.nativeQuestionAt >= this.actionStartedAt ? "dialog" : quietAnswer(clickContext.claimsBefore, await this.readClaims(page));
+            if (answer === "dialog")
+                return result + `\nℹ The click opened a dialog (a step, not a submit), so no request was expected yet.` + forcedNote;
+            if (answer === "validation")
+                return result + `\nℹ Client-side validation answered (no request expected).` + forcedNote;
             return (result +
                 `\nℹ NOTE: this submit-style click fired ZERO network requests and no navigation — if the UI showed success, the data may have been silently discarded (worth verifying; category: other/silent-failure).` +
                 forcedNote);
@@ -2369,20 +3055,33 @@ export class BrowserEngine {
         try {
             state = (await locator.evaluate((node) => {
                 const n = node;
+                const type = n.tagName === "INPUT" ? n.type.toLowerCase() : "";
                 if (n.isContentEditable)
-                    return { existing: (n.innerText || n.textContent || "").trim(), caretAppendable: true };
+                    return { existing: (n.innerText || n.textContent || "").trim(), caretAppendable: true, type };
                 if (typeof n.value === "string") {
                     // selectionStart is null on number/date/email-style inputs — caret
                     // placement is unsupported there, so append must go via fill().
-                    return { existing: n.value, caretAppendable: typeof n.selectionStart === "number" };
+                    return { existing: n.value, caretAppendable: typeof n.selectionStart === "number", type };
                 }
-                return { existing: "", caretAppendable: false };
+                return { existing: "", caretAppendable: false, type };
             }, undefined, { timeout: this.limits.actionMs }));
         }
         catch (err) {
             throw new Error(`Could not read the field's existing content before typing — aborting rather than risk overwriting it (${err instanceof Error ? err.message.split("\n")[0] : err}). Take a new scout_snapshot and retry.`);
         }
-        const { existing, caretAppendable } = state;
+        const { existing, caretAppendable, type } = state;
+        if (APP_FILLED_TYPES.has(type)) {
+            // A date or time field holds one value in one format: anything else is
+            // refused by the browser as a bare "Malformed value", and appending to
+            // what it holds can only produce that. So the value is put in the
+            // field's format, or refused naming it, and always replaces.
+            const date = normaliseDateValue(type, text);
+            if ("refused" in date)
+                throw new Error(`Not typed: ${date.refused}`);
+            await locator.fill(date.value, { timeout: this.limits.actionMs });
+            return ((date.note ? ` (${date.note})` : "") +
+                (existing && existing !== date.value ? ` (replaced existing content ${JSON.stringify(existing.slice(0, 60))}: a ${type} field holds one value)` : ""));
+        }
         if (replace || !existing || text === "") {
             await locator.fill(text, { timeout: this.limits.actionMs });
             return existing && (replace || text === "") ? ` (replaced existing content ${JSON.stringify(existing.slice(0, 60))})` : "";
@@ -2424,14 +3123,14 @@ export class BrowserEngine {
     }
     async typeNow(ref, text, pressEnter = false, replace = false) {
         const page = this.requirePage();
-        const { el, liveLabel } = await this.resolveForAction(ref);
+        const { el, liveLabel, live } = await this.resolveForAction(ref);
         if (el.role === "file") {
             // fill() refuses a file input — and it used to refuse with a stack
             // trace, leaving every upload form stranded. Point at the tool that can.
             return (`${ref} is a file input ("${el.name || el.testid || "unnamed"}") — text cannot be typed into it. ` +
                 `Use scout_upload {ref:"${ref}"}: a small valid fixture is generated and matched to the input's accept attribute, or pass fixture / filePath.`);
         }
-        const refusal = this.actionPolicyCheck(el, liveLabel);
+        const refusal = this.actionPolicyCheck(el, liveLabel, live);
         if (refusal)
             return refusal;
         const embed = this.foreignEmbedOf(el);
@@ -2494,7 +3193,7 @@ export class BrowserEngine {
         if (opts.ref) {
             const resolved = await this.resolveForAction(opts.ref);
             el = resolved.el;
-            const refusal = this.actionPolicyCheck(el, resolved.liveLabel);
+            const refusal = this.actionPolicyCheck(el, resolved.liveLabel, resolved.live);
             if (refusal)
                 return refusal;
             const embed = this.foreignEmbedOf(el);
@@ -2634,7 +3333,8 @@ export class BrowserEngine {
     async measureLayout(page, elements, url) {
         const viewport = page.viewportSize() ?? { width: 1280, height: 900 };
         const byDocument = new Map();
-        for (const el of elements) {
+        // A live region is a message, not a control: its box overlapping a control is not a collision.
+        for (const el of trackedElements(elements)) {
             const doc = el.frame ? el.key.slice(0, el.key.indexOf("|") + 1) : "";
             byDocument.set(doc, [...(byDocument.get(doc) ?? []), el]);
         }
@@ -2742,44 +3442,77 @@ export class BrowserEngine {
                 ? `\nRevealed on hover:\n${notes.map((t) => `  · ${t}`).join("\n")}${caveat}`
                 : `\n(no tooltip, overlay, or new page text appeared within ${HOVER_REVEAL_WINDOW_MS / 1000}s — this element reveals nothing on hover${churning ? "; page content was changing on its own, so the text-diff fallback was suppressed" : ""}${this.headed ? ". NOTE: in headed mode the PHYSICAL mouse cursor competes with the synthetic pointer — if it is resting over the browser window, hover warm-ups are cancelled; ask the user to move it off the window and retry" : ""})`));
     }
-    /** Record a dropdown's options and the ones picked, by the values selectOption reported. */
+    /**
+     * The label of the option a select step picks, matched as selectOption
+     * matches it (value or label). Empty when none matches; null when it could
+     * not be read, which the caller refuses, since the pick cannot be vetted.
+     */
+    static async chosenOptionLabel(loc, value) {
+        if (value === undefined)
+            return "";
+        return loc
+            .evaluate((node, v) => {
+            const opts = Array.from(node.options ?? []);
+            const o = opts.find((x) => x.value === v || x.label === v || (x.textContent || "").trim() === v);
+            return o ? (o.label || o.textContent || "").trim().slice(0, 120) : "";
+        }, value)
+            .catch(() => null);
+    }
+    /**
+     * What a select is asked to pick, settled against the dropdown's options
+     * BEFORE the pick (forms.ts matchOption): a value naming no option, or more
+     * than one, is refused at once instead of waiting out the action limit. The
+     * pick goes by index, so the option chosen is the one matched. A control
+     * whose options cannot be read (not a native select) keeps selectOption's
+     * own matching, and its label as chosenOptionLabel reads it.
+     */
+    static async resolveSelectPick(loc, value) {
+        const options = await loc.evaluate(listSelectOptions, undefined, { timeout: 1000 }).catch(() => null);
+        if (!options)
+            return { arg: value, label: await BrowserEngine.chosenOptionLabel(loc, value), option: null };
+        const match = matchOption(options, value);
+        if ("refused" in match)
+            return match;
+        return { arg: { index: match.index }, label: match.option.label, option: match.option };
+    }
+    /** Record a dropdown's options, the one it held before, and the ones picked, by the values selectOption reported. */
     recordSelectChoice(fingerprint, key, options, picked) {
         const labels = options.map((o) => o.label);
+        const loaded = options.filter((o) => o.selected).map((o) => o.label);
         const chosen = picked.map((v) => options.find((o) => o.value === v)?.label).filter((l) => !!l);
         if (chosen.length === 0)
-            this.memory.recordSelectChoice(fingerprint, key, labels, "");
+            this.memory.recordSelectChoice(fingerprint, key, labels, "", loaded);
         for (const label of chosen)
-            this.memory.recordSelectChoice(fingerprint, key, labels, label);
+            this.memory.recordSelectChoice(fingerprint, key, labels, label, loaded);
     }
     async select(ref, value) {
         return this.withinLimit("action", () => this.selectNow(ref, value));
     }
     async selectNow(ref, value) {
         const page = this.requirePage();
-        const { el, liveLabel } = await this.resolveForAction(ref);
-        const refusal = this.actionPolicyCheck(el, liveLabel);
+        const { el, liveLabel, live } = await this.resolveForAction(ref);
+        const refusal = this.actionPolicyCheck(el, liveLabel, live);
         if (refusal)
             return refusal;
-        if (this.readOnly) {
-            // Bulk-action dropdowns fire on change — vet the chosen option itself.
-            const optionLabel = (await this.scopeOf(el)
-                .evaluate(`(() => { const node = ${xpathLookup(el.xpath)}; if (!node) return ''; const v = ${JSON.stringify(value)}; ` +
-                `const opts = Array.from(node.options || []); ` +
-                `const o = opts.find(o => o.value === v || o.label === v || (o.textContent || '').trim() === v); ` +
-                `return o ? (o.label || o.textContent || '').trim().slice(0, 120) : ''; })()`)
-                .catch(() => ""));
-            if (isDestructive(value) || isDestructive(optionLabel)) {
-                this.logAction({ action: "select:refused", target: optionLabel || value, url: page.url() });
-                return destructiveRefusal(optionLabel || value, this.mode);
-            }
-        }
         const loc = this.scopeOf(el).locator(`xpath=${el.xpath}`);
+        const pick = await BrowserEngine.resolveSelectPick(loc, value);
+        if ("refused" in pick) {
+            this.logAction({ action: "select:no-match", target: `${el.name || el.testid || "dropdown"}: ${value}`.slice(0, 200), url: page.url() });
+            return `NOT SELECTED: ${pick.refused} Nothing was changed.`;
+        }
+        // Bulk-action dropdowns fire on change — vet the chosen option itself. The
+        // dropdown is not judged by its options (destructiveLabelOf), so the pick is the check: one that cannot be read is refused.
+        if (this.readOnly && pickIsDestructive(value, el.testid, pick.label)) {
+            this.logAction({ action: "select:refused", target: pick.label || value, url: page.url() });
+            return destructiveRefusal(pick.label || value, this.mode);
+        }
         const options = el.tag === "select" ? await readSelectOptions(loc) : null;
-        const picked = await loc.selectOption(value, { timeout: this.limits.actionMs });
+        const picked = await loc.selectOption(pick.arg, { timeout: this.limits.actionMs });
         this.memory.markExercised(this.currentFingerprint, el.key, "select");
         if (options)
             this.recordSelectChoice(this.currentFingerprint, el.key, options, picked);
-        return this.afterAction("select", `${el.role} "${el.name}" = ${value}`);
+        const matched = pick.option && pick.option.value !== value ? ` (matched option ${JSON.stringify(pick.option.value)}, labelled ${JSON.stringify(pick.option.label)})` : "";
+        return this.afterAction("select", `${el.role} "${el.name}" = ${value}${matched}`);
     }
     /**
      * Enter/Space activate the focused element — apply the same destructive
@@ -2848,6 +3581,7 @@ export class BrowserEngine {
     async pressNow(key) {
         this.actionStartedAt = Date.now();
         const page = this.requirePage();
+        await this.beginInput();
         const refusal = await this.vetFocusedActivation(key);
         if (refusal)
             return refusal;
@@ -2909,17 +3643,66 @@ export class BrowserEngine {
             return false;
         }
     }
-    async navigate(target) {
+    /** `leave` answers a leave confirmation the page raises (policy.ts dialogResponse); undefined lets the mode decide. */
+    async navigate(target, leave) {
+        this.leaveChoice = leave;
+        try {
+            return await this.navigateNow(target);
+        }
+        finally {
+            this.leaveChoice = undefined;
+            this.onLeaveRefused = null;
+        }
+    }
+    async navigateNow(target) {
         this.actionStartedAt = Date.now();
         const page = this.requirePage();
-        const url = target.startsWith("http") ? target : `${this.baseUrl}${target.startsWith("/") ? "" : "/"}${target}`;
-        if (!this.isSameOrigin(url)) {
-            return `REFUSED: ${url} is outside the attached origin (${this.baseUrl}). Exploration is fenced to the app under test.`;
-        }
+        // A path resolves against the origin, not the page the session attached on (request.ts resolveTarget).
+        const resolved = resolveTarget(this.baseUrl, target);
+        if (!("url" in resolved)) {
+            return resolved.offOrigin
+                ? `REFUSED: ${target.trim()} is outside the attached origin (${new URL(this.baseUrl).origin}). Exploration is fenced to the app under test.`
+                : `REFUSED: ${resolved.problem}`;
+        }
+        const url = resolved.url;
         // A notice describes ONE navigation. Clearing up front means a notice left
         // undelivered by a previous throw can never prepend itself to this result.
         this.authLoss.clear();
-        await this.withinLimit("nav", () => page.goto(url, { waitUntil: "domcontentloaded", timeout: this.limits.navMs }));
+        // A page holding unsent input can ask to confirm leaving. Answered "stay",
+        // the navigation is cancelled, which a browser reports as an aborted load
+        // (or, in some engines, never reports at all), so the answer itself ends
+        // the wait and the result says what happened instead of ERR_ABORTED.
+        // Only a confirmation raised by this navigation explains its failure, not one left over from before it.
+        const dialogsBefore = this.dialogsSeen.length;
+        const stayed = new Promise((resolve) => {
+            this.onLeaveRefused = () => resolve("stayed");
+        });
+        const going = this.withinLimit("nav", () => page.goto(url, { waitUntil: "domcontentloaded", timeout: this.limits.navMs }));
+        let outcome;
+        try {
+            outcome = await Promise.race([going.then(() => "went"), stayed]);
+        }
+        catch (err) {
+            if (!this.leaveRefused(dialogsBefore))
+                throw err;
+            outcome = "stayed";
+        }
+        finally {
+            this.onLeaveRefused = null;
+        }
+        if (outcome === "stayed") {
+            // The cancelled load settles on its own; its error is the cancellation this result reports.
+            going.catch((err) => {
+                this.logAction({
+                    action: "navigate:cancelled",
+                    target: err instanceof Error ? err.message.split("\n")[0].slice(0, 160) : String(err),
+                    url: page.url(),
+                });
+            });
+            // Not a navigation outcome: the session stayed by its own answer, so nothing is recorded for the auth-loss tracker.
+            const result = await this.afterAction("navigate", url);
+            return result.replace(/^OK: navigate /, "NOT NAVIGATED: ");
+        }
         // Settle BEFORE judging where we landed. A client-side auth guard redirects
         // after hydration, not during goto, so reading page.url() here showed the
         // requested path and the bounce went unnoticed — which is precisely how a
@@ -3028,8 +3811,9 @@ export class BrowserEngine {
      * Replace this context's cookies and storage with a profile, in place: same
      * pages, listeners and policy. Playwright is handed only what it restores;
      * the profile's sessionStorage list is not part of its storage state.
+     * With `load` "cookies" only the cookie jar is replaced (profileLoadWhileHeld, refresh.ts).
      */
-    async applyState(state) {
+    async applyState(state, load = "storage") {
         if (!this.context)
             return { ok: false, why: "no browser is open" };
         let storageState;
@@ -3039,8 +3823,15 @@ export class BrowserEngine {
         catch (err) {
             return { ok: false, why: `the saved profile could not be split (${err instanceof Error ? err.message : String(err)})` };
         }
+        const playwrightState = storageState;
         try {
-            await this.context.setStorageState(storageState);
+            if (load === "cookies") {
+                await this.context.clearCookies();
+                await this.context.addCookies(playwrightState.cookies ?? []);
+            }
+            else {
+                await this.context.setStorageState(playwrightState);
+            }
         }
         catch (err) {
             return { ok: false, why: `the browser refused its saved profile (${err instanceof Error ? err.message.split("\n")[0] : String(err)})` };
@@ -3051,113 +3842,352 @@ export class BrowserEngine {
         return { ok: true };
     }
     /**
-     * The refresh broker's route handler. A request carrying none of the role's
-     * refresh tokens is handed on untouched. One carrying one waits for the
-     * role's refresh lock; holding it, the session re-reads the profile, loads
-     * it and sends the current token in place of a spent one when another
-     * session rotated it meanwhile, and keeps the lock until the page has
-     * stored the rotation and it is written back. A lock that cannot be had is
-     * reported and the request dropped: sending a token another session may
-     * have spent is what revokes the family. Token values are never logged.
+     * The refresh broker's route handler, run after the write policy has let a
+     * request out. brokerDecision (refresh.ts) says which requests are refresh
+     * calls; every other request goes on untouched, and a static asset is
+     * decided before the first await so it is never held back. A refresh waits
+     * for the role's lock; holding it, the session re-reads the profile, and
+     * when another session has rotated the token meanwhile it loads that
+     * profile and sends the current token in place of the spent one. The lock
+     * is kept until the rotation is written back. Whatever goes wrong here, the
+     * request goes on as the page sent it, with a line in the action log: an
+     * app whose requests fail is worse than the rare double refresh. Token
+     * values are never logged.
      */
     async brokerRefresh(route) {
-        const broker = this.refresh;
         const req = route.request();
-        if (!broker)
-            return route.fallback();
-        const headers = await req.allHeaders().catch(() => req.headers());
-        const wire = { url: req.url(), body: req.postData(), headers };
-        // Spent tokens too: a page still holding one would otherwise send it unbrokered.
-        const sent = presentedToken(wire, [...broker.known, ...broker.spent]);
-        if (!sent)
-            return route.fallback();
-        const where = `${req.method()} ${pathnameOf(req.url())}`;
+        const broker = this.refresh;
+        const method = req.method();
+        if (!broker || isStaticAsset(method, req.resourceType()))
+            return this.passOn(route);
+        const where = `${method} ${pathnameOf(req.url())}`;
+        let decision;
+        try {
+            const tokens = [...broker.known, ...broker.spent];
+            const learned = this.learnedEndpoints();
+            const base = { method, url: req.url(), resourceType: req.resourceType(), body: req.postData() };
+            decision = brokerDecision({ ...base, headers: req.headers() }, tokens, learned);
+            // The Cookie header is read only for a request it could make a refresh call:
+            // a refresh cookie scoped to "/" rides on every request the page makes.
+            if (decision.kind === "pass" && decision.why === "no known token" && cookieMayCount(method, base.url, learned)) {
+                decision = brokerDecision({ ...base, headers: await this.withCookieHeader(req) }, tokens, learned);
+            }
+        }
+        catch (err) {
+            return this.unbrokered(route, where, err);
+        }
+        if (decision.kind === "pass")
+            return this.passOn(route);
         let lock;
         try {
             lock = await acquireLock(lockPathFor(broker.file));
         }
         catch (err) {
-            this.refreshCounts.failed += 1;
-            this.logAction({
-                action: "refresh-broker:dropped",
-                target: `${where} (${err instanceof Error ? err.message : String(err)})`,
-                url: this.page?.url() ?? "",
-            });
-            await route.abort("blockedbyclient").catch(() => { });
-            return;
+            return this.unbrokered(route, where, err);
         }
+        this.brokeredRequests.add(req);
+        const sent = decision.sent;
         let handedOn = false;
         try {
             const read = this.readRoleProfile();
             if (!read.ok)
                 throw new Error(read.why);
             const plan = planRefresh(sent, refreshTokenSlots(read.state));
-            let presented = sent;
-            let overrides = {};
-            if (plan.kind === "swap") {
-                // Another session rotated the token while this one waited: load what it saved, and send the current token.
-                const applied = await this.applyState(read.state);
-                if (!applied.ok)
-                    throw new Error(applied.why);
-                const swapped = swapRequest(wire, sent.value, plan.to.value);
-                overrides = {
+            if (plan.kind === "unknown") {
+                // The profile holds another sign-in now: send this one on, and leave the profile alone.
+                this.logAction({ action: "refresh-broker", target: `${where} with ${sent.slot} (no longer in the profile; sent as is)`, url: this.page?.url() ?? "" });
+                handedOn = true;
+                lock.release();
+                return this.passOn(route);
+            }
+            if (plan.kind === "send") {
+                this.logAction({ action: "refresh-broker", target: `${where} with ${sent.slot}`, url: this.page?.url() ?? "" });
+                handedOn = true;
+                this.trackRefreshTask(this.writeBackAfter(this.pageAnswer(req), sent, lock, false));
+                return this.passOn(route);
+            }
+            // Another session rotated the token while this one waited: load what it saved, and send the current token.
+            const loaded = profileLoadWhileHeld(req.isNavigationRequest());
+            const applied = await this.applyState(read.state, loaded);
+            if (!applied.ok)
+                throw new Error(applied.why);
+            this.refreshCounts.swapped += 1;
+            const all = await req.allHeaders();
+            const cookieLine = Object.entries(all).find(([name]) => name.toLowerCase() === "cookie")?.[1] ?? "";
+            const swapped = swapRequest({ url: req.url(), body: req.postData(), headers: all }, sent.value, plan.to.value);
+            if (swapToken(cookieLine, sent.value, plan.to.value) === cookieLine) {
+                // Not in the Cookie header the request shows: a route override carries a token
+                // in its body, URL or headers, and a browser that adds cookies after this
+                // handler (WebKit) takes them from the jar the profile was just loaded into.
+                this.logAction({
+                    action: "refresh-broker",
+                    target: `${where} with ${plan.to.slot} (rotated by another session; loaded its profile)`,
+                    url: this.page?.url() ?? "",
+                });
+                handedOn = true;
+                // Reported once the request goes out with the current token, so a swap that then fails is reported only as a failure.
+                this.refreshEvents.push("swapped");
+                this.trackRefreshTask(this.writeBackAfter(this.pageAnswer(req), plan.to, lock, true, writeBackStorageFrom(loaded, plan.to)));
+                return this.passOn(route, {
                     ...(swapped.url ? { url: swapped.url } : {}),
                     ...(swapped.body !== undefined ? { postData: swapped.body } : {}),
-                    ...(swapped.headers ? { headers: swapped.headers } : {}),
-                };
-                presented = plan.to;
-                this.refreshCounts.swapped += 1;
+                    ...(swapped.headers ? { headers: headersForResend(swapped.headers, null) } : {}),
+                });
+            }
+            // In the Cookie header, which a browser keeps as it built it whatever a
+            // route override says: the broker sends the request itself and answers
+            // the page with the response. Only a script's request; anything else
+            // goes on as the page sent it.
+            handedOn = true;
+            const type = req.resourceType();
+            if (type !== "fetch" && type !== "xhr") {
+                lock.release();
+                return this.unbrokered(route, where, new Error(`the spent token is in its Cookie header, and a ${type} request is not one the broker answers itself`));
+            }
+            let response;
+            try {
+                response = await route.fetch({
+                    ...(swapped.url ? { url: swapped.url } : {}),
+                    ...(swapped.body !== undefined ? { postData: swapped.body } : {}),
+                    headers: headersForResend(swapped.headers ?? all, swapToken(cookieLine, sent.value, plan.to.value)),
+                    maxRedirects: 0,
+                });
+            }
+            catch (err) {
+                lock.release();
+                return this.unbrokered(route, where, err);
             }
             this.logAction({
                 action: "refresh-broker",
-                target: `${where} with ${presented.slot}${plan.kind === "swap" ? " (rotated by another session; loaded its profile)" : plan.kind === "unknown" ? " (no longer in the profile; sent as is)" : ""}`,
+                target: `${where} with ${plan.to.slot} (rotated by another session; loaded its profile and sent the current cookie)`,
                 url: this.page?.url() ?? "",
             });
-            handedOn = true;
-            if (plan.kind === "unknown") {
-                // The profile holds another sign-in now: send this one on, and leave the profile alone.
-                lock.release();
-                await route.fallback(overrides);
+            this.refreshEvents.push("swapped");
+            // The response's cookies are already in the browser's jar, so the write-back does not wait on the page.
+            this.trackRefreshTask(this.writeBackAfter(Promise.resolve(BrowserEngine.fetchedAnswer(response)), plan.to, lock, true));
+            await route.fulfill({ response }).catch(() => {
+                /* the page went away before its answer: the rotation is still saved */
+            });
+        }
+        catch (err) {
+            if (handedOn) {
+                this.logAction({
+                    action: "refresh-broker:error",
+                    target: `${where} (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`,
+                    url: this.page?.url() ?? "",
+                });
                 return;
             }
-            const task = this.writeBackAfter(req, presented, lock).finally(() => this.refreshTasks.delete(task));
-            this.refreshTasks.add(task);
-            await route.fallback(overrides);
+            lock.release();
+            return this.unbrokered(route, where, err);
+        }
+    }
+    /**
+     * A request's headers with the Cookie header it will be sent with. Some
+     * browsers (WebKit) add cookies only after the route handler has run, so
+     * when the request shows none, the line is built from the browser's jar
+     * for that URL, which is what will be sent.
+     */
+    async withCookieHeader(req) {
+        const headers = await req.allHeaders();
+        if (Object.keys(headers).some((name) => name.toLowerCase() === "cookie") || !this.context)
+            return headers;
+        const jar = await this.context.cookies(req.url());
+        return jar.length > 0 ? { ...headers, cookie: jar.map((c) => `${c.name}=${c.value}`).join("; ") } : headers;
+    }
+    /** Hand a request on as it is, or with overrides. A request the page has already cancelled rejects this; nothing is left to send then. */
+    async passOn(route, overrides) {
+        await route.fallback(overrides).catch(() => { });
+    }
+    /** The broker could not do its job for this request: it goes on as the page sent it, and the action log says why. */
+    async unbrokered(route, where, err) {
+        this.refreshCounts.failed += 1;
+        this.refreshEvents.push("failed");
+        // Unbrokered after all: if its response rotates the cookie, the rotation watcher saves it.
+        this.brokeredRequests.delete(route.request());
+        this.logAction({
+            action: "refresh-broker:unbrokered",
+            target: `${where} sent as the page sent it (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`,
+            url: this.page?.url() ?? "",
+        });
+        return this.passOn(route);
+    }
+    /** Track a write-back so close() waits for it to release the role's lock. */
+    trackRefreshTask(task) {
+        const tracked = task.finally(() => this.refreshTasks.delete(tracked));
+        this.refreshTasks.add(tracked);
+    }
+    /** The page's response to a request, or null if none came in 30 seconds. */
+    pageAnswer(req) {
+        let timer;
+        const answered = req
+            .response()
+            .then((res) => res ? { ok: res.ok(), status: res.status(), text: () => res.text(), setCookies: () => res.headerValues("set-cookie") } : null)
+            .finally(() => clearTimeout(timer));
+        return Promise.race([answered, new Promise((resolve) => (timer = setTimeout(() => resolve(null), 30000)))]);
+    }
+    /** A response the broker fetched itself, read the way the write-back reads one. */
+    static fetchedAnswer(res) {
+        return {
+            ok: res.ok(),
+            status: res.status(),
+            text: () => res.text(),
+            setCookies: async () => res
+                .headersArray()
+                .filter((h) => h.name.toLowerCase() === "set-cookie")
+                .map((h) => h.value),
+        };
+    }
+    /**
+     * The endpoints learned to rotate the role's token: this session's, and
+     * those any session of the role saved beside the profile, re-read at most
+     * twice a second and only when the file changed.
+     */
+    learnedEndpoints() {
+        const broker = this.refresh;
+        if (!broker)
+            return new Set();
+        const now = Date.now();
+        if (now - broker.learnedCheckedAt < 500)
+            return broker.learned;
+        broker.learnedCheckedAt = now;
+        const file = endpointsPathFor(broker.file);
+        try {
+            const mtimeMs = fs.statSync(file).mtimeMs;
+            if (mtimeMs !== broker.learnedMtimeMs) {
+                broker.learnedMtimeMs = mtimeMs;
+                for (const key of readLearnedEndpoints(file))
+                    broker.learned.add(key);
+            }
         }
         catch (err) {
-            if (!handedOn) {
-                lock.release();
-                this.refreshCounts.failed += 1;
+            // No file yet means nothing learned yet. Any other error keeps what this session already knows.
+            if (err.code !== "ENOENT")
                 this.logAction({
-                    action: "refresh-broker:dropped",
-                    target: `${where} (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`,
+                    action: "refresh-broker:error",
+                    target: `could not read the learned endpoints (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`,
+                    url: "",
+                });
+        }
+        return broker.learned;
+    }
+    /**
+     * A response that replaced the role's refresh cookie with a new token on a
+     * request the broker did not take the lock for: that endpoint rotates the
+     * token. It is learned, for this session at once and for every session of
+     * the role through the file beside the profile, so the next call to it is
+     * brokered; and the rotation is written back, so the other sessions do not
+     * go on presenting the token this one spent. Only a POST, PUT or PATCH is
+     * learned, and never a sign-in, sign-up or sign-out (learnableEndpoint).
+     */
+    watchRotation(res) {
+        const broker = this.refresh;
+        if (!broker || !broker.known.some((t) => t.cookie !== undefined))
+            return;
+        const req = res.request();
+        // A GET is never learned: a server that re-issues the cookie on its reads would otherwise put them all behind the lock.
+        const method = req.method();
+        if (method !== "POST" && method !== "PUT" && method !== "PATCH")
+            return;
+        if (this.brokeredRequests.has(req) || !res.ok() || !learnableEndpoint(req.url()))
+            return;
+        this.trackRefreshTask((async () => {
+            const rotated = rotatedCookies(await res.headerValues("set-cookie"), broker.known);
+            if (rotated.length > 0)
+                await this.adoptRotation(endpointKey(req.method(), req.url()), rotated);
+        })().catch((err) => {
+            this.logAction({
+                action: "refresh-broker:error",
+                target: `${pathnameOf(req.url())}: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
+                url: this.page?.url() ?? "",
+            });
+        }));
+    }
+    /** Learn an endpoint seen to rotate the token, and write the rotation back if the profile still holds the token it replaced. */
+    async adoptRotation(key, rotated) {
+        const broker = this.refresh;
+        if (!broker)
+            return;
+        const isNew = !broker.learned.has(key);
+        broker.learned.add(key);
+        if (isNew) {
+            this.refreshCounts.learned += 1;
+            this.refreshEvents.push("learned");
+        }
+        const names = rotated.map((r) => r.slot).join(", ");
+        let lock;
+        try {
+            lock = await acquireLock(lockPathFor(broker.file));
+        }
+        catch (err) {
+            this.logAction({
+                action: "refresh-broker:learned",
+                target: `${key} rotates ${names}; not saved (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`,
+                url: this.page?.url() ?? "",
+            });
+            return;
+        }
+        try {
+            const file = endpointsPathFor(broker.file);
+            const list = readLearnedEndpoints(file);
+            if (!list.includes(key))
+                writeLearnedEndpoints(file, withLearnedEndpoint(list, key));
+            const read = this.readRoleProfile();
+            if (!read.ok)
+                throw new Error(read.why);
+            const current = refreshTokenSlots(read.state);
+            // Only over the token this session spent: a profile another session moved on since is left as it is.
+            const stillSpent = rotated.every((r) => current.some((c) => c.slot === r.slot && c.value === r.value));
+            let now = undefined;
+            // The jar takes the Set-Cookie as the response arrives; a short wait covers a browser that is a moment behind.
+            for (let waited = 0; stillSpent && waited <= 1000; waited += 50) {
+                const state = await this.context?.storageState().catch(() => undefined);
+                if (state && rotated.every((r) => rotationStored(state, r))) {
+                    now = await this.withPageIndexedDB(state, (full) => rotated.every((r) => rotationStored(full, r)));
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            if (now) {
+                const state = profileAfterRotation(now, read.state);
+                writeProfile(broker.projectDir, broker.role, state);
+                this.rememberTokens(refreshTokenSlots(state));
+                this.logAction({
+                    action: "refresh-broker:learned",
+                    target: `${key} rotates ${names}; saved to the profile, and brokered from now on`,
+                    url: this.page?.url() ?? "",
+                });
+            }
+            else {
+                this.logAction({
+                    action: "refresh-broker:learned",
+                    target: `${key} rotates ${names}; brokered from now on (${stillSpent ? "the browser had not stored the new token" : "the profile already holds another token"}, so the profile was left as it is)`,
                     url: this.page?.url() ?? "",
                 });
-                await route.abort("blockedbyclient").catch(() => { });
             }
         }
+        finally {
+            lock.release();
+        }
     }
     /**
      * Once the refresh is answered, write the rotation back over the profile
      * and release the lock. The page's own state is saved once it holds the
      * rotated token, so the next session gets the access token with it; a page
      * that has not stored it in time has the token read from the response
-     * instead. A refused or failed refresh changes nothing on disk.
+     * instead. A refused or failed refresh changes nothing on disk, and nor does
+     * one whose response left a refresh cookie as it was (a server that does
+     * not rotate refresh tokens). `storageFrom` says whether the origins'
+     * storage written back is the page's or stays the profile's (writeBackStorageFrom, refresh.ts).
      */
-    async writeBackAfter(req, presented, lock) {
+    async writeBackAfter(answer, presented, lock, swapped, storageFrom = "page") {
         const broker = this.refresh;
         try {
-            let timer;
-            const res = await Promise.race([
-                req.response().finally(() => clearTimeout(timer)),
-                new Promise((resolve) => {
-                    timer = setTimeout(() => resolve(null), 30000);
-                }),
-            ]);
+            const res = await answer;
             if (!broker)
                 return;
-            if (!res || !res.ok()) {
-                const why = res ? `answered ${res.status()}` : "had no response";
+            if (!res || !res.ok) {
+                const why = res ? `answered ${res.status}` : "had no response";
                 this.logAction({
                     action: "refresh-broker:not-saved",
                     target: `${presented.slot}: the refresh ${why}; the profile was left as it was`,
@@ -3166,24 +4196,36 @@ export class BrowserEngine {
                 return;
             }
             let state = null;
-            for (let waited = 0; waited <= 5000; waited += 50) {
+            // A cookie is in the browser's jar by the time the response is; a token the page stores itself can take longer.
+            const patienceMs = presented.cookie !== undefined ? 1000 : 5000;
+            for (let waited = 0; waited <= patienceMs; waited += 50) {
                 const now = await this.context?.storageState().catch(() => null);
                 if (now && rotationStored(now, presented)) {
+                    const full = await this.withPageIndexedDB(now, (read) => rotationStored(read, presented));
                     const onDisk = this.readRoleProfile();
-                    state = profileAfterRotation(now, onDisk.ok ? onDisk.state : null);
+                    state = profileAfterRotation(full, onDisk.ok ? onDisk.state : null, storageFrom);
                     break;
                 }
                 await new Promise((r) => setTimeout(r, 50));
             }
             if (!state) {
                 const body = await res.text().catch(() => "");
-                const rotated = rotatedFromResponse(body, await res.headerValues("set-cookie").catch(() => []));
+                const rotated = rotatedFromResponse(body, await res.setCookies().catch(() => []));
                 const read = this.readRoleProfile();
                 if (rotated && read.ok)
                     state = swapProfileToken(read.state, presented.value, rotated);
             }
+            if (!state && presented.cookie !== undefined) {
+                this.logAction({
+                    action: "refresh-broker:unrotated",
+                    target: `${presented.slot}: the response kept it as it was; nothing to save`,
+                    url: this.page?.url() ?? "",
+                });
+                return;
+            }
             if (!state) {
                 this.refreshCounts.failed += 1;
+                this.refreshEvents.push("failed");
                 this.logAction({
                     action: "refresh-broker:not-saved",
                     target: `${presented.slot}: the page stored no rotated token and the response named none`,
@@ -3194,9 +4236,13 @@ export class BrowserEngine {
             writeProfile(broker.projectDir, broker.role, state);
             this.rememberTokens(refreshTokenSlots(state));
             this.refreshCounts.refreshed += 1;
+            // A swap was reported as it happened; this is the session's own refresh.
+            if (!swapped)
+                this.refreshEvents.push("refreshed");
         }
         catch (err) {
             this.refreshCounts.failed += 1;
+            this.refreshEvents.push("failed");
             this.logAction({
                 action: "refresh-broker:not-saved",
                 target: `${presented.slot}: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
@@ -3207,6 +4253,24 @@ export class BrowserEngine {
             lock.release();
         }
     }
+    /**
+     * The page's storage state read again with its IndexedDB, which a plain read
+     * leaves out and a saved profile keeps. The plain state when that read fails
+     * or no longer shows the rotation; profileAfterRotation then keeps the
+     * profile's own IndexedDB, so nothing is dropped either way.
+     */
+    async withPageIndexedDB(plain, holds) {
+        const full = await this.context?.storageState({ indexedDB: true }).catch(() => null);
+        return full && holds(full) ? full : plain;
+    }
+    /** Report (and clear) what the refresh broker did since the last action: counts only (refreshNotice). */
+    drainRefresh() {
+        if (this.refreshEvents.length === 0)
+            return "";
+        const events = this.refreshEvents;
+        this.refreshEvents = [];
+        return refreshNotice(events);
+    }
     /** Take `now` as the role's current tokens; the ones it replaces are kept as spent, so a page that still sends one is caught. */
     rememberTokens(now) {
         if (!this.refresh)
@@ -3217,12 +4281,14 @@ export class BrowserEngine {
     }
     /** What the refresh broker did this session, or "" when it did nothing. Counts only. */
     refreshSummary() {
-        const { refreshed, swapped, failed } = this.refreshCounts;
-        if (refreshed + swapped + failed === 0)
+        const { refreshed, swapped, failed, learned } = this.refreshCounts;
+        if (refreshed + swapped + failed + learned === 0)
             return "";
         const parts = [`refreshed role '${this.role}''s token ${refreshed} time${refreshed === 1 ? "" : "s"} under the role's lock`];
         if (swapped > 0)
             parts.push(`${swapped} of them after another session had rotated it`);
+        if (learned > 0)
+            parts.push(`learned ${learned} endpoint${learned === 1 ? "" : "s"} that rotate${learned === 1 ? "s" : ""} it`);
         if (failed > 0)
             parts.push(`${failed} refresh${failed === 1 ? "" : "es"} could not be brokered (see the action log)`);
         return parts.join("; ");
@@ -3243,11 +4309,25 @@ export class BrowserEngine {
         }
         this.authLoss.record({ requestedRoute, landedRoute, bounced, role: this.role, target: requestedUrl });
     }
-    async goBack() {
+    /** `leave` answers a leave confirmation the page raises (policy.ts dialogResponse); undefined lets the mode decide. */
+    async goBack(leave) {
         this.actionStartedAt = Date.now();
         const page = this.requirePage();
-        await page.goBack({ waitUntil: "domcontentloaded", timeout: this.limits.backNavMs }).catch(() => { });
-        return this.afterAction("back", "");
+        this.leaveChoice = leave;
+        try {
+            // A back that goes nowhere (no history, a cancelled leave) is reported by the URL the result shows.
+            await page.goBack({ waitUntil: "domcontentloaded", timeout: this.limits.backNavMs }).catch((err) => {
+                this.logAction({
+                    action: "back:no-navigation",
+                    target: err instanceof Error ? err.message.split("\n")[0].slice(0, 160) : String(err),
+                    url: page.url(),
+                });
+            });
+            return await this.afterAction("back", "");
+        }
+        finally {
+            this.leaveChoice = undefined;
+        }
     }
     /** The full route contract: scanned filesystem routes ∪ link-discovered route classes. */
     allKnownRoutes() {
@@ -3268,7 +4348,10 @@ export class BrowserEngine {
      *
      * Visited/attempted keys are stored NORMALIZED, so the normalized form of
      * each known route is compared too — normalizePath is idempotent, so this
-     * only adds matches for routes that genuinely were reached.
+     * only adds matches for routes that genuinely were reached. Reached is
+     * memory's reachedRoutes, the gap ledger's own rule: stored routes are read
+     * through today's route identity, and a base path is reached by one of its
+     * tabs or sections.
      */
     unvisitedKnownRoutes() {
         if (!this.memory)
@@ -3276,11 +4359,11 @@ export class BrowserEngine {
         const all = this.allKnownRoutes();
         if (all.length === 0)
             return [];
-        const visited = new Set(Object.values(this.memory.states).map((s) => s.route));
+        const reached = reachedRoutes(Object.values(this.memory.states).map((s) => s.route));
         const attempted = this.memory.attemptedByRole(this.role);
         return all.filter((r) => {
             const n = normalizePath(r);
-            return !visited.has(r) && !(r in attempted) && !visited.has(n) && !(n in attempted);
+            return !reached(r) && !(r in attempted) && !(n in attempted);
         });
     }
     /** Map a route class to something goto-able (discovered classes carry a concrete example). */
@@ -3326,12 +4409,16 @@ export class BrowserEngine {
      * harvested from their links, none is marked visited or attempted, and a
      * failed load is not remembered, so the pages and what they link to stay on
      * the unvisited list exactly as before. A check's re-test loads use it.
+     *
+     * `deadline` (epoch ms): no route is started once it has passed; those left
+     * stay unvisited. The first run's time budget is the only caller.
      */
     async crawl(paths, opts = {}) {
         const page = this.requirePage();
         const memory = this.memory;
         this.crawlHealth = [];
-        const targets = (paths && paths.length > 0 ? paths : this.crawlableRoutes().map((r) => this.navigablePath(r))).slice(0, Math.min(150, opts.limit ?? 150));
+        const explicit = !!paths && paths.length > 0;
+        const targets = (explicit ? paths : this.crawlableRoutes().map((r) => this.navigablePath(r))).slice(0, Math.min(150, opts.limit ?? 150));
         if (targets.length === 0) {
             const failed = this.unvisitedKnownRoutes().filter((r) => this.loadFailedRoutes.has(normalizePath(r)));
             if (failed.length > 0) {
@@ -3350,11 +4437,16 @@ export class BrowserEngine {
         const queue = [...targets];
         for (let i = 0; i < queue.length; i++) {
             const path = queue[i];
-            const url = `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
-            if (!this.isSameOrigin(url)) {
-                summary.push(`${path} — SKIPPED (off-origin)`);
+            if (opts.deadline !== undefined && Date.now() >= opts.deadline) {
+                summary.push(`… stopped at the time limit: ${queue.length - i} route(s) not started`);
+                break;
+            }
+            const resolved = resolveTarget(this.baseUrl, path);
+            if (!("url" in resolved)) {
+                summary.push(`${path} — SKIPPED (${resolved.offOrigin ? "off-origin" : resolved.problem})`);
                 continue;
             }
+            const url = resolved.url;
             this.actionStartedAt = Date.now();
             this.oracles.drain(false); // discard pre-route leftovers WITHOUT marking their signatures as reported
             let status = "ERR";
@@ -3370,11 +4462,7 @@ export class BrowserEngine {
                 // must not count a route as covered in every later run's gap ledger.
                 if (!opts.measureOnly)
                     this.loadFailedRoutes.add(normalizePath(url));
-                // The browser commits its own error page for this failure tens of
-                // milliseconds after goto has thrown, and that commit interrupts the next
-                // navigation, charging this route's failure to the next one. Wait for it;
-                // a browser that shows no error page simply lets the wait time out.
-                await page.waitForEvent("framenavigated", { predicate: (f) => f === page.mainFrame(), timeout: 1500 }).catch(() => undefined);
+                await this.errorPageCommitted(page);
                 summary.push(`${path} — LOAD FAILED`);
                 // The page a re-attach went back to never loaded, so nothing says whether it worked.
                 if (this.authLoss.reattaching)
@@ -3398,14 +4486,14 @@ export class BrowserEngine {
             }
             await this.settle();
             this.harvestPaused = opts.measureOnly === true;
-            const { elements, forms } = await this.collect().finally(() => (this.harvestPaused = false));
+            const { elements, forms, aliases } = await this.collect().finally(() => (this.harvestPaused = false));
             const finalUrl = page.url();
             const route = normalizePath(finalUrl);
-            const fp = fingerprintState(finalUrl, elements);
+            const fp = fingerprintState(finalUrl, trackedElements(elements));
             if (!opts.measureOnly) {
-                memory.visitState(fp, finalUrl, route, elements.map((el) => el.key));
+                memory.visitState(fp, finalUrl, route, trackedElements(elements).map((el) => el.key), inertKeys(elements), this.sessionKey, aliases);
                 for (const f of forms)
-                    memory.recordForm(fp, f.key, f.guarded);
+                    memory.recordForm(fp, f.key, f.guarded, this.sessionKey);
                 memory.recordRoleAccess(this.role, route, "reached");
             }
             // If we landed somewhere else (auth wall, canonical redirect), the
@@ -3440,7 +4528,7 @@ export class BrowserEngine {
                 url: finalUrl,
                 status: typeof status === "number" ? status : null,
                 loginRedirect,
-                elements: elements.length,
+                elements: trackedElements(elements).length,
                 unnamed: own.filter(missingName).map(describeControl),
                 placeholderOnly: own.filter(placeholderOnly).map(placeholderEvidence),
                 violations: violations.map(({ kind, severity, detail, url, embed }) => ({ kind, severity, detail, url, ...(embed ? { embed } : {}) })),
@@ -3449,22 +4537,40 @@ export class BrowserEngine {
                 design: inspected?.design ?? [],
                 ...(inspected?.auditError ? { auditError: inspected.auditError } : {}),
             });
-            const deadEnd = elements.length === 0;
+            const deadEnd = trackedElements(elements).length === 0;
             // A field labelled only by its placeholder counts here too: to someone reading the crawl, it has no label.
             // Counted over the page's own controls, as the check's lists are: another site's frame is not this app's to fix.
             const unnamed = own.filter((el) => missingName(el) || placeholderOnly(el)).length;
-            const missingTestid = elements.filter((el) => !el.testid && !el.disabled).length;
-            const flags = [loginRedirect ? "AUTH-REDIRECT" : null, deadEnd ? "DEAD-END" : null, violations.length > 0 ? `${violations.length}⚠` : null].filter(Boolean);
-            summary.push(`${path} — ${status} · ${elements.length} el` +
-                (missingTestid ? ` · ${missingTestid} no-testid` : "") +
-                (unnamed ? ` · ${unnamed} unnamed` : "") +
-                (flags.length ? ` · ${flags.join(" ")}` : ""));
-            if (violations.length > 0 || deadEnd || loginRedirect || (typeof status === "number" && status >= 400)) {
+            const missingTestid = trackedElements(elements).filter((el) => !el.testid && !el.disabled).length;
+            // What the page's main area holds besides controls: "41 el" alone cannot tell a page
+            // of text from a main area that rendered nothing.
+            const main = await this.readMainRegion(page);
+            // A main area holding only an alert or a loading placeholder is the usual look of a broken route that answered 200.
+            const shows = main && !deadEnd ? mainState(main) : null;
+            const stateFlag = mainStateFlag(shows);
+            const flags = [
+                loginRedirect ? "AUTH-REDIRECT" : null,
+                deadEnd ? "DEAD-END" : null,
+                stateFlag,
+                violations.length > 0 ? `${violations.length}⚠` : null,
+            ].filter((f) => f !== null);
+            const outcome = { path, status, requestedRoute, landedRoute: route, loginRedirect, deadEnd, mainState: shows };
+            summary.push(crawlLine(outcome, { elements: trackedElements(elements).length, missingTestid, unnamed, main: main ? mainRegionTag(main) : null }, flags));
+            // A path asked for by name joins the route contract once it answered as a page (crawl.ts crawledRoute).
+            const joined = explicit && !opts.measureOnly ? crawledRoute(outcome) : null;
+            if (joined)
+                memory.addDiscoveredRoutes([{ route: joined, example: path }]);
+            if (violations.length > 0 || deadEnd || stateFlag || loginRedirect || (typeof status === "number" && status >= 400)) {
                 const detail = violations
                     .slice(0, 3)
                     .map((v) => `    ${v.kind}: ${v.detail.slice(0, 160)}`)
                     .join("\n");
-                problems.push(`${path}${loginRedirect ? " → redirected to login (auth missing/expired?)" : ""}${deadEnd ? " → dead end" : ""}${detail ? `\n${detail}` : ""}`);
+                const showing = shows === "error"
+                    ? ` → main area shows only an error view${main?.text ? ` ("${main.text.slice(0, 80)}")` : ""}`
+                    : shows === "loading"
+                        ? ` → main area still shows only a loading placeholder after settling${main?.text ? ` ("${main.text.slice(0, 80)}")` : ""}`
+                        : "";
+                problems.push(`${path}${loginRedirect ? " → redirected to login (auth missing/expired?)" : ""}${deadEnd ? " → dead end" : ""}${showing}${detail ? `\n${detail}` : ""}`);
             }
             // A role session that lost its sign-in on this route re-attaches once
             // and visits the routes the loss bounced again, next. Their bounced
@@ -3490,7 +4596,7 @@ export class BrowserEngine {
         }
         // Crawl leaves the page wherever it ended — refs from before are gone.
         this.refs.clear();
-        this.lastSnap = null;
+        this.forgetSnapshots();
         this.snapshotUrl = "";
         const unvisited = this.unvisitedKnownRoutes();
         return (
@@ -3512,11 +4618,18 @@ export class BrowserEngine {
      * time by semantic locator (testid= / text= / label=), never by snapshot
      * ref, so the plan is immune to DOM drift. Aborts on the first oracle
      * violation or policy refusal so the driver re-enters at the interesting moment.
+     * With onViolation "continue", a new error status (or its console echo) is
+     * listed on its step's line and the plan goes on (oracles.ts planStopsAt):
+     * for a sweep of independent steps, where a later step does not depend on
+     * an earlier one. A failed step or a policy refusal still stops it.
      */
-    async runPlan(steps) {
+    async runPlan(steps, onViolation = "stop") {
         const page = this.requirePage();
         const transcript = [];
-        const resolveTarget = (target) => {
+        const planStartedAt = Date.now();
+        /** Steps the plan went on past a new violation at (onViolation "continue"). */
+        const continuedPast = [];
+        const locatePlanTarget = (target) => {
             const parsed = parseTarget(target);
             if (!parsed)
                 throw new Error(`Plan targets must be ${TARGET_HELP} (got: ${target})`);
@@ -3534,12 +4647,17 @@ export class BrowserEngine {
         };
         for (const [i, step] of steps.slice(0, 20).entries()) {
             this.actionStartedAt = Date.now();
+            // A navigation or a scroll is not input: navigate() moves the action mark itself, and what a scroll loads is the page's own doing.
+            if (step.action !== "navigate" && step.action !== "scroll")
+                await this.beginInput();
             const desc = `${i + 1}. ${step.action} ${step.target ?? step.value ?? ""}`;
             // Identity captured BEFORE the action — buttons that relabel themselves
             // (Add to Cart → View Cart) are unmatchable in the post-action DOM.
             let preTestid = null;
             let preLabel = "";
             let forcedClick = false;
+            let cover = null;
+            let coverReadAt = 0;
             // What a type step has to say about the field it typed into; it goes on
             // the step's own line, so it cannot read as the previous step's.
             let note = "";
@@ -3591,7 +4709,7 @@ export class BrowserEngine {
                 else {
                     if (!step.target)
                         throw new Error(`${step.action} needs a target`);
-                    const loc = resolveTarget(step.target);
+                    const loc = locatePlanTarget(step.target);
                     // Coverage is recorded against the state the element LIVED IN, so it
                     // has to be captured before the action changes the page. Marking it
                     // afterwards (as this did) recorded against the state the click
@@ -3610,7 +4728,17 @@ export class BrowserEngine {
                     preTestid = await loc.getAttribute("data-testid").catch(() => null);
                     const label = await liveLabel(loc);
                     preLabel = label;
-                    if (this.readOnly && (step.action === "click" || step.action === "select" || step.action === "upload") && isDestructive(label, step.value)) {
+                    // A dropdown is named by all its options; a select step is judged by the option it picks (destructiveLabelOf).
+                    const isSelect = step.action === "select" && (await loc.evaluate((n) => n.tagName.toLowerCase() === "select").catch(() => false));
+                    // The option a select step means, settled before anything is picked: one naming none fails the step at once.
+                    const pick = step.action === "select" ? await BrowserEngine.resolveSelectPick(loc, step.value ?? "") : null;
+                    if (pick && "refused" in pick) {
+                        transcript.push(`${desc} → FAILED: ${pick.refused}`);
+                        break;
+                    }
+                    if (this.readOnly &&
+                        (step.action === "click" || step.action === "select" || step.action === "upload") &&
+                        (isSelect ? pickIsDestructive(step.value, preTestid, pick ? pick.label : null) : isDestructive(label, step.value))) {
                         transcript.push(`${desc} → ${destructiveRefusal(label || step.target, this.mode)}`);
                         break;
                     }
@@ -3620,7 +4748,7 @@ export class BrowserEngine {
                             preState = await this.stateHolding(probe, preState, preState !== null && preState === lastCapture);
                             form = { kind: "click", probe };
                         }
-                        forcedClick = (await this.resilientClick(loc, this.limits.actionMs)).forced;
+                        ({ forced: forcedClick, cover, coverReadAt } = await this.resilientClick(loc, this.limits.actionMs));
                     }
                     else if (step.action === "hover") {
                         const { before, bodyBefore, churning } = await this.hoverBaselines();
@@ -3653,7 +4781,7 @@ export class BrowserEngine {
                     }
                     else if (step.action === "select") {
                         const options = await readSelectOptions(loc);
-                        const picked = await loc.selectOption(step.value ?? "", { timeout: this.limits.actionMs });
+                        const picked = await loc.selectOption(pick && !("refused" in pick) ? pick.arg : (step.value ?? ""), { timeout: this.limits.actionMs });
                         if (options)
                             chose = { options, picked };
                     }
@@ -3683,12 +4811,12 @@ export class BrowserEngine {
                     try {
                         // Record the state the action LANDED on (it may be a new screen
                         // this plan just reached, and it deserves coverage of its own)…
-                        const { elements, forms } = await this.collect();
+                        const { elements, forms, aliases } = await this.collect();
                         const url = page.url();
-                        const fp = fingerprintState(url, elements);
-                        this.memory.visitState(fp, url, normalizePath(url), elements.map((el) => el.key));
+                        const fp = fingerprintState(url, trackedElements(elements));
+                        this.memory.visitState(fp, url, normalizePath(url), trackedElements(elements).map((el) => el.key), inertKeys(elements), this.sessionKey, aliases);
                         for (const f of forms)
-                            this.memory.recordForm(fp, f.key, f.guarded);
+                            this.memory.recordForm(fp, f.key, f.guarded, this.sessionKey);
                         this.memory.recordRoleAccess(this.role, normalizePath(url), "reached");
                         lastCapture = { fp, elements, url };
                         // …but mark the acted-on element in the state it came FROM, using
@@ -3723,17 +4851,24 @@ export class BrowserEngine {
                 await this.scanForInjections();
                 await this.scanForContradictions();
                 const violations = this.oracles.drain();
-                const mutations = this.drainMutations() + this.drainBlocked() + this.drainCreated();
+                const mutations = this.drainDialogs() + this.drainMutations() + this.drainBlocked() + this.drainRefresh() + this.drainCreated();
+                const forcedNote = !forcedClick
+                    ? ""
+                    : cover
+                        ? ` (forced — the strict click timed out because at its centre it is ${describeCover(cover, this.blockedBetween(Math.max(planStartedAt, this.snapshotAt), coverReadAt))}; a forced click still landed)`
+                        : " (forced — the strict click timed out on this element's hit-test/stability check but a forced click still landed; something may render on top of it or delegate via a label, cross-check GEOMETRY overlaps before calling it a bug)";
                 // Abort only on NEW violations: a known-failing endpoint repeating on
                 // every navigation must not make every plan abort at step 1.
-                if (violations.some((v) => !v.repeat)) {
+                if (planStopsAt(violations, onViolation)) {
                     transcript.push(`${desc} → OK${note}, but oracle fired:${formatViolations(violations)}${mutations}`);
                     transcript.push(`PLAN ABORTED at step ${i + 1} — investigate before continuing.`);
                     break;
                 }
-                const forcedNote = forcedClick
-                    ? " (forced — the strict click timed out on this element's hit-test/stability check but a forced click still landed; something may render on top of it or delegate via a label, cross-check GEOMETRY overlaps before calling it a bug)"
-                    : "";
+                if (violations.some((v) => !v.repeat)) {
+                    continuedPast.push(i + 1);
+                    transcript.push(`${desc} → OK (${page.url()})${note}${forcedNote}, oracle fired (continuing: onViolation "continue"):${formatViolations(violations)}${mutations}`);
+                    continue;
+                }
                 transcript.push(`${desc} → OK (${page.url()})${note}${mutations}${forcedNote}`);
             }
             catch (err) {
@@ -3756,12 +4891,15 @@ export class BrowserEngine {
             }
         }
         this.refs.clear();
-        this.lastSnap = null;
+        this.forgetSnapshots();
         this.snapshotUrl = "";
         // Count step lines, not transcript lines — hover reveals and scroll
         // positions push informational entries that are not steps.
         const ran = transcript.filter((l) => /^\d+\. /.test(l)).length;
-        return `PLAN (${ran}/${Math.min(steps.length, 20)} steps ran):\n${transcript.join("\n")}\nTake scout_snapshot to see the resulting state.`;
+        const continued = continuedPast.length > 0
+            ? `\nCONTINUED PAST new oracle violations at step${continuedPast.length > 1 ? "s" : ""} ${continuedPast.join(", ")} (onViolation "continue"); each is listed on its step's line and kept for the report.`
+            : "";
+        return `PLAN (${ran}/${Math.min(steps.length, 20)} steps ran):\n${transcript.join("\n")}${continued}\nTake scout_snapshot to see the resulting state.`;
     }
     /** A plan's or a flow's target as a Playwright locator (every match; callers pick). */
     static locatorFor(page, target) {
@@ -3841,10 +4979,6 @@ export class BrowserEngine {
                 await (this.page ?? page).waitForTimeout(100).catch(() => { });
             }
         };
-        const firstLine = (err) => (err instanceof Error ? err.message : String(err))
-            .split("\n")[0]
-            .replace(/^[a-z]+\.[a-zA-Z]+: /, "")
-            .trim();
         try {
             for (const [i, step] of steps.entries()) {
                 const n = i + 1;
@@ -3854,10 +4988,15 @@ export class BrowserEngine {
                 let failure = null;
                 let refusal = null;
                 this.actionStartedAt = Date.now();
+                if (step.action === "click" || step.action === "type" || step.action === "select" || step.action === "press")
+                    await this.beginInput();
                 try {
                     const current = this.requirePage();
                     if (step.action === "navigate") {
-                        const url = `${this.baseUrl}${step.target}`;
+                        const resolved = resolveTarget(this.baseUrl, step.target);
+                        if (!("url" in resolved))
+                            throw new Error(resolved.problem);
+                        const url = resolved.url;
                         const resp = await current
                             .goto(url, { waitUntil: "domcontentloaded", timeout: this.limits.crawlNavMs })
                             .catch((err) => Promise.reject(explainTimeout(err, "nav", this.limits.crawlNavMs)));
@@ -3890,7 +5029,14 @@ export class BrowserEngine {
                             const label = ((await loc.getAttribute("aria-label").catch(() => null)) ??
                                 (await loc.textContent({ timeout: 1000 }).catch(() => null)) ??
                                 "").trim();
-                            if (this.readOnly && step.action !== "type" && isDestructive(label, step.action === "select" ? step.value : undefined)) {
+                            // A dropdown is named by all its options; a select step is judged by the option it picks (destructiveLabelOf).
+                            const isSelect = step.action === "select" && (await loc.evaluate((n) => n.tagName.toLowerCase() === "select").catch(() => false));
+                            const testid = await loc.getAttribute("data-testid").catch(() => null);
+                            if (this.readOnly &&
+                                step.action !== "type" &&
+                                (isSelect
+                                    ? pickIsDestructive(step.value, testid, await BrowserEngine.chosenOptionLabel(loc, step.value))
+                                    : isDestructive(label, step.action === "select" ? step.value : undefined))) {
                                 refusal = destructiveRefusal(label || step.target, this.mode);
                             }
                             else if (step.action === "click") {
@@ -3937,7 +5083,7 @@ export class BrowserEngine {
                     }
                 }
                 catch (err) {
-                    failure = firstLine(explainTimeout(err, "action", this.limits.actionMs));
+                    failure = firstLineOf(explainTimeout(err, "action", this.limits.actionMs));
                 }
                 await this.scanForInjections().catch(() => { });
                 await this.scanForContradictions().catch(() => { });
@@ -3988,7 +5134,7 @@ export class BrowserEngine {
             page.off("websocket", onSocket);
             context.off("response", onResponse);
             this.refs.clear();
-            this.lastSnap = null;
+            this.forgetSnapshots();
             this.snapshotUrl = "";
         }
     }
@@ -4011,10 +5157,9 @@ export class BrowserEngine {
         this.designAuditCount += 1;
         if (this.memory)
             this.memory.auditsThisRun += 1;
-        // The census is built from previous audits, so the first few pages of a run
-        // score with chrome included and later ones don't. That is the same warm-up
-        // the coverage census has: nothing is knowable as "shared" until it has been
-        // seen on several routes.
+        // The census is built from previous audits and knows nothing until it has
+        // seen several routes; the shell's landmarks (design.ts) cover those first
+        // pages, so the shell is out of the score from the first audit.
         const { report, score, signatures, defects } = analyzeDesign(payload, page.viewportSize() ?? { width: 1280, height: 900 }, this.memory?.designChromeKeys() ?? new Set());
         const route = normalizePath(page.url());
         this.memory?.recordDesignElements(route, signatures);
@@ -4061,15 +5206,15 @@ export class BrowserEngine {
      * clicked, and the write policy is not involved. The rectangle's rules are
      * capture.ts.
      */
-    async captureElement(target, margin) {
+    async captureElement(target, margin, log = true) {
         const page = this.requirePage();
         let el;
         if (target.ref) {
             el = this.refs.get(target.ref);
             if (!el)
                 throw new Error(`Unknown ref "${target.ref}". Refs are only valid from the latest scout_snapshot — take a new snapshot.`);
-            if (page.url() !== this.snapshotUrl) {
-                this.refs.clear();
+            if (!refsSurviveUrlChange(this.snapshotUrl, page.url())) {
+                this.dropRefs(`the page moved to ${page.url()}`);
                 throw new Error(`Page URL changed since the last snapshot (now ${page.url()}). Take a new scout_snapshot.`);
             }
         }
@@ -4094,12 +5239,141 @@ export class BrowserEngine {
         if (!clip)
             throw new Error(`${el.name || el.key} is outside the viewport, so it has no picture.`);
         const png = await page.screenshot({ type: "png", clip, animations: "disabled" });
-        this.logAction({ action: "capture", target: el.key.slice(0, 200), url: page.url() });
+        if (log)
+            this.logAction({ action: "capture", target: el.key.slice(0, 200), url: page.url() });
         // Found by key, the refs were rebuilt without a snapshot: none of them may be acted on.
         if (target.key)
-            this.refs.clear();
+            this.dropRefs("an element was captured by its key");
         return { png, key: el.key, label: el.name, url: page.url() };
     }
+    /**
+     * A finding's picture, as a PNG: the element `ref` names plus
+     * `margin` (captureElement), or the viewport. An element that cannot be
+     * pictured (a stale ref, one not displayed) leaves the viewport instead, and
+     * `note` says why, so a finding is never filed without the evidence that was
+     * there to take. What is taken and how it is bounded is capture.ts and png.ts.
+     */
+    async captureEvidence(ref, margin) {
+        let note;
+        if (ref) {
+            try {
+                // Not logged: the log is what a later finding's repro trace is built from, and a picture is no step to repeat.
+                const shot = await this.captureElement({ ref }, margin, false);
+                return { png: shot.png, frame: "element", label: shot.label };
+            }
+            catch (err) {
+                note = `${ref} could not be pictured (${err instanceof Error ? err.message : String(err)}), so the viewport was`;
+            }
+        }
+        const page = this.requirePage();
+        const png = await page.screenshot({ type: "png", animations: "disabled", scale: "css", timeout: this.limits.actionMs });
+        return { png, frame: "viewport", label: "", ...(note ? { note } : {}) };
+    }
+    /**
+     * After a navigation threw. The browser commits its own error page for the
+     * failure tens of milliseconds after goto has thrown, and that commit
+     * interrupts the next navigation, charging this failure to the next page.
+     * Wait for it; a browser that shows no error page simply lets the wait time
+     * out, which is not an error.
+     */
+    async errorPageCommitted(page) {
+        await page.waitForEvent("framenavigated", { predicate: (f) => f === page.mainFrame(), timeout: 1500 }).catch(() => undefined);
+    }
+    /** The browser this session drives. */
+    get browserEngine() {
+        return this.engineName;
+    }
+    /** Whether the page and its browser are still there: a failure after either is gone is the engine's, not the page's. */
+    get alive() {
+        return !!this.page && !this.page.isClosed() && !!this.browser?.isConnected();
+    }
+    /** True when `p` settles in time, false when it times out. Any other failure is thrown, so a closed page never reads as a slow one. */
+    static async inTime(p) {
+        try {
+            await p;
+            return true;
+        }
+        catch (err) {
+            if (err instanceof Error && isTimeoutMessage(err.message))
+                return false;
+            throw err;
+        }
+    }
+    /**
+     * A picture for `scenescout check --baseline`: the page at `pathOnApp`
+     * loaded afresh (from a blank page, so a target that differs from the last
+     * only by its #fragment is still a new load), told the motion preference
+     * `how` names, read once its fonts have loaded and its animations are
+     * stopped, then either the viewport from the top (no target) or one element,
+     * found the way a saved flow finds its target, with `how.margin` around it.
+     * The screenshot is taken with `how`'s animation and caret settings, at one
+     * picture pixel per CSS pixel. Reads only. Throws a sentence when it cannot
+     * take the picture. `cut` says when an element reaches outside the window.
+     * What is compared and what it means is baseline.ts, which also holds the
+     * settings; the rectangle is capture.ts. Call endBaselineCaptures when done.
+     */
+    async captureForBaseline(pathOnApp, target, how) {
+        const page = this.requirePage();
+        const action = (p) => p.catch((err) => Promise.reject(explainTimeout(err, "action", this.limits.actionMs)));
+        const within = `within ${this.limits.actionMs / 1000}s — ${limitHint("action", this.limits.actionMs)}`;
+        // Before the load, so a page that reads the preference once, as it starts, reads it too.
+        await page.emulateMedia({ reducedMotion: how.reducedMotion });
+        let resp;
+        try {
+            await page.goto("about:blank", { timeout: this.limits.crawlNavMs });
+            resp = await page.goto(`${this.baseUrl}${pathOnApp}`, { waitUntil: "domcontentloaded", timeout: this.limits.crawlNavMs });
+        }
+        catch (err) {
+            await this.errorPageCommitted(page);
+            throw explainTimeout(err, "nav", this.limits.crawlNavMs);
+        }
+        const status = resp?.status() ?? null;
+        if (status !== null && status >= 400)
+            throw new Error(`the page answered HTTP ${status}`);
+        await this.settle();
+        // A sign-in page pictured as the page's baseline would be written by an update and compared from then on.
+        const landed = await this.landedUrl(page);
+        if (this.authLoss.isLoginRedirect(pathOnApp, landed, this.baseUrl)) {
+            throw new Error(`the page sent the browser to sign-in (${new URL(landed).pathname}): the session is missing or expired`);
+        }
+        // Text drawn in a fallback font, then again when the web font arrives, would differ from one run to the next.
+        const fonts = page.waitForFunction("!document.fonts || document.fonts.status === 'loaded'", null, { timeout: this.limits.actionMs });
+        if (!(await BrowserEngine.inTime(fonts)))
+            throw new Error(`its fonts were still loading, not done ${within}`);
+        // Stopped before anything is measured, not only for the screenshot: a target that itself moves would be cropped mid-movement.
+        if (how.animations === "disabled")
+            await page.evaluate(STOP_ANIMATIONS_SCRIPT);
+        const viewport = page.viewportSize() ?? (await page.evaluate("({ width: innerWidth, height: innerHeight })"));
+        const deviceScaleFactor = Number(await page.evaluate("window.devicePixelRatio"));
+        const settings = { type: "png", animations: how.animations, caret: how.caret, scale: "css", timeout: this.limits.actionMs };
+        let png;
+        let cut = null;
+        if (!target) {
+            await page.evaluate("window.scrollTo(0, 0)");
+            png = await action(page.screenshot(settings));
+        }
+        else {
+            const locator = BrowserEngine.locatorFor(page, target).first();
+            if (!(await BrowserEngine.inTime(locator.waitFor({ state: "visible", timeout: this.limits.actionMs })))) {
+                throw new Error(`nothing visible matches it ${within}`);
+            }
+            await action(locator.scrollIntoViewIfNeeded({ timeout: this.limits.actionMs }));
+            const box = await action(locator.boundingBox({ timeout: this.limits.actionMs }));
+            if (!box)
+                throw new Error("it is not displayed");
+            const clip = captureClip(box, how.margin, viewport);
+            if (!clip)
+                throw new Error("it is outside the viewport");
+            cut = cutByViewport(box, viewport);
+            png = await action(page.screenshot({ ...settings, clip }));
+        }
+        this.logAction({ action: "capture", target: target ? `baseline ${pathOnApp}` : `baseline ${pathOnApp} (page)`, url: page.url() });
+        return { png, viewport, deviceScaleFactor, cut };
+    }
+    /** Stop telling the page to reduce motion, so what runs after the baselines (saved flows) sees the page as a user does. */
+    async endBaselineCaptures() {
+        await this.requirePage().emulateMedia({ reducedMotion: null });
+    }
     /**
      * What the live view shows next to a session's name. The task is what the
      * agent said the session is for; the objective is the goal of the journey it
@@ -4383,6 +5657,6 @@ export class BrowserEngine {
         this.refs.clear();
         this.snapshotUrl = "";
         this.currentFingerprint = "";
-        this.lastSnap = null;
+        this.forgetSnapshots();
     }
 }