@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/utils/AnalysisStateManager.js

@@ -24,11 +24,9 @@ export function setTestsRepoDir(dir) {
  *
  * The tests repo is a RUN-scoped fact, but analyze_changes is called once per
  * repository and only the PRIMARY call carries `testsRepoDir` — a related
- * repo's call omits it. An unconditional set therefore wiped the primary's
- * value on the second call of every multi-repo run, and by report time the
- * tests repo was unknown: a UI test generated there looked unbacked by any
- * working tree and the agent demoted it out of newTestsCreated (SKYR-4204,
- * run 32536569467). Callers that mean to clear it use setTestsRepoDir.
+ * repo's call omits it. An unconditional set therefore wipes the primary's
+ * value on the second call of every multi-repo run, leaving the tests repo
+ * unknown by report time. Callers that mean to clear it use setTestsRepoDir.
  */
 export function rememberTestsRepoDir(dir) {
     if (dir)
@@ -39,21 +37,53 @@ export function getTestsRepoDir() {
 }
 /**
  * Multi-repo run anchor: the path of the run-scoped analysis state file for the
- * current Testbot run. One Testbot run = one MCP server process, so a single
- * module-level value is naturally run-scoped (same pattern as _testsRepoDir and
- * processSessionRegistry above).
+ * 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.
+ *
+ * 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.
  */
 let _activeRunStatePath;
 /** Filename of the run-scoped analysis state file under `runArtifactDir()`.
  *  Single-sourced so the constructor that WRITES there and `resolveRunStatePath`
  *  which LOOKS there cannot drift apart. */
 export const RUN_STATE_FILE_NAME = "analyze-changes-state.json";
+/** Filename of the pointer that carries the multi-repo anchor across a server
+ *  restart. It holds one line: the absolute path of the run's state file. */
+export const RUN_STATE_POINTER_FILE_NAME = "run-state-path";
+function runStatePointerFile() {
+    const runDir = runArtifactDir();
+    return runDir ? path.join(runDir, RUN_STATE_POINTER_FILE_NAME) : undefined;
+}
+/** The anchored path a previous process wrote, or undefined. A pointer naming a
+ *  file that is gone is deleted rather than returned: the run it belonged to is
+ *  over, and a stale path would send this stage to the wrong file. */
+function readRunStatePointer() {
+    const pointer = runStatePointerFile();
+    if (!pointer)
+        return undefined;
+    let pointed;
+    try {
+        pointed = fs.readFileSync(pointer, "utf-8").trim();
+    }
+    catch {
+        return undefined;
+    }
+    if (pointed && fs.existsSync(pointed))
+        return pointed;
+    try {
+        fs.unlinkSync(pointer);
+    }
+    catch {
+        // Nothing depends on the delete succeeding; the path is unusable either way.
+    }
+    return undefined;
+}
 /**
  * Directory holding this run's Skyramp artifacts — the state file, and the report written
  * beside it (SKYR-4147) — or undefined outside a run.
@@ -62,15 +92,13 @@ export const RUN_STATE_FILE_NAME = "analyze-changes-state.json";
  * work it out from the environment on their own. So neither has to tell the other where
  * the run's files live, and the path never passes through the model.
  *
- * The GitHub Action is the only caller customers run, and GitHub sets `RUNNER_TEMP` for
- * it; the eval harness sets it itself. Nothing customers run is on another CI system, so
- * the GitHub-specific name is only a naming problem — it does not break anything today.
- * If a caller on another CI system is added, rename this then, or let it read that
- * system's variable. Do not add a second variable for a caller that does not exist.
+ * The GitHub Action is the only caller customers run and GitHub sets `RUNNER_TEMP` for it;
+ * the eval harness sets it itself. If a caller on another CI system is added, rename this
+ * then, or let it read that system's variable. Do not add a second variable for a caller
+ * that does not exist.
  *
- * Kept in one place for the same reason `RUN_STATE_FILE_NAME` is: the directory used to be
- * written out at three call sites, so only the filename was safe from the three copies
- * drifting apart. testbot keeps its matching copy in one place too, in `skyrampTempDir()`.
+ * Kept in ONE place, like `RUN_STATE_FILE_NAME`: written out per call site, the copies
+ * drift. testbot keeps its matching copy in `skyrampTempDir()`.
  */
 export function runArtifactDir() {
     const runnerTemp = process.env.RUNNER_TEMP?.trim();
@@ -78,6 +106,21 @@ export function runArtifactDir() {
 }
 export function setActiveRunStatePath(stateFilePath) {
     _activeRunStatePath = stateFilePath;
+    const pointer = runStatePointerFile();
+    if (!pointer)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(pointer), { recursive: true });
+        fs.writeFileSync(pointer, stateFilePath, "utf-8");
+    }
+    catch (error) {
+        // The in-memory anchor still holds for this process, so this stage works
+        // either way. Only a later stage loses the path.
+        logger.warning("Could not write the run state pointer", {
+            pointer,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
 }
 export function getActiveRunStatePath() {
     return _activeRunStatePath;
@@ -85,21 +128,30 @@ export function getActiveRunStatePath() {
 /** Reset the run anchor — for tests, and as a safety hook between runs. */
 export function clearActiveRunStatePath() {
     _activeRunStatePath = undefined;
+    const pointer = runStatePointerFile();
+    if (!pointer)
+        return;
+    try {
+        fs.unlinkSync(pointer);
+    }
+    catch {
+        // Absent already, which is the state this asks for.
+    }
 }
 /**
  * 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), but 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 without a new anchor mechanism. Standalone/IDE usage has no
- * RUNNER_TEMP and resolves to undefined — correct, since there is no run state.
+ * 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.
  *
- * Lives here rather than in each caller so the convention has one home: this is
- * the module that decides where the file goes, so it is the module that should
- * decide where to look for it.
+ * 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.
  */
 export function resolveRunStatePath(explicitPath) {
     if (explicitPath)
@@ -107,6 +159,9 @@ export function resolveRunStatePath(explicitPath) {
     const anchored = getActiveRunStatePath();
     if (anchored)
         return anchored;
+    const pointed = readRunStatePointer();
+    if (pointed)
+        return pointed;
     const runDir = runArtifactDir();
     if (runDir) {
         return path.join(runDir, RUN_STATE_FILE_NAME);
@@ -124,7 +179,7 @@ export function resolveRunStatePath(explicitPath) {
  * write to a file that holds no run data is already a no-op.
  *
  * Returns the path rather than a boolean so a caller can also key per-run state on
- * it, and lives here because this is the module that decides where the file goes.
+ * it. It lives here because this is the module that decides where the file goes.
  */
 export function currentRunStateFile() {
     const stateFile = resolveRunStatePath();
@@ -187,7 +242,7 @@ export function hasSessionData(sessionId) {
  * and wrap it properly.
  */
 export function normalizeRecommendationState(data) {
-    if (!data.analysis && data.apiEndpoints) {
+    if (!data.analysis && data.metadata) {
         logger.info("Detected unwrapped RepositoryAnalysis — adapting");
         return {
             repositoryPath: data.repositoryPath ||
@@ -214,6 +269,44 @@ const STATE_FILE_PREFIXES = {
  * - analysis: Test maintenance workflow (discovery, drift, execution, health)
  * - recommendation: Test recommendation workflow (analyze repo, map tests, recommendations)
  */
+/** The run-wide root fields no analysis payload owns. Read by `writeData` so a
+ *  rebuild of the root cannot delete what another tool wrote there. */
+/** Write through a temporary file and rename over the target: `writeFile` truncates
+ *  then writes, and both readers THROW on a parse failure. */
+async function writeFileAtomically(target, contents) {
+    // `rename` needs only a writable DIRECTORY, so it would replace a read-only
+    // state file a plain write refuses. Two callers depend on that refusal.
+    try {
+        await fs.promises.access(target, fs.constants.W_OK);
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+    }
+    // Per CALL, not per process: the run is ONE process, so two writes racing
+    // inside it share a pid, interleave their bytes and publish unparseable JSON.
+    const temp = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await fs.promises.writeFile(temp, contents, "utf-8");
+        await fs.promises.rename(temp, target);
+    }
+    catch (error) {
+        await fs.promises.rm(temp, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+const ROOT_FIELDS_OWNED_ELSEWHERE = ["plan", "registrationCount", "reportObjections"];
+function carryForwardRootFields(data, existing) {
+    if (!existing)
+        return {};
+    const carried = {};
+    for (const field of ROOT_FIELDS_OWNED_ELSEWHERE) {
+        const incoming = data?.[field];
+        if (incoming === undefined && existing[field] !== undefined)
+            carried[field] = existing[field];
+    }
+    return carried;
+}
 export class StateManager {
     stateFile;
     sessionId;
@@ -318,13 +411,16 @@ export class StateManager {
             // rewriting the primary (root) payload preserves the multi-repo sections.
             let existingMetadata;
             let existingRelated;
+            let existingRoot;
             if (this.exists()) {
                 const existing = await this.readFullState();
                 existingMetadata = existing?.metadata;
                 existingRelated = existing?.relatedRepos;
+                existingRoot = existing ?? undefined;
             }
             const state = {
                 ...data,
+                ...carryForwardRootFields(data, existingRoot),
                 metadata: {
                     sessionId: this.sessionId,
                     stateType: this.stateType,
@@ -343,7 +439,7 @@ export class StateManager {
             await fs.promises.mkdir(path.dirname(this.stateFile), {
                 recursive: true,
             });
-            await fs.promises.writeFile(this.stateFile, JSON.stringify(state, null, 2), "utf-8");
+            await writeFileAtomically(this.stateFile, JSON.stringify(state, null, 2));
             logger.debug(`Wrote data to state file: ${this.stateFile}`);
         }
         catch (error) {
@@ -359,16 +455,18 @@ 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? Primary when `repo` is falsy (single-repo /
-     *  legacy callers), when no state file exists yet (the FIRST write of a run is
-     *  the primary — the testbot prompt mandates the primary is analyzed first), or
-     *  when `repo` matches the `repo` recorded on the root metadata. A non-empty
-     *  `repo` that doesn't match an already-recorded root is a RELATED repo. */
-    async isPrimaryRepo(repo) {
+    /** 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;
-        // First write of the run is the primary (the prompt mandates the primary is
-        // analyzed first), even when it carries an explicit owner/repo.
+        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();
@@ -379,13 +477,18 @@ export class StateManager {
     }
     /**
      * Write one repo's analysis into the run-scoped state file. The primary repo
-     * (repo absent, or matching the root's recorded repo, or the first write of the
-     * run) is written to the root via writeData(); a related repo is upserted into
+     * (repo absent, matching the declared `primaryRepo`, matching the root's
+     * recorded repo, or the first write of a run that declares no primary) is
+     * written to the root via writeData(); a related repo is upserted into
      * `relatedRepos[repo]`, preserving the primary + other sections. Used by
      * skyramp_analyze_changes — every repo in the run writes the SAME stateFile path.
      */
+    /** Fields another tool owns, carried forward when this caller's payload omits
+     *  them: `writeData` rebuilds the root from its payload, and an analyze call that
+     *  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)) {
+        if (await this.isPrimaryRepo(options.repo, options.primaryRepo)) {
             await this.writeData(data, {
                 repositoryPath: options.repositoryPath,
                 step: options.step,
@@ -395,14 +498,17 @@ export class StateManager {
             });
             return;
         }
-        // Related repo: read the current file (must already exist — primary is
-        // analyzed first), upsert this repo's section, write back.
+        // Related repo: upsert this repo's section into the current file. The file
+        // need not exist yet — with a declared primary a related repo may write
+        // first, and then the root is created EMPTY and tagged with the primary's
+        // name, so the primary's own call still lands at the root when it arrives.
         const existing = (await this.readFullState());
         const base = existing ??
             {
                 metadata: {
                     sessionId: this.sessionId,
                     stateType: this.stateType,
+                    repository: options.primaryRepo,
                     createdAt: new Date().toISOString(),
                     updatedAt: new Date().toISOString(),
                 },
@@ -421,7 +527,7 @@ export class StateManager {
         base.relatedRepos = relatedRepos;
         base.metadata = { ...base.metadata, updatedAt: new Date().toISOString() };
         await fs.promises.mkdir(path.dirname(this.stateFile), { recursive: true });
-        await fs.promises.writeFile(this.stateFile, JSON.stringify(base, null, 2), "utf-8");
+        await writeFileAtomically(this.stateFile, JSON.stringify(base, null, 2));
         logger.debug(`Wrote ${options.repo} section to state file: ${this.stateFile}`);
     }
     /**
@@ -494,22 +600,6 @@ export class StateManager {
             logger.debug(`Deleted state file: ${this.stateFile}`);
         }
     }
-    async getSize() {
-        if (!this.exists()) {
-            return 0;
-        }
-        const stats = await fs.promises.stat(this.stateFile);
-        return stats.size;
-    }
-    async getSizeFormatted() {
-        const bytes = await this.getSize();
-        if (bytes === 0)
-            return "0 B";
-        const k = 1024;
-        const sizes = ["B", "KB", "MB", "GB"];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
-        return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-    }
     /**
      * Cleanup old state files
      * @param maxAgeHours Maximum age in hours

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

@@ -288,7 +288,7 @@ function lintArrayDepth(commentless) {
                 rule: "array-missing-next-index-check",
                 severity: "warn",
                 message: `Items of \`${base}\` are asserted up to index ${maxIdx}, but index ${maxIdx + 1} is never asserted absent.`,
-                remediation: `Add an absence assertion for the index after the last expected item (e.g. \`getValue(response, "${nextPath}")\` is undefined / None).`,
+                remediation: `Add an absence assertion for the index after the last expected item (e.g. \`getValue(response, "${nextPath}")\` is null / None).`,
             });
         }
     }

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

@@ -15,6 +15,8 @@ const EXACT_MATCHERS = new Set([
     "toEqual",
     "toStrictEqual",
     "toBeUndefined",
+    "toBeNull",
+    "to_be_null",
     "to_have_text",
     "to_have_value",
     "to_have_attribute",
@@ -47,6 +49,8 @@ const PARTIAL_MATCHERS = new Set([
     "to_be_enabled",
     "to_be_hidden",
 ]);
+/** 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. */
 const CHAIN_LINKS = new Set([
     "not",
@@ -75,9 +79,14 @@ export function detectAssertionLanguage(testFile) {
             return undefined;
     }
 }
-function matcherWeight(matcher) {
+function matcherWeight(matcher, links = []) {
     if (matcher === undefined)
         return 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.
+    if (NULL_MATCHERS.has(matcher) && links.includes("not"))
+        return 1;
     if (EXACT_MATCHERS.has(matcher))
         return 3;
     if (PARTIAL_MATCHERS.has(matcher))
@@ -85,12 +94,45 @@ function matcherWeight(matcher) {
     // Unknown matchers weigh 1, never 0 — any added assertion raises the score.
     return 1;
 }
-function fingerprintOf(raw, start, end) {
-    return raw
-        .slice(start, end)
-        .replace(/\s+/g, " ")
-        .trim()
-        .slice(0, FINGERPRINT_CHAR_CAP);
+function fingerprintOf(statement) {
+    return statement.replace(/\s+/g, " ").trim().slice(0, FINGERPRINT_CHAR_CAP);
+}
+/** The first comma at paren/bracket/brace depth 0 and outside any quoted literal,
+ *  or -1. A call's own arguments sit deeper, so `f(a, b)` yields no split, and a
+ *  comma inside `'…'`, `"…"` or `` `…` `` is text, not a separator. Callers pass
+ *  raw source here (a fingerprint), where quotes are still present; the python
+ *  scanner uses the same two quote forms, so one scan covers both dialects. */
+function topLevelCommaIndex(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === "'" || c === '"' || c === "`") {
+            // Skip to the matching close quote. An unterminated literal ends the scan,
+            // so a truncated fingerprint yields no split rather than a bogus one.
+            i++;
+            while (i < text.length && text[i] !== c) {
+                if (text[i] === "\\")
+                    i++;
+                i++;
+            }
+            if (i >= text.length)
+                return -1;
+        }
+        else if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}")
+            depth--;
+        else if (depth === 0 && c === ",")
+            return i;
+    }
+    return -1;
+}
+/** An argument list without whatever follows its first argument. Every assertion
+ *  form here takes the subject first and an optional MESSAGE after it, and the
+ *  message describes the assertion rather than being part of what it checks. */
+function firstArgument(args) {
+    const comma = topLevelCommaIndex(args);
+    return comma === -1 ? args : args.slice(0, comma);
 }
 function startOfLine(src, offset) {
     const nl = src.lastIndexOf("\n", offset - 1);
@@ -107,39 +149,51 @@ function expectSites(raw, stripped) {
         const argClose = balancedCloseIndex(stripped, openIdx);
         if (argClose === -1)
             continue;
+        // `expect(actual, "message")` takes the message second. Cut it at the first
+        // top-level comma of the STRIPPED args, where a comma inside a string or a
+        // template literal has already been blanked and so is not one.
+        const commaInArgs = topLevelCommaIndex(stripped.slice(openIdx + 1, argClose));
+        const actualEnd = commaInArgs === -1 ? argClose : openIdx + 1 + commaInArgs;
+        const actual = raw.slice(openIdx + 1, actualEnd);
         // Walk the chain past link members (.not / .resolves / …) to the matcher.
         let cursor = argClose + 1;
         let matcher;
+        const links = [];
         for (;;) {
             const link = /^\s*\.\s*([A-Za-z_]\w*)/.exec(stripped.slice(cursor));
             if (!link)
                 break;
             cursor += link[0].length;
-            if (CHAIN_LINKS.has(link[1]))
+            if (CHAIN_LINKS.has(link[1])) {
+                links.push(link[1]);
                 continue;
+            }
             matcher = link[1];
             break;
         }
-        // Statement extent: start of the site's line through the matcher call's
-        // closing paren (or the expect close when there is no chained call).
-        let stmtEnd = argClose + 1;
+        let matcherArgs;
         if (matcher !== undefined) {
             const matcherOpen = /^\s*\(/.exec(stripped.slice(cursor));
             if (matcherOpen) {
-                const close = balancedCloseIndex(stripped, cursor + matcherOpen[0].length - 1);
+                const open = cursor + matcherOpen[0].length - 1;
+                const close = balancedCloseIndex(stripped, open);
                 if (close !== -1)
-                    stmtEnd = close + 1;
-            }
-            else {
-                stmtEnd = cursor;
+                    matcherArgs = raw.slice(open + 1, close);
             }
         }
-        const stmtStart = startOfLine(raw, m.index);
+        // Built from parts rather than sliced off the line, so a reworded message
+        // and any code sharing the line are both outside the key. Run 34073154568
+        // improved a message, was told the assertion was removed, and reverted the
+        // wording to satisfy the check.
+        const soft = /\.\s*soft/.test(m[0]) ? ".soft" : "";
         sites.push({
             line: lineOfOffset(stripped, m.index),
             matcher,
-            weight: matcherWeight(matcher),
-            fingerprint: fingerprintOf(raw, stmtStart, stmtEnd),
+            weight: matcherWeight(matcher, links),
+            fingerprint: fingerprintOf(`expect${soft}(${actual})` +
+                links.map((link) => `.${link}`).join("") +
+                (matcher === undefined ? "" : `.${matcher}`) +
+                (matcherArgs === undefined ? "" : `(${matcherArgs})`)),
         });
         re.lastIndex = Math.max(re.lastIndex, argClose + 1);
     }
@@ -149,6 +203,9 @@ function expectSites(raw, stripped) {
 function pythonAssertWeight(stmt) {
     if (stmt.includes("==") ||
         stmt.includes("!=") ||
+        // `is None` is the python spelling of `toBeNull` — an exact absence check.
+        // `is not None` stays weak: it is the existence idiom the rubric bans.
+        /\bis\s+None\b/.test(stmt) ||
         // Same tier rule (and same spelling tolerance) as the node-assert scanner
         // — the two had drifted, scoring an identical schema check 3 in JS and 1
         // in python when spelled checkSchema.
@@ -182,7 +239,7 @@ function pythonAssertSites(raw, stripped) {
             sites.push({
                 line: i + 1,
                 weight: pythonAssertWeight(stmt),
-                fingerprint: fingerprintOf(raw, offset + (line.length - line.trimStart().length), stmtEnd),
+                fingerprint: fingerprintOf(raw.slice(offset + (line.length - line.trimStart().length), stmtEnd)),
             });
             i = last;
             offset = stmtEnd + 1;
@@ -220,7 +277,7 @@ function callSites(raw, stripped, re, matcherOf, weightOf) {
             line: lineOfOffset(stripped, m.index),
             matcher: matcherOf(m),
             weight: weightOf(m, args),
-            fingerprint: fingerprintOf(raw, startOfLine(raw, m.index), close === -1 ? m.index + m[0].length : close + 1),
+            fingerprint: fingerprintOf(raw.slice(startOfLine(raw, m.index), close === -1 ? m.index + m[0].length : close + 1)),
         });
     }
     return sites;
@@ -256,7 +313,12 @@ export function subjectOf(fingerprint) {
         const close = balancedCloseIndex(fingerprint, openIdx);
         if (close === -1)
             return undefined;
-        return fingerprint.slice(openIdx + 1, close).replace(/\s+/g, "");
+        // The message went into the subject too, so a reworded message lost the
+        // correlation that tells a REPLACED assertion from a REMOVED one. Dropping
+        // it here is also what lets a baseline written before this change still
+        // correlate: its fingerprint no longer matches, but its subject does.
+        const subject = firstArgument(fingerprint.slice(openIdx + 1, close)).replace(/\s+/g, "");
+        return subject.length > 0 ? subject : undefined;
     }
     // Node assert: the subject is the first top-level argument
     // (`assert.strictEqual(SUBJECT, expected, msg?)`, `assert.ok(SUBJECT, msg?)`).
@@ -265,20 +327,7 @@ export function subjectOf(fingerprint) {
         const openIdx = nodeAssert.index + nodeAssert[0].length - 1;
         const close = balancedCloseIndex(fingerprint, openIdx);
         const args = fingerprint.slice(openIdx + 1, close === -1 ? undefined : close);
-        let depth = 0;
-        let end = args.length;
-        for (let i = 0; i < args.length; i++) {
-            const c = args[i];
-            if (c === "(" || c === "[" || c === "{")
-                depth++;
-            else if (c === ")" || c === "]" || c === "}")
-                depth--;
-            else if (depth === 0 && c === ",") {
-                end = i;
-                break;
-            }
-        }
-        const subject = args.slice(0, end).replace(/\s+/g, "");
+        const subject = firstArgument(args).replace(/\s+/g, "");
         return subject.length > 0 ? subject : undefined;
     }
     const assertPrefix = /^assert\s+/.exec(fingerprint);

package/build/utils/assertion-verify/ui-lints.d.ts

@@ -1,8 +1,3 @@
 import type { AssertionLanguage } from "./metrics.js";
 import { type LintFinding, type LintOptions } from "./lint-types.js";
-/** UI (Playwright) lints. Python (playwright-python) UI specs deliberately get
- *  the site-scoped lints only: the structural rules' patterns and accept-lists
- *  are JS/TS-specific (imports, waitForResponse shapes, expect matcher accept
- *  forms), and porting them without a python golden corpus to validate against
- *  would recreate the false-block class review round 2 removed. Pinned by test. */
 export declare function lintUiSpec(raw: string, language: AssertionLanguage, opts?: LintOptions): LintFinding[];

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

@@ -222,6 +222,36 @@ function lintUnassertedTrailingAction(stripped) {
  *  are JS/TS-specific (imports, waitForResponse shapes, expect matcher accept
  *  forms), and porting them without a python golden corpus to validate against
  *  would recreate the false-block class review round 2 removed. Pinned by test. */
+// SKYR-4305 — a removal guard (`toBeHidden()` / `not.toBeVisible()` on an element a
+// PR removed) is only meaningful next to a positive assertion on the same page: alone
+// it passes on a blank page, a 404, a typo'd testid, or a page the element never
+// rendered on. `toBeHidden` is a PARTIAL_MATCHER (weight 2), so the strength gate does
+// not catch a negative-only spec; this lint does.
+const ABSENCE_ASSERT_RE = /\.\s*(?:toBeHidden|to_be_hidden)\s*\(|\.\s*not\s*\.\s*(?:toBeVisible|toBeAttached)\s*\(|\.\s*not_to_be_(?:visible|attached)\s*\(/g;
+// Only Playwright LOCATOR/page matchers count as the positive half of the pair —
+// they prove something rendered. Generic Jest matchers (toBe/toEqual/toHaveLength)
+// are deliberately absent: `expect(resp.status()).toBe(200)` next to a lone
+// toBeHidden() proves nothing about the page.
+const POSITIVE_ASSERT_RE = /\.\s*(?:toHaveText|toContainText|toHaveValue|toHaveValues|toHaveAttribute|toHaveCount|toHaveURL|toHaveTitle|toHaveId|toHaveClass|toHaveCSS|toHaveJSProperty|toHaveAccessibleName|toHaveAccessibleDescription|toHaveRole|toHaveScreenshot|toBeVisible|toBeChecked|toBeEnabled|toBeDisabled|toBeEditable|toBeEmpty|toBeFocused|toBeInViewport|toContainClass|to_have_text|to_contain_text|to_have_value|to_have_values|to_have_attribute|to_have_count|to_have_url|to_have_title|to_have_id|to_have_class|to_have_css|to_have_js_property|to_have_accessible_name|to_have_accessible_description|to_have_role|to_have_screenshot|to_be_visible|to_be_checked|to_be_enabled|to_be_disabled|to_be_editable|to_be_empty|to_be_focused|to_be_in_viewport|to_contain_class)\s*\(/;
+function lintNegativeOnlySpec(commentless) {
+    ABSENCE_ASSERT_RE.lastIndex = 0;
+    const first = ABSENCE_ASSERT_RE.exec(commentless);
+    if (!first)
+        return [];
+    // Strip the absence assertions themselves, then look for a Playwright matcher
+    // on a rendered element (generic Jest matchers do not count — see POSITIVE_ASSERT_RE).
+    const remainder = commentless.replace(ABSENCE_ASSERT_RE, "");
+    ABSENCE_ASSERT_RE.lastIndex = 0;
+    if (POSITIVE_ASSERT_RE.test(remainder))
+        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")
         return [];
@@ -240,5 +270,7 @@ export function lintUiSpec(raw, language, opts) {
         findings.push(...lintUnassertedTrailingAction(stripped));
     }
     findings.push(...lintTautologies(commentless, opts));
+    if (!maintenance)
+        findings.push(...lintNegativeOnlySpec(commentless));
     return findings;
 }