mjolnir-qa 2.0.2 → 3.0.0

package/dist/mcp/stdio.mjs

@@ -1,8 +1,8 @@
 import { createRequire } from "node:module";
 import { createInterface } from "node:readline";
 import { Buffer as Buffer$1 } from "node:buffer";
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import * as ts$2 from "ts-morph";
 import ts, { Project, SyntaxKind, ts as ts$1 } from "ts-morph";
@@ -56,6 +56,38 @@ const DEDUCTIONS = {
 	info: 1
 };
 //#endregion
+//#region src/engine/completion.ts
+function deriveCompletion(input) {
+	const truncationReasons = [...new Set(input.truncationReasons)].sort();
+	const reasons = /* @__PURE__ */ new Set();
+	if (input.discoveryTruncated) reasons.add("discovery-truncated");
+	if (input.rulesPartial) reasons.add("rules-partial");
+	if (input.skippedFiles > 0) reasons.add(`skipped-files:${input.skippedFiles}`);
+	if (input.rulesCrashed > 0) reasons.add(`rules-crashed:${input.rulesCrashed}`);
+	if (input.scopeIgnored > 0) reasons.add(`scope-ignored:${input.scopeIgnored}`);
+	if (input.scopeUnrecognized > 0) reasons.add(`scope-unrecognized:${input.scopeUnrecognized}`);
+	if (input.parseFailed > 0) reasons.add(`parse-failed:${input.parseFailed}`);
+	if (input.parseFallbacks && input.parseFallbacks > 0) reasons.add(`parse-fallbacks:${input.parseFallbacks}`);
+	if (input.scopeDegraded) reasons.add(`scope-degraded:${input.scopeDegraded}`);
+	if (input.runtimeIncomplete) reasons.add("runtime-incomplete");
+	if (input.identityIncomplete) reasons.add("identity-incomplete");
+	for (const reason of truncationReasons) reasons.add(`truncated:${reason}`);
+	const discoveryPartial = input.discoveryTruncated || input.scopeIgnored > 0 || input.scopeUnrecognized > 0 || input.scopeDegraded !== void 0;
+	const rulesPartial = input.rulesPartial || input.rulesCrashed > 0 || input.parseFailed > 0;
+	return {
+		partial: discoveryPartial || rulesPartial || input.skippedFiles > 0 || input.runtimeIncomplete === true || input.identityIncomplete === true || truncationReasons.length > 0,
+		analysisStatus: {
+			discovery: discoveryPartial ? "partial" : "complete",
+			rules: rulesPartial ? "partial" : "complete",
+			skippedFiles: input.skippedFiles,
+			rulesCrashed: input.rulesCrashed,
+			parseFallbacks: input.parseFallbacks ?? 0,
+			...truncationReasons.length > 0 ? { truncationReasons } : {},
+			reasons: [...reasons].sort()
+		}
+	};
+}
+//#endregion
 //#region src/engine/runtime-corroboration.ts
 /**
 * Stamp runtime corroboration + trust levels onto findings (mutates in
@@ -822,7 +854,10 @@ function sha256$1(text) {
 	return createHash("sha256").update(text).digest("hex");
 }
 function canonical(value) {
-	return JSON.stringify(value);
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
 }
 function buildRunIdentity(input) {
 	const inputFingerprint = sha256$1([...input.files].map((f) => f.hash ? `${f.path}:${f.hash}` : `${f.path}:${f.size}`).sort().join("\n"));
@@ -904,7 +939,7 @@ function buildEvidenceGraph(parts) {
 * scripts/sync-sarif-version.cjs and guarded by the version-consistency
 * spec. cli.ts re-exports this as CLI_VERSION.
 */
-const ENGINE_VERSION = "2.0.2";
+const ENGINE_VERSION = "3.0.0";
 //#endregion
 //#region src/engine/contract-versions.ts
 /**
@@ -1065,7 +1100,9 @@ function basename$1(p) {
 * Internal files (cache, hashes) use `isRecord`; user-facing files
 * (config, plugins) use stricter checks that throw descriptive errors.
 */
+const MAX_JSON_BYTES = 16777216;
 function parseJsonFile(text, source, validate) {
+	if (Buffer.byteLength(text, "utf8") > MAX_JSON_BYTES) throw new Error(`JSON source exceeds the ${MAX_JSON_BYTES}-byte limit: ${source}`);
 	let parsed;
 	try {
 		parsed = JSON.parse(text);
@@ -1084,6 +1121,59 @@ function isRecord(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 //#endregion
+//#region src/lib/fs-bounded.ts
+function closeQuiet(fd) {
+	try {
+		closeSync(fd);
+	} catch {
+		return;
+	}
+}
+function readFileBounded(path, maxBytes) {
+	let fd;
+	try {
+		const pathStat = lstatSync(path);
+		if (pathStat.isSymbolicLink()) return {
+			ok: false,
+			reason: "symlink"
+		};
+		if (!pathStat.isFile()) return {
+			ok: false,
+			reason: "unreadable"
+		};
+		fd = openSync(path, 0);
+		const fdStat = fstatSync(fd);
+		if (!fdStat.isFile() || fdStat.size > maxBytes) return {
+			ok: false,
+			reason: fdStat.size > maxBytes ? "too-large" : "unreadable"
+		};
+		const chunks = [];
+		let total = 0;
+		const buffer = Buffer.allocUnsafe(Math.min(65536, maxBytes));
+		while (true) {
+			const read = readSync(fd, buffer, 0, buffer.length, null);
+			if (read === 0) break;
+			total += read;
+			if (total > maxBytes) return {
+				ok: false,
+				reason: "too-large"
+			};
+			chunks.push(Buffer.from(buffer.subarray(0, read)));
+		}
+		return {
+			ok: true,
+			data: Buffer.concat(chunks)
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "unreadable"
+		};
+	} finally {
+		if (fd !== void 0) closeQuiet(fd);
+	}
+}
+//#endregion
 //#region src/config/config-schema.ts
 const VALID_GATES = /* @__PURE__ */ new Set([
 	"advisory",
@@ -1182,7 +1272,11 @@ const CONFIG_NAMES = ["mjolnir.config.json", ".mjolnir.json"];
 function findConfigPath(root) {
 	for (const name of CONFIG_NAMES) {
 		const p = join(root, name);
-		if (existsSync(p)) return p;
+		try {
+			if (existsSync(p) && !lstatSync(p).isSymbolicLink()) return p;
+		} catch {
+			continue;
+		}
 	}
 	return null;
 }
@@ -1202,7 +1296,10 @@ function loadConfig(root, options = {}) {
 		const p = join(root, name);
 		if (!existsSync(p)) continue;
 		try {
-			const parsed = parseJsonFile(readFileSync(p, "utf8"), p, (v) => isRecord(v));
+			if (!existsSync(p) || lstatSync(p).isSymbolicLink()) continue;
+			const read = readFileBounded(p, 1048576);
+			if (!read.ok) throw new Error("config source could not be read safely");
+			const parsed = parseJsonFile(read.data.toString("utf8"), p, (v) => isRecord(v));
 			return {
 				config: parsed,
 				path: p,
@@ -1496,8 +1593,9 @@ function sharedWalk(options) {
 			}
 			const full = join(dir, entry.name);
 			const rel = relative(options.root, full).replaceAll("\\", "/");
+			if (entry.isDirectory() && options.skipDirs.includes(entry.name)) continue;
 			if (options.ignoreMatcher.isIgnored(rel)) {
-				options.onIgnored?.();
+				if (!rel.startsWith(".mjolnir/")) options.onIgnored?.(rel);
 				continue;
 			}
 			if (entry.isSymbolicLink()) {
@@ -1505,7 +1603,6 @@ function sharedWalk(options) {
 				continue;
 			}
 			if (entry.isDirectory()) {
-				if (options.skipDirs.includes(entry.name)) continue;
 				if (rel.split("/").length > LIMITS$1.maxDepth) {
 					options.onSkipped("max-depth");
 					continue;
@@ -1523,7 +1620,7 @@ function sharedWalk(options) {
 			} catch {
 				options.onSkipped("stat-failed");
 			}
-			else if (entry.isFile()) options.onUnrecognized?.();
+			else if (entry.isFile()) options.onUnrecognized?.(rel);
 		}
 	};
 	walk(options.root);
@@ -3625,7 +3722,7 @@ const SCAN_ADAPTERS = [
 * the adapter that claims it; per-adapter caps still apply.
 */
 function discoverAllTestFiles(ctx, languageAdapters, buckets, fixtureDirMemo) {
-	const walkSkips = languageAdapters.reduce((common, a) => common.filter((name) => a.dirSkips.includes(name)), languageAdapters[0]?.dirSkips ?? []);
+	const walkSkips = [.../* @__PURE__ */ new Set([...languageAdapters.reduce((common, a) => common.filter((name) => a.dirSkips.includes(name)), languageAdapters[0]?.dirSkips ?? []), ".mjolnir"])];
 	sharedWalk({
 		root: ctx.workspace.root,
 		deadline: ctx.deadline,
@@ -3651,10 +3748,35 @@ function discoverAllTestFiles(ctx, languageAdapters, buckets, fixtureDirMemo) {
 		},
 		isFull: () => languageAdapters.every((a) => (buckets.get(a.id)?.length ?? 0) >= ctx.maxFiles),
 		fixtureDirMemo,
-		onIgnored: ctx.onIgnored,
-		onUnrecognized: ctx.onUnrecognized
+		onIgnored: (path) => {
+			if (isScopeRelevantIgnored(path)) ctx.onIgnored?.(path);
+		},
+		onUnrecognized: (path) => {
+			if (typeof path === "string" && isUnrecognizedSourceCandidate(path)) ctx.onUnrecognized?.(path);
+		}
 	});
 }
+function isScopeRelevantIgnored(path) {
+	const name = path.replaceAll("\\", "/").split("/").pop() ?? path;
+	return /\.(?:[cm]?[jt]sx?|py|java|cs|ya?ml|min\.js)$/i.test(name);
+}
+function isUnrecognizedSourceCandidate(path) {
+	const normalized = path.replaceAll("\\", "/");
+	const name = normalized.split("/").pop() ?? normalized;
+	if (normalized.includes(".github/workflows/") || name === "azure-pipelines.yml" || name === "Jenkinsfile") return false;
+	const extensionIndex = name.lastIndexOf(".");
+	const stem = extensionIndex > 0 ? name.slice(0, extensionIndex) : name;
+	if (name === "mjolnir.config.json" || name === ".mjolnir.json" || name === "package.json" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock" || [
+		"playwright",
+		"vitest",
+		"vite",
+		"eslint",
+		"tsconfig",
+		"jsconfig"
+	].some((prefix) => stem === prefix || stem.startsWith(`${prefix}.`))) return false;
+	const testLike = /(?:^|\/)__tests__\//i.test(normalized) || /\.(?:spec|test)\.[cm]?[jt]sx?$/i.test(name);
+	return /\.(?:[cm]?[jt]sx?|py|java|cs|ya?ml)$/i.test(name) && testLike;
+}
 /** Whether ANY shipped adapter would discover this path as a test file. */
 function isKnownTestFile(path) {
 	return SCAN_ADAPTERS.some((a) => a.isTestFile(path));
@@ -3681,17 +3803,14 @@ typescriptAdapter.testFileGlobs, pythonAdapter.testFileGlobs, javaAdapter.testFi
 * The fix: resolve git ONCE per process to an ABSOLUTE path by walking
 * the PATH directly (never consulting the CWD), verify the candidate is
 * an existing file, and pass that path to execFileSync. Resolution is
-* memoized; a failure to find a real git anywhere on PATH degrades to
-* the plain name (previous behavior) with the resolution error recorded
-* — degraded git data already means full-file attribution, never a
-* crash.
+* memoized; a failure to find a real git anywhere on PATH is recorded
+* and callers degrade without invoking a bare name.
 */
 let resolvedGit = void 0;
 /**
 * The absolute path of the git binary Mjölnir will invoke, or null when
-* PATH carries no executable `git` at all (S1 degradation: callers fall
-* back to the bare name and their own try/catch — same honest degrade
-* as before, minus the CWD-hijack surface).
+* PATH carries no executable `git` at all. Callers must degrade without
+* invoking a bare name.
 */
 function resolveGitPath() {
 	if (resolvedGit !== void 0) return resolvedGit;
@@ -3724,7 +3843,8 @@ function resolveGitPath() {
 * the previous inline `git()` helpers, with the hijack surface closed.
 */
 function runGit(root, args) {
-	const exe = resolveGitPath() ?? "git";
+	const exe = resolveGitPath();
+	if (!exe) return null;
 	try {
 		return execFileSync(exe, [
 			"-C",
@@ -3860,7 +3980,7 @@ function computeChangedScope(root, baseBranch) {
 				"--",
 				...chunk
 			]);
-			if (output === null) continue;
+			if (output === null) return null;
 			const sections = output.split("\ndiff --git ");
 			for (const section of sections) {
 				const body = section.startsWith("diff --git ") ? section : `diff --git ${section}`;
@@ -3888,6 +4008,11 @@ function computeChangedScope(root, baseBranch) {
 		"--unified=0",
 		"HEAD"
 	], changedFiles);
+	if (committedDiffs === null || workingDiffs === null) return {
+		changed: {},
+		degraded: true,
+		reason: "diff-failed"
+	};
 	for (const file of changedFiles) {
 		const committedDiff = committedDiffs.get(file);
 		const workingDiff = workingDiffs.get(file);
@@ -3913,8 +4038,11 @@ const LIMITS_MAX_LINES = 1e6;
 function allLinesOf(root, file) {
 	const full = join(root, file);
 	try {
-		if (statSync(full).size > LIMITS$1.maxFileBytes) return null;
-		const lineCount = readFileSync(full, "utf8").split("\n").length;
+		const stat = lstatSync(full);
+		if (stat.isSymbolicLink() || !stat.isFile()) return null;
+		const read = readFileBounded(full, LIMITS$1.maxFileBytes);
+		if (!read.ok) return null;
+		const lineCount = read.data.toString("utf8").split("\n").length;
 		return Array.from({ length: lineCount }, (_, i) => i + 1);
 	} catch {
 		return null;
@@ -11967,6 +12095,85 @@ function configurableAggregation(results, config) {
 	};
 }
 //#endregion
+//#region src/lib/fs-atomic.ts
+/**
+* Atomic file writes (audit S9).
+*
+* Every durability-critical write in Mjölnir (baseline, stats, badge,
+* TRIAGE.md, scaffolded rule files) used to hand-roll
+* `writeFileSync(path, data)` — a crash mid-write left a TRUNCATED file
+* at the real path, and a subsequent read (diff, badge endpoint) served
+* confident nonsense from it.
+*
+* `writeFileAtomic` writes to a temp sibling, then RENAMES. On the same
+* volume rename is atomic: readers see either the complete old file or
+* the complete new file, never a half-written one. The temp name is
+* created with `wx` (exclusive) so concurrent writers cannot interleave,
+* stale temps are cleaned up on failure, and on Windows the rename is
+* retried briefly because a concurrent reader can hold the destination
+* open (EBUSY/EPERM).
+*/
+function atomicTempPath(path) {
+	return `${path}.mjolnir-${process.pid}-${Date.now()}-${randomBytes(4).toString("hex")}.tmp`;
+}
+/**
+* Atomically replace `path` with `data`.
+*/
+function writeFileAtomic(path, data, opts = {}) {
+	const dir = dirname(path);
+	if (opts.mkdirs !== false && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmp = atomicTempPath(path);
+	let fd;
+	try {
+		fd = openSync(tmp, "wx", opts.mode ?? 420);
+		writeSync(fd, data, null, opts.encoding ?? "utf8");
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+	try {
+		renameWithWindowsRetry(tmp, path);
+	} catch (err) {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {}
+		throw err;
+	}
+}
+/**
+* renameSync retry loop for Windows: a concurrent reader (another scan,
+* a badge endpoint, an editor) holding the destination open makes
+* rename fail with EBUSY/EPERM. A short bounded retry closes the race
+* without turning an atomic swap into a partial write.
+*
+* Internal contract test hook: the platform check keeps this loop off
+* the POSIX hot path; on win32 the EBUSY/EPERM arms are exercised by
+* the fs-atomic-retry spec (mocked renameSync).
+*/
+const RENAME_RETRIES = 8;
+const RENAME_RETRY_DELAY_MS = 25;
+/** Synchronous sleep that does not spin the CPU. */
+function sleepSync(ms) {
+	try {
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+	} catch {
+		const until = Date.now() + ms;
+		while (Date.now() < until);
+	}
+}
+function renameWithWindowsRetry(from, to) {
+	for (let attempt = 0;; attempt++) try {
+		renameSync(from, to);
+		return;
+	} catch (err) {
+		const code = err?.code;
+		if (process.platform === "win32" && (code === "EBUSY" || code === "EPERM") && attempt < RENAME_RETRIES) {
+			sleepSync(RENAME_RETRY_DELAY_MS);
+			continue;
+		}
+		throw err;
+	}
+}
+//#endregion
 //#region src/engine/scan-cache.ts
 /**
 * Local incremental scan cache (Beta-to-Stable 1.0 plan, M5.2 / A-2).
@@ -12002,6 +12209,17 @@ const MAX_ENTRIES$1 = 4096;
 * serialized size; the newest entries win (real LRU-by-use).
 */
 const MAX_TOTAL_BYTES = 33554432;
+const MAX_FINDINGS_PER_ENTRY = 1e4;
+function isCachedFinding(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["ruleId"] === "string" && typeof value["category"] === "string" && typeof value["severity"] === "string" && typeof value["confidence"] === "string" && typeof value["findingType"] === "string" && typeof value["file"] === "string" && Number.isSafeInteger(value["line"]) && Number.isSafeInteger(value["column"]) && typeof value["message"] === "string" && typeof value["why"] === "string" && typeof value["fix"] === "string";
+}
+function isCacheFile(value) {
+	if (!isRecord(value) || value["version"] !== CACHE_VERSION) return false;
+	const entries = value["entries"];
+	if (!isRecord(entries) || Object.keys(entries).length > MAX_ENTRIES$1) return false;
+	return Object.values(entries).every((entry) => isRecord(entry) && Array.isArray(entry["findings"]) && entry["findings"].length <= MAX_FINDINGS_PER_ENTRY && entry["findings"].every(isCachedFinding));
+}
 /** sha256 hex of a string — the only hash this module needs. */
 function sha256(text) {
 	return createHash("sha256").update(text).digest("hex");
@@ -12100,12 +12318,15 @@ function createScanCache(root) {
 	let totalBytes = 0;
 	try {
 		if (existsSync(file)) {
-			entries = parseJsonFile(readFileSync(file, "utf8"), file, (v) => isRecord(v) && v["version"] === CACHE_VERSION && isRecord(v["entries"])).entries;
+			const stat = lstatSync(file);
+			if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_TOTAL_BYTES) throw new Error("invalid cache file");
+			entries = parseJsonFile(readFileSync(file, "utf8"), file, isCacheFile).entries;
 			for (const [k, v] of Object.entries(entries)) {
-				const size = JSON.stringify(v).length + k.length + 4;
+				const size = Buffer.byteLength(JSON.stringify(v), "utf8") + k.length + 4;
 				entryBytes.set(k, size);
 				totalBytes += size;
 			}
+			if (totalBytes > MAX_TOTAL_BYTES) throw new Error("cache byte budget exceeded");
 		}
 	} catch {
 		entries = {};
@@ -12131,11 +12352,13 @@ function createScanCache(root) {
 		},
 		store(key, findings, fileBudgetExceeded) {
 			if (fileBudgetExceeded) return;
+			if (findings.length > MAX_FINDINGS_PER_ENTRY) return;
+			const entryJson = JSON.stringify(findings);
+			const newBytes = Buffer.byteLength(entryJson, "utf8") + key.length + 4;
+			if (newBytes > MAX_TOTAL_BYTES) return;
 			const replacedBytes = entryBytes.get(key) ?? 0;
 			delete entries[key];
-			const entryJson = JSON.stringify(findings);
 			entries[key] = { findings: structuredClone(findings) };
-			const newBytes = entryJson.length + key.length + 4;
 			entryBytes.set(key, newBytes);
 			totalBytes = totalBytes - replacedBytes + newBytes;
 			let count = Object.keys(entries).length;
@@ -12152,10 +12375,10 @@ function createScanCache(root) {
 			if (!dirty) return;
 			try {
 				mkdirSync(dir, { recursive: true });
-				writeFileSync(file, JSON.stringify({
+				writeFileAtomic(file, JSON.stringify({
 					version: CACHE_VERSION,
 					entries
-				}), "utf8");
+				}), { encoding: "utf8" });
 			} catch {}
 		}
 	};
@@ -13798,6 +14021,31 @@ function loadPlugins(root, gateOpen = false) {
 * next catalog render (locked by tests/local-rules.spec.ts).
 */
 const LOCAL_RULES_DIR = "mjolnir-rules";
+const MAX_EXTERNAL_RULES = 1e3;
+const MAX_RULE_FILE_BYTES = 1048576;
+const MAX_PATTERNS_PER_RULE = 100;
+function hasNestedQuantifier(pattern) {
+	for (let i = 0; i < pattern.length; i++) {
+		if (pattern.charAt(i) !== "(") continue;
+		let bodyHasQuantifier = false;
+		let j = i + 1;
+		for (; j < pattern.length && pattern.charAt(j) !== ")"; j++) {
+			const bodyChar = pattern.charAt(j);
+			if (bodyChar === "+" || bodyChar === "*" || bodyChar === "?") {
+				bodyHasQuantifier = true;
+				break;
+			}
+		}
+		if (bodyHasQuantifier) {
+			while (j < pattern.length && pattern.charAt(j) !== ")") j++;
+			if (j + 1 < pattern.length) {
+				const next = pattern.charAt(j + 1);
+				if (next === "+" || next === "*" || next === "{") return true;
+			}
+		}
+	}
+	return false;
+}
 const ALLOWED_CATEGORIES = /* @__PURE__ */ new Set([
 	"QA-TEST",
 	"QA-TQUAL",
@@ -13827,7 +14075,7 @@ const ALLOWED_QA_IMPACTS = /* @__PURE__ */ new Set([
 * Missing directory → empty result (not an error — most workspaces
 * carry none).
 */
-async function loadLocalRules(root, gateOpen = true) {
+async function loadLocalRules(root, gateOpen = false) {
 	const result = {
 		rules: [],
 		errors: [],
@@ -13835,6 +14083,15 @@ async function loadLocalRules(root, gateOpen = true) {
 	};
 	const dir = join(root, LOCAL_RULES_DIR);
 	if (!existsSync(dir)) return result;
+	try {
+		if (lstatSync(dir).isSymbolicLink()) {
+			result.errors.push(`external rules directory "${LOCAL_RULES_DIR}/" is a symlink — skipped`);
+			return result;
+		}
+	} catch (err) {
+		result.errors.push(`external rules directory "${LOCAL_RULES_DIR}/" could not be inspected: ${err instanceof Error ? err.message : String(err)}`);
+		return result;
+	}
 	let entries;
 	try {
 		entries = readdirSync(dir);
@@ -13843,7 +14100,20 @@ async function loadLocalRules(root, gateOpen = true) {
 		return result;
 	}
 	for (const entry of entries.sort()) {
+		if (result.rules.length >= MAX_EXTERNAL_RULES) {
+			result.errors.push(`external rule budget exceeded (${MAX_EXTERNAL_RULES})`);
+			break;
+		}
 		const path = join(dir, entry);
+		try {
+			if (lstatSync(path).isSymbolicLink()) {
+				result.errors.push(`external rule "${LOCAL_RULES_DIR}/${entry}" is a symlink — skipped`);
+				continue;
+			}
+		} catch (err) {
+			result.errors.push(`external rule "${LOCAL_RULES_DIR}/${entry}" could not be inspected: ${err instanceof Error ? err.message : String(err)}`);
+			continue;
+		}
 		if (entry.endsWith(".json")) loadJsonRule(path, result);
 		else if (entry.endsWith(".mjs") || entry.endsWith(".js")) {
 			if (!gateOpen) result.skipped.push(`${LOCAL_RULES_DIR}/${entry}`);
@@ -13856,6 +14126,10 @@ function loadJsonRule(path, result) {
 	const name = `${LOCAL_RULES_DIR}/${path.split(/[\\/]/).pop()}`;
 	let raw;
 	try {
+		if (lstatSync(path).size > MAX_RULE_FILE_BYTES) {
+			result.errors.push(`external rule "${name}" exceeds the file size budget`);
+			return;
+		}
 		raw = JSON.parse(readFileSync(path, "utf8"));
 	} catch (err) {
 		result.errors.push(`external rule "${name}" is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
@@ -13876,7 +14150,7 @@ function loadJsonRule(path, result) {
 		return;
 	}
 	const patterns = decl["patterns"];
-	if (!Array.isArray(patterns) || patterns.length === 0 || !patterns.every((p) => typeof p === "string" && p.length > 0)) {
+	if (!Array.isArray(patterns) || patterns.length === 0 || patterns.length > MAX_PATTERNS_PER_RULE || !patterns.every((p) => typeof p === "string" && p.length > 0)) {
 		result.errors.push(`external rule ${id} must declare a non-empty "patterns" array of regex source strings.`);
 		return;
 	}
@@ -13892,6 +14166,10 @@ function loadJsonRule(path, result) {
 			result.errors.push(`external rule ${id} has a pattern longer than 512 chars — likely a copy-paste error.`);
 			return;
 		}
+		if (hasNestedQuantifier(p)) {
+			result.errors.push(`external rule ${id} has a nested quantifier that may cause catastrophic backtracking`);
+			return;
+		}
 		const quantifiers = p.match(/[+*?]|\{\d/g);
 		if (quantifiers && quantifiers.length > 64) {
 			result.errors.push(`external rule ${id} has a pattern with more than 64 quantifier/wildcard tokens — likely catastrophic backtracking.`);
@@ -14071,6 +14349,8 @@ function renderGateNotice(skipped) {
 * module moved. Re-exports in cli.ts keep the historical import surface.
 */
 const UNIVERSAL_RULES = RULES.map(asUniversal);
+const DEFAULT_MAX_DURATION_MS$1 = 6e5;
+const MAX_DURATION_MS$1 = 36e5;
 /** Registered rule IDs — used to warn on unknown severityOverrides keys (M4). */
 const KNOWN_RULE_IDS = new Set(RULES.map((r) => r.id));
 /**
@@ -14287,7 +14567,9 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 	let testDeclarationCount = 0;
 	let rulesPartial = false;
 	let parseFailed = 0;
+	let parseFallbacks = 0;
 	let scanned = 0;
+	let analyzed = 0;
 	for (const path of testFiles) {
 		if (Date.now() > deadline) {
 			rulesPartial = true;
@@ -14301,7 +14583,12 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 		if (!isCiAdapter) testFileCount++;
 		let text;
 		try {
-			text = readFileSync(path, "utf8").replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+			const readResult = readFileBounded(path, LIMITS$1.maxFileBytes);
+			if (!readResult.ok) {
+				skippedFiles++;
+				continue;
+			}
+			text = readResult.data.toString("utf8").replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
 		} catch {
 			skippedFiles++;
 			continue;
@@ -14335,6 +14622,7 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 		const cachedFindings = cache.lookup(cacheKey);
 		if (cachedFindings) {
 			for (const f of cachedFindings) findings.push(f);
+			analyzed++;
 			continue;
 		}
 		hooks.onProgress?.({
@@ -14361,10 +14649,12 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 			}
 			const actualMode = parsed ? "ast" : "regex";
 			if (wantsAst && actualMode === "regex") {
+				parseFallbacks++;
 				cacheKey = fileCacheKey(rulesDigest, text, identity(actualMode));
 				const fallbackFindings = cache.lookup(cacheKey);
 				if (fallbackFindings) {
 					for (const f of fallbackFindings) findings.push(f);
+					analyzed++;
 					continue;
 				}
 			}
@@ -14395,8 +14685,10 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 					fileBudgetExceeded = true;
 				}
 			});
+			if (!fileRuleFailed && !fileBudgetExceeded) analyzed++;
 			if (!fileRuleFailed) cache.store(cacheKey, findings.slice(findingsStart), fileBudgetExceeded);
 		} catch {
+			if (wantsAst) parseFallbacks++;
 			skippedFiles++;
 			parseFailed++;
 		} finally {
@@ -14409,7 +14701,9 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 		testDeclarationCount,
 		rulesPartial,
 		parseFailed,
-		scanned
+		parseFallbacks,
+		scanned,
+		analyzed
 	};
 }
 /**
@@ -14455,13 +14749,15 @@ function applyPostScanProcessing(findings, workspace, args, hooks, scanRoot, dec
 	for (const w of warnings) hooks.onConfigWarning?.(w);
 	applySeverityOverrides(findings, config);
 	const active = loadSuppressions(workspace.root).entries.filter((e) => e.status === "active");
-	const suppressionCount = active.length;
+	hooks.onPreSuppressionFindings?.([...findings]);
+	let suppressionCount = 0;
 	if (active.length > 0) {
 		const ruleOnly = new Set(active.filter((e) => !e.files?.length).map((e) => e.ruleId));
 		const kept = findings.filter((f) => {
 			if (ruleOnly.has(f.ruleId)) return false;
 			return !active.some((e) => e.files?.length && e.ruleId === f.ruleId && e.files.some((g) => pathMatchesGlob(f.file, g)));
 		});
+		suppressionCount = findings.length - kept.length;
 		findings.length = 0;
 		for (const f of kept) findings.push(f);
 	}
@@ -14485,6 +14781,7 @@ function applyPostScanProcessing(findings, workspace, args, hooks, scanRoot, dec
 	for (const f of findings) f.fixGroupId = f.ruleId;
 	const discoveredReport = discoverAndParseRuntimeReport(scanRoot.root);
 	const runtimeReportPath = discoveredReport?.path;
+	const runtimeIncomplete = discoveredReport !== void 0 && discoveredReport.report.analysisComplete !== true;
 	let forensicVerdicts;
 	if (discoveredReport && discoveredReport.report.analysisComplete === true) try {
 		buildEvidenceRecords(discoveredReport.report, discoveredReport.path);
@@ -14497,6 +14794,7 @@ function applyPostScanProcessing(findings, workspace, args, hooks, scanRoot, dec
 		suppressionCount,
 		frameworks,
 		runtimeReportPath,
+		runtimeIncomplete,
 		forensicVerdicts,
 		config
 	};
@@ -14565,10 +14863,13 @@ function assembleScanResult(o) {
 	if (o.scopeIgnored > 0) scopeReasons.push(`ignored:${o.scopeIgnored}`);
 	if (o.scopeUnrecognized > 0) scopeReasons.push(`unrecognized:${o.scopeUnrecognized}`);
 	if (o.parseFailed > 0) scopeReasons.push(`parseFailed:${o.parseFailed}`);
+	if (o.skippedFiles > 0) scopeReasons.push(`skipped:${o.skippedFiles}`);
+	if (o.scopeInfo.degraded) scopeReasons.push(`degraded:${o.scopeInfo.degraded}`);
+	if (o.runtimeIncomplete) scopeReasons.push("runtime-incomplete");
 	for (const reason of o.truncationReasons) scopeReasons.push(`truncated:${reason}`);
 	const scopeIntegrity = {
 		discovered: o.testFiles.length,
-		analyzed: Math.max(0, o.scanned),
+		analyzed: Math.max(0, o.analyzed ?? o.scanned),
 		ignored: o.scopeIgnored,
 		unrecognized: o.scopeUnrecognized,
 		parseFailed: o.parseFailed,
@@ -14577,28 +14878,59 @@ function assembleScanResult(o) {
 		...scopeReasons.length > 0 ? { reasons: scopeReasons } : {}
 	};
 	const scopeAdjustedTotal = scopeReasons.length > 0 && total >= 100 ? 99 : total;
+	let identityIncomplete = false;
 	const inputSnapshot = o.testFiles.map((p) => {
 		const relPath = relative(o.workspace.root, p).replaceAll("\\", "/");
 		try {
-			const content = readFileSync(p);
-			const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+			const read = readFileBounded(resolve(o.workspace.root, p), LIMITS$1.maxFileBytes);
+			if (!read.ok) {
+				if (existsSync(o.workspace.root)) identityIncomplete = true;
+				return {
+					path: relPath,
+					size: 0,
+					hash: "UNAVAILABLE"
+				};
+			}
+			const hash = createHash("sha256").update(read.data).digest("hex");
 			return {
 				path: relPath,
-				size: content.length,
+				size: read.data.length,
 				hash
 			};
 		} catch {
+			if (existsSync(o.workspace.root)) identityIncomplete = true;
 			return {
 				path: relPath,
-				size: 0
+				size: 0,
+				hash: "UNAVAILABLE"
 			};
 		}
 	});
 	let reportDigest;
 	if (o.runtimeReportPath) try {
-		const reportBytes = readFileSync(o.runtimeReportPath);
-		reportDigest = createHash("sha256").update(reportBytes).digest("hex").slice(0, 16);
-	} catch {}
+		const reportPath = resolve(o.workspace.root, o.runtimeReportPath);
+		if (lstatSync(reportPath).isFile()) {
+			const read = readFileBounded(reportPath, LIMITS$1.maxFileBytes);
+			if (!read.ok) identityIncomplete = true;
+			else reportDigest = createHash("sha256").update(read.data).digest("hex");
+		}
+	} catch {
+		identityIncomplete = true;
+	}
+	const completion = deriveCompletion({
+		discoveryTruncated: o.discoveryTruncated,
+		rulesPartial: o.rulesPartial,
+		skippedFiles: o.skippedFiles,
+		rulesCrashed: o.rulesCrashed,
+		truncationReasons: o.truncationReasons,
+		scopeIgnored: o.scopeIgnored,
+		scopeUnrecognized: o.scopeUnrecognized,
+		parseFailed: o.parseFailed,
+		parseFallbacks: o.parseFallbacks ?? 0,
+		...o.scopeInfo.degraded !== void 0 ? { scopeDegraded: o.scopeInfo.degraded } : {},
+		...o.runtimeIncomplete !== void 0 ? { runtimeIncomplete: o.runtimeIncomplete } : {},
+		identityIncomplete
+	});
 	const runIdentity = buildRunIdentity({
 		files: inputSnapshot,
 		rules: [...o.REVISION_BY_RULE_ID.entries()].map(([id, detectorRevision]) => ({
@@ -14616,13 +14948,14 @@ function assembleScanResult(o) {
 	const evidenceGraph = buildEvidenceGraph({ runId: runIdentity });
 	const hasTests = o.testFileCount > 0 && o.testDeclarationCount > 0;
 	const suiteInvalidatedBy = [...new Set(o.findings.filter((f) => SUITE_INVALIDATING_RULE_IDS.has(f.ruleId)).map((f) => f.ruleId))].sort();
+	const finalScore = hasTests ? completion.partial && scopeAdjustedTotal >= 100 ? 99 : scopeAdjustedTotal : null;
 	const result = {
 		schemaVersion: 1,
-		partial: o.discoveryTruncated || o.rulesPartial || o.skippedFiles > 0 || o.rulesCrashed > 0 || o.scopeInfo.degraded !== void 0,
+		partial: completion.partial,
 		scopeIntegrity,
 		runIdentity,
 		evidenceGraph,
-		score: hasTests ? scopeAdjustedTotal : null,
+		score: finalScore,
 		...hasTests ? {} : { reason: "no-tests-found" },
 		frameworks: o.frameworks.frameworks,
 		frameworkDetectionUnknown: o.frameworks.unknown,
@@ -14648,12 +14981,8 @@ function assembleScanResult(o) {
 			file: o.cache.stats.file
 		} } : {},
 		analysisStatus: {
-			discovery: o.discoveryTruncated ? "partial" : "complete",
-			rules: o.rulesPartial ? "partial" : "complete",
-			skippedFiles: o.skippedFiles,
-			durationMs: elapsed,
-			rulesCrashed: o.rulesCrashed,
-			...o.truncationReasons.size > 0 ? { truncationReasons: [...o.truncationReasons].sort() } : {}
+			...completion.analysisStatus,
+			durationMs: elapsed
 		},
 		scoringModelVersion: SCORING_MODEL_VERSION
 	};
@@ -14701,7 +15030,8 @@ function assembleScanResult(o) {
 */
 async function runScan(args, hooks = {}) {
 	const started = Date.now();
-	const deadline = started + args.maxDurationMs;
+	const requestedDuration = Number.isFinite(args.maxDurationMs) ? args.maxDurationMs : DEFAULT_MAX_DURATION_MS$1;
+	const deadline = started + Math.min(Math.max(1, requestedDuration), MAX_DURATION_MS$1);
 	const discovered = discoverWorkspace(args.target);
 	const targetAbs = resolve(args.target);
 	const scanRoot = discovered && discovered.root !== targetAbs && targetAbs.startsWith(discovered.root + sep) ? {
@@ -14780,6 +15110,7 @@ async function runScan(args, hooks = {}) {
 			scopeUnrecognized++;
 		}
 	});
+	hooks.onTestFilesDiscovered?.(testFiles);
 	const analysis = await runFileAnalysisPhase(findings, testFiles, workspace, activeRules, hooks, cache, rulesDigest, deadline, truncationReasons, declarationsByFile, fileProvenance, (ruleId, file, error) => {
 		rulesCrashed++;
 		hooks.onRuleCrash?.(ruleId, file, error);
@@ -14789,7 +15120,9 @@ async function runScan(args, hooks = {}) {
 	testDeclarationCount = analysis.testDeclarationCount;
 	rulesPartial = analysis.rulesPartial;
 	parseFailed = analysis.parseFailed;
+	const parseFallbacks = analysis.parseFallbacks;
 	const scanned = analysis.scanned;
+	const analyzed = analysis.analyzed;
 	const postScan = applyPostScanProcessing(findings, workspace, args, hooks, scanRoot, declarationsByFile, testDeclarationCount, tierByRuleId, REVISION_BY_RULE_ID);
 	testDeclarationCount = postScan.testDeclarationCount;
 	const result = assembleScanResult({
@@ -14805,7 +15138,9 @@ async function runScan(args, hooks = {}) {
 		scopeIgnored,
 		scopeUnrecognized,
 		parseFailed,
+		parseFallbacks,
 		scanned,
+		analyzed,
 		testFiles,
 		workspace,
 		scanRoot,
@@ -14818,6 +15153,7 @@ async function runScan(args, hooks = {}) {
 		suppressionCount: postScan.suppressionCount,
 		frameworks: postScan.frameworks,
 		runtimeReportPath: postScan.runtimeReportPath,
+		runtimeIncomplete: postScan.runtimeIncomplete,
 		forensicVerdicts: postScan.forensicVerdicts,
 		config: postScan.config,
 		fileProvenance,
@@ -14849,6 +15185,10 @@ function digestView(f) {
 		trustLevel: f.trustLevel ?? null,
 		confidence: f.confidence,
 		findingType: f.findingType,
+		qaImpact: f.qaImpact,
+		findingId: f.findingId ?? null,
+		rootCauseId: f.rootCauseId ?? null,
+		deduplicationGroup: f.deduplicationGroup ?? null,
 		fixGroupId: f.fixGroupId ?? null
 	};
 }
@@ -14869,8 +15209,12 @@ function canonicalScanJson(result) {
 			rules: result.analysisStatus.rules,
 			skippedFiles: result.analysisStatus.skippedFiles,
 			rulesCrashed: result.analysisStatus.rulesCrashed ?? 0,
-			truncationReasons: result.analysisStatus.truncationReasons ?? []
+			parseFallbacks: result.analysisStatus.parseFallbacks ?? 0,
+			truncationReasons: result.analysisStatus.truncationReasons ?? [],
+			reasons: result.analysisStatus.reasons ?? []
 		},
+		scopeIntegrity: result.scopeIntegrity ?? null,
+		runIdentity: result.runIdentity ?? null,
 		findings: result.findings.map(digestView)
 	});
 }
@@ -14927,9 +15271,13 @@ function buildMachineContract(result) {
 			rules: result.analysisStatus.rules,
 			skippedFiles: result.analysisStatus.skippedFiles,
 			rulesCrashed: result.analysisStatus.rulesCrashed ?? 0,
+			...result.analysisStatus.parseFallbacks !== void 0 ? { parseFallbacks: result.analysisStatus.parseFallbacks } : {},
 			truncationReasons: result.analysisStatus.truncationReasons ?? [],
+			...result.analysisStatus.reasons !== void 0 ? { reasons: result.analysisStatus.reasons } : {},
 			frameworkDetectionUnknown: result.frameworkDetectionUnknown,
-			durationMs: result.analysisStatus.durationMs
+			durationMs: result.analysisStatus.durationMs,
+			...result.scopeIntegrity !== void 0 ? { scopeIntegrity: result.scopeIntegrity } : {},
+			...result.runIdentity !== void 0 ? { runIdentity: result.runIdentity } : {}
 		},
 		...result.trustSummary !== void 0 ? { trustSummary: result.trustSummary } : {},
 		...result.agenticProfile !== void 0 ? { provenance: result.agenticProfile } : {},
@@ -15290,12 +15638,15 @@ function trustVerdictFor(v) {
 * today the honest command set is repeat/compare/inspect, not
 * "collect a trace", because trace.zip is not yet ingested.
 */
+function safeTriageText(value) {
+	return value.replace(/[;&|`$()\\\r\n]/g, " ").slice(0, 200);
+}
 function nextActionFor(v) {
 	switch (classifyVerdict(v)) {
-		case "RETRY-DEPENDENT": return `repeat execution of this test (3+ runs) to confirm the flake rate, then quarantine + ticket: ${v.file}`;
-		case "TIMEOUT": return `re-run in isolation to separate slowness from a hang: npx playwright test ${v.file} --timeout 60000`;
-		case "FAILING": return `reproduce locally: npx playwright test ${v.file} -g "${v.title.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}" — then fix and re-run`;
-		case "SKIPPED": return `inspect the skip condition in ${v.file} — a skip after a failure usually hides an environment problem`;
+		case "RETRY-DEPENDENT": return `repeat execution of this test (3+ runs) to confirm the flake rate, then quarantine + ticket: ${safeTriageText(v.file)}`;
+		case "TIMEOUT": return `re-run this test in isolation with a 60-second timeout to separate slowness from a hang: ${safeTriageText(v.file)}`;
+		case "FAILING": return `reproduce this test in isolation, then fix and re-run: ${safeTriageText(v.file)} — ${safeTriageText(v.title)}`;
+		case "SKIPPED": return `inspect the skip condition in ${safeTriageText(v.file)} — a skip after a failure usually hides an environment problem`;
 	}
 }
 /** Deterministic guided rows, worst first (same order law as triageRows). */
@@ -15390,7 +15741,16 @@ function renderPwRunSummary(s) {
 */
 /** Hard caps (§21 threat model: parameter size + resource bounds). */
 const MAX_PARAM_BYTES = 65536;
+const MAX_DURATION_MS = 36e5;
+const DEFAULT_MAX_DURATION_MS = 6e5;
 const PROTOCOL_VERSION = "2025-06-18";
+const CONFIGURED_ROOT = process.env.MJOLNIR_WORKSPACE_ROOT ? resolve(process.env.MJOLNIR_WORKSPACE_ROOT) : null;
+function isPathAllowed(path) {
+	if (!CONFIGURED_ROOT) return true;
+	const candidate = resolve(path);
+	const rel = relative(CONFIGURED_ROOT, candidate);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
 /** JSON-RPC error codes (subset used here). */
 const MCP_ERRORS = {
 	PARSE: -32700,
@@ -15509,7 +15869,10 @@ function validateParams(name, args) {
 	if (Buffer$1.byteLength(JSON.stringify(args), "utf8") > MAX_PARAM_BYTES) return `parameters exceed ${MAX_PARAM_BYTES} bytes (threat model §21)`;
 	if (name === "scan") {
 		if (typeof args["path"] !== "string" || args["path"].length === 0) return "scan requires a non-empty string `path`";
-		if (args["maxDurationMs"] !== void 0 && typeof args["maxDurationMs"] !== "number") return "`maxDurationMs` must be a number";
+		if (args["maxDurationMs"] !== void 0) {
+			const duration = args["maxDurationMs"];
+			if (typeof duration !== "number" || !Number.isFinite(duration) || duration <= 0 || duration > MAX_DURATION_MS) return "`maxDurationMs` must be a finite positive number within the server budget";
+		}
 	}
 	if (name === "explain") {
 		if (typeof args["ruleId"] !== "string" || !/^QA-[A-Z]+-\d{3}$/.test(args["ruleId"])) return "explain requires `ruleId` matching /^QA-[A-Z]+-\\d{3}$/";
@@ -15554,6 +15917,24 @@ async function handleToolCall(call) {
 			message: paramError
 		}
 	};
+	const pathArgument = call.args["path"];
+	if (typeof pathArgument === "string" && !isPathAllowed(pathArgument)) return {
+		jsonrpc: "2.0",
+		id: call.id,
+		error: {
+			code: MCP_ERRORS.INVALID_PARAMS,
+			message: "path is outside the configured workspace root"
+		}
+	};
+	const fixturesRoot = call.args["fixturesRoot"];
+	if (typeof fixturesRoot === "string" && !isPathAllowed(fixturesRoot)) return {
+		jsonrpc: "2.0",
+		id: call.id,
+		error: {
+			code: MCP_ERRORS.INVALID_PARAMS,
+			message: "fixturesRoot is outside the configured workspace root"
+		}
+	};
 	try {
 		if (call.name === "scan") {
 			const target = resolve(call.args["path"]);
@@ -15565,7 +15946,7 @@ async function handleToolCall(call) {
 					message: `scan target does not exist: ${target}`
 				}
 			};
-			const maxDurationMs = typeof call.args["maxDurationMs"] === "number" ? call.args["maxDurationMs"] : Number.POSITIVE_INFINITY;
+			const maxDurationMs = typeof call.args["maxDurationMs"] === "number" ? call.args["maxDurationMs"] : DEFAULT_MAX_DURATION_MS;
 			const result = await serializeScan(() => runScan({
 				target,
 				json: true,