scenescout 3.14.0 → 3.15.0

package/dist/engine/check.js

@@ -107,12 +107,19 @@ export const WORTH_A_LOOK_RULES = {
         help: "Links with no underline, in the same colour as the page's body text. In running text a reader cannot tell them from the text around them; in navigation this styling is common, and the check cannot tell the two apart.",
         convention: "a visible link style (an underline or a distinct colour) wherever links appear, navigation included",
     },
+    "scrolled-out-controls": {
+        title: "Controls scrolled out of view sideways",
+        help: "Controls inside a horizontally scrolling container (a wide table's last column, say) lie outside its visible width at this viewport, so only a sideways scroll of the container shows them. A wide table that scrolls is a common, deliberate layout; it matters where a project keeps every row's actions in view.",
+        convention: "row actions and other controls that stay in view without a sideways scroll of their container at this viewport width",
+    },
 };
 export const CHECK_RULE_IDS = [...Object.keys(CHECK_RULES), ...Object.keys(WORTH_A_LOOK_RULES)];
 export function isWorthALookRule(rule) {
     return Object.prototype.hasOwnProperty.call(WORTH_A_LOOK_RULES, rule);
 }
-const SEVERITY_RANK = { high: 0, medium: 1, low: 2 };
+export const SEVERITY_RANK = { high: 0, medium: 1, low: 2 };
+/** The route a defect of the app's shared shell is charged to: one fix, however many pages show it. */
+export const SHARED_CHROME_ROUTE = "(shared chrome)";
 /** Snapshot refs (`e12`) are numbered per run; evidence carrying them would never match itself twice. */
 function stripRefs(line) {
     return line.replace(/\be\d+\s+/g, "").trim();
@@ -166,6 +173,8 @@ export function geometryRule(line) {
         return "offpage-control";
     if (/ overlaps /.test(line))
         return "overlapping-controls";
+    if (/ scrolled out of view inside a horizontally scrolling container /.test(line))
+        return "scrolled-out-controls";
     return "layout-issue";
 }
 /**
@@ -238,7 +247,7 @@ export function checkFindings(routes, origin, ignore = [], flows = []) {
         for (const p of r.placeholderOnly)
             add("placeholder-only-label", p, route);
         for (const d of r.design)
-            add(d.rule, d.detail, d.chrome ? "(shared chrome)" : route);
+            add(d.rule, d.detail, d.chrome ? SHARED_CHROME_ROUTE : route);
     }
     for (const f of flows) {
         for (const { path, violation } of f.violations)
@@ -367,7 +376,13 @@ export const CHECK_OPTION_NAMES = [
     "nav-timeout-ms",
 ];
 export const MAX_CHECK_ROUTES = 150;
+/** Link discovery rounds: each crawl reveals the routes its pages link to. Past a few, a site is paginating rather than revealing. */
+export const MAX_DISCOVERY_ROUNDS = 6;
 export const DEFAULT_CHECK_ROUTES = 50;
+/** A path given on the command line, resolved from the directory the command runs in; the same on every platform. */
+export function resolveArgPath(cwd, p) {
+    return p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p) ? p : `${cwd.replace(/[\\/]$/, "")}/${p}`;
+}
 /** Parse `scenescout check` arguments. Every mistake is a sentence, never a half-configured run. */
 export function parseCheckArgs(args, cwd) {
     const positional = [];
@@ -461,7 +476,7 @@ export function parseCheckArgs(args, cwd) {
     const gateRetests = oneOf("gate-retests", GATE_RETESTS, DEFAULT_SETTINGS.gateRetests);
     if (!gateRetests)
         return { ok: false, error: `--gate-retests must be one of ${GATE_RETESTS.join(", ")}` };
-    const resolve = (p) => (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p) ? p : `${cwd.replace(/[\\/]$/, "")}/${p}`);
+    const resolve = (p) => resolveArgPath(cwd, p);
     return {
         ok: true,
         options: {
@@ -548,7 +563,7 @@ const RETEST_SARIF_RULE = {
     defaultConfiguration: { level: "error" },
 };
 function sarifLocation(route) {
-    return route === "(shared chrome)"
+    return route === SHARED_CHROME_ROUTE
         ? {
             physicalLocation: { artifactLocation: { uri: "", uriBaseId: "APP" } },
             message: { text: "the app's shared shell, on every page that renders it" },
@@ -659,10 +674,63 @@ function code(text) {
     const pad = longest > 0 ? " " : "";
     return `${fence}${pad}${text}${pad}${fence}`;
 }
+/** The first three routes as code spans, and how many more. */
 function routeList(routes) {
     const shown = routes.slice(0, 3).map(code);
     return shown.join(", ") + (routes.length > 3 ? ` and ${routes.length - 3} more` : "");
 }
+/** One markdown list item for an issue: its title, rule, evidence and routes. */
+export function issueLine(i) {
+    return `**${CHECK_RULES[i.rule].title}** \`${i.rule}\`: ${cell(i.evidence)}${i.embed ? ` _(in an embed of ${i.embed}: its behaviour, not the app's)_` : ""} — ${routeList(i.routes)}`;
+}
+/** The issues, one section per severity, worst first. Shared by the check's report and the first run's. */
+export function issueSections(issues) {
+    const lines = [];
+    for (const sev of CHECK_SEVERITIES) {
+        const of = issues.filter((i) => i.severity === sev);
+        if (of.length === 0)
+            continue;
+        lines.push("", `## ${sev[0].toUpperCase()}${sev.slice(1)} (${of.length})`, "");
+        for (const i of of)
+            lines.push(`- ${issueLine(i)}`);
+    }
+    return lines;
+}
+const WORTH_A_LOOK_INTRO = "Measured exactly, and defects only under a convention of your project that the check cannot see.";
+/** The worth-a-look section, or nothing when there is none. `gated`: the report is a gate's, so say these never fail it. */
+export function worthALookSection(observations, gated = true) {
+    if (observations.length === 0)
+        return [];
+    const lines = [
+        "",
+        `## Worth a look (${observations.length})`,
+        "",
+        `${WORTH_A_LOOK_INTRO} They are not counted above${gated ? " and never fail the gate, at any --fail-on" : ""}.`,
+        "",
+    ];
+    for (const o of observations) {
+        lines.push(`- **${WORTH_A_LOOK_RULES[o.rule].title}** \`${o.rule}\`: ${cell(o.evidence)} — a defect only if your project uses ${o.convention} — ${routeList(o.routes)}`);
+    }
+    return lines;
+}
+/** The table of routes measured, with each one's status, controls and issue count. */
+export function routesTable(result) {
+    const lines = ["", "## Routes", "", "| Route | Status | Controls | Issues |", "|---|---|---|---|"];
+    for (const r of result.routes) {
+        const n = result.issues.filter((i) => i.routes.includes(r.path)).length;
+        const status = (r.loadError !== undefined ? "did not load" : r.loginRedirect ? `${r.status ?? "?"} → sign-in` : String(r.status ?? "?")) +
+            (r.auditError ? ` (design not measured: ${cell(r.auditError.slice(0, 80))})` : "");
+        // Plain text, not a code span: inside a table cell a code span keeps the backslashes cell() adds.
+        lines.push(`| ${cell(r.path)} | ${status} | ${r.elements} | ${n} |`);
+    }
+    return lines;
+}
+/** The routes known and not visited, as one line; nothing when every known route was visited. */
+export function unvisitedLine(unvisited, why) {
+    if (unvisited.length === 0)
+        return [];
+    return ["", `Not visited (${why}): ${unvisited.slice(0, 20).map(code).join(", ")}${unvisited.length > 20 ? " …" : ""}`];
+}
 /** The human report: the verdict first, then what failed it, then everything else. */
 export function formatCheck(result) {
     const { passed, counts, failing, retestsFailing, couldNotRun } = summarise(result);
@@ -683,32 +751,10 @@ export function formatCheck(result) {
         (result.worthALook.length > 0 ? ` · ${result.worthALook.length} worth a look, never gated` : ""));
     // Right under the verdict: what a green check was allowed to do is part of what it means.
     lines.push("", `Settings — ${describeSettings(result)}`);
-    for (const sev of CHECK_SEVERITIES) {
-        const of = result.issues.filter((i) => i.severity === sev);
-        if (of.length === 0)
-            continue;
-        lines.push("", `## ${sev[0].toUpperCase()}${sev.slice(1)} (${of.length})`, "");
-        for (const i of of) {
-            lines.push(`- **${CHECK_RULES[i.rule].title}** \`${i.rule}\`: ${cell(i.evidence)}${i.embed ? ` _(in an embed of ${i.embed}: its behaviour, not the app's)_` : ""} — ${routeList(i.routes)}`);
-        }
-    }
-    if (result.worthALook.length > 0) {
-        lines.push("", `## Worth a look (${result.worthALook.length})`, "", "Measured exactly, and defects only under a convention of your project that the check cannot see. They are not counted above and never fail the gate, at any --fail-on.", "");
-        for (const o of result.worthALook) {
-            lines.push(`- **${WORTH_A_LOOK_RULES[o.rule].title}** \`${o.rule}\`: ${cell(o.evidence)} — a defect only if your project uses ${o.convention} — ${routeList(o.routes)}`);
-        }
-    }
-    lines.push("", "## Routes", "", "| Route | Status | Controls | Issues |", "|---|---|---|---|");
-    for (const r of result.routes) {
-        const n = result.issues.filter((i) => i.routes.includes(r.path)).length;
-        const status = (r.loadError !== undefined ? "did not load" : r.loginRedirect ? `${r.status ?? "?"} → sign-in` : String(r.status ?? "?")) +
-            (r.auditError ? ` (design not measured: ${cell(r.auditError.slice(0, 80))})` : "");
-        // Plain text, not a code span: inside a table cell a code span keeps the backslashes cell() adds.
-        lines.push(`| ${cell(r.path)} | ${status} | ${r.elements} | ${n} |`);
-    }
-    if (result.unvisited.length > 0) {
-        lines.push("", `Not visited (over --max-routes): ${result.unvisited.slice(0, 20).map(code).join(", ")}${result.unvisited.length > 20 ? " …" : ""}`);
-    }
+    lines.push(...issueSections(result.issues));
+    lines.push(...worthALookSection(result.worthALook));
+    lines.push(...routesTable(result));
+    lines.push(...unvisitedLine(result.unvisited, "over --max-routes"));
     if (result.flows.length > 0 || result.skippedFlows.length > 0) {
         lines.push("", `## Flows (${result.flows.length})`, "");
         for (const f of result.flows) {
@@ -778,6 +824,7 @@ export function toSummaryJson(result, toolVersion) {
             ...(r.auditError !== undefined ? { designNotMeasured: r.auditError } : {}),
         })),
         unvisited: result.unvisited,
+        ...(result.timeBudget ? { timeBudget: result.timeBudget } : {}),
         ignored: result.ignored,
         flows: result.flows.map((f) => ({
             name: f.name,

package/dist/engine/ci.js

@@ -36,6 +36,21 @@ export const DEFAULT_EFFORT = "low";
  */
 export const CI_MODES = ["observe", "read-only", "safe-write", "destructive"];
 export const CI_LEVELS = ["minimal", "medium", "extensive"];
+/**
+ * How a filed finding is told apart from one already stored. `rule`: the
+ * store's rule alone (memory.ts isDuplicateFinding). `judge`: the rule first,
+ * then, for a filing the rule keeps apart, a model asked about the open
+ * findings on the same page (engine/dedup.ts DedupJudge), with the rule's
+ * decision kept whenever the model cannot answer. A CI run already sends
+ * pages to a model and holds a key, so it judges by default; the MCP server
+ * judges only when asked to (DEDUP_ENV or scout_attach {dedup}).
+ */
+export const DEDUP_MODES = ["rule", "judge"];
+export const DEFAULT_CI_DEDUP = "judge";
+/** Turns the dedup judge on for the MCP server: `rule` (the default) or `judge`. An attach's `dedup` wins over it. */
+export const DEDUP_ENV = "SCENESCOUT_DEDUP";
+/** Which provider the MCP server's dedup judge uses when both keys are in its environment. */
+export const DEDUP_PROVIDER_ENV = "SCENESCOUT_DEDUP_PROVIDER";
 export const DEFAULT_CAPS = { turns: 40, tokens: 1_500_000, wallMs: 20 * 60_000 };
 const CAP_BOUNDS = { turns: [1, 500], tokens: [1_000, 20_000_000], minutes: [1, 360] };
 /** Every option `scenescout ci` accepts; the ci action's inputs are these names (ci-test holds them equal). */
@@ -62,6 +77,7 @@ export const CI_OPTION_NAMES = [
     "out",
     "show",
     "compare-url",
+    "dedup",
 ];
 /** The longest --show description: it becomes a line of the model's prompt. */
 export const MAX_SHOW = 200;
@@ -225,6 +241,9 @@ export function parseCiArgs(args, cwd) {
     const navTimeout = parseLimitFlag("nav", flags.get("nav-timeout-ms"));
     if (!navTimeout.ok)
         return navTimeout;
+    const dedup = flags.get("dedup") ?? DEFAULT_CI_DEDUP;
+    if (!DEDUP_MODES.includes(dedup))
+        return { ok: false, error: `--dedup must be one of ${DEDUP_MODES.join(", ")}` };
     const resolve = (p) => (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p) ? p : `${cwd.replace(/[\\/]$/, "")}/${p}`);
     return {
         ok: true,
@@ -247,6 +266,7 @@ export function parseCiArgs(args, cwd) {
             ...(compareUrl ? { compareUrl } : {}),
             ...(actionTimeout.value !== undefined ? { actionTimeoutMs: actionTimeout.value } : {}),
             ...(navTimeout.value !== undefined ? { navTimeoutMs: navTimeout.value } : {}),
+            dedup: dedup,
         },
     };
 }
@@ -278,6 +298,57 @@ export function detectProvider(env, options) {
         return { ok: false, error: `--effort must be one of ${EFFORTS[provider].join(", ")} for ${provider}` };
     return { ok: true, resolved: { provider, model: options.model ?? DEFAULT_MODEL[provider], effort, baseUrl: options.baseUrl ?? DEFAULT_BASE_URL[provider] } };
 }
+// ── the dedup judge's model ─────────────────────────────────────────────────
+/**
+ * The effort the dedup judge asks at: the lowest the provider's API takes.
+ * Measured, effort none judged as well as low and changed no verdict
+ * (docs/benchmark.md); the Messages API has no none, so Anthropic gets low.
+ */
+export function judgeEffort(provider) {
+    return EFFORTS[provider][0];
+}
+/** The MCP server's dedup mode from its environment: `rule` when unset. A value that is neither is refused, naming the variable. */
+export function dedupModeFromEnv(env) {
+    const raw = (env[DEDUP_ENV] ?? "").trim();
+    if (raw === "")
+        return "rule";
+    if (!DEDUP_MODES.includes(raw))
+        throw new Error(`${DEDUP_ENV} must be one of ${DEDUP_MODES.join(", ")}, not ${JSON.stringify(raw)}`);
+    return raw;
+}
+/**
+ * The key and model the MCP server's dedup judge uses when no CI run answers
+ * for it: the provider whose key is in the server's environment (with both,
+ * the one DEDUP_PROVIDER_ENV names), its default model and its lowest effort.
+ * A missing key is an answer (`ok: false`, and the rule decides); a provider
+ * name that is neither is refused.
+ */
+export function judgeKeyConfig(env) {
+    const named = (env[DEDUP_PROVIDER_ENV] ?? "").trim();
+    if (named !== "" && !PROVIDERS.includes(named))
+        throw new Error(`${DEDUP_PROVIDER_ENV} must be one of ${PROVIDERS.join(", ")}, not ${JSON.stringify(named)}`);
+    const withKey = PROVIDERS.filter((p) => present(env, KEY_ENV[p]));
+    let provider;
+    if (named !== "") {
+        provider = named;
+        if (!withKey.includes(provider))
+            return { ok: false, error: `${DEDUP_PROVIDER_ENV}=${provider} needs ${KEY_ENV[provider]} in the server's environment` };
+    }
+    else if (withKey.length === 0) {
+        return { ok: false, error: `the judge needs ${KEY_ENV.anthropic} or ${KEY_ENV.openai} in the server's environment` };
+    }
+    else if (withKey.length > 1) {
+        return { ok: false, error: `both ${KEY_ENV.anthropic} and ${KEY_ENV.openai} are set: set ${DEDUP_PROVIDER_ENV} to anthropic or openai to choose` };
+    }
+    else {
+        provider = withKey[0];
+    }
+    return {
+        ok: true,
+        resolved: { provider, model: DEFAULT_MODEL[provider], effort: judgeEffort(provider), baseUrl: DEFAULT_BASE_URL[provider] },
+        key: (env[KEY_ENV[provider]] ?? "").trim(),
+    };
+}
 /**
  * The environment the MCP server and its browser are started with: this
  * process's, without the keys. Nothing on that side needs them, and a key a
@@ -576,6 +647,14 @@ export function findingsThisRun(before, after) {
     const runsBefore = new Map(before.map((f) => [f.id, f.runs]));
     return after.filter((f) => f.status !== "resolved" && (!runsBefore.has(f.id) || f.runs > (runsBefore.get(f.id) ?? 0)));
 }
+/** One line on how a run deduplicated, for the summary. */
+export function dedupLine(d) {
+    if (d.by === "rule")
+        return "the rule alone";
+    const tokens = d.usage.input + d.usage.output;
+    return (`the rule, then the model judge${d.effort ? ` at effort ${d.effort}` : ""} for filings it kept apart: ${d.calls} call(s)` +
+        `${d.failed ? `, ${d.failed} without an answer (the rule decided those)` : ""}, ${n(tokens)} tokens (in the usage below), ${(d.ms / 1000).toFixed(1)}s`);
+}
 const SEVERITY_ORDER = { high: 0, medium: 1, low: 2 };
 function pathOf(url) {
     try {
@@ -604,6 +683,7 @@ export function ciSummaryMarkdown(r, secrets = []) {
         ...(r.capture ? [] : [`| Level | ${r.level} — completion contract ${r.contractMet ? "met" : "not met (the report's gap ledger says what is missing)"} |`]),
         `| Mode | ${r.mode} |`,
         `| Model | ${r.provider} ${cell(r.model, secrets)}, effort ${r.effort} |`,
+        ...(r.dedup ? [`| Finding dedup | ${dedupLine(r.dedup)} |`] : []),
         `| Usage | ${usageLine(r.spend, r.model, r.endedAt, r.price)} |`,
         ``,
     ];
@@ -668,6 +748,23 @@ export function ciSummaryJson(r, version, secrets = []) {
             seconds: Math.round((r.endedAt - r.spend.startedAt) / 1000),
             estimatedCostUsd: estimateCost(r.model, r.spend.usage, r.price),
         },
+        ...(r.dedup
+            ? {
+                dedup: {
+                    by: r.dedup.by,
+                    ...(r.dedup.by === "judge"
+                        ? {
+                            effort: r.dedup.effort,
+                            calls: r.dedup.calls,
+                            failed: r.dedup.failed,
+                            inputTokens: r.dedup.usage.input,
+                            outputTokens: r.dedup.usage.output,
+                            seconds: Math.round(r.dedup.ms / 100) / 10,
+                        }
+                        : {}),
+                },
+            }
+            : {}),
         counts: {
             high: r.findings.filter((f) => !isWorthALook(f) && f.severity === "high").length,
             medium: r.findings.filter((f) => !isWorthALook(f) && f.severity === "medium").length,

package/dist/engine/claims.js

@@ -86,6 +86,20 @@ const ERROR_RE = /\b(?:error|failed|failure|could ?n[o'’]?t|unable to|went wro
  * unreported because the Danger zone said "This cannot be undone."
  */
 const REFUSAL_RE = /\b(?:can(?:not|[’'`]?t| not)|must be|(?:is|are) already|only (?:an? |the )?\w+(?: \w+)? (?:can|may|be)|may only|can only(?: be)?|(?:nothing|not) (?:was|has been|have been|been) (?:saved|sent|deleted|updated|created|changed|submitted)|(?:was|were|has|have|is|are)(?: not|n[’']t)(?: been)? (?:saved|sent|deleted|updated|created|changed|submitted))\b/i;
+/**
+ * Words that name a refusal outright. An admission when the page ANNOUNCES them
+ * or puts them up in answer to the action, as when a toast echoes the server's
+ * "was refused" message. Not page-wide: "Rejected" and "Blocked" are ordinary
+ * status badges and filter tabs on record pages, and counted wherever they
+ * stood they would excuse every lie on such a page.
+ */
+const REFUSED_RE = /\b(?:refused|rejected|blocked)\b/i;
+/**
+ * Addresses of a page's own infrastructure writes: a token refresh, telemetry,
+ * an error monitor, a heartbeat. Refusing one says nothing about whether the
+ * change the user made was kept, so it is never paired with a success claim.
+ */
+export const INFRASTRUCTURE_WRITE_RE = /\/auth\/(refresh|token|session)|refresh[-_]?token|\/telemetry|\/analytics|\/heartbeat|\/sentry|\/collect\b|\/logs?\b|\/metrics\b/i;
 /** Whether a piece of announced text explains a refusal. */
 export function isRefusalNotice(text) {
     const trimmed = text.trim();
@@ -110,6 +124,15 @@ export function classify(text) {
         return "empty";
     return null;
 }
+/** What counts as an open dialog: a native one or an ARIA one. */
+const DIALOG_SEL = 'dialog[open], [role="dialog"], [role="alertdialog"]';
+/** Page-side count of the open dialogs alone, for a caller that needs nothing else the claim scan reads. */
+export const OPEN_DIALOGS_SCRIPT = `(() => {
+  const visible = ${VISIBLE_SRC};
+  let dialogs = 0;
+  for (const d of document.querySelectorAll(${JSON.stringify(DIALOG_SEL)})) if (visible(d)) dialogs += 1;
+  return dialogs;
+})()`;
 function shortUrl(url) {
     try {
         const u = new URL(url);
@@ -128,25 +151,42 @@ function standIn(req) {
         ? ` The refusal was the write policy's stand-in (the server never received the request); what failed is the page's handling of a refusal, which a real one would meet the same way.`
         : "";
 }
+/** Whether an announced sentence admits the failure: an error, a refusal named outright, or one explained in the app's own words. */
+function admitsInAnnouncement(text) {
+    return classify(text) === "error" || REFUSED_RE.test(text) || isRefusalNotice(text);
+}
 /**
  * The contradictions this action produced, if any.
  *
  * Both rules are silent whenever the page admits the failure, and both require
  * a genuinely refused request — the page half never fires alone.
+ *
+ * `before` is what the page said when the action began, when the action was
+ * the user's (a click, a keypress, typing). A success claim already on screen
+ * then is not the page's answer to this action's write: a status badge reading
+ * "Published", a heading, a row from earlier. Only what the action put up can
+ * contradict what the action's write met. Without it, every text counts.
  */
-export function findContradictions(requests, page) {
+export function findContradictions(requests, page, before) {
     const refused = requests.filter(isRefused);
     if (refused.length === 0)
         return [];
     const claims = page.texts.map(classify);
+    const earlier = before ? new Set([...before.texts, ...(before.announced ?? [])]) : null;
+    const isNew = (text) => earlier === null || !earlier.has(text);
     // An app that says what went wrong has behaved correctly, and nothing below
     // applies. This is checked before anything else so that a page carrying both
     // an error banner and a stale empty state is not reported.
     if (claims.includes("error"))
         return [];
-    // A refusal explained in the app's own words, where the page announces its
-    // responses. Help text with the same wording elsewhere excuses nothing.
-    if ((page.announced ?? []).some(isRefusalNotice))
+    // An admission where the page announces its responses: an error, a refusal
+    // named outright (an app echoing the server's "was refused"), or one
+    // explained in the app's own words. Help text with the same wording
+    // elsewhere excuses nothing.
+    if ((page.announced ?? []).some(admitsInAnnouncement))
+        return [];
+    // A refusal named outright in text the action put up, announced or not.
+    if (earlier !== null && page.texts.some((t) => isNew(t) && t.length <= CLAIM_TEXT_MAX && REFUSED_RE.test(t)))
         return [];
     const out = [];
     const reads = refused.filter((r) => !WRITING_METHODS.has(r.method.toUpperCase()));
@@ -162,15 +202,36 @@ export function findContradictions(requests, page) {
             evidence: `refused-empty ${say(worst)}`,
         });
     }
-    const writes = refused.filter((r) => WRITING_METHODS.has(r.method.toUpperCase()));
-    if (writes.length > 0 && claims.includes("success")) {
+    // Only writes this action sent, and not the page's own infrastructure.
+    const isActionWrite = (r) => WRITING_METHODS.has(r.method.toUpperCase()) && !r.background && !INFRASTRUCTURE_WRITE_RE.test(r.url);
+    const writes = refused.filter(isActionWrite);
+    // Writes of the same action that went through. The message may be about
+    // one of them, so a success claim beside them is a PARTIAL false success:
+    // part of the user's change was refused and the page said nothing about
+    // that part. Still reported, at medium, because silent partial loss is a
+    // real defect; all refused stays high.
+    const kept = requests.filter((r) => isActionWrite(r) && DATA_RESOURCES.has(r.resourceType) && !r.blockedByPolicy && r.status !== null && r.status < 400);
+    const successAt = claims.findIndex((c, i) => c === "success" && isNew(page.texts[i]));
+    if (writes.length > 0 && successAt >= 0) {
         const worst = writes[0];
-        const message = page.texts[claims.indexOf("success")];
-        out.push({
-            kind: "false_success",
-            detail: `${say(worst)} was refused, and the page says ${JSON.stringify(message.trim().slice(0, 80))}. The user is told their change was kept when the server rejected it.${standIn(worst)}`,
-            evidence: `false-success ${say(worst)}`,
-        });
+        const message = JSON.stringify(page.texts[successAt].trim().slice(0, 80));
+        if (kept.length === 0) {
+            out.push({
+                kind: "false_success",
+                detail: `${say(worst)} was refused, and the page says ${message}. The user is told their change was kept when the server rejected it.${standIn(worst)}`,
+                evidence: `false-success ${say(worst)}`,
+            });
+        }
+        else {
+            const total = writes.length + kept.length;
+            out.push({
+                kind: "false_success",
+                severity: "medium",
+                detail: `partial: ${writes.length} of ${total} writes from this action were refused (${say(worst)}), and the page says ${message} with no word about the refused part. ` +
+                    `The user is told their change was kept when part of it was rejected.${standIn(worst)}`,
+                evidence: `false-success-partial ${say(worst)}`,
+            });
+        }
     }
     return out;
 }
@@ -200,6 +261,7 @@ export const CLAIM_SCAN_SCRIPT = `(() => {
   // is a container of static text (its form's help, its warning), and counting
   // it brought back the help text this set exists to exclude.
   const ANNOUNCES = "[role~='status'], [role~='alert'], [aria-live]:not([aria-live='off']), output";
+  const COLUMN_HEADER = "th, [role~='columnheader'], [aria-sort]";
   const seen = new Set();
   const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
   let el = document.body;
@@ -207,7 +269,8 @@ export const CLAIM_SCAN_SCRIPT = `(() => {
     let own = "";
     for (const node of el.childNodes) if (node.nodeType === 3) own += node.nodeValue;
     own = own.replace(/\\s+/g, " ").trim();
-    if (own && own.length <= ${CLAIM_TEXT_MAX} && !seen.has(own) && visible(el)) {
+    // A column header names what a column holds ("Updated on", "Completed"); it claims nothing.
+    if (own && own.length <= ${CLAIM_TEXT_MAX} && !seen.has(own) && !el.closest(COLUMN_HEADER) && visible(el)) {
       seen.add(own);
       texts.push(own);
     }
@@ -243,7 +306,10 @@ export const CLAIM_SCAN_SCRIPT = `(() => {
       if (s && s.length <= ${CLAIM_TEXT_MAX} && !announced.includes(s)) announced.push(s);
     }
   }
+  // Open dialogs, so a page error raised as one opens can be read as the
+  // confirmation a router cancelled a route change for (oracles.ts).
+  let dialogs = 0;
+  for (const d of document.querySelectorAll(${JSON.stringify(DIALOG_SEL)})) if (visible(d)) dialogs += 1;
 
-
-  return { texts, announced, emptyLists };
+  return { texts, announced, emptyLists, dialogs };
 })()`;