tewip-ai 0.4.0

package/dist/engine/drift-rules.js

@@ -0,0 +1,98 @@
+import { extractLocator, isElementNotFound, locatorName, strictModeViolation } from './error-parse.js';
+import { describeElement, rankCandidates } from './similarity.js';
+export const DRIFT_MIN_SIMILARITY = 0.6;
+/** Best and runner-up drift candidates closer than this are treated as ambiguous. */
+const DRIFT_AMBIGUITY_GAP = 0.05;
+function declined(source, message, data) {
+    return { category: null, confidence: 0, evidence: [{ source, message, data }] };
+}
+export const locatorDrift = {
+    id: 'locator-drift',
+    evaluate({ record, history, loadSnapshot }) {
+        if (!isElementNotFound(record.errorMessage))
+            return null;
+        const locator = extractLocator(record.errorMessage);
+        if (!locator)
+            return declined(this.id, 'element not found, but the locator could not be read from the error');
+        // Drift means the element used to match and stopped: that needs a run where this test passed.
+        // Without one, a similar name on the page is a coincidence as easily as a rename, and these
+        // were the rule's false drift calls on an unseen Gutenberg week (rules-5).
+        if (history.runs >= 2 && history.passesOnOtherCommits === 0 && history.passesBeforeStreak === 0) {
+            return declined(this.id, `${locator} not found, and this test has no recorded passing run (${history.failures} failures in ${history.runs} runs), so nothing shows the element ever matched`, { locator });
+        }
+        const snapshot = loadSnapshot();
+        if (!snapshot)
+            return declined(this.id, `${locator} not found; no page snapshot to look for a renamed element`, { locator });
+        const [best, second] = rankCandidates(locator, snapshot);
+        if (!best || best.score < DRIFT_MIN_SIMILARITY) {
+            const closest = best ? `closest: ${describeElement(best.element)} at ${best.score.toFixed(2)}` : `none of ${snapshot.length} elements share a word with it`;
+            return declined(this.id, `${locator} not found and nothing similar is on the page (${closest})`, { locator });
+        }
+        const candidate = best.element;
+        const evidence = [
+            {
+                source: this.id,
+                message: `${locator} not found, but the page has ${describeElement(candidate)} (similarity ${best.score.toFixed(2)})`,
+                data: { locator, candidate, similarity: best.score },
+            },
+        ];
+        let confidence = 0.5 + 0.45 * best.score;
+        if (second && best.score - second.score < DRIFT_AMBIGUITY_GAP) {
+            confidence -= 0.1;
+            evidence.push({ source: this.id, message: `ambiguous: ${describeElement(second.element)} is almost as similar (${second.score.toFixed(2)})` });
+        }
+        return { category: 'LOCATOR_DRIFT', confidence, evidence };
+    },
+};
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * An action (click, fill…) whose locator now matches several elements, exactly one of which
+ * carries the locator's name as a whole word: e.g. `name: 'Edit'` resolving to "Editor canvas"
+ * twice and "Edit link" once. Playwright matches names by substring, so a new element with a
+ * similar name broke the locator; the element the test means is the one with the whole word,
+ * and Playwright's error already prints a unique locator for it. Found in real Gutenberg fixes
+ * (label rule v4, rules-5). Assertions decline: a toBeHidden() that finds extra elements is as
+ * likely a behaviour change as a locator problem.
+ */
+export const locatorDriftStrict = {
+    id: 'locator-drift-strict',
+    evaluate({ record }) {
+        const violation = strictModeViolation(record.errorMessage);
+        if (!violation)
+            return null;
+        const { locator, count, isAction, elements } = violation;
+        const name = locatorName(locator);
+        if (!name)
+            return declined(this.id, `${locator} matched ${count} elements, and it names no element to pick among them`, { locator });
+        // Playwright shortens long names in its suggestions ("64966a11-b3fa-4c41-b5bd-"), so a long
+        // prefix of the name counts as the same name.
+        const sameName = (n) => n.toLowerCase() === name.toLowerCase() || (n.length >= 20 && name.toLowerCase().startsWith(n.toLowerCase()));
+        const exact = elements.filter((e) => e.name && sameName(e.name));
+        const word = new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegExp(name)}($|[^\\p{L}\\p{N}])`, 'iu');
+        const matches = exact.length > 0 ? exact : elements.filter((e) => e.name && word.test(e.name));
+        const names = elements.map((e) => `"${e.name ?? e.locator}"`).join(', ');
+        if (matches.length === 0) {
+            // Checked fact for the AI: substring matches of other elements say nothing about whether
+            // the intended element still exists, which LOCATOR_DRIFT requires.
+            return declined(this.id, `${locator} matched ${count} elements (${names}), but none is named "${name}": only other elements whose names contain that text, so this is no evidence that the intended element still exists`, { locator });
+        }
+        if (!isAction)
+            return declined(this.id, `an assertion's locator ${locator} matched ${count} elements (${names}): the page may have changed behaviour, not only names`, { locator });
+        if (matches.length > 1) {
+            return declined(this.id, `${locator} matched ${count} elements (${names}) and ${matches.length} of them are named with "${name}", so the intended one is unclear`, { locator });
+        }
+        const [target] = matches;
+        const others = elements.filter((e) => e !== target).map((e) => `"${e.name ?? e.locator}"`);
+        return {
+            category: 'LOCATOR_DRIFT',
+            confidence: 0.9,
+            evidence: [
+                {
+                    source: this.id,
+                    message: `${locator} now matches ${count} elements: the page gained ${others.join(', ')} next to the intended ${target.locator}`,
+                    data: { locator, candidate: { role: target.role, name: target.name }, replacement: target.locator, similarity: 1 },
+                },
+            ],
+        };
+    },
+};

package/dist/engine/driver-errors.js

@@ -0,0 +1,103 @@
+// Deterministic readers for the error wording of browser and component-test tools other than
+// Playwright: Selenium (Java, Python, JavaScript, C#), WebdriverIO, Cypress, Testing Library (React,
+// Vue, Angular, Svelte), Vue Test Utils, jest-dom, and the mobile tools (Appium, Espresso, Detox,
+// Maestro, XCUITest, Flutter). Each tool says "element not found",
+// "something else took the click" and "the element went stale" in its own words; these map them
+// onto the same signals the rules read from Playwright. None of them guess: no match, no signal.
+// The patterns were checked against real messages pasted into public GitHub issues and pull
+// requests: 264 from browser tools (old and new driver versions, every Selenium binding) and 260
+// from component tests (Testing Library, Vue Test Utils, jest-dom, Jasmine).
+/** The element was looked for and never found, as each tool reports it, with the locator used. */
+const NOT_FOUND = [
+    // Selenium, Chrome and Edge drivers: Unable to locate element: {"method":"css selector","selector":"#save"}
+    // The selector is printed without escaping its own quotes, and a paste may cut it off.
+    { pattern: /Unable to locate element:\s*\{"method":\s*"([^"]+)"(?:,\s*"selector":\s*"(.*?)(?:"\}|$))?/m, locator: (m) => (m[2] !== undefined ? `${m[1]}=${m[2].replaceAll(`\\"`, `"`)}` : m[1]) },
+    // Atata (C#): Unable to locate element:\n- By: XPath ".//td[6]"
+    { pattern: /Unable to locate element:\s*- By: (\w+ ".*?")$/m, locator: (m) => m[1] },
+    // Selenium, Firefox driver: Unable to locate element: #save (the selector may start on the next line)
+    { pattern: /Unable to locate element:[ \t]*\n?[ \t]*([^\s;{'"][^\n;]*)/, locator: (m) => m[1].trim() },
+    // Selenium explicit waits (Java), in their many shapes: waiting for visibility of element located by
+    // By.id: save (tried for...), waiting for element to be clickable: By.id: save, waiting for By.css: x to be displayed.
+    // Waits for an element to disappear or go stale are not "not found" and are left out.
+    { pattern: /Expected condition failed: waiting for (?![^\n]*(?:invisibility|stale|to be invisible))[\s\S]{0,80}?(By\.\w+:\s*[\s\S]+?|css=[^\n(]+?)(?=\s+to be \w|\s*\(tried for|\s*$)/m, locator: (m) => m[1].replace(/\s+/g, ' ').trim() },
+    // Selenium JavaScript waits: Waiting for element to be located By(css selector, #save)\nWait timed out after 10043ms
+    { pattern: /Waiting for element to be located (?:By\(([^,]+), (.+?)\)|(by function\(\))|(\S+))\s*\n?\s*Wait timed out/, locator: (m) => (m[1] ? `${m[1]}=${m[2]}` : m[3] ?? m[4]) },
+    // Selenium C# waits: Element with By By.XPath: //x not found
+    { pattern: /Element with By (By\.\w+: .+?) not found/, locator: (m) => m[1] },
+    // WebdriverIO: element ("#save") still not displayed after 5000ms; the selector may hold quotes, or none
+    { pattern: /element \((?:"(.*?)"|([^)"\s][^)]*))\)\s*still not (?:displayed|existing|clickable|enabled) after \d+ ?ms/, locator: (m) => m[1] ?? m[2] },
+    // WebdriverIO: Can't call click on element with selector "#save" because element wasn't found
+    { pattern: /on element with selector "(.*?)" because element wasn't found/, locator: (m) => m[1] },
+    // Cypress: Expected to find element: `#save`, but never found it. Old versions quote with ' or not at all;
+    // cy.contains adds "containing text: 'x'".
+    { pattern: /Expected to find element:\s*[`']?([^`'\n]+?)[`']?(?:\s+containing text:\s*'((?:[^'\\]|\\.)*)')?,?\s+but never found it/, locator: (m) => (m[2] !== undefined ? `cy.contains('${m[1]}', '${m[2]}')` : m[1]) },
+    // Cypress: Expected to find content: 'Save' [within the element: <h1>] but never did.
+    { pattern: /Expected to find content:\s*'((?:[^'\\]|\\.)*)'[\s\S]{0,300}?but never did/, locator: (m) => `cy.contains('${m[1]}')` },
+    // Testing Library (React, Vue, Angular, Svelte component tests), written as the same getBy... query
+    // Playwright uses, so the drift rules can read its name: Unable to find an accessible element with
+    // the role "button" and name "Save".
+    { pattern: /Unable to find an accessible element with the role "([^"]+)"(?: and name (?:"([^"\n]*)"|`([^`\n]*)`))?/, locator: (m) => (m[2] ?? m[3]) !== undefined ? `getByRole('${m[1]}', { name: ${arg(m[2] ?? m[3])} })` : `getByRole('${m[1]}')` },
+    // Older Testing Library: Unable to find role="button" and name "Save"
+    { pattern: /Unable to find role="([^"]+)"(?: and name (?:"([^"\n]*)"|`([^`\n]*)`))?/, locator: (m) => (m[2] ?? m[3]) !== undefined ? `getByRole('${m[1]}', { name: ${arg(m[2] ?? m[3])} })` : `getByRole('${m[1]}')` },
+    { pattern: /Unable to find an element by: \[data-testid="([^"]+)"\]/, locator: (m) => `getByTestId('${m[1]}')` },
+    { pattern: /Unable to find a label with the text of: (.+?)\.?$/m, locator: (m) => `getByLabel(${arg(m[1])})` },
+    { pattern: /Unable to find an element with the (placeholder text|alt text|title|display value)(?: of)?: (.+?)\.?$/m, locator: (m) => `getBy${{ 'placeholder text': 'Placeholder', 'alt text': 'AltText', title: 'Title', 'display value': 'DisplayValue' }[m[1]]}(${arg(m[2])})` },
+    { pattern: /Unable to find an element with the text: (.+?)\.?(?: This could be| \.\.\.|$)/m, locator: (m) => `getByText(${arg(m[1])})` },
+    // Espresso (Android): NoMatchingViewException: No views in hierarchy found matching: (view.getId() is <2131296257/app:id/save>...)
+    { pattern: /No views in hierarchy found matching:[ \t]*([^\n]+)/, locator: (m) => m[1].trim() },
+    // Detox: No elements found for "MATCHER(identifier == "save-button")"
+    // The matcher itself holds quotes, so this takes everything up to the last one on the line.
+    { pattern: /No elements found for[ \t]*[“"']([^\n]+)[”"']/, locator: (m) => m[1].trim() },
+    // Maestro: Element not found: Text matching regex: Save
+    { pattern: /Element not found:[ \t]*([^\n]+)/, locator: (m) => m[1].trim() },
+    // XCUITest: No matches found for Element at index 25
+    { pattern: /No matches found for[ \t]*([^\n]+)/, locator: (m) => m[1].trim() },
+    // Flutter: Actual: Found 0 widgets with widget matching predicate: [] // identifier('L1 O')
+    { pattern: /Found 0 widgets with[ \t]*([^\n]+)/, locator: (m) => m[1].trim() },
+    // Vue Test Utils 1: [vue-test-utils]: find did not return button.save, cannot call trigger() on empty Wrapper
+    { pattern: /find did not return (.+?), cannot call/, locator: (m) => m[1] },
+];
+/** A Testing Library argument: a /regex/ stays as written, text is quoted. */
+const arg = (s) => (/^\/.*\/[a-z]*$/.test(s.trim()) ? s.trim() : `'${s.trim().replaceAll("'", "\\'")}'`);
+/**
+ * Not found, with no locator printed: Selenium's Python bindings, Vue Test Utils 2 ("Cannot call text
+ * on an empty DOMWrapper") and jest-dom given a query that found nothing ("received value must be an
+ * HTMLElement", "element could not be found in the document").
+ */
+const NOT_FOUND_BARE = /\bNoSuchElement(?:Exception|Error)\b|\bno such element\b|Cannot call \w+ on an empty (?:DOM)?Wrapper|received value must be an HTMLElement or an SVGElement|element could not be found in the document|An element could not be located on the page using the given search parameters/i;
+export function driverElementNotFound(message) {
+    return NOT_FOUND_BARE.test(message) || NOT_FOUND.some(({ pattern }) => pattern.test(message));
+}
+/** The locator a Selenium, WebdriverIO or Cypress lookup used, as the error printed it. */
+export function driverLocator(message) {
+    for (const { pattern, locator } of NOT_FOUND) {
+        const m = message.match(pattern);
+        if (m)
+            return locator(m);
+    }
+    return null;
+}
+/** What received the click instead, when a tool reports the click was blocked. */
+export function driverClickIntercepted(message) {
+    // Chrome: ... is not clickable at point (10, 20). Other element would receive the click: <div class="overlay">
+    const chrome = message.match(/Other element would receive the click:\s*`?(<[^>]+>)?/);
+    if (chrome)
+        return chrome[1] ?? 'another element';
+    // Firefox: Element <li> is not clickable at point (1168,92) because another element <a href="/x"> obscures it
+    const firefox = message.match(/is not clickable at point \([^)]*\) because another element (<[^>]+>)/);
+    if (firefox)
+        return firefox[1];
+    // Chrome, when it cannot name the element on top: element click intercepted: Element is not clickable at point (241, 600)
+    if (/element click intercepted|ElementClickIntercepted(?:Exception|Error)/.test(message))
+        return 'another element';
+    // Cypress: cy.click() failed because this element: <button> is being covered by another element: <div class="modal">
+    const cypress = message.match(/(?:is|it's|its) being covered by another element:?\s*`?(<[^>]+>)?/);
+    return cypress ? cypress[1] ?? 'another element' : null;
+}
+/** The element was found, then the page replaced it before the test used it. */
+export function driverStaleElement(message) {
+    if (/waiting for [^\n]*to become stale|staleness of/i.test(message))
+        return null;
+    const m = message.match(/\bStaleElementReference(?:Exception|Error)\b|stale element (?:reference|not found)|element is not attached to the page document|element reference (?:of .{0,200}? )?is stale|with the reference \S+ is stale|is no longer (?:attached|connected) to the DOM|failed because the page updated while this command was executing|failed because (?:this|the) element is detached from the DOM/i);
+    return m ? m[0] : null;
+}

package/dist/engine/engine.js

@@ -0,0 +1,76 @@
+import { RULES } from './rules.js';
+import { readPageSnapshot } from './snapshot.js';
+import { summarizeTrace } from './trace/trace-summary.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROJECT_ROOT } from '../reporters/store.js';
+/** Bump whenever a rule or threshold changes, so stored diagnoses can be recomputed. */
+export const ENGINE_VERSION = 'rules-9';
+/** Subtracted when rules disagree on the category, so the decision is less likely to trigger an autonomous action. */
+const CONFLICT_PENALTY = 0.1;
+const round2 = (n) => Math.round(Math.min(1, Math.max(0, n)) * 100) / 100;
+function evaluate(rule, input) {
+    try {
+        return rule.evaluate(input);
+    }
+    catch (error) {
+        return { category: null, confidence: 0, evidence: [{ source: rule.id, message: `rule crashed: ${String(error)}` }] };
+    }
+}
+export function diagnose(input, now = new Date()) {
+    const base = { source: 'rules', engineVersion: ENGINE_VERSION, diagnosedAt: now.toISOString() };
+    const outcomes = RULES.map((rule) => ({ rule, outcome: evaluate(rule, input) })).filter((x) => x.outcome !== null);
+    const matches = outcomes.filter((x) => x.outcome.category !== null);
+    if (matches.length === 0) {
+        // Narrowest rules first: their notes say the most about this particular failure.
+        const notes = outcomes.flatMap((x) => x.outcome.evidence).reverse();
+        return {
+            ...base,
+            category: 'UNKNOWN',
+            confidence: 0,
+            evidence: notes.length > 0 ? notes : [{ source: 'engine', message: 'no rule applies to this kind of failure' }],
+        };
+    }
+    const [winner, ...others] = matches;
+    const evidence = [...winner.outcome.evidence];
+    let confidence = winner.outcome.confidence;
+    const conflicts = others.filter((x) => x.outcome.category !== winner.outcome.category);
+    if (conflicts.length > 0) {
+        confidence -= CONFLICT_PENALTY;
+        const list = conflicts.map((x) => `${x.rule.id} → ${x.outcome.category}`).join(', ');
+        evidence.push({ source: 'engine', message: `lower-priority rules disagree (${list}); confidence lowered by ${CONFLICT_PENALTY}` });
+    }
+    evidence.push(...others.filter((x) => x.outcome.category === winner.outcome.category).flatMap((x) => x.outcome.evidence));
+    return { ...base, category: winner.outcome.category, confidence: round2(confidence), ruleId: winner.rule.id, evidence };
+}
+/** Requests that failed during one attempt, from its trace; [] when there is no readable trace. */
+function failedRequestsOfAttempt(record) {
+    const rel = record.attachments.find((a) => a.name === 'trace')?.path;
+    if (!rel || !existsSync(join(PROJECT_ROOT, rel)))
+        return [];
+    try {
+        return summarizeTrace(join(PROJECT_ROOT, rel)).network.failed;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Requests that failed during this test in this run, across every attempt. A retry often
+ * succeeds in reaching a dependency that failed the first time, and only one attempt's trace
+ * carries the failure; a person triaging looks at all of them, so the rules do too.
+ */
+function failedRequestsOf(record, attempts = []) {
+    const all = [record, ...attempts.filter((a) => a !== record)];
+    return all.flatMap(failedRequestsOfAttempt);
+}
+/** Diagnoses `targets` using the point-in-time history held by `index`. */
+export function diagnoseRecords(targets, index, now = new Date()) {
+    return targets.map((record) => diagnose({
+        record,
+        history: index.historyAsOf(record.testId, record.runId),
+        run: index.runContext(record.runId),
+        loadSnapshot: () => readPageSnapshot(record),
+        loadFailedRequests: () => failedRequestsOf(record, index.runContext(record.runId).failures.filter((f) => f.testId === record.testId)),
+    }, now));
+}

package/dist/engine/error-parse.js

@@ -0,0 +1,150 @@
+// Deterministic readers for Playwright error messages. Each returns null (or false)
+// when the message does not carry the signal; none of them guess. Selenium, WebdriverIO and
+// Cypress wording is read by driver-errors.ts and folded in here, so the rules see one signal.
+import { driverElementNotFound, driverLocator } from './driver-errors.js';
+const CALL_LOG = /\n\s*Call log:/;
+const headOf = (message) => message.split(CALL_LOG)[0];
+const callLogOf = (message) => message.split(CALL_LOG)[1] ?? '';
+/** The element the failing call waited for never matched anything on the page. */
+export function isElementNotFound(message) {
+    if (/element\(s\) not found/i.test(message) || driverElementNotFound(message))
+        return true;
+    const callLog = callLogOf(message);
+    return /Timeout \d+ms exceeded/.test(headOf(message)) && /waiting for /.test(callLog) && !/resolved to /.test(callLog);
+}
+const LOCATOR_START = /^(?:locator|getBy[A-Z]\w*|frameLocator|internal:)/;
+/** The locator the failing call was waiting for, as Playwright printed it. */
+export function extractLocator(message) {
+    const waited = [...message.matchAll(/waiting for (.+)/g)].map((m) => m[1].trim()).filter((s) => LOCATOR_START.test(s));
+    const header = message.match(/^\s*Locator:\s*(.+)$/m)?.[1]?.trim();
+    return waited.at(-1) ?? header ?? driverLocator(message);
+}
+/**
+ * How each language's assertion library prints "got the wrong value". Each pattern captures the
+ * expected and the actual value; the order of the groups differs, so each names its own.
+ */
+const MISMATCH_PATTERNS = [
+    // Playwright, Jest, Vitest, node:test: "Expected: 4" / "Received: 3" on separate lines.
+    // A runner may print the error type first: "AssertionError: Expected: 4", or node:test's
+    // "Error [ERR_TEST_FAILURE]: Expected: 4".
+    { pattern: /^(?:[\w.]*Error(?: \[\w+\])?:\s*)?\s*Expected[^:\n]*:\s*(.+)$[\s\S]*?^\s*Received[^:\n]*:\s*(.+)$/m, expected: 1, received: 2 },
+    // xUnit (.NET): "Expected: 4" / "Actual: 3".
+    { pattern: /^\s*Expected:\s*(.+)$[\s\S]*?^\s*Actual:\s*(.+)$/m, expected: 1, received: 2 },
+    // NUnit (.NET): "Expected: 4" / "But was: 3".
+    { pattern: /^\s*Expected:\s*(.+)$[\s\S]*?^\s*But was:\s*(.+)$/m, expected: 1, received: 2 },
+    // RSpec (Ruby): "expected: 4" / "got: 3".
+    { pattern: /^\s*(?:\d+\)\s*)?expected:\s*(.+)$[\s\S]*?^\s*got:\s*(.+)$/m, expected: 1, received: 2 },
+    // JUnit 4/5, TestNG, Kotlin (Java/JVM): "expected: <4> but was: <3>".
+    { pattern: /expected:\s*<([^>\n]*)>\s*but was:\s*<([^>\n]*)>/, expected: 1, received: 2 },
+    // Go convention: "got 3, want 4".
+    { pattern: /\bgot:?\s*([^,\n]+),\s*want:?\s*(.+)$/m, expected: 2, received: 1 },
+    // Rust assert_eq!: "left: 3" / "right: 4" (actual on the left by convention).
+    { pattern: /^\s*left:\s*(.+)$[\s\S]*?^\s*right:\s*(.+)$/m, expected: 2, received: 1 },
+    // Python unittest: "AssertionError: 3 != 4" (actual first).
+    { pattern: /AssertionError:\s*([^\n]+?)\s+!=\s+([^\n]+)$/m, expected: 2, received: 1 },
+    // pytest assertion rewriting: "assert 3 == 4" (actual first by convention).
+    { pattern: /^\s*(?:E\s+)?assert\s+(.+?)\s+==\s+(.+)$/m, expected: 2, received: 1 },
+    // PHPUnit: "Failed asserting that 3 is identical to 4." / "... matches expected 4."
+    { pattern: /Failed asserting that (.+?) (?:is identical to|is equal to|matches expected) (.+?)\.?$/m, expected: 2, received: 1 },
+    // Chai (Mocha): "expected 3 to equal 4".
+    { pattern: /expected (.+?) to (?:deeply )?(?:equal|be|eql) (.+)$/m, expected: 2, received: 1 },
+    // MSTest (.NET): "Assert.AreEqual failed. Expected:<1>. Actual:<2>." on one line.
+    { pattern: /Expected:\s*<(.*?)>\.\s*Actual:\s*<(.*?)>/, expected: 1, received: 2 },
+    // JUnit 4 identity: "expected same:<X> was not:<Y>".
+    { pattern: /expected same:\s*<(.*?)>\s*was not:\s*<(.*?)>/, expected: 1, received: 2 },
+    // GoogleTest (C++): "Value of: add(1, 1)" / "  Actual: 3" / "Expected: 2" - actual comes first.
+    { pattern: /^\s*Actual:\s*(.+)$[\s\S]{0,200}?^\s*Expected:\s*(.+)$/m, expected: 2, received: 1 },
+    // GoogleTest equality: "Expected equality of these values:\n  2\n  3" (expected first, then actual).
+    { pattern: /Expected equality of these values:\s*\n\s*(.+)\n\s*(.+)/, expected: 1, received: 2 },
+    // Catch2 (C++): "REQUIRE( Factorial(0) == 1 )" / "with expansion:" / "  0 == 1".
+    { pattern: /with expansion:\s*\n\s*(.+?)\s*==\s*(.+)$/m, expected: 2, received: 1 },
+    // XCTest (Swift/iOS): 'XCTAssertEqual failed: ("54") is not equal to ("100")'.
+    { pattern: /XCTAssert\w* failed:\s*\("?(.*?)"?\)\s*is not equal to\s*\("?(.*?)"?\)/, expected: 2, received: 1 },
+    // swift-testing: "Expectation failed: (current → .detached) == .attached".
+    { pattern: /Expectation failed:\s*\(.*?→\s*(.+?)\)\s*==\s*(.+)$/m, expected: 2, received: 1 },
+    // ScalaTest: "2 did not equal 1".
+    { pattern: /^\s*(.+?) did not equal (.+?)\s*$/m, expected: 2, received: 1 },
+    // MUnit (Scala): "=> Obtained\n1\n=> Diff (- expected, + obtained)\n-2\n+1".
+    { pattern: /=> Obtained\s*\n\s*(.+)\n[\s\S]{0,200}?^-\s*(.+)$/m, expected: 2, received: 1 },
+    // Deno and PHPUnit diffs: "[Diff] Actual / Expected" then "-   actual" / "+   expected".
+    { pattern: /\[Diff\] Actual \/ Expected[\s\S]{0,200}?^\s*-\s*(.+)$\s*^\s*\+\s*(.+)$/m, expected: 2, received: 1 },
+    // PHPUnit: "--- Expected\n+++ Actual\n@@ @@\n-'bar'\n+'baz'".
+    { pattern: /--- Expected\s*\n\+\+\+ Actual[\s\S]{0,200}?^-(.+)$\s*^\+(.+)$/m, expected: 1, received: 2 },
+    // API testing, where the value is an HTTP status. REST Assured: "Expected status code <200> but
+    // was <500>"; Newman: "expected response to have status code 201 but got 405"; supertest:
+    // 'expected 200 "OK", got 403 "Forbidden"'; Karate: "status code was: 500, expected: 200".
+    { pattern: /Expected status code <(\d{3})> but was <(\d{3})>/, expected: 1, received: 2 },
+    { pattern: /expected response to have status code (\d{3}) but got (\d{3})/, expected: 1, received: 2 },
+    { pattern: /expected (\d{3}) "[^"\n]*", got (\d{3}) "[^"\n]*"/, expected: 1, received: 2 },
+    { pattern: /status code was: (\d{3}), expected: (\d{3})/, expected: 2, received: 1 },
+    // Jasmine (Angular's Karma default): "Expected 3 to equal 4." or, inside an object or array,
+    // "Expected $[0] = 'Dashboard' to equal 'Screenshots'.".
+    { pattern: /^\s*(?:Error: )?Expected (?:\$[^\s=]*\s*=\s*)?(.+?) to (?:equal|be) (.+?)\.$/m, expected: 2, received: 1 },
+];
+/** A comparison that found the value (or element) but not the expected one, in any language. */
+export function valueMismatch(message) {
+    // A message that says an element was never found is not a wrong value, whatever shape it takes:
+    // Flutter prints "Expected: exactly one matching candidate / Actual: Found 0 widgets", which
+    // otherwise reads as a mismatch and then as a real bug.
+    if (isElementNotFound(message))
+        return null;
+    const head = headOf(message);
+    for (const { pattern, expected: e, received: r } of MISMATCH_PATTERNS) {
+        const m = head.match(pattern);
+        if (!m)
+            continue;
+        const expected = m[e]?.trim();
+        const received = m[r]?.trim();
+        if (!expected || !received || /element\(s\) not found/i.test(received))
+            return null;
+        return { expected, received };
+    }
+    return null;
+}
+const NETWORK_PATTERNS = [
+    {
+        kind: 'connection',
+        confidence: 0.9,
+        pattern: /net::ERR_[A-Z_]+|NS_ERROR_[A-Z_]+|\b(?:ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|EHOSTUNREACH|ENETUNREACH|EPIPE)\b|socket hang up|connection (?:refused|reset|closed)/i,
+    },
+    // Node's built-in fetch (undici) reports every network-level failure (refused, reset, DNS) as
+    // this one line, with the real cause nested where test reporters usually drop it.
+    { kind: 'connection', confidence: 0.8, pattern: /TypeError: fetch failed/ },
+    { kind: 'http-5xx', confidence: 0.85, pattern: /\b(?:5\d\d\s+)?(?:Internal Server Error|Bad Gateway|Service Unavailable|Gateway Time-?out)\b/i },
+    { kind: 'http-5xx', confidence: 0.85, pattern: /\b(?:status(?:\s*code)?|HTTP(?:\/[\d.]+)?|response code)\b\D{0,12}\b5\d\d\b/i },
+    // The API-testing wordings, where what came back was a server error or an auth refusal:
+    // REST Assured, Newman, supertest and Karate each say it differently.
+    { kind: 'http-5xx', confidence: 0.85, pattern: /but was <5\d\d>|but got 5\d\d\b|, got 5\d\d "|status code was: 5\d\d/ },
+    { kind: 'auth', confidence: 0.7, pattern: /but was <40[13]>|but got 40[13]\b|, got 40[13] "|status code was: 40[13]/ },
+    // expect(response.status()).toBe(200) that received a 5xx.
+    { kind: 'http-5xx', confidence: 0.8, pattern: /Expected[^:\n]*:\s*"?[23]\d\d"?\s*\n\s*Received[^:\n]*:\s*"?5\d\d\b"?/ },
+    { kind: 'auth', confidence: 0.7, pattern: /\b(?:401|403)\s+(?:Unauthorized|Forbidden)\b|\b(?:invalid|expired) (?:auth(?:entication)? )?(?:token|session|credentials)\b/i },
+    { kind: 'auth', confidence: 0.7, pattern: /Expected[^:\n]*:\s*"?[23]\d\d"?\s*\n\s*Received[^:\n]*:\s*"?40[13]\b"?/ },
+];
+/** First network / dependent-service / auth signal in the message, strongest first. */
+export function networkSignal(message) {
+    for (const { kind, confidence, pattern } of NETWORK_PATTERNS) {
+        const match = message.match(pattern)?.[0];
+        if (match)
+            return { kind, confidence, match: match.replace(/\s+/g, ' ').trim() };
+    }
+    return null;
+}
+/** A locator that matched several elements; Playwright lists each one with a unique locator. */
+export function strictModeViolation(message) {
+    const head = headOf(message);
+    const m = head.match(/strict mode violation: (.+) resolved to (\d+) elements/);
+    if (!m)
+        return null;
+    const elements = [...head.matchAll(/^\s*\d+\) .* aka (.+)$/gm)].map(([, locator]) => {
+        const role = locator.match(/^getByRole\('([^']+)'/)?.[1];
+        const name = locator.match(/name: '((?:[^'\\]|\\.)*)'/)?.[1]?.replaceAll("\\'", "'");
+        return { locator: locator.trim(), role, name };
+    });
+    return { locator: m[1].trim(), count: Number(m[2]), isAction: !/^\s*Error: expect\(/.test(head), elements };
+}
+/** The accessible name or text a locator looks for, when it names one. */
+export function locatorName(locator) {
+    const m = [...locator.matchAll(/(?:name: |getBy(?:Text|Label|Title|Placeholder|AltText)\(|cy\.contains\()'((?:[^'\\]|\\.)*)'/g)].at(-1);
+    return m ? m[1].replaceAll("\\'", "'") : null;
+}

package/dist/engine/history.js

@@ -0,0 +1,105 @@
+import { errorShape, errorSignature } from './signature.js';
+/** How many of a test's most recent runs the rules look at. */
+export const HISTORY_WINDOW = 50;
+const distinct = (records) => new Set(records.map((r) => errorSignature(r.errorMessage))).size;
+export class HistoryIndex {
+    runs;
+    position = new Map();
+    constructor(records, summaries) {
+        const entries = new Map();
+        const entry = (runId, at, sha) => {
+            const existing = entries.get(runId);
+            if (existing) {
+                if (at < existing.at)
+                    existing.at = at;
+                existing.sha ||= sha;
+                return existing;
+            }
+            const created = { runId, at, sha, branch: '', attempts: {}, failures: [] };
+            entries.set(runId, created);
+            return created;
+        };
+        for (const s of summaries) {
+            const e = entry(s.runId, s.startedAt, s.gitSha);
+            e.branch ||= s.branch ?? '';
+            for (const [testId, n] of Object.entries(s.attempts))
+                e.attempts[testId] = (e.attempts[testId] ?? 0) + n;
+        }
+        for (const r of records)
+            entry(r.runId, r.timestamp, r.gitSha).failures.push(r);
+        // A run with no summary line: its failures are the only attempts we know about.
+        for (const e of entries.values()) {
+            for (const r of e.failures) {
+                const failed = e.failures.filter((f) => f.testId === r.testId).length;
+                e.attempts[r.testId] = Math.max(e.attempts[r.testId] ?? 0, failed);
+            }
+        }
+        this.runs = [...entries.values()].sort((a, b) => a.at.localeCompare(b.at) || a.runId.localeCompare(b.runId));
+        this.runs.forEach((e, i) => this.position.set(e.runId, i));
+    }
+    /** Run ids, oldest first. */
+    get runIds() {
+        return this.runs.map((e) => e.runId);
+    }
+    historyAsOf(testId, runId) {
+        const until = this.indexOf(runId);
+        const entries = this.runs
+            .slice(0, until + 1)
+            .filter((e) => (e.attempts[testId] ?? 0) > 0)
+            .slice(-HISTORY_WINDOW)
+            .map((e) => ({ sha: e.sha, branch: e.branch, attempts: e.attempts[testId], failures: e.failures.filter((f) => f.testId === testId) }));
+        const sha = this.runs[until].sha;
+        const sameCommit = sha ? entries.filter((e) => e.sha === sha) : [];
+        const otherCommits = sha ? entries.filter((e) => e.sha !== sha) : [];
+        let streakStart = entries.length;
+        while (streakStart > 0 && entries[streakStart - 1].failures.length >= entries[streakStart - 1].attempts)
+            streakStart--;
+        const before = entries.slice(0, streakStart);
+        const streak = entries.slice(streakStart);
+        const runs = entries.reduce((sum, e) => sum + e.attempts, 0);
+        const allFailures = entries.flatMap((e) => e.failures);
+        const failuresBeforeStreak = before.reduce((sum, e) => sum + e.failures.length, 0);
+        const current = this.runs[until].attempts[testId] ? entries[entries.length - 1] : undefined;
+        const sum = (xs, f) => xs.reduce((n, e) => n + f(e), 0);
+        return {
+            currentRunAttempts: current?.attempts ?? 0,
+            currentRunFailures: current?.failures.length ?? 0,
+            sameCommitAttempts: sum(sameCommit, (e) => e.attempts),
+            sameCommitFailures: sum(sameCommit, (e) => e.failures.length),
+            passesOnOtherCommits: sum(otherCommits, (e) => e.attempts - e.failures.length),
+            failingRunsOnOtherCommits: otherCommits.filter((e) => e.failures.length > 0).length,
+            testId,
+            runs,
+            failures: allFailures.length,
+            failureRate: runs === 0 ? 0 : allFailures.length / runs,
+            distinctErrors: distinct(allFailures),
+            failingStreak: streak.length,
+            streakDistinctErrors: distinct(streak.flatMap((e) => e.failures)),
+            failuresBeforeStreak,
+            passesBeforeStreak: before.reduce((sum, e) => sum + e.attempts, 0) - failuresBeforeStreak,
+            // Counted within this run's own branch. Across branches the same test legitimately passes on
+            // one line of work and fails on another, which looks like flipping but is not.
+            earlierFlakeShapes: [
+                ...new Set((current ? entries.slice(0, -1) : entries)
+                    .filter((e) => e.failures.length > 0 && e.failures.length < e.attempts)
+                    .flatMap((e) => e.failures.map((f) => errorShape(f.errorMessage)))),
+            ],
+            alternations: entries
+                .filter((e) => e.branch === this.runs[until].branch)
+                .reduce((acc, e) => {
+                const failed = e.failures.length > 0;
+                return { count: acc.count + (acc.last !== null && acc.last !== failed ? 1 : 0), last: failed };
+            }, { count: 0, last: null }).count,
+        };
+    }
+    runContext(runId) {
+        const e = this.runs[this.indexOf(runId)];
+        return { runId, branch: e.branch, testsAttempted: Object.keys(e.attempts).length, failures: e.failures };
+    }
+    indexOf(runId) {
+        const i = this.position.get(runId);
+        if (i === undefined)
+            throw new Error(`run ${runId} is not in the history index`);
+        return i;
+    }
+}