mjolnir-qa 0.5.7 → 0.5.9

package/dist/cli.mjs

@@ -6,7 +6,7 @@ import { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "no
 import process$1 from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import * as ts$1 from "ts-morph";
-import { Project, ts } from "ts-morph";
+import { Project, SyntaxKind, ts } from "ts-morph";
 import { Language, Parser } from "web-tree-sitter";
 import { parse } from "yaml";
 import { createHash, randomBytes } from "node:crypto";
@@ -7245,11 +7245,587 @@ function matchBrace$1(text, open) {
 	return -1;
 }
 //#endregion
+//#region src/engine/qa-model.ts
+/**
+* Extract the semantic model for one parsed file. Resolves undefined
+* when the language has no extractor or the parse stage produced no
+* tree (the astQuery discipline: undefined = no model, never an empty
+* claim). Python needs no AST — regex boundaries over the text.
+*/
+function extractQaModel(file) {
+	if (file.path.endsWith(".java")) return extractJavaModel(file);
+	if (file.path.endsWith(".cs")) return extractCSharpModel(file);
+	if (file.path.endsWith(".py")) return extractPythonModel(file);
+	if (/\.[cm]?[jt]sx?$/.test(file.path)) return extractTsModel(file, parseTsFile(file));
+}
+function pos(text, index) {
+	return {
+		index,
+		...nodeLineCol(text, index)
+	};
+}
+/** JUnit 4/5, TestNG setup/teardown annotation simple names. */
+const JAVA_HOOK_ANNOTATIONS = /* @__PURE__ */ new Set([
+	"BeforeEach",
+	"AfterEach",
+	"BeforeAll",
+	"AfterAll",
+	"Before",
+	"After",
+	"BeforeClass",
+	"AfterClass",
+	"BeforeMethod",
+	"AfterMethod",
+	"BeforeSuite",
+	"AfterSuite"
+]);
+/** Retry annotation simple names (JV retry-masking family: @RetryingTest). */
+const JAVA_RETRY_ANNOTATIONS = /* @__PURE__ */ new Set(["RetryingTest"]);
+/** All annotation simple names on a Java modifiers node. */
+function javaAnnotationNames(modifiers) {
+	const names = [];
+	for (const child of modifiers.children) {
+		if (child?.type !== "marker_annotation" && child?.type !== "annotation") continue;
+		const nameNode = child.childForFieldName("name");
+		if (!nameNode) continue;
+		let last;
+		for (const part of nameNode.children) if (part?.type === "identifier") last = part.text;
+		names.push(last ?? nameNode.text);
+	}
+	return names;
+}
+function extractJavaModel(file) {
+	const tree = getTreeSitterTree(file.ast);
+	if (!tree) return void 0;
+	const text = file.text;
+	const nodes = [];
+	for (const test of javaTestMethods(tree)) nodes.push({
+		concept: "test",
+		name: test.name,
+		start: pos(text, test.annotation.startIndex),
+		end: pos(text, test.body.endIndex),
+		truncated: test.body.hasError
+	});
+	for (const decl of tree.rootNode.descendantsOfType("method_declaration")) {
+		const modifiers = decl.childForFieldName("modifiers") ?? decl.children[0];
+		if (!modifiers || modifiers.type !== "modifiers") continue;
+		const body = decl.childForFieldName("body");
+		if (!body) continue;
+		const nameNode = decl.childForFieldName("name");
+		if (!nameNode) continue;
+		for (const annotation of javaAnnotationNames(modifiers)) {
+			if (JAVA_HOOK_ANNOTATIONS.has(annotation)) {
+				let concept = "setup";
+				if (annotation.startsWith("After")) concept = "teardown";
+				nodes.push({
+					concept,
+					name: nameNode.text,
+					start: pos(text, decl.startIndex),
+					end: pos(text, body.endIndex),
+					truncated: body.hasError
+				});
+				break;
+			}
+			if (JAVA_RETRY_ANNOTATIONS.has(annotation)) {
+				nodes.push({
+					concept: "retry",
+					name: nameNode.text,
+					start: pos(text, decl.startIndex),
+					end: pos(text, body.endIndex),
+					truncated: body.hasError
+				});
+				break;
+			}
+		}
+	}
+	nodes.push(...javaCSharpCallNodes(tree, text, JAVA_CALLEE_CONCEPTS));
+	return {
+		language: "java",
+		nodes
+	};
+}
+/** MSTest/NUnit setup/teardown attribute simple names. */
+const CS_HOOK_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"TestInitialize",
+	"TestCleanup",
+	"SetUp",
+	"TearDown",
+	"OneTimeSetUp",
+	"OneTimeTearDown",
+	"ClassInitialize",
+	"ClassCleanup",
+	"AssemblyInitialize",
+	"AssemblyCleanup",
+	"FixtureSetUp",
+	"FixtureTearDown"
+]);
+/** Retry attribute simple names (CS retry-masking family: [Retry(n)]). */
+const CS_RETRY_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"Retry",
+	"RetryFact",
+	"RetryTheory"
+]);
+function extractCSharpModel(file) {
+	const tree = getTreeSitterTree(file.ast);
+	if (!tree) return void 0;
+	const text = file.text;
+	const nodes = [];
+	for (const test of csharpTestMethods(tree)) nodes.push({
+		concept: "test",
+		name: test.name,
+		start: pos(text, test.attribute.startIndex),
+		end: pos(text, test.body.endIndex),
+		truncated: test.body.hasError
+	});
+	for (const decl of tree.rootNode.descendantsOfType("method_declaration")) {
+		const body = decl.childForFieldName("body");
+		if (!body) continue;
+		const nameNode = decl.childForFieldName("name");
+		if (!nameNode) continue;
+		let attr;
+		for (const child of decl.children) {
+			if (child?.type !== "attribute_list") continue;
+			for (const grand of child.children) {
+				if (grand?.type !== "attribute") continue;
+				const attrName = grand.childForFieldName("name");
+				if (!attrName) continue;
+				let last;
+				for (const part of attrName.children) if (part?.type === "identifier") last = part.text;
+				const simple = last ?? attrName.text;
+				if (CS_HOOK_ATTRIBUTES.has(simple) || CS_RETRY_ATTRIBUTES.has(simple)) {
+					attr = simple;
+					break;
+				}
+			}
+			if (attr) break;
+		}
+		if (!attr) continue;
+		let concept;
+		if (attr.includes("TearDown") || attr.includes("Cleanup")) concept = "teardown";
+		else if (CS_RETRY_ATTRIBUTES.has(attr)) concept = "retry";
+		else concept = "setup";
+		nodes.push({
+			concept,
+			name: nameNode.text,
+			start: pos(text, decl.startIndex),
+			end: pos(text, body.endIndex),
+			truncated: body.hasError
+		});
+	}
+	nodes.push(...javaCSharpCallNodes(tree, text, CS_CALLEE_CONCEPTS));
+	for (const throwStmt of tree.rootNode.descendantsOfType("throw_statement")) {
+		const creation = throwStmt.namedChildren.find((c) => c?.type === "object_creation_expression");
+		if (!creation) continue;
+		const typeNode = creation.childForFieldName("type");
+		if (!typeNode) continue;
+		const typeName = typeNode.text;
+		if (/assert/i.test(typeName) && /exception/i.test(typeName)) nodes.push({
+			concept: "assertion",
+			name: typeName,
+			callee: typeName,
+			start: pos(text, creation.startIndex),
+			end: pos(text, creation.endIndex),
+			text: creation.text,
+			ancestors: ancestorCallNames(creation)
+		});
+	}
+	return {
+		language: "csharp",
+		nodes
+	};
+}
+/**
+* Java callee vocabulary — copied from the rules that measured it:
+* assert-prefix/bare fail/verify + helper idiom (QA-JV-103's oracle),
+* waitFor* (QA-JV-103 isThrowingWait + QA-JV-105), Thread.sleep
+* (QA-JV-102/hard-sleep family), navigate/goto (hardcoded-url JV),
+* querySelector/locator (shared-page/brittle-selectors JV), route/
+* exposeFunction/setRoute (blanket-route JV + QA-CS-102's environment
+* delegates), mock/spy (QA-JV fixture practice: Mockito mock/spy).
+*/
+const JAVA_CALLEE_CONCEPTS = {
+	exact: {
+		fail: "assertion",
+		verify: "assertion",
+		navigate: "navigation",
+		goto: "navigation",
+		querySelector: "locator",
+		querySelectorAll: "locator",
+		locator: "locator",
+		frameLocator: "locator",
+		route: "network-interaction",
+		setRoute: "network-interaction",
+		exposeFunction: "interaction",
+		mock: "mock",
+		spy: "mock"
+	},
+	receiverQualified: { sleep: { Thread: "wait" } },
+	prefixes: [
+		{
+			test: (n) => /^assert[A-Z]/.test(n),
+			concept: "assertion"
+		},
+		{
+			test: (n) => isHelperIdiom(n) && /^[vca]/.test(n),
+			concept: "assertion"
+		},
+		{
+			test: (n) => n.startsWith("waitFor"),
+			concept: "wait"
+		},
+		{
+			test: (n) => /^(?:click|fill|tap|hover|dblclick|press|check|selectOption|type|focus)$/.test(n),
+			concept: "action"
+		}
+	]
+};
+/**
+* C# callee vocabulary — copied from the rules that measured it:
+* Assert receiver + Shouldly + Expect + Verify + helper idiom +
+* WaitFor*Async≠WaitForTimeoutAsync (QA-CS-103), Thread/Task Sleep/Delay
+* (QA-CS-102), GotoAsync (hardcoded-url CS), RouteAsync/SetRoute/
+* RouteFromHARAsync/ExposeFunctionAsync/AddLocatorHandlerAsync
+* (QA-CS-102's ENVIRONMENT_DELEGATE_APIS), ClickAsync/FillAsync…,
+* Locator/FrameLocator/GetBy*.
+*/
+const CS_CALLEE_CONCEPTS = {
+	exact: {
+		expect: "assertion",
+		Expect: "assertion",
+		GotoAsync: "navigation",
+		GoToAsync: "navigation",
+		RouteAsync: "network-interaction",
+		RouteFromHARAsync: "network-interaction",
+		RouteFromHAR: "network-interaction",
+		SetRoute: "network-interaction",
+		SetRouteHandler: "network-interaction",
+		UnrouteAllAsync: "network-interaction",
+		AddLocatorHandlerAsync: "interaction",
+		ExposeFunctionAsync: "interaction",
+		ExposeFunction: "interaction",
+		ExposeBindingAsync: "interaction",
+		RunAxe: "assertion",
+		Locator: "locator",
+		FrameLocator: "locator",
+		GetByTestId: "locator",
+		GetByRole: "locator",
+		GetByText: "locator",
+		GetByLabel: "locator",
+		GetByPlaceholder: "locator",
+		GetByAltText: "locator",
+		GetByTitle: "locator",
+		QuerySelector: "locator",
+		QuerySelectorAll: "locator"
+	},
+	receiverQualified: {
+		Sleep: { Thread: "wait" },
+		Delay: { Task: "wait" }
+	},
+	prefixes: [
+		{
+			test: (n) => n === "Should" || /^Should[A-Z]/.test(n),
+			concept: "assertion"
+		},
+		{
+			test: isHelperIdiom,
+			concept: "assertion"
+		},
+		{
+			test: (n) => n.startsWith("WaitFor") && n.endsWith("Async") && n !== "WaitForTimeoutAsync",
+			concept: "wait"
+		},
+		{
+			test: (n) => n === "WaitForTimeoutAsync",
+			concept: "wait"
+		},
+		{
+			test: (n) => /^(?:ClickAsync|FillAsync|TapAsync|HoverAsync|DblClickAsync|PressAsync|CheckAsync|UncheckAsync|SelectOptionAsync|FocusAsync|TypeAsync)$/.test(n),
+			concept: "action"
+		}
+	]
+};
+/**
+* Classify every invocation in the tree against a table, carrying
+* callee/receiver/text/ancestors. Ancestors are the enclosing invocation
+* callee names up to the method boundary (outer→inner) — the
+* firstAncestorCallNamed generalization, so containment decisions
+* (route delegates, WhenAny races) are expressible over the model.
+*/
+function javaCSharpCallNodes(tree, text, table) {
+	const nodes = [];
+	for (const call of invocationsWithin(tree.rootNode)) {
+		const callee = callName(call);
+		if (callee === void 0) continue;
+		const receiver = receiverText(call);
+		let concept = table.exact[callee];
+		if (concept === void 0 && receiver !== void 0) concept = table.receiverQualified[callee]?.[receiver];
+		if (concept === void 0) {
+			for (const p of table.prefixes) if (p.test(callee)) {
+				concept = p.concept;
+				break;
+			}
+		}
+		if (concept === void 0) continue;
+		const node = {
+			concept,
+			name: callee,
+			callee,
+			start: pos(text, call.startIndex),
+			end: pos(text, call.endIndex),
+			text: call.text,
+			ancestors: ancestorCallNames(call)
+		};
+		if (receiver !== void 0) node.receiver = receiver;
+		nodes.push(node);
+	}
+	return nodes;
+}
+/** Enclosing invocation callee names, outer→inner, to the method boundary. */
+function ancestorCallNames(node) {
+	const names = [];
+	let current = node.parent;
+	while (current) {
+		if (current.type === "method_declaration" || current.type === "constructor_declaration") break;
+		if (isInvocation(current)) {
+			const name = callName(current);
+			if (name !== void 0) names.unshift(name);
+		}
+		current = current.parent;
+	}
+	return names;
+}
+/**
+* TS callee vocabulary — copied from the rules that measured it:
+* expect/assert (qa-pw-002, qa-test-003), waitFor + goto/route families
+* (qa-pw-101/102/103/118/123/142), evaluate/exposeFunction (qa-pw-005),
+* click/fill and the locator family (qa-pw-004/104/112/113/114/145),
+* jest/vi mock+retryTimes (qa-test-006, qa-tqual-001), delay/sleep/pause
+* helper idioms (qa-test-004), describe.serial (qa-pw-117).
+*/
+const TS_CALLEE_CONCEPTS = {
+	exact: {
+		expect: "assertion",
+		assert: "assertion",
+		goto: "navigation",
+		route: "network-interaction",
+		unroute: "network-interaction",
+		routeFromHAR: "network-interaction",
+		evaluate: "interaction",
+		evaluateHandle: "interaction",
+		exposeFunction: "interaction",
+		addInitScript: "interaction",
+		addLocatorHandler: "interaction",
+		locator: "locator",
+		frameLocator: "locator",
+		getByTestId: "locator",
+		getByRole: "locator",
+		getByText: "locator",
+		getByLabel: "locator",
+		getByPlaceholder: "locator",
+		getByAltText: "locator",
+		getByTitle: "locator",
+		$: "locator",
+		$$: "locator"
+	},
+	receiverQualified: {},
+	prefixes: [
+		{
+			test: (n) => n.startsWith("waitFor"),
+			concept: "wait"
+		},
+		{
+			test: (n) => /^(?:delay|sleep|pause|wait|timeout)$/.test(n),
+			concept: "wait"
+		},
+		{
+			test: (n) => /^(?:click|dblclick|fill|hover|tap|check|uncheck|selectOption|press|type|focus|dragTo)$/.test(n),
+			concept: "action"
+		},
+		{
+			test: (n) => n === "retryTimes",
+			concept: "retry"
+		},
+		{
+			test: (n) => n === "mock" || n === "fn" || n === "spyOn",
+			concept: "mock"
+		}
+	]
+};
+const TS_TEST_CALLEE_RE = /^(?:it|test)(?:\.\w+)*$/;
+const TS_HOOK_CONCEPTS = {
+	beforeEach: "setup",
+	beforeAll: "setup",
+	afterEach: "teardown",
+	afterAll: "teardown"
+};
+function calleeChainText(expr) {
+	return expr.getText().replace(/\s+/g, "");
+}
+function extractTsModel(file, sf) {
+	const text = file.text;
+	const nodes = [];
+	for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const chain = calleeChainText(call.getExpression());
+		const parts = chain.split(".");
+		const base = parts[parts.length - 1];
+		const start = pos(text, call.getStart());
+		const end = pos(text, call.getEnd());
+		if (TS_TEST_CALLEE_RE.test(chain)) {
+			const callback = call.getArguments().find((a) => a.getKindName().includes("Function"));
+			if (callback) {
+				nodes.push({
+					concept: "test",
+					name: chain,
+					start,
+					end: pos(text, callback.getEnd())
+				});
+				continue;
+			}
+		}
+		const hook = TS_HOOK_CONCEPTS[base];
+		if (hook && /(?:^|\.)(?:beforeEach|beforeAll|afterEach|afterAll)$/.test(chain)) {
+			const callback = call.getArguments().find((a) => a.getKindName().includes("Function"));
+			const node = {
+				concept: hook,
+				name: chain,
+				start
+			};
+			if (callback) node.end = pos(text, callback.getEnd());
+			nodes.push(node);
+			continue;
+		}
+		if (/^describe(?:\.\w+)*\.serial$/.test(chain) || /\.describe\.serial/.test(chain)) {
+			nodes.push({
+				concept: "lifecycle",
+				name: chain,
+				start,
+				end
+			});
+			continue;
+		}
+		const receiverParts = chain.split(".");
+		const name = receiverParts[receiverParts.length - 1];
+		let receiver;
+		if (receiverParts.length > 1) receiver = receiverParts.slice(0, -1).join(".");
+		let concept = TS_CALLEE_CONCEPTS.exact[name];
+		if (concept === void 0) {
+			for (const p of TS_CALLEE_CONCEPTS.prefixes) if (p.test(name)) {
+				concept = p.concept;
+				break;
+			}
+		}
+		if (concept === void 0) continue;
+		const node = {
+			concept,
+			name,
+			callee: name,
+			start,
+			end,
+			text: call.getText(),
+			awaited: isAwaitedTsCall(call)
+		};
+		if (receiver !== void 0) node.receiver = receiver;
+		nodes.push(node);
+	}
+	let language = "javascript";
+	if (/\.[cm]?ts$/.test(file.path) || /\.tsx$/.test(file.path)) language = "typescript";
+	return {
+		language,
+		nodes
+	};
+}
+/**
+* Awaitedness (qa-pw-002's consumption oracle: an AwaitExpression or
+* ReturnStatement ancestor consumes the promise). Carried as an extra
+* field on TS call nodes — the model stays grammar-agnostic, consumers
+* narrow.
+*/
+function isAwaitedTsCall(call) {
+	let parent = call.getParent();
+	while (parent) {
+		const kind = parent.getKindName();
+		if (kind === "AwaitExpression" || kind === "ReturnStatement") return true;
+		if (kind === "ArrowFunction" || kind === "FunctionDeclaration" || kind === "FunctionExpression") return false;
+		parent = parent.getParent();
+	}
+	return false;
+}
+/**
+* Python vocabularies copied from the rules that measured them:
+* def test_ (qa-py-003), @pytest.fixture (qa-py-011), time.sleep/
+* wait_for_timeout (qa-py-005/qa-py-102/qa-py-103), assert/self.assert*
+* (qa-py-003's oracle vocabulary).
+*/
+const PY_TEST_RE = /^([ \t]*)(?:async\s+)?def\s+(test_\w+)\s*\([^)]*\)\s*:/gm;
+const PY_FIXTURE_RE = /@pytest\.fixture\b/g;
+const PY_WAIT_RE = /\btime\.sleep\s*\(|\.wait_for_timeout\s*\(/g;
+const PY_ASSERT_RE = /^([ \t]*)assert\b/gm;
+const PY_SELF_ASSERT_RE = /self\.assert[A-Z]\w*\s*\(/g;
+function extractPythonModel(file) {
+	const text = file.text;
+	const nodes = [];
+	const push = (concept, m, name) => {
+		const node = {
+			concept,
+			start: {
+				index: m.index,
+				line: lineAt(text, m.index),
+				column: colAt(text, m.index)
+			},
+			end: {
+				index: m.index + m[0].length,
+				line: lineAt(text, m.index + m[0].length),
+				column: colAt(text, m.index + m[0].length)
+			},
+			text: m[0]
+		};
+		if (name !== void 0) node.name = name;
+		nodes.push(node);
+	};
+	for (const re of [
+		PY_TEST_RE,
+		PY_FIXTURE_RE,
+		PY_WAIT_RE,
+		PY_ASSERT_RE,
+		PY_SELF_ASSERT_RE
+	]) {
+		re.lastIndex = 0;
+		let m;
+		while ((m = re.exec(text)) !== null) {
+			let concept = "assertion";
+			if (re === PY_TEST_RE) concept = "test";
+			else if (re === PY_FIXTURE_RE) concept = "fixture";
+			else if (re === PY_WAIT_RE) concept = "wait";
+			push(concept, m, re === PY_TEST_RE ? m[2] : void 0);
+		}
+	}
+	return {
+		language: "python",
+		nodes
+	};
+}
+//#endregion
 //#region src/rules/java/qa-jv-105-wait-for-timeout.ts
 /**
 * QA-JV-105 — waitForTimeout / hardcoded navigation waits.
 * Severity: warning · Confidence: high · deterministic-defect
 * Playwright-Java's page.waitForTimeout is a hard sleep.
+*
+* Lane A migration dossier (blueprint §10, hard-sleep JV/CS family —
+* the plan's suggested first family):
+* 1. BASELINE (rev 1, LEXICAL): regex over codeText; FP 0.10 (n=20).
+* 2. IMPLEMENTATION (rev 2, QA_MODEL): a finding requires a real
+*    method_invocation node with callee `waitForTimeout` — string/
+*    comment/declaration containment structurally cannot fire.
+* 3. RE-MEASUREMENT: sidecar regenerated at rev 2 in this change.
+* 4. FN check: parity tests over committed must-fire fixtures prove
+*    finding-identical results; must-not-fire fixtures pin precision.
+* 5. PERFORMANCE: model extraction walks the existing parse tree —
+*    no additional parse.
+* 6. ADR: QA-model adopted (grammar precision > lexical simplicity;
+*    the tree is already available at rule time). Legacy lexical
+*    fallback retained ONLY for AST-less contexts (parse declined /
+*    unit tests).
 */
 const jvWaitForTimeout = defineRule({
 	id: "QA-JV-105",
@@ -7269,12 +7845,34 @@ const jvWaitForTimeout = defineRule({
 	],
 	falsePositiveRisk: "low",
 	autofix: false,
-	detectionStrategy: "LEXICAL",
+	detectionStrategy: "QA_MODEL",
 	introduced: "0.3.8",
+	detectorRevision: 2,
 	run(ctx) {
-		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
 		if (!ctx.path.endsWith(".java")) return findings;
+		const tree = getTreeSitterTree(ctx.ast);
+		if (tree) {
+			const model = extractQaModel({
+				path: ctx.path,
+				text: ctx.text,
+				ast: tree
+			});
+			for (const node of model.nodes) if (node.concept === "wait" && node.callee === "waitForTimeout") findings.push({
+				severity: "warning",
+				confidence: "high",
+				findingType: "deterministic-defect",
+				qaImpact: "FLAKY-RISK",
+				file: ctx.path,
+				line: node.start.line,
+				column: node.start.column,
+				message: "`waitForTimeout()` hard sleep.",
+				why: "Fixed waits encode hope, not synchronization — too short flakes under load, too long slows every run.",
+				fix: "Use `page.locator(...).waitFor()` or `assertThat(locator).isVisible()` with auto-waiting."
+			});
+			return findings;
+		}
+		const text = ctx.codeText ?? ctx.text;
 		const re = /\.waitForTimeout\s*\(/g;
 		let m;
 		while ((m = re.exec(text)) !== null) findings.push({
@@ -7551,6 +8149,21 @@ function matchBrace(text, open) {
 * PascalCase Async-suffixed .NET API (verified in
 * docs/JAVA-CSHARP-IDIOM-MAPPING.md — .NET Playwright is async-only,
 * there is no sync WaitForTimeout).
+*
+* Lane A migration dossier (blueprint §10, hard-sleep JV/CS family):
+* 1. BASELINE (rev 1, LEXICAL): regex over codeText; FP 0.25 (n=16) —
+*    adjudicated FP classes were prose mentions in comments/strings.
+* 2. IMPLEMENTATION (rev 2, QA_MODEL): a finding requires a real
+*    invocation_expression node with callee `WaitForTimeoutAsync` —
+*    declarations, comments and strings are invisible to the grammar.
+* 3. RE-MEASUREMENT: sidecar regenerated at rev 2 in this change.
+* 4. FN check: parity tests over committed must-fire fixtures prove
+*    finding-identical results; must-not-fire fixtures pin precision.
+* 5. PERFORMANCE: model extraction walks the existing parse tree —
+*    no additional parse.
+* 6. ADR: QA-model adopted (grammar precision > lexical simplicity).
+*    Legacy lexical fallback retained ONLY for AST-less contexts
+*    (parse declined / unit tests).
 */
 const csWaitForTimeout = defineRule({
 	id: "QA-CS-105",
@@ -7570,13 +8183,35 @@ const csWaitForTimeout = defineRule({
 	],
 	falsePositiveRisk: "low",
 	autofix: false,
-	detectionStrategy: "LEXICAL",
+	detectionStrategy: "QA_MODEL",
 	introduced: "0.4.0",
 	tier: "extended",
+	detectorRevision: 2,
 	run(ctx) {
-		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
 		if (!ctx.path.endsWith(".cs")) return findings;
+		const tree = getTreeSitterTree(ctx.ast);
+		if (tree) {
+			const model = extractQaModel({
+				path: ctx.path,
+				text: ctx.text,
+				ast: tree
+			});
+			for (const node of model.nodes) if (node.concept === "wait" && node.callee === "WaitForTimeoutAsync") findings.push({
+				severity: "warning",
+				confidence: "high",
+				findingType: "deterministic-defect",
+				qaImpact: "FLAKY-RISK",
+				file: ctx.path,
+				line: node.start.line,
+				column: node.start.column,
+				message: "`WaitForTimeoutAsync()` hard sleep.",
+				why: "Fixed waits encode hope, not synchronization — too short flakes under load, too long slows every run.",
+				fix: "Use `await Assertions.Expect(locator).ToBeVisibleAsync()` or `locator.WaitForAsync()` with auto-waiting."
+			});
+			return findings;
+		}
+		const text = ctx.codeText ?? ctx.text;
 		const re = /\.WaitForTimeoutAsync\s*\(/g;
 		let m;
 		while ((m = re.exec(text)) !== null) findings.push({
@@ -8869,7 +9504,7 @@ const MEASURED_FP = {
 	"QA-CS-105": {
 		fpRate: .25,
 		n: 16,
-		detectorRevision: 1,
+		detectorRevision: 2,
 		ciLow: .1018,
 		ciHigh: .495
 	},
@@ -8932,7 +9567,7 @@ const MEASURED_FP = {
 	"QA-JV-105": {
 		fpRate: .1,
 		n: 20,
-		detectorRevision: 1,
+		detectorRevision: 2,
 		ciLow: .0279,
 		ciHigh: .301
 	},
@@ -12575,7 +13210,7 @@ function renderSarif(result, repoRootUri) {
 		tool: { driver: {
 			name: "Mjölnir",
 			informationUri: "https://github.com/Sergey-Bar/Mjolnir",
-			version: "0.5.7",
+			version: "0.5.9",
 			rules: [...rules.values()].map((r) => {
 				const meta = RULES.find((x) => x.id === r.id);
 				return {
@@ -17000,7 +17635,7 @@ const { runScan, buildUniversalRules, fallbackWorkspace, pathMatchesGlob, isVali
 * `scripts/sync-sarif-version.cjs` on release and guarded by
 * `tests/version-consistency.spec.ts` locally.
 */
-const CLI_VERSION = "0.5.7";
+const CLI_VERSION = "0.5.9";
 function parseArgs(argv, onError) {
 	const args = {
 		target: ".",