@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/build/utils/AnalysisStateManager.js

@@ -35,15 +35,53 @@ export function rememberTestsRepoDir(dir) {
 export function getTestsRepoDir() {
     return _testsRepoDir;
 }
+/**
+ * The run's PRIMARY checkout — its path and its `owner/repo`. Declared at the
+ * run's entry point, never inferred from write order: the testbot action passes
+ * its workingDirectory and its slug to the prompt, so rendering the prompt is
+ * where the run says which checkout is primary (the same capture point as the
+ * report language).
+ *
+ * Write order cannot decide this. A docs-only primary diff lets the related
+ * repo's analyze call land first, and taking the root from whoever wrote first
+ * flipped the attribution of every test in the run (SKYR-4333).
+ *
+ * Entry without a prompt render — IDE use, a bare analyze call — has no
+ * declaration to read, so the first analyze call declares its own here.
+ */
+let _primary;
+export function rememberPrimaryRepository(repositoryPath, repo) {
+    if (!_primary)
+        _primary = { repositoryPath, repo };
+}
+/**
+ * Test seam, and the declaration the prompt render makes at the start of a run.
+ *
+ * A render is a run boundary, so it drops the in-memory state-file anchor as well:
+ * a server that renders a second prompt is serving a second run, and the first
+ * run's file must not take the second run's analysis. The pointer file stays, since
+ * it lives in the job's own `RUNNER_TEMP` — a later STAGE of the same run renders
+ * again in a fresh process and must still find that run's file.
+ */
+export function setPrimaryRepository(primary) {
+    _primary = primary;
+    _activeRunStatePath = undefined;
+}
+export function getPrimaryRepository() {
+    return _primary;
+}
 /**
  * Multi-repo run anchor: the path of the run-scoped analysis state file for the
  * current Testbot run.
  *
- * skyramp_analyze_changes sets this on the FIRST call of a multi-repo run (the one
- * carrying a `repository`) and REUSES it on subsequent related-repo calls, so every
- * repo's analysis lands in ONE state file with per-repo sections — without the agent
- * ever passing a file path (which previously caused filename hallucinations).
- * Single-repo / standalone calls (no `repository`) never set or read this.
+ * skyramp_analyze_changes sets this on the FIRST call of a run and REUSES it on
+ * every later call, so a multi-repo run's analyses land in ONE state file with
+ * per-repo sections — without the agent ever passing a file path (which previously
+ * caused filename hallucinations). A single-repo run takes the same path now that
+ * `repository` is required on every call.
+ *
+ * `setPrimaryRepository` clears it: the prompt render that declares the run's primary
+ * is the same boundary that ends the previous run's file.
  *
  * A staged Testbot run starts a NEW server process per stage, so this value is gone
  * at every stage boundary. That is what the pointer file below is for.
@@ -142,16 +180,15 @@ export function clearActiveRunStatePath() {
  * The run's state-file path, for tools that need to read or amend it without the
  * agent naming it.
  *
- * `setActiveRunStatePath` is only called by skyramp_analyze_changes on multi-repo
- * runs (the ones carrying a `repository` param). It is read back two ways: from
- * memory in this process, and from the pointer file a previous stage of the same
- * run wrote — a staged run starts a fresh server per stage, so memory alone would
- * send later stages to the wrong file.
+ * `setActiveRunStatePath` is called by skyramp_analyze_changes on every run. It is
+ * read back two ways: from memory in this process, and from the pointer file a
+ * previous stage of the same run wrote — a staged run starts a fresh server per
+ * stage, so memory alone would send later stages to the wrong file.
  *
- * A single-repo Testbot run's path is still deterministic in CI: the StateManager
- * constructor above roots "analysis" state under `runArtifactDir()`. Falling back
- * to that covers single-repo runs. Standalone/IDE usage has no RUNNER_TEMP and
- * resolves to undefined — correct, since there is no run state.
+ * The path is deterministic in CI either way: the StateManager constructor above
+ * roots "analysis" state under `runArtifactDir()`, so a run whose anchor was cleared
+ * at a stage boundary resolves to the same file. Standalone/IDE usage has no
+ * RUNNER_TEMP and resolves to undefined — correct, since there is no run state.
  */
 export function resolveRunStatePath(explicitPath) {
     if (explicitPath)
@@ -168,6 +205,50 @@ export function resolveRunStatePath(explicitPath) {
     }
     return undefined;
 }
+/** Whether two paths name the same file. Compared by device and inode, not by
+ *  spelling: `./`, a `..` round-trip, a trailing slash, a symlink and a differing
+ *  case on a case-insensitive disk all name one file, and a string compare calls
+ *  four of those five a different one. Falls back to the resolved spelling when
+ *  either path cannot be read. */
+function namesTheSameFile(a, b) {
+    try {
+        const left = fs.statSync(a);
+        const right = fs.statSync(b);
+        return left.dev === right.dev && left.ino === right.ino;
+    }
+    catch {
+        return path.resolve(a) === path.resolve(b);
+    }
+}
+/**
+ * The state file a tool may act on, or a refusal saying why not.
+ *
+ * A run's state file holds THIS run's analysis and THIS run's plan. A path from
+ * another run carries another run's, and every check would then judge this diff
+ * against it — silently, because both files are valid state files. So a named path
+ * is accepted only when it names the file this run created.
+ *
+ * Gated on `currentRunStateFile`, never on `resolveRunStatePath`: that one builds a
+ * path out of `RUNNER_TEMP`, which GitHub Actions sets on every job including this
+ * repo's own CI, so it answers "where would the file be" and not "is there a run".
+ * Refusing on it would refuse a named path wherever that variable merely exists.
+ *
+ * With no run of its own — standalone use, an IDE, a test — the named path is the
+ * only one there is, and is taken as given.
+ */
+export function resolveOwnRunStatePath(explicitPath) {
+    if (!explicitPath)
+        return { path: resolveRunStatePath() };
+    const own = currentRunStateFile();
+    if (!own)
+        return { path: explicitPath };
+    if (namesTheSameFile(explicitPath, own))
+        return { path: own };
+    return {
+        refusal: `stateFile names ${explicitPath}, which is not this run's state file. This run's is ${own}, ` +
+            `and it holds the analysis and the plan every check reads. Leave stateFile out — the run finds its own.`,
+    };
+}
 /**
  * The run's state file if this process is actually serving a run, else undefined.
  *
@@ -299,7 +380,76 @@ const ROOT_FIELDS_OWNED_ELSEWHERE = [
     "plan",
     "registrationCount",
     "reportObjections",
+    "maxFixAttempts",
+    // Written by the generators, and the analysis payload has none — so without
+    // this a second analyze drops the list of files this run wrote. The report's
+    // execution check reads a missing key as "nothing was written" and goes
+    // quiet, which is the one failure it must not have.
+    "generatedTests",
 ];
+/**
+ * Execution records survive a re-analysis. A repeat `skyramp_analyze_changes`
+ * rewrites a section from a payload that has no `testExecutions` and whose
+ * `existingTests[]` rows carry no `executionBefore/After` — it discovers tests,
+ * it does not run them. Dropping the records would reset every file's
+ * attempt counter (SKYR-4460) while the run-wide cap survives, and lose the
+ * before/after statuses the report reads. So the incoming section keeps the
+ * existing records: `testExecutions` merged (incoming wins per file), and each
+ * existing-test row that lacks execution results takes them from the row with
+ * the same `testFile`. Returns the fields to overlay; empty when nothing carries.
+ */
+function carryForwardExecutionRecords(incoming, existing, where) {
+    if (!existing)
+        return {};
+    const carried = {};
+    const priorExecutions = existing.testExecutions;
+    if (priorExecutions && Object.keys(priorExecutions).length > 0) {
+        const incomingExecutions = (incoming?.testExecutions ?? {});
+        const merged = { ...priorExecutions, ...incomingExecutions };
+        if (Object.keys(merged).length > Object.keys(incomingExecutions).length) {
+            carried.testExecutions = merged;
+        }
+    }
+    const priorRows = existing.existingTests;
+    const incomingRows = incoming?.existingTests;
+    if (Array.isArray(priorRows) && Array.isArray(incomingRows)) {
+        const byFile = new Map();
+        for (const row of priorRows) {
+            if (row?.testFile && (row.executionBefore || row.executionAfter))
+                byFile.set(row.testFile, row);
+        }
+        if (byFile.size > 0) {
+            let touched = 0;
+            const rows = incomingRows.map((row) => {
+                const prior = row?.testFile ? byFile.get(row.testFile) : undefined;
+                if (!prior)
+                    return row;
+                const next = { ...row };
+                if (next.executionBefore === undefined && prior.executionBefore) {
+                    next.executionBefore = prior.executionBefore;
+                    touched++;
+                }
+                if (next.executionAfter === undefined && prior.executionAfter) {
+                    next.executionAfter = prior.executionAfter;
+                    touched++;
+                }
+                return next;
+            });
+            if (touched > 0)
+                carried.existingTests = rows;
+        }
+    }
+    if (Object.keys(carried).length > 0) {
+        logger.info("Carried execution records through a state rewrite", {
+            where,
+            testExecutions: carried.testExecutions
+                ? Object.keys(carried.testExecutions).length
+                : 0,
+            existingTestRows: carried.existingTests ? "merged" : "unchanged",
+        });
+    }
+    return carried;
+}
 function carryForwardRootFields(data, existing) {
     if (!existing)
         return {};
@@ -410,6 +560,24 @@ export class StateManager {
      * Data fields are spread at root level alongside metadata
      */
     async writeData(data, options) {
+        await this.persist(data, options, options.repository);
+    }
+    /**
+     * Append to the root payload of a state file the run has already created.
+     * Takes no repository: the name the first write recorded stays, and the
+     * metadata it wrote is what these callers read back before patching it.
+     */
+    async appendData(data, options) {
+        const recorded = (await this.readFullState())?.metadata.repository;
+        // Not a check on the field — the field is required and always there. This
+        // is the caller appending to a run that never started, which loses the
+        // payload silently if it writes an untagged root instead.
+        if (!recorded) {
+            throw new Error(`no state file to append to at ${this.stateFile}: the run's first write creates it`);
+        }
+        await this.persist(data, options, recorded);
+    }
+    async persist(data, options, repository) {
         try {
             // Read existing metadata + any related-repo sections if file exists, so
             // rewriting the primary (root) payload preserves the multi-repo sections.
@@ -425,16 +593,17 @@ export class StateManager {
             const state = {
                 ...data,
                 ...carryForwardRootFields(data, existingRoot),
+                ...carryForwardExecutionRecords(data, existingRoot, `root of ${this.stateFile}`),
                 metadata: {
                     sessionId: this.sessionId,
                     stateType: this.stateType,
                     repositoryPath: options?.repositoryPath || existingMetadata?.repositoryPath,
-                    repository: options?.repository ?? existingMetadata?.repository,
+                    repository,
                     createdAt: existingMetadata?.createdAt || new Date().toISOString(),
                     updatedAt: new Date().toISOString(),
                     // Preserve the prior step when the caller omits one (matches
                     // repositoryPath/repository/createdAt above) so a metadata-agnostic
-                    // write — e.g. persistExternalRun appending externalTestResults —
+                    // write — e.g. skyramp_execute_test recording an execution —
                     // does not wipe the pipeline step recorded by an earlier phase.
                     step: options?.step ?? existingMetadata?.step,
                 },
@@ -459,25 +628,12 @@ export class StateManager {
     // matching the root's metadata.repo) targets the PRIMARY section, so all
     // single-repo behavior is unchanged.
     // -----------------------------------------------------------------------
-    /** Is `repo` the primary section? By NAME when the caller declares one: the run
-     *  says which repo is primary, so whichever call lands first cannot decide it.
-     *  Otherwise the legacy rule — falsy `repo` (single-repo callers), the first
-     *  write of the run, or a `repo` matching the root metadata (SKYR-4333: a
-     *  docs-only primary diff let the related repo write first and take the root). */
-    async isPrimaryRepo(repo, primaryRepo) {
-        if (!repo)
-            return true;
-        if (primaryRepo)
-            return repo === primaryRepo;
-        // No primary declared: the first write of the run is the primary, even when
-        // it carries an explicit owner/repo.
-        if (!this.exists())
-            return true;
-        const full = await this.readFullState();
-        // File already exists: primary only if `repo` matches the repo recorded on
-        // the root. An untagged root means the primary was written without a repo
-        // (legacy/single-repo), so any non-empty `repo` here is a RELATED repo.
-        return full?.metadata.repository === repo;
+    /** Is `repo` the primary section? By NAME, against the name the run declared
+     *  for its primary checkout — so whichever call lands first cannot decide it
+     *  (SKYR-4333: a docs-only primary diff let the related repo write first and
+     *  take the root). */
+    isPrimaryRepo(repo, primaryRepo) {
+        return repo === primaryRepo;
     }
     /**
      * Write one repo's analysis into the run-scoped state file. The primary repo
@@ -492,7 +648,25 @@ export class StateManager {
      *  did so deleted the plan the agent had registered. NAMED rather than "keep
      *  everything omitted", which would resurrect fields a re-analysis clears. */
     async writeRepoData(data, options) {
-        if (await this.isPrimaryRepo(options.repo, options.primaryRepo)) {
+        await this.route(data, options, options.primary.repo);
+    }
+    /**
+     * Update one repo's section of a state file the run has already created.
+     * Takes no primary: the root records the primary's name, and these callers
+     * (execute, run-existing-tests, actions) read the section back before they
+     * patch it, so the run is already under way.
+     */
+    async updateRepoData(data, options) {
+        const recorded = (await this.readFullState())?.metadata.repository;
+        // Not a check on the field — the field is required and the root always has
+        // one. This is a caller patching a run that never started.
+        if (!recorded) {
+            throw new Error(`no state file to update at ${this.stateFile}: skyramp_analyze_changes creates it`);
+        }
+        await this.route(data, options, recorded);
+    }
+    async route(data, options, primaryRepo) {
+        if (this.isPrimaryRepo(options.repo, primaryRepo)) {
             await this.writeData(data, {
                 repositoryPath: options.repositoryPath,
                 step: options.step,
@@ -512,7 +686,10 @@ export class StateManager {
                 metadata: {
                     sessionId: this.sessionId,
                     stateType: this.stateType,
-                    repository: options.primaryRepo,
+                    // The primary's own name AND path, so a root created by a related
+                    // repo's earlier call still describes the primary completely.
+                    repository: primaryRepo,
+                    repositoryPath: options.primary?.repositoryPath,
                     createdAt: new Date().toISOString(),
                     updatedAt: new Date().toISOString(),
                 },
@@ -524,8 +701,12 @@ export class StateManager {
         // that skyramp_analyze_changes recorded — getRepoRepositoryPath() relies on
         // it to re-absolutize that repo's test paths.
         const priorRepositoryPath = relatedRepos[options.repo]?.repositoryPath;
+        const priorData = relatedRepos[options.repo]?.data;
         relatedRepos[options.repo] = {
-            data,
+            data: {
+                ...data,
+                ...carryForwardExecutionRecords(data, priorData, `section ${options.repo} of ${this.stateFile}`),
+            },
             repositoryPath: options.repositoryPath ?? priorRepositoryPath,
         };
         base.relatedRepos = relatedRepos;
@@ -539,10 +720,10 @@ export class StateManager {
      * undefined → the primary (root) section (identical to readData()).
      */
     async readRepoData(repo) {
-        if (await this.isPrimaryRepo(repo)) {
+        const full = await this.readFullState();
+        if (!repo || (full && this.isPrimaryRepo(repo, full.metadata.repository))) {
             return this.readData();
         }
-        const full = await this.readFullState();
         return full?.relatedRepos?.[repo]?.data ?? null;
     }
     /**
@@ -551,7 +732,7 @@ export class StateManager {
      */
     async getRepoRepositoryPath(repo) {
         const full = await this.readFullState();
-        if (await this.isPrimaryRepo(repo)) {
+        if (!repo || (full && this.isPrimaryRepo(repo, full.metadata.repository))) {
             return full?.metadata.repositoryPath;
         }
         return full?.relatedRepos?.[repo]?.repositoryPath;
@@ -572,13 +753,16 @@ export class StateManager {
      */
     async listRepoCheckouts() {
         const full = await this.readFullState();
+        // No file, no checkouts — a question about the run, not about the field.
+        if (!full)
+            return [];
         const checkouts = [
             {
-                root: full?.metadata.repositoryPath,
-                repository: full?.metadata.repository,
+                root: full.metadata.repositoryPath,
+                repository: full.metadata.repository,
                 primary: true,
             },
-            ...Object.entries(full?.relatedRepos ?? {}).map(([repository, section]) => ({
+            ...Object.entries(full.relatedRepos ?? {}).map(([repository, section]) => ({
                 root: section.repositoryPath,
                 repository,
                 primary: false,

package/build/utils/assertion-verify/api-shared-lints.js

@@ -41,9 +41,16 @@ function assertedStatuses(commentless, statusUseOffsets) {
     for (const offset of statusUseOffsets) {
         const lineEnd = commentless.indexOf("\n", offset);
         const line = commentless.slice(offset, lineEnd === -1 ? undefined : lineEnd);
-        const code = /\b([1-5]\d{2})\b/.exec(line);
-        if (code)
-            statuses.push(Number(code[1]));
+        // Every status-looking token on the line, not the first: a label such as
+        // `expect(r.statusCode, "legacy 404").toBe(200)` reads 404 before the code
+        // the matcher actually asserts. Two different codes on one line means the
+        // line does not say which is asserted, so NaN goes in and every exemption
+        // below refuses to fire on it.
+        const codes = new Set([...line.matchAll(/\b([1-5]\d{2})\b/g)].map((m) => Number(m[1])));
+        if (codes.size === 1)
+            statuses.push([...codes][0]);
+        else if (codes.size > 1)
+            statuses.push(Number.NaN);
     }
     return statuses;
 }
@@ -94,10 +101,12 @@ const STATUS_HELPER_BEFORE_RE = /check_?status_?code\s*\(\s*$/i;
  *  Any other read — getValue/get_response_value/checkSchema/.json()/passed as a
  *  call argument, including inside a template-literal or f-string interpolation
  *  — clears it. Exempt: DELETE calls, sole 204/202 statuses, poll bindings
- *  inside loops. Severity follows the rubric: unconditional (`hard`) for
- *  4xx/5xx — an error body must always be asserted — and advisory (`warn`)
- *  when only 2xx statuses are asserted, because a 200 can legitimately carry
- *  no body (/logout, /cancel) and that is not deterministically knowable. */
+ *  inside loops, and any response whose asserted statuses are all >= 400 — a
+ *  refusal is proven by the refusal, and which error fields a test pins is the
+ *  plan's decision. Severity: unconditional (`hard`) for a response nothing
+ *  asserts at all, and advisory (`warn`) when only 2xx statuses are asserted,
+ *  because a 200 can legitimately carry no body (/logout, /cancel) and that is
+ *  not deterministically knowable. */
 function lintStatusOnlyResponses(stripped, commentless, language, bindings) {
     const findings = [];
     for (const { varName, declIndex, declClose } of bindings) {
@@ -144,27 +153,36 @@ function lintStatusOnlyResponses(stripped, commentless, language, bindings) {
         if (statuses.length > 0 && statuses.every((s) => s === 204 || s === 202)) {
             continue;
         }
-        // Never-used responses and asserted error statuses are unconditional
-        // violations; a 2xx-only status check is advisory (empty-body 200s exist).
-        const severity = statusUses === 0 || statuses.some((s) => s >= 400) ? "hard" : "warn";
+        // A refused request is proven by the refusal. Which error body fields a test
+        // pins, if any, is the plan's decision — a case that states the exact code or
+        // wording gets it asserted, and one that does not must not be forced into
+        // pinning today's spelling, because the fixed app refuses the same input with
+        // a different code. This lint made that a hard failure and so contradicted the
+        // planning rule on `mrugesh/refusal-not-status`.
+        // EVERY asserted status, the way the 204/202 exemption above reads them: a
+        // variable reused for a refused call and then a successful one asserts both,
+        // and `some` let the successful one's missing body ride out on the refusal.
+        if (statuses.length > 0 && statuses.every((status) => status >= 400))
+            continue;
+        // A response nothing asserts at all is still an unconditional violation; a
+        // 2xx-only status check stays advisory, because empty-body 200s exist.
+        const severity = statusUses === 0 ? "hard" : "warn";
         findings.push({
             rule: "status-only-response",
             severity,
             line: lineOfOffset(stripped, declIndex),
             message: statusUses > 0
-                ? severity === "hard"
-                    ? `Error response \`${varName}\` is only checked for its status code — the error body (code/message/detail) must be asserted.`
-                    : `Response \`${varName}\` is only checked for its status code.`
+                ? `Response \`${varName}\` is only checked for its status code.`
                 : `Response \`${varName}\` is captured but never asserted.`,
             // The advisory case is phrased as a question, not an instruction. A
             // response no behaviour in the file depends on is CORRECT with its
             // status code and nothing more (SKYR-4310) — telling the agent to
             // assert the body regardless is how a 136-assertion test gets written
-            // to prove a default page size. The hard case is unchanged: an error
-            // body carries the evidence, so it is never optional.
+            // to prove a default page size. The hard case is now only a response
+            // nothing asserts at all.
             remediation: severity === "warn"
                 ? `If a behaviour this file tests depends on this response's body, assert the fields it depends on via \`${helperCall(language, varName)}\`. If no behaviour depends on it, the status code alone is the right answer — leave it.`
-                : `Assert the error body's fields via \`${helperCall(language, varName)}\` after the status assertion.`,
+                : `Assert this response's status, and the fields a behaviour in this file depends on via \`${helperCall(language, varName)}\`.`,
         });
     }
     return findings;

package/build/utils/assertion-verify/metrics.js

@@ -27,6 +27,10 @@ const EXACT_MATCHERS = new Set([
     "to_equal",
     "toHaveJSProperty",
     "to_have_js_property",
+    // SKYR-4462: an exact computed value, the same tier as toHaveAttribute and
+    // strictly stronger than toContainText (which already weighs 2).
+    "toHaveCSS",
+    "to_have_css",
 ]);
 /** Pattern/partial/state matchers — weaker than exact values, but real
  *  behavioral assertions: `toBeDisabled` after an action asserts a semantic
@@ -48,7 +52,25 @@ const PARTIAL_MATCHERS = new Set([
     "to_be_disabled",
     "to_be_enabled",
     "to_be_hidden",
+    // SKYR-4462: token-bounded class match — a real class assertion, the
+    // appearance rule's preferred form.
+    "toContainClass",
+    "to_contain_class",
 ]);
+// SKYR-4462: numeric comparison matchers. Generic on their own (an existence-
+// tier `expect(count).toBeGreaterThan(0)` is padding), so they earn weight 2
+// ONLY when the compared subject reads a geometry property — a boundingBox()
+// x/y/edge comparison, the one appearance case that has no record-time kind.
+const RANGE_MATCHERS = new Set([
+    "toBeLessThan",
+    "toBeGreaterThan",
+    "toBeLessThanOrEqual",
+    "toBeGreaterThanOrEqual",
+]);
+// `.x` / `.y` / `.left` … or `['x']` / `["width"]` — a boundingBox() geometry
+// access. `count`, `.length`, `status_code` do not match, so their comparisons
+// stay existence-tier.
+const GEOMETRY_ACCESS = /(?:\.|\[['"])(?:x|y|left|top|right|bottom|width|height)\b/;
 /** Absence matchers whose tier depends on whether the chain negates them. */
 const NULL_MATCHERS = new Set(["toBeNull", "to_be_null"]);
 /** Chain links to skip between `expect(...)` and the matcher. */
@@ -79,9 +101,13 @@ export function detectAssertionLanguage(testFile) {
             return undefined;
     }
 }
-function matcherWeight(matcher, links = []) {
+function matcherWeight(matcher, links = [], subject = "") {
     if (matcher === undefined)
         return 1;
+    // A boundingBox() ordering comparison is a real layout assertion; the same
+    // matcher on a count/length is padding, so it is the subject that decides.
+    if (RANGE_MATCHERS.has(matcher))
+        return GEOMETRY_ACCESS.test(subject) ? 2 : 1;
     // `not.toBeNull()` is the weak existence idiom the rubric bans, while a bare
     // `toBeNull()` is the exact absence assertion it asks for. Same matcher, so
     // only the chain separates them.
@@ -189,7 +215,7 @@ function expectSites(raw, stripped) {
         sites.push({
             line: lineOfOffset(stripped, m.index),
             matcher,
-            weight: matcherWeight(matcher, links),
+            weight: matcherWeight(matcher, links, actual),
             fingerprint: fingerprintOf(`expect${soft}(${actual})` +
                 links.map((link) => `.${link}`).join("") +
                 (matcher === undefined ? "" : `.${matcher}`) +
@@ -199,8 +225,11 @@ function expectSites(raw, stripped) {
     }
     return sites;
 }
-/** Weight of a bare python `assert` statement, classified by its operators. */
-function pythonAssertWeight(stmt) {
+/** Weight of a bare python `assert` statement, classified by its operators.
+ *  `raw` is the unstripped text: the geometry check reads a `['x']` key that the
+ *  string-blanking pass would otherwise erase; the operator checks stay on the
+ *  stripped `stmt` so they never match inside a string literal. */
+function pythonAssertWeight(stmt, raw = stmt) {
     if (stmt.includes("==") ||
         stmt.includes("!=") ||
         // `is None` is the python spelling of `toBeNull` — an exact absence check.
@@ -211,7 +240,11 @@ function pythonAssertWeight(stmt) {
         // in python when spelled checkSchema.
         /\bcheck_?schema\s*\(/i.test(stmt))
         return 3;
-    if (/\bre\s*\.\s*(?:match|fullmatch)\s*\(|\.startswith\s*\(|\bin\b/.test(stmt))
+    if (/\bre\s*\.\s*(?:match|fullmatch)\s*\(|\.startswith\s*\(|\bin\b/.test(stmt) ||
+        // SKYR-4462: a bounding_box x/y ordering compare (image['x'] < info['x']),
+        // the python twin of toBeLessThan on a geometry property. A plain range
+        // check (status_code >= 200) reads no geometry access and stays weight 1.
+        (/[<>]/.test(stmt) && GEOMETRY_ACCESS.test(raw)))
         return 2;
     return 1;
 }
@@ -238,7 +271,7 @@ function pythonAssertSites(raw, stripped) {
             const stmtEnd = offset + stmt.length;
             sites.push({
                 line: i + 1,
-                weight: pythonAssertWeight(stmt),
+                weight: pythonAssertWeight(stmt, raw.slice(offset + (line.length - line.trimStart().length), stmtEnd)),
                 fingerprint: fingerprintOf(raw.slice(offset + (line.length - line.trimStart().length), stmtEnd)),
             });
             i = last;

package/build/utils/assertion-verify/ui-lints.js

@@ -244,13 +244,15 @@ function lintNegativeOnlySpec(commentless) {
     ABSENCE_ASSERT_RE.lastIndex = 0;
     if (POSITIVE_ASSERT_RE.test(remainder))
         return [];
-    return [{
+    return [
+        {
             rule: "negative-only-spec",
             severity: "hard",
             line: lineOfOffset(commentless, first.index),
             message: "Every locator assertion in this spec asserts absence (toBeHidden / not.toBeVisible); nothing proves the page rendered, so it passes on a blank page, a 404 or a typo'd selector.",
             remediation: "Add at least one positive assertion on a retained element of the same page (toHaveText / toHaveValue / toHaveCount / toHaveURL) next to the absence assertions.",
-        }];
+        },
+    ];
 }
 export function lintUiSpec(raw, language, opts) {
     if (language === "java")