scenescout 3.15.0 → 3.17.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, INFRASTRUCTURE_WRITE_RE, OPEN_DIALOGS_SCRIPT } 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, stateFlags, stateChange, trackedElements, inertKeys, MAIN_REGION_SCRIPT, mainRegionLine, mainRegionTag, } from "./collector.js";
-import { OracleMonitor, formatViolations, httpErrorDetail, requestKey } 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, isSubmitLike, 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, brokerDecision, brokerEnabled, cookieMayCount, endpointKey, endpointsPathFor, headersForResend, isStaticAsset, learnableEndpoint, lockPathFor, planRefresh, profileAfterRotation, readLearnedEndpoints, REFRESH_BROKER_ENV, refreshTokenSlots, rotatedCookies, rotatedFromResponse, rotationStored, swapProfileToken, swapRequest, swapToken, withLearnedEndpoint, writeLearnedEndpoints, } 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
@@ -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. */
@@ -245,6 +336,8 @@ export class BrowserEngine {
     refreshTasks = new Set();
     /** What the broker did this session, for the lane report: counts only. */
     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.
@@ -257,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
@@ -318,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. */
@@ -334,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.
      *
@@ -362,11 +513,15 @@ 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
@@ -375,6 +530,7 @@ export class BrowserEngine {
         this.oracles.replayStarted(target.url);
         try {
             raw = (await page.evaluate(script));
+            this.pageRequests.markReplay(method.method, target.url);
         }
         catch (err) {
             // The page could not run the fetch at all (a navigation mid-call, a
@@ -389,7 +545,7 @@ export class BrowserEngine {
             for (const hop of this.replayHops.splice(0))
                 this.oracles.replayEnded(hop);
         }
-        const result = toReplayResult(raw);
+        const result = toReplayResult(raw, input.view);
         this.logAction({
             action: "request",
             target: `${method.method} ${input.path}`,
@@ -397,7 +553,7 @@ 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;
@@ -540,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
@@ -552,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;
@@ -653,14 +809,27 @@ export class BrowserEngine {
         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.
-            background: this.inputSince === null || this.inputSince < this.actionStartedAt || started < this.inputSince,
+            // 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,
+            }),
         });
     }
     /**
@@ -672,6 +841,12 @@ export class BrowserEngine {
     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
@@ -681,6 +856,8 @@ export class BrowserEngine {
     async beginInput() {
         this.inputSince = this.actionStartedAt;
         this.claimBaseline = null;
+        this.documentLoadSince = null;
+        this.actedControl = null;
         const page = this.page;
         if (!page || page.isClosed())
             return;
@@ -691,6 +868,31 @@ export class BrowserEngine {
             // 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.
@@ -702,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;
@@ -718,7 +922,17 @@ export class BrowserEngine {
         }
         // 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;
-        for (const found of findContradictions(requests, state, before)) {
+        // 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);
@@ -785,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;
     }
@@ -792,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)) {
@@ -818,7 +1042,11 @@ export class BrowserEngine {
         let profileNote = "";
         this.refresh = null;
         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)
@@ -855,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);
@@ -866,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();
@@ -877,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.
@@ -891,6 +1139,7 @@ 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));
@@ -906,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();
@@ -927,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 ?? []);
@@ -950,42 +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()))
@@ -1061,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();
@@ -1123,8 +1405,9 @@ export class BrowserEngine {
                 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();
@@ -1140,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);
@@ -1152,6 +1434,18 @@ export class BrowserEngine {
                     this.routedWrites.note(rule, method, url, bodyDigest(req.postDataBuffer()));
                     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
                 // (POST gets an id, PUT saves content under it) faster than the
@@ -1186,6 +1480,8 @@ export class BrowserEngine {
                         this.pendingCreations.add(task);
                     }
                     this.routedWrites.note(rule, method, url, bodyDigest(req.postDataBuffer()));
+                    if (method === "POST")
+                        this.clearRefusedPost(url);
                     return route.fallback();
                 }
                 return refuse();
@@ -1225,7 +1521,7 @@ export class BrowserEngine {
                     this.page = newPage;
                     this.refs.clear();
                     this.snapshotUrl = "";
-                    this.lastSnap = null;
+                    this.forgetSnapshots();
                 }
                 else {
                     void this.leaveAndClose(newPage);
@@ -1265,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
@@ -1279,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);
     }
@@ -1325,21 +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) => {
             this.nativeDialogAt = Date.now();
-            const action = this.readOnly ? "dismiss" : "accept";
+            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.");
@@ -1406,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;
     /**
@@ -1424,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();
@@ -1441,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))) ?? []);
@@ -1453,36 +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 }) => {
-            // 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 baseKey = frameElementKey(el.liveOnly ? `live:${el.role}` : 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.
                 // A message is not a control: "Could not delete" in an alert is not a Delete button.
-                destructive: el.liveOnly ? false : isDestructive(el.name, el.testid),
+                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));
@@ -1494,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;
@@ -1524,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());
@@ -1617,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, trackedElements(elements));
-        this.memory?.visitState(fp, url, normalizePath(url), trackedElements(elements).map((el) => el.key), inertKeys(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 };
     }
     /**
@@ -1704,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, trackedElements(elements));
         this.currentFingerprint = fp;
-        const isNew = memory.visitState(fp, url, route, trackedElements(elements).map((el) => el.key), inertKeys(elements));
+        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
@@ -1721,6 +2099,14 @@ 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 = [
@@ -1729,27 +2115,37 @@ export class BrowserEngine {
                 dup ? `copy#${Number(dup[1]) + 1}` : null,
                 el.disabled ? "disabled" : null,
                 el.destructive ? "DESTRUCTIVE" : null,
+                ...affordanceFlags(el),
                 labelFlag(el),
                 // "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 = {
+        // 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, disabled: el.disabled, state: stateFlags(el.state) }])),
-        };
+            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
@@ -1761,40 +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;
             });
             // 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 = prev.byKey.get(el.key);
+                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;
+            // 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 the last snapshot (${unchanged} interactables, refs unchanged).`;
+                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})`),
                             // 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 ${prev.byKey.get(el.key)?.label ? `"${prev.byKey.get(el.key)?.label}"` : "empty"})`
+                                ? `~ ${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 = 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 —
@@ -1837,39 +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,
+        });
+    }
+    /** 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) {
+    actionPolicyCheck(el, liveLabel, live = {}) {
         if (!this.readOnly)
             return null;
         // Same-origin navigation links are exempt: navigation is non-destructive
@@ -1883,8 +2364,18 @@ 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;
     }
@@ -1927,12 +2418,13 @@ 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);
@@ -1942,14 +2434,23 @@ export class BrowserEngine {
         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) {
@@ -2149,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,
@@ -2167,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.
@@ -2185,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();
         }
@@ -2210,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)`,
@@ -2230,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() {
@@ -2342,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);
@@ -2351,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
@@ -2391,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.
@@ -2439,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;
@@ -2459,13 +2975,20 @@ export class BrowserEngine {
         // (silent no-op forms): capture the count before to compare after.
         const xhrBefore = this.xhrCount;
         const submitLike = isSubmitLike(el.role, el.name, el.testid);
-        const clickContext = { viaLink: el.role === "link", urlBefore: page.url(), dialogsBefore: this.claimBaseline?.dialogs ?? null };
+        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}"`, clickContext);
@@ -2486,20 +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 !== this.snapshotUrl)
+            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);
@@ -2522,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))})` : "";
@@ -2577,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);
@@ -2647,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);
@@ -2896,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
@@ -3064,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
@@ -3183,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;
@@ -3194,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)})` };
@@ -3267,11 +3903,12 @@ export class BrowserEngine {
             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));
+                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 applied = await this.applyState(read.state);
+            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;
@@ -3288,7 +3925,9 @@ export class BrowserEngine {
                     url: this.page?.url() ?? "",
                 });
                 handedOn = true;
-                this.trackRefreshTask(this.writeBackAfter(this.pageAnswer(req), plan.to, lock));
+                // 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 } : {}),
@@ -3323,8 +3962,9 @@ export class BrowserEngine {
                 target: `${where} with ${plan.to.slot} (rotated by another session; loaded its profile and sent the current cookie)`,
                 url: this.page?.url() ?? "",
             });
+            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));
+            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 */
             });
@@ -3362,6 +4002,7 @@ export class BrowserEngine {
     /** 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({
@@ -3469,8 +4110,10 @@ export class BrowserEngine {
             return;
         const isNew = !broker.learned.has(key);
         broker.learned.add(key);
-        if (isNew)
+        if (isNew) {
             this.refreshCounts.learned += 1;
+            this.refreshEvents.push("learned");
+        }
         const names = rotated.map((r) => r.slot).join(", ");
         let lock;
         try {
@@ -3500,7 +4143,7 @@ export class BrowserEngine {
             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 = state;
+                    now = await this.withPageIndexedDB(state, (full) => rotated.every((r) => rotationStored(full, r)));
                     break;
                 }
                 await new Promise((r) => setTimeout(r, 50));
@@ -3534,9 +4177,10 @@ export class BrowserEngine {
      * that has not stored it in time has the token read from the response
      * 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).
+     * 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(answer, presented, lock) {
+    async writeBackAfter(answer, presented, lock, swapped, storageFrom = "page") {
         const broker = this.refresh;
         try {
             const res = await answer;
@@ -3557,8 +4201,9 @@ export class BrowserEngine {
             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));
@@ -3580,6 +4225,7 @@ export class BrowserEngine {
             }
             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`,
@@ -3590,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)}`,
@@ -3603,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)
@@ -3641,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() {
@@ -3666,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)
@@ -3674,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). */
@@ -3732,7 +4417,8 @@ export class BrowserEngine {
         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) {
@@ -3755,11 +4441,12 @@ export class BrowserEngine {
                 summary.push(`… stopped at the time limit: ${queue.length - i} route(s) not started`);
                 break;
             }
-            const url = `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
-            if (!this.isSameOrigin(url)) {
-                summary.push(`${path} — SKIPPED (off-origin)`);
+            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";
@@ -3775,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)
@@ -3803,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, trackedElements(elements));
             if (!opts.measureOnly) {
-                memory.visitState(fp, finalUrl, route, trackedElements(elements).map((el) => el.key), inertKeys(elements));
+                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
@@ -3862,18 +4545,32 @@ export class BrowserEngine {
             // 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);
-            const flags = [loginRedirect ? "AUTH-REDIRECT" : null, deadEnd ? "DEAD-END" : null, violations.length > 0 ? `${violations.length}⚠` : null].filter(Boolean);
-            summary.push(`${path} — ${status} · ${trackedElements(elements).length} el` +
-                (main ? ` · ${mainRegionTag(main)}` : "") +
-                (missingTestid ? ` · ${missingTestid} no-testid` : "") +
-                (unnamed ? ` · ${unnamed} unnamed` : "") +
-                (flags.length ? ` · ${flags.join(" ")}` : ""));
-            if (violations.length > 0 || deadEnd || loginRedirect || (typeof status === "number" && status >= 400)) {
+            // 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
@@ -3899,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 (
@@ -3921,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})`);
@@ -3952,6 +4656,8 @@ export class BrowserEngine {
             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 = "";
@@ -4003,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
@@ -4022,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;
                     }
@@ -4032,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();
@@ -4065,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 };
                     }
@@ -4095,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, trackedElements(elements));
-                        this.memory.visitState(fp, url, normalizePath(url), trackedElements(elements).map((el) => el.key), inertKeys(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
@@ -4135,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) {
@@ -4168,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) {
@@ -4253,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;
@@ -4271,7 +4993,10 @@ export class BrowserEngine {
                 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)));
@@ -4304,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") {
@@ -4351,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(() => { });
@@ -4402,7 +5134,7 @@ export class BrowserEngine {
             page.off("websocket", onSocket);
             context.off("response", onResponse);
             this.refs.clear();
-            this.lastSnap = null;
+            this.forgetSnapshots();
             this.snapshotUrl = "";
         }
     }
@@ -4474,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.`);
             }
         }
@@ -4507,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
@@ -4796,6 +5657,6 @@ export class BrowserEngine {
         this.refs.clear();
         this.snapshotUrl = "";
         this.currentFingerprint = "";
-        this.lastSnap = null;
+        this.forgetSnapshots();
     }
 }