slopbrick 0.18.7 → 0.19.0

package/dist/engine/worker.cjs

@@ -1,9 +1,14 @@
 const __importMetaUrl = require("url").pathToFileURL(__filename).href;
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,8 +21,418 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/engine/parser-rust.ts
+function getRustParser() {
+  if (cachedParser) return { ok: true, parser: cachedParser };
+  if (loadError) return { ok: false, error: loadError };
+  try {
+    rustLanguage = import_tree_sitter_rust.default;
+    if (!rustLanguage || typeof rustLanguage !== "object") {
+      throw new Error("tree-sitter-rust: language export is missing or malformed");
+    }
+    const parser = new import_tree_sitter.default();
+    parser.setLanguage(rustLanguage);
+    cachedParser = parser;
+    return { ok: true, parser };
+  } catch (err) {
+    loadError = err instanceof Error ? err : new Error(String(err));
+    return { ok: false, error: loadError };
+  }
+}
+function effectiveParser() {
+  if (forcedFailure) return { ok: false, error: forcedFailure };
+  return getRustParser();
+}
+function parseRust(source) {
+  const result = effectiveParser();
+  if (!result.ok) return null;
+  if (!source || source.trim() === "") return null;
+  try {
+    const rawTree = result.parser.parse(source);
+    if (!rawTree) return null;
+    const tree = rawTree;
+    if (!tree || !tree.rootNode) return null;
+    if (tree.rootNode.type === "ERROR" && tree.rootNode.childCount === 0) {
+      return null;
+    }
+    return tree;
+  } catch {
+    return null;
+  }
+}
+function isRustParserAvailable() {
+  const result = getRustParser();
+  return result.ok;
+}
+var import_tree_sitter, import_tree_sitter_rust, cachedParser, rustLanguage, loadError, forcedFailure;
+var init_parser_rust = __esm({
+  "src/engine/parser-rust.ts"() {
+    "use strict";
+    import_tree_sitter = __toESM(require("tree-sitter"), 1);
+    import_tree_sitter_rust = __toESM(require("tree-sitter-rust"), 1);
+    cachedParser = null;
+    rustLanguage = null;
+    loadError = null;
+    forcedFailure = null;
+  }
+});
+
+// src/engine/visitors/rust.ts
+function parseRustFile(filePath, source, options = {}) {
+  const empty = {
+    imports: [],
+    functions: [],
+    structs: [],
+    traits: [],
+    impls: []
+  };
+  if (!isRustParserAvailable() || options.forceFallback) {
+    return empty;
+  }
+  const tree = parseRust(source);
+  if (!tree) return empty;
+  return walkRustTree(tree);
+}
+function walkRustTree(tree) {
+  const ctx = { inTestConfig: false };
+  const out = {
+    imports: [],
+    functions: [],
+    structs: [],
+    traits: [],
+    impls: []
+  };
+  walkChildren(tree.rootNode, ctx, out);
+  return out;
+}
+function walkChildren(node, ctx, out) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    visitNode(child, ctx, out);
+  }
+}
+function visitNode(node, ctx, out) {
+  const innerCtx = { ...ctx };
+  const attrState = readPrecedingAttributes(node);
+  switch (node.type) {
+    case "use_declaration": {
+      out.imports.push(extractUse(node));
+      return;
+    }
+    case "function_item": {
+      const isMethod = isInImplBlock(node);
+      out.functions.push(extractFunction(node, attrState, innerCtx.inTestConfig, isMethod));
+      walkChildren(getField(node, "body") ?? node, innerCtx, out);
+      return;
+    }
+    case "struct_item": {
+      out.structs.push(extractStruct(node, attrState));
+      const body = getField(node, "body");
+      if (body) walkChildren(body, innerCtx, out);
+      return;
+    }
+    case "trait_item": {
+      out.traits.push(extractTrait(node, attrState));
+      const body = getField(node, "body");
+      if (body) walkChildren(body, innerCtx, out);
+      return;
+    }
+    case "impl_item": {
+      const implEntry = extractImpl(node, attrState, innerCtx);
+      out.impls.push(implEntry.entry);
+      const body = getField(node, "body");
+      if (body) walkChildren(body, innerCtx, out);
+      return;
+    }
+    case "mod_item": {
+      const modIsTest = innerCtx.inTestConfig || attrState.isTestCfg;
+      const modCtx = { ...innerCtx, inTestConfig: modIsTest };
+      const body = getField(node, "body");
+      if (body) walkChildren(body, modCtx, out);
+      return;
+    }
+    default: {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) visitNode(child, innerCtx, out);
+      }
+    }
+  }
+}
+function readPrecedingAttributes(node) {
+  const state = {
+    isTestCfg: false,
+    isTest: false,
+    isPub: false,
+    derives: []
+  };
+  const parent = node.parent;
+  if (!parent) return state;
+  for (let i = 0; i < parent.namedChildCount; i++) {
+    const sibling = parent.namedChild(i);
+    if (!sibling || sibling === node) continue;
+    if (sibling.endIndex > node.startIndex) continue;
+    if (sibling.type !== "attribute_item") continue;
+    decodeAttribute(sibling, state);
+  }
+  return state;
+}
+function decodeAttribute(attr, state) {
+  for (let i = 0; i < attr.namedChildCount; i++) {
+    const child = attr.namedChild(i);
+    if (!child || child.type !== "attribute") continue;
+    const name = firstIdentifier(child);
+    if (!name) continue;
+    if (name === "cfg") {
+      const cfgText = child.text;
+      if (/\btest\b/.test(cfgText) && !/\bnot\(test\)/.test(cfgText)) {
+        state.isTestCfg = true;
+      }
+    } else if (name === "test") {
+      state.isTest = true;
+    } else if (name === "derive") {
+      for (let j = 0; j < child.namedChildCount; j++) {
+        const inner = child.namedChild(j);
+        if (inner) {
+          const matches = inner.text.matchAll(/\b([A-Z][A-Za-z0-9_]*)\b/g);
+          for (const m of matches) state.derives.push(m[1]);
+        }
+      }
+    }
+  }
+}
+function firstIdentifier(node) {
+  const text = node.text;
+  const idMatch = text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+  return idMatch ? idMatch[1] : null;
+}
+function extractUse(node) {
+  const text = node.text;
+  const argument = node.namedChild(0);
+  const argField = node.childForFieldName("argument");
+  const path = argField?.text ?? argument?.text ?? "";
+  const names = [];
+  let isGlob = false;
+  const useListNode = findUseListNode(argument);
+  if (useListNode) {
+    for (let i = 0; i < useListNode.namedChildCount; i++) {
+      const item = useListNode.namedChild(i);
+      if (item.type === "use_wildcard") {
+        isGlob = true;
+      } else if (item.type === "identifier") {
+        names.push({ name: item.text });
+      } else if (item.type === "use_as_clause") {
+        const alias = item.childForFieldName("alias");
+        const binding = item.childForFieldName("path");
+        if (binding) {
+          names.push({ name: binding.text, alias: alias?.text });
+        } else {
+          names.push({ name: item.text });
+        }
+      } else if (item.type === "scoped_identifier") {
+        const idents = collectIdentifiers(item);
+        names.push({ name: idents[idents.length - 1] ?? item.text });
+      } else if (item.text.includes(" as ")) {
+        const [head, alias] = item.text.split(/\s+as\s+/);
+        names.push({ name: (head ?? "").trim(), alias: alias?.trim() });
+      } else {
+        names.push({ name: item.text });
+      }
+    }
+  } else if (argument?.type === "use_wildcard") {
+    isGlob = true;
+  } else if (argument) {
+    const idents = collectIdentifiers(argument);
+    const last = idents[idents.length - 1] ?? argument.text;
+    names.push({ name: last });
+    const asMatch = text.match(/\s+as\s+(\w+)\s*;?\s*$/);
+    if (asMatch) names[0].alias = asMatch[1];
+  }
+  return {
+    path: path.trim(),
+    names,
+    isGlob,
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column
+  };
+}
+function extractFunction(node, attrs, inheritedTestConfig, isMethod) {
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "<anon>";
+  const params = node.childForFieldName("parameters");
+  const body = node.childForFieldName("body");
+  const visibilityMod = node.namedChild(0);
+  const isPublic = visibilityMod?.type === "visibility_modifier";
+  let receiver;
+  if (isMethod && params) {
+    const selfParam = findSelfParameter(params);
+    if (selfParam) receiver = selfParam.text;
+  }
+  const bodyLines = body ? body.endPosition.row - body.startPosition.row + 1 : 0;
+  const inTestConfig = inheritedTestConfig || attrs.isTest || attrs.isTestCfg || isFunctionAttrTest(node);
+  return {
+    name,
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    isPublic,
+    isMethod,
+    receiver,
+    bodyLines,
+    inTestConfig
+  };
+}
+function extractStruct(node, attrs) {
+  const nameNode = node.childForFieldName("name");
+  return {
+    name: nameNode?.text ?? "<anon>",
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    isPublic: hasVisibility(node),
+    isDerive: attrs.derives.length > 0,
+    derives: [...attrs.derives]
+  };
+}
+function extractTrait(node, _attrs) {
+  const nameNode = node.childForFieldName("name");
+  return {
+    name: nameNode?.text ?? "<anon>",
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    isPublic: hasVisibility(node)
+  };
+}
+function extractImpl(node, _attrs, _ctx) {
+  const traitNode = node.childForFieldName("trait");
+  const typeNode = node.childForFieldName("type");
+  const typeText = typeNode?.text ?? "<anon>";
+  const traitText = traitNode?.text;
+  const body = node.childForFieldName("body");
+  const methods = [];
+  if (body) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const child = body.namedChild(i);
+      if (child?.type === "function_item") {
+        const m = child.childForFieldName("name");
+        if (m) methods.push(m.text);
+      }
+    }
+  }
+  return {
+    entry: {
+      type: typeText,
+      trait: traitText ?? void 0,
+      methods,
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column
+    }
+  };
+}
+function findUseListNode(argument) {
+  if (!argument) return null;
+  if (argument.type === "use_list") return argument;
+  if (argument.type === "scoped_use_list") {
+    for (let i = 0; i < argument.namedChildCount; i++) {
+      const c = argument.namedChild(i);
+      if (c?.type === "use_list") return c;
+    }
+  }
+  return null;
+}
+function getField(node, fieldName) {
+  return node.childForFieldName(fieldName);
+}
+function collectIdentifiers(node) {
+  const out = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    if (child.type === "identifier" || child.type === "type_identifier") {
+      out.push(child.text);
+    } else if (child.type === "scoped_identifier" || child.type === "nested_identifier") {
+      out.push(...collectIdentifiers(child));
+    }
+  }
+  return out;
+}
+function hasVisibility(node) {
+  return node.namedChild(0)?.type === "visibility_modifier";
+}
+function isInImplBlock(node) {
+  for (let p = node.parent; p; p = p.parent) {
+    if (p.type === "impl_item") return true;
+    if (p.type === "function_item" || p.type === "source_file") return false;
+  }
+  return false;
+}
+function findSelfParameter(params) {
+  for (let i = 0; i < params.namedChildCount; i++) {
+    const child = params.namedChild(i);
+    if (child?.type === "self_parameter") return child;
+  }
+  return null;
+}
+function isFunctionAttrTest(node) {
+  void node;
+  return false;
+}
+var SERVICE_SUFFIXES, SERVICE_SUFFIX_GROUP, RUST_SERVICE_STRUCT_RE, RUST_SERVICE_IMPL_RE;
+var init_rust = __esm({
+  "src/engine/visitors/rust.ts"() {
+    "use strict";
+    init_parser_rust();
+    SERVICE_SUFFIXES = [
+      "Service",
+      "Manager",
+      "Handler",
+      "Repository",
+      "Controller",
+      "Helper",
+      "Factory",
+      "Provider",
+      "Store",
+      "API",
+      "Client",
+      "Adapter",
+      "Resolver",
+      "Mapper",
+      "Transformer",
+      "Serializer",
+      "Validator",
+      "Strategy",
+      "Facade",
+      "Decorator",
+      "Observer",
+      "Builder",
+      "Command",
+      "Processor",
+      "Worker",
+      "Job",
+      "Actor",
+      "Executor"
+    ];
+    SERVICE_SUFFIX_GROUP = `(?:${SERVICE_SUFFIXES.join("|")})`;
+    RUST_SERVICE_STRUCT_RE = new RegExp(
+      `^(?:pub(?:\\(crate\\)|\\(super\\))?\\s+)?struct\\s+(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
+      "gm"
+    );
+    RUST_SERVICE_IMPL_RE = new RegExp(
+      `^impl(?:<[^>]+>)?\\s+(?:${SERVICE_SUFFIX_GROUP}\\s+for\\s+)?(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
+      "gm"
+    );
+  }
+});
+
 // src/engine/worker.ts
 var worker_exports = {};
 __export(worker_exports, {
@@ -4258,7 +4673,7 @@ function parseBlankModule(source) {
     tsx: false,
     target: "es2022"
   });
-  return { ast, source: replaced };
+  return { ast, source };
 }
 function parseScriptContent(content, isTypeScript) {
   if (isTypeScript) {
@@ -4344,8 +4759,16 @@ function parseSource(source, filePath) {
     // but no SWC support. Return a blank-padded empty module so
     // regex-only rules can still fire (markdown-leakage, comment-
     // ratio, etc.) without burning the parseError path.
+    // v0.18.9: `.rs` is in the same bucket. The visitor layer
+    // (`engine/visitors/rust.ts`) carries the tree-sitter-backed
+    // parse + extractFacts attaches the result to `facts.v2.rustFile`.
+    // The rule layer (`rules/rust/*.ts`) reads that field. parseBlankModule
+    // lets the worker continue past the parser — without this, parseWithSwc
+    // would throw on every .rs file, the worker would count it as a
+    // parseError, and the v2-build's buildRustFileRecord would never run.
     case "py":
     case "go":
+    case "rs":
       return parseBlankModule(source);
     default:
       return parseWithSwc(source, filePath);
@@ -5040,76 +5463,6 @@ function tokenizeIdentifiers(source) {
   return tokens;
 }
 var SQRT_2_TIMES_LN_2 = Math.sqrt(2 * Math.LN2);
-function ecdfAt(sortedSamples, x) {
-  let lo = 0;
-  let hi = sortedSamples.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    if (sortedSamples[mid] <= x) lo = mid + 1;
-    else hi = mid;
-  }
-  return lo / sortedSamples.length;
-}
-function ksStatistic(sampleA, sampleB) {
-  if (sampleA.length === 0 || sampleB.length === 0) return 1;
-  const sortedA = [...sampleA].sort((a, b) => a - b);
-  const sortedB = [...sampleB].sort((a, b) => a - b);
-  const allPoints = [...sortedA, ...sortedB].sort((a, b) => a - b);
-  let maxDiff = 0;
-  for (const x of allPoints) {
-    const fa = ecdfAt(sortedA, x);
-    const fb = ecdfAt(sortedB, x);
-    const diff = Math.abs(fa - fb);
-    if (diff > maxDiff) maxDiff = diff;
-  }
-  return maxDiff;
-}
-function ksPValue(statistic, n, m) {
-  if (n === 0 || m === 0) return 1;
-  if (statistic < 0) return 1;
-  if (statistic > 1) return 0;
-  const lambda = Math.sqrt(n * m / (n + m)) * statistic;
-  if (lambda > 3.6) return 0;
-  let p = 0;
-  for (let j = 1; j < 1e3; j++) {
-    const term = 2 * Math.pow(-1, j - 1) * Math.exp(-2 * j * j * lambda * lambda);
-    p += term;
-    if (Math.abs(term) < 1e-15) break;
-  }
-  return Math.max(0, Math.min(1, p));
-}
-function ksTest(sampleA, sampleB, alpha = 0.05) {
-  const statistic = ksStatistic(sampleA, sampleB);
-  const pValue = ksPValue(statistic, sampleA.length, sampleB.length);
-  return {
-    statistic,
-    pValue,
-    significant: pValue < alpha,
-    n: sampleA.length,
-    m: sampleB.length
-  };
-}
-function multiFeatureKsTest(features, baselines, alpha = 0.05) {
-  const featureNames = [...features.keys()];
-  const k = featureNames.length;
-  const bonferroniAlpha = k > 0 ? alpha / k : alpha;
-  const perFeature = /* @__PURE__ */ new Map();
-  const significantFeatures = [];
-  for (const name of featureNames) {
-    const sample = features.get(name);
-    const baseline = baselines.get(name);
-    if (!sample || !baseline) continue;
-    const result = ksTest(sample, baseline, bonferroniAlpha);
-    perFeature.set(name, result);
-    if (result.significant) significantFeatures.push(name);
-  }
-  return {
-    perFeature,
-    bonferroniAlpha,
-    anySignificant: significantFeatures.length > 0,
-    significantFeatures
-  };
-}
 
 // src/engine/visitors/react.ts
 function isObject(node) {
@@ -6910,6 +7263,7 @@ function dispatchNode(node, parent, path, vctx) {
 }
 
 // src/engine/visitors/v2-build.ts
+init_rust();
 var TAILWIND_COLOR_RE = /^(?:bg|text|border|ring|from|to|via|fill|stroke)-([a-z]+-\d+|white|black|transparent|current|\[.+?\])$/;
 var TAILWIND_SPACING_RE = /^(?:[pm][xytrbl]?|gap|space-[xy])-(\d+(?:\.\d+)?)$/;
 var TAILWIND_RADIUS_RE = /^(?:rounded(?:-[a-z]+)?)-(.+)$/;
@@ -7090,9 +7444,60 @@ function buildV2Facts(facts, source, ext, framework, config, templateClassNames
     })),
     disabledRules: extractDisabledRules(source),
     templateClassNames,
+    // v0.18.9 — populate the Rust AST record when the file is `.rs`.
+    // Calling `parseRustFile` here keeps the dead-code detector's
+    // import-binding pass a pure function over the same source the
+    // walker saw. The native-binding guard lives inside
+    // `parseRustFile` (returns an empty record when tree-sitter is
+    // unavailable).
+    rustFile: buildRustFileRecord(facts.filePath, source),
     _source: source
   };
 }
+function buildRustFileRecord(filePath, source) {
+  if (!filePath.toLowerCase().endsWith(".rs")) return void 0;
+  const structure = parseRustFile(filePath, source);
+  return {
+    imports: structure.imports.map((i) => ({
+      path: i.path,
+      names: i.names.map((n) => ({ name: n.name, ...n.alias ? { alias: n.alias } : {} })),
+      isGlob: i.isGlob,
+      line: i.line,
+      column: i.column
+    })),
+    functions: structure.functions.map((f) => ({
+      name: f.name,
+      line: f.line,
+      column: f.column,
+      isPublic: f.isPublic,
+      isMethod: f.isMethod,
+      ...f.receiver ? { receiver: f.receiver } : {},
+      bodyLines: f.bodyLines,
+      inTestConfig: f.inTestConfig
+    })),
+    structs: structure.structs.map((s) => ({
+      name: s.name,
+      line: s.line,
+      column: s.column,
+      isPublic: s.isPublic,
+      isDerive: s.isDerive,
+      derives: [...s.derives]
+    })),
+    traits: structure.traits.map((t) => ({
+      name: t.name,
+      line: t.line,
+      column: t.column,
+      isPublic: t.isPublic
+    })),
+    impls: structure.impls.map((ip) => ({
+      ...ip.trait ? { trait: ip.trait } : {},
+      type: ip.type,
+      methods: [...ip.methods],
+      line: ip.line,
+      column: ip.column
+    }))
+  };
+}
 function splitFilePath(filePath) {
   const baseName = filePath.split("/").pop() ?? filePath;
   const dotIdx = baseName.lastIndexOf(".");
@@ -34594,9 +34999,43 @@ var unusedImportRule = createRule({
         advice: `Remove the import or use '${binding.name}' somewhere in the file. This is the most common AI-iteration rot \u2014 the model added the import when it introduced a feature, then rewrote the function without cleaning up.`
       });
     }
+    if (facts.v2.rustFile) {
+      const strippedSource = stripUseDeclarations(facts.v2._source ?? "");
+      const referenced = collectRustReferencedNames(strippedSource);
+      for (const imp of facts.v2.rustFile.imports) {
+        for (const nameEntry of imp.names) {
+          if (referenced.has(nameEntry.name)) continue;
+          const source = ` from '${imp.path}'`;
+          issues.push({
+            ruleId: "dead/unused-import",
+            category: "logic",
+            severity: "low",
+            aiSpecific: true,
+            message: `Unused import: '${nameEntry.name}'${source}`,
+            line: imp.line,
+            column: imp.column,
+            advice: `Remove the '${imp.path}' import or use '${nameEntry.name}' somewhere in the file. Rust's compiler only flags unused imports per module \u2014 the tree-sitter-backed walker here surfaces them for slopbrick's dead-code rules regardless of #[allow(unused_imports)].`
+          });
+        }
+      }
+    }
     return issues;
   }
 });
+function collectRustReferencedNames(source) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of source.matchAll(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+    out.add(m[1]);
+  }
+  return out;
+}
+function stripUseDeclarations(source) {
+  let out = source;
+  out = out.replace(/^\s*use\s+[\s\S]*?;\s*$/gm, "");
+  out = out.replace(/\/\/[^\n]*/g, "");
+  out = out.replace(/\/\*[\s\S]*?\*\//g, "");
+  return out;
+}
 
 // src/rules/dead/unused-local.ts
 var SKIP_NAMES = /* @__PURE__ */ new Set(["React", "_"]);
@@ -35753,6 +36192,218 @@ var brokenLinkRule = createRule({
   }
 });
 
+// src/rules/dup/identical-block.ts
+var crypto = __toESM(require("crypto"), 1);
+var WINDOW_SIZE = 10;
+var MIN_NORMALIZED_LENGTH = 40;
+var HASH_PREFIX_LENGTH = 16;
+var DEDUP_CACHE = /* @__PURE__ */ new Map();
+function normalizeAndHash(lines) {
+  const normalized = lines.map(
+    (line) => line.replace(/\/\/.*$/, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim()
+  ).filter((line) => line.length > 0).join("\n");
+  if (normalized.length < MIN_NORMALIZED_LENGTH) return void 0;
+  return crypto.createHash("sha1").update(normalized).digest("hex").slice(0, HASH_PREFIX_LENGTH);
+}
+var dupIdenticalBlockRule = createRule({
+  id: "dup/identical-block",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: false,
+  description: "Block of >=10 lines is identical across >=2 files (Type-1 clone detector)",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const filePath = facts.filePath;
+    const lines = source.split("\n");
+    for (let i = 0; i <= lines.length - WINDOW_SIZE; i++) {
+      const window = lines.slice(i, i + WINDOW_SIZE);
+      const hash = normalizeAndHash(window);
+      if (!hash) continue;
+      const existing = DEDUP_CACHE.get(hash) ?? [];
+      const matches = existing.filter((m) => m.file !== filePath);
+      for (const match of matches) {
+        issues.push({
+          ruleId: "dup/identical-block",
+          category: "logic",
+          severity: "medium",
+          aiSpecific: false,
+          message: `Identical ${WINDOW_SIZE}-line block at line ${i + 1} also appears in ${match.file}:${match.line + 1}`,
+          line: i + 1,
+          column: 0,
+          advice: "Refactor to a shared helper. This is a Type-1 clone (byte-for-byte identical after normalization). Common in AI-generated code that copy-pastes from training data.",
+          extras: {
+            duplicateOf: {
+              file: match.file,
+              line: match.line + 1,
+              hash
+            }
+          }
+        });
+      }
+      existing.push({ file: filePath, line: i });
+      DEDUP_CACHE.set(hash, existing);
+    }
+    return issues;
+  }
+});
+
+// src/rules/go/error-wrap-without-context.ts
+var ERR_WRAP_REGEX = /fmt\.Errorf\(\s*"((?:[^"\\]|\\.)*)"\s*,\s*([^)]+)\)/g;
+var GENERIC_PREFIX_REGEX = /^\s*(?:error|err|failed|wrap(?:ping)?|invalid)\s*(?::\s*)?%w\b/i;
+var goErrorWrapWithoutContextRule = createRule({
+  id: "go/error-wrap-without-context",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: 'fmt.Errorf wrap without operation context \u2014 AI defaults to generic "error: %w"',
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let match;
+    ERR_WRAP_REGEX.lastIndex = 0;
+    while ((match = ERR_WRAP_REGEX.exec(source)) !== null) {
+      const formatString = match[1];
+      if (!formatString.includes("%w")) continue;
+      if (formatString.length >= 30) continue;
+      if (!GENERIC_PREFIX_REGEX.test(formatString)) continue;
+      const line = source.slice(0, match.index).split("\n").length;
+      issues.push({
+        ruleId: "go/error-wrap-without-context",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `fmt.Errorf wrap with generic message "${formatString}" \u2014 include the failing operation`,
+        line,
+        column: match[0].indexOf("fmt") + 1,
+        advice: 'Real Go errors include the failing operation: `fmt.Errorf("opening config: %w", err)`. Generic messages ("error: %w", "failed: %w") tell the reader nothing about what failed. Reference: go/error-wrap-without-context v0.19. See: https://github.com/golang/go/wiki/CodeReviewComments#error-strings'
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/go/nil-slice-vs-empty.ts
+var NIL_SLICE_DECL_REGEX = /^[\t ]*var\s+([A-Za-z_][A-Za-z0-9_]*)\s+\[\][\w.*]+\b/gm;
+var EMPTY_SLICE_ASSIGN_REGEX = /^[\t ]*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:\[\][\w.*]*\{\}|make\(\[\][\w.*]*)/gm;
+var goNilSliceVsEmptyRule = createRule({
+  id: "go/nil-slice-vs-empty",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Variable declared `var x []int` but later assigned `x = []int{}` or `make([]int, n)` \u2014 pick one form",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const nilDecls = /* @__PURE__ */ new Map();
+    let m;
+    NIL_SLICE_DECL_REGEX.lastIndex = 0;
+    while ((m = NIL_SLICE_DECL_REGEX.exec(source)) !== null) {
+      nilDecls.set(m[1], source.slice(0, m.index).split("\n").length);
+    }
+    if (nilDecls.size === 0) return issues;
+    EMPTY_SLICE_ASSIGN_REGEX.lastIndex = 0;
+    while ((m = EMPTY_SLICE_ASSIGN_REGEX.exec(source)) !== null) {
+      const name = m[1];
+      if (!nilDecls.has(name)) continue;
+      const declLine = nilDecls.get(name);
+      const assignLine = source.slice(0, m.index).split("\n").length;
+      if (assignLine <= declLine) continue;
+      issues.push({
+        ruleId: "go/nil-slice-vs-empty",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Variable '${name}' declared as nil slice (line ${declLine}) but assigned an empty slice (line ${assignLine}) \u2014 pick one form`,
+        line: declLine,
+        column: 1,
+        advice: "Either declare as `var " + name + " = []int{}` or assign with `make([]int, 0)`. The nil/empty inconsistency is an AI signal \u2014 real code picks one form and sticks with it. Reference: go/nil-slice-vs-empty v0.19."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/go/struct-tag-inconsistency.ts
+var JSON_TAG_REGEX = /`json:"([^",]+)(?:,([^"]+))?"`/g;
+var goStructTagInconsistencyRule = createRule({
+  id: "go/struct-tag-inconsistency",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: 'Struct fields mix json:"foo" and json:"foo,omitempty" \u2014 pick one convention per struct',
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const structRegex = /type\s+[A-Z][A-Za-z0-9_]*\s+struct\s*\{/g;
+    let structMatch;
+    while ((structMatch = structRegex.exec(source)) !== null) {
+      const startIdx = structMatch.index;
+      const openBrace = source.indexOf("{", startIdx);
+      if (openBrace < 0) continue;
+      let depth = 1;
+      let i = openBrace + 1;
+      while (i < source.length && depth > 0) {
+        const ch = source[i];
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+        i++;
+      }
+      const structBody = source.slice(openBrace, i);
+      const structLine = source.slice(0, startIdx).split("\n").length;
+      const styleCount = {};
+      const tagMatches = [];
+      let m;
+      JSON_TAG_REGEX.lastIndex = 0;
+      while ((m = JSON_TAG_REGEX.exec(structBody)) !== null) {
+        const tag = m[1];
+        const options = m[2] ?? "";
+        const style = options ? "with-options" : "no-options";
+        styleCount[style] = (styleCount[style] ?? 0) + 1;
+        tagMatches.push({ tag, style, idx: openBrace + m.index });
+      }
+      const styles = Object.keys(styleCount);
+      if (styles.length < 2 || tagMatches.length < 2) continue;
+      const dominant = styles.reduce(
+        (a, b) => (styleCount[a] ?? 0) >= (styleCount[b] ?? 0) ? a : b
+      );
+      const minority = tagMatches.filter((t) => t.style !== dominant);
+      if (minority.length === 0) continue;
+      for (const m2 of minority) {
+        const line = source.slice(0, m2.idx).split("\n").length;
+        issues.push({
+          ruleId: "go/struct-tag-inconsistency",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `Struct mixes json tag styles \u2014 this field uses "json:"${m2.tag}${m2.style === "with-options" ? ",..." : ""}"" but the dominant style is ${dominant === "with-options" ? "with options (e.g. omitempty)" : "no options"}`,
+          line,
+          column: 1,
+          advice: 'Pick one tag style per struct. If most fields are `json:"foo"`, this field should be too. Real Go code maintains consistency within a struct (or within a package). Reference: go/struct-tag-inconsistency v0.19.'
+        });
+      }
+      if (issues.length > 0) break;
+    }
+    return issues;
+  }
+});
+
 // src/rules/layout/gap-monopoly.ts
 var GAP_RE = /\bgap(?:-x|-y)?-(\d+)\b/g;
 var gapMonopolyRule = createRule({
@@ -36540,82 +37191,6 @@ var keyPropMissingRule = createRule({
   }
 });
 
-// src/rules/logic/ks-distribution-shift.ts
-var MIN_SAMPLES_PER_FEATURE = 20;
-function extractFileFeatures(source) {
-  const lines = source.split("\n");
-  const lineLengths = lines.map((l) => l.length);
-  const identifierLengths = [];
-  const idRe = /[A-Za-z_$][A-Za-z0-9_$]*/g;
-  let m;
-  while ((m = idRe.exec(source)) !== null) {
-    identifierLengths.push(m[0].length);
-  }
-  const commentDensity = lines.map((l) => {
-    const trimmed = l.trim();
-    if (trimmed.length === 0) return 0;
-    const commentChars = (trimmed.match(/^\/\/.*$/)?.[0]?.length ?? 0) + (trimmed.match(/^\s*\/\*.*?\*\/\s*$/)?.at(0)?.length ?? 0);
-    return commentChars / trimmed.length;
-  });
-  return { lineLengths, identifierLengths, commentDensity };
-}
-var ksDistributionShiftRule = createRule({
-  id: "logic/ks-distribution-shift",
-  category: "logic",
-  severity: "medium",
-  aiSpecific: false,
-  description: "Multi-feature Kolmogorov\u2013Smirnov distribution-shift vs corpus baseline (Bonferroni-corrected). Peer-reviewed ML distribution-shift detector (arXiv:2510.15996, Oct 2025).",
-  create(context) {
-    return context;
-  },
-  analyze(_context, facts) {
-    const issues = [];
-    if (!facts.v2) return issues;
-    const source = facts.v2._source ?? "";
-    if (source.length < 200) return issues;
-    const features = extractFileFeatures(source);
-    const samples = /* @__PURE__ */ new Map([
-      ["lineLengths", features.lineLengths],
-      ["identifierLengths", features.identifierLengths],
-      ["commentDensity", features.commentDensity]
-    ]);
-    const baselines = getCorpusBaselines();
-    const baselinesMap = /* @__PURE__ */ new Map();
-    if (baselines) {
-      baselinesMap.set("lineLengths", baselines.features.lineLengths.sample);
-      baselinesMap.set("identifierLengths", baselines.features.identifierLengths.sample);
-      baselinesMap.set("commentDensity", baselines.features.commentDensity.sample);
-    } else {
-      baselinesMap.set("lineLengths", [20, 25, 30, 32, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]);
-      baselinesMap.set("identifierLengths", [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 24, 28]);
-      baselinesMap.set("commentDensity", [0, 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5]);
-    }
-    for (const [name, vals] of samples) {
-      if (vals.length < MIN_SAMPLES_PER_FEATURE) samples.delete(name);
-    }
-    if (samples.size === 0) return issues;
-    const result = multiFeatureKsTest(samples, baselinesMap, 0.05);
-    if (!result.anySignificant) return issues;
-    const shifted = result.significantFeatures.join(", ");
-    const details = result.significantFeatures.map((name) => {
-      const r = result.perFeature.get(name);
-      if (!r) return name;
-      return `${name} (D=${r.statistic.toFixed(3)}, p=${r.pValue.toExponential(2)})`;
-    }).join("; ");
-    issues.push({
-      ruleId: "logic/ks-distribution-shift",
-      category: "logic",
-      severity: "medium",
-      aiSpecific: true,
-      message: `Distribution shift detected on ${result.significantFeatures.length} of ${result.perFeature.size} features (Bonferroni \u03B1=${result.bonferroniAlpha.toExponential(2)}). Features: ${shifted}. Detail: ${details}.`,
-      line: 1,
-      column: 1,
-      advice: "Inspect the shifted features. KS detects both AI anomalies and production-rot anomalies (it is symmetric); combine with Heaps/Zipf for AI-specific signal."
-    });
-    return issues;
-  }
-});
-
 // src/rules/logic/math-any-density.ts
 var ANY_PER_100_LINES = 5;
 var MIN_ABSOLUTE = 6;
@@ -36677,7 +37252,7 @@ var mathAnyDensityRule = createRule({
 });
 
 // src/rules/logic/math-console-log-storm.ts
-var WINDOW_SIZE = 30;
+var WINDOW_SIZE2 = 30;
 var STORM_THRESHOLD = 5;
 var CONSOLE_LOG_RE = /\bconsole\.log\s*\(/g;
 var mathConsoleLogStormRule = createRule({
@@ -36708,7 +37283,7 @@ var mathConsoleLogStormRule = createRule({
       let maxEndLine = 0;
       let i = 0;
       for (let j = 0; j < lines.length; j++) {
-        while (lines[j] - lines[i] > WINDOW_SIZE) i++;
+        while (lines[j] - lines[i] > WINDOW_SIZE2) i++;
         const count = j - i + 1;
         if (count > maxCount) {
           maxCount = count;
@@ -36722,7 +37297,7 @@ var mathConsoleLogStormRule = createRule({
         category: "logic",
         severity: "high",
         aiSpecific: true,
-        message: `${maxCount} console.log calls clustered in a ${WINDOW_SIZE}-line window ending at line ${maxEndLine}. AI debug-sprays logs in a single function; humans use one strategic log.`,
+        message: `${maxCount} console.log calls clustered in a ${WINDOW_SIZE2}-line window ending at line ${maxEndLine}. AI debug-sprays logs in a single function; humans use one strategic log.`,
         line: firstIdx >= 0 ? lines[firstIdx] : 1,
         column: firstIdx >= 0 ? columns[firstIdx] : 1,
         advice: "Replace debug logs with a proper debugger or logger.debug() \u2014 remove all console.log before shipping."
@@ -37509,6 +38084,326 @@ var uxPatternFragmentationRule = createRule({
   }
 });
 
+// src/rules/rust/stringly-typed.ts
+var SUSPECT_PARAM_NAMES = /* @__PURE__ */ new Set([
+  "kind",
+  "type",
+  "mode",
+  "event",
+  "status",
+  "category",
+  "action",
+  "state",
+  "level",
+  "role",
+  "tier",
+  "phase",
+  "tag",
+  "format",
+  "shape",
+  "direction",
+  "side",
+  "method"
+]);
+var MAX_VARIANT_COUNT = 32;
+var rustStringlyTypedRule = createRule({
+  id: "rust/stringly-typed",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: true,
+  description: "String / &str parameter where a typed enum exists in the same file",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2?.rustFile) return issues;
+    const source = facts.v2._source ?? "";
+    if (!source) return issues;
+    const lineOffsets = buildLineOffsets2(source);
+    const enumCandidates = collectEnumCandidates(source);
+    if (enumCandidates.length === 0) return issues;
+    for (const fn of facts.v2.rustFile.functions) {
+      const paramText = extractParameterText(source, lineOffsets, fn);
+      if (!paramText) continue;
+      const matches = scanForStringlyParams(paramText);
+      if (matches.length === 0) continue;
+      issues.push({
+        ruleId: "rust/stringly-typed",
+        category: "logic",
+        severity: "medium",
+        aiSpecific: true,
+        message: matches.length === 1 ? `Parameter '${matches[0].name}' typed as '${matches[0].type}', but enum ${enumCandidates[0].name} exists in the file` : `Function has ${matches.length} stringly-typed parameters; enum ${enumCandidates[0].name} exists in the file`,
+        line: fn.line,
+        column: fn.column,
+        advice: `Replace the String/&str parameter with the typed enum. Stringly-typed APIs lose type information at the boundary; a typo ('Click' vs 'click') only fails at runtime. AI agents introduce these during exploratory scaffolding, then never replace them with the existing enum.`
+      });
+    }
+    return issues;
+  }
+});
+function collectEnumCandidates(source) {
+  const out = [];
+  const enumRe = /^(?:pub(?:\([^)]+\))?\s+)?enum\s+(\w+)\s*\{([^}]*)\}/gm;
+  for (const m of source.matchAll(enumRe)) {
+    const body = m[2] ?? "";
+    const variants = body.split(/,(?![^()]*\))/).map((s) => s.trim()).filter((s) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(s.split(/\s+/)[0] ?? ""));
+    if (variants.length > MAX_VARIANT_COUNT) continue;
+    if (variants.length < 2) continue;
+    out.push({ name: m[1], variantCount: variants.length, line: lineOfMatch(source, m.index ?? 0) });
+  }
+  return out;
+}
+function lineOfMatch(source, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) {
+    if (source[i] === "\n") line++;
+  }
+  return line;
+}
+function buildLineOffsets2(source) {
+  const out = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n") out.push(i + 1);
+  }
+  return out;
+}
+function extractParameterText(source, lineOffsets, fn) {
+  const start = lineOffsets[Math.max(0, fn.line - 1)] ?? 0;
+  const head = source.slice(start, start + 400);
+  const openIdx = head.indexOf("(");
+  if (openIdx < 0) return "";
+  let closeIdx = -1;
+  let depth = 0;
+  for (let i = openIdx; i < head.length; i++) {
+    if (head[i] === "(") depth++;
+    else if (head[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        closeIdx = i;
+        break;
+      }
+    }
+  }
+  if (closeIdx < 0) return "";
+  return head.slice(openIdx + 1, closeIdx);
+}
+function scanForStringlyParams(paramText) {
+  const out = [];
+  for (const m of paramText.matchAll(
+    /\b([a-z_][a-zA-Z0-9_]*)\s*:\s*(&\s*(?:mut\s+)?(?:str|String)\b)/g
+  )) {
+    const name = m[1];
+    const type = m[2];
+    if (!SUSPECT_PARAM_NAMES.has(name)) continue;
+    out.push({ name, type });
+  }
+  return out;
+}
+
+// src/rules/rust/todo-macro.ts
+init_parser_rust();
+var TODO_MACROS = /* @__PURE__ */ new Set(["todo", "unimplemented", "todo_unimplemented"]);
+var rustTodoMacroRule = createRule({
+  id: "rust/todo-macro",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: true,
+  description: "todo!() / unimplemented!() macro invocation in production code",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2?.rustFile) return issues;
+    const source = facts.v2._source ?? "";
+    if (!source) return issues;
+    const tree = parseRust(source);
+    if (!tree) return issues;
+    const testScopes = /* @__PURE__ */ new Set();
+    for (const fn of facts.v2.rustFile.functions) {
+      if (fn.inTestConfig && fn.name) testScopes.add(fn.name);
+    }
+    collectMacroIssues(tree.rootNode, testScopes, issues);
+    return issues;
+  }
+});
+function collectMacroIssues(node, testScopes, issues) {
+  if (node.type === "macro_invocation") {
+    const text = node.text;
+    const m = text.match(/^([A-Za-z_][A-Za-z0-9_]*)/);
+    const macroName = m?.[1] ?? "";
+    if (TODO_MACROS.has(macroName)) {
+      if (!isInsideMacroDefinition(node) && !isInsideTestFunction(node, testScopes)) {
+        issues.push({
+          ruleId: "rust/todo-macro",
+          category: "logic",
+          severity: "medium",
+          aiSpecific: true,
+          message: `'${macroName}!()' in production code \u2014 both expand to panic!()`,
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column,
+          advice: `Implement the function body or remove the stub. '${macroName}!()' is fine in test scaffolding (#[cfg(test)]); here it is a panic risk. AI agents commonly leave these behind after iterative refactors when the placeholder branch is never filled in.`
+        });
+      }
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) collectMacroIssues(child, testScopes, issues);
+  }
+}
+function isInsideMacroDefinition(node) {
+  for (let p = node.parent; p; p = p.parent) {
+    if (p.type === "macro_definition") return true;
+    if (p.type === "source_file") return false;
+  }
+  return false;
+}
+function isInsideTestFunction(node, testScopes) {
+  for (let p = node.parent; p; p = p.parent) {
+    if (p.type === "function_item") {
+      const nameField = p.childForFieldName("name");
+      const name = nameField?.text;
+      if (name && testScopes.has(name)) return true;
+      if (p.text.startsWith("#[test]") || p.text.startsWith("#[cfg(test)]")) return true;
+      return false;
+    }
+    if (p.type === "source_file") return false;
+  }
+  return false;
+}
+
+// src/rules/rust/unused-pub-fn.ts
+var API_CONVENTION_NAMES = /* @__PURE__ */ new Set([
+  "new",
+  "default",
+  "from",
+  "from_str",
+  "from_iter",
+  "try_from",
+  "into",
+  "into_iter",
+  "try_into",
+  "as_ref",
+  "as_mut",
+  "clone",
+  "fmt",
+  "eq",
+  "hash",
+  "partial_cmp",
+  "cmp",
+  "ord",
+  "partial_eq"
+]);
+var rustUnusedPubFnRule = createRule({
+  id: "rust/unused-pub-fn",
+  category: "logic",
+  severity: "low",
+  aiSpecific: true,
+  description: "Public function in a Rust file that has no in-file references",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2?.rustFile) return issues;
+    const rust = facts.v2.rustFile;
+    const referenced = collectReferencedNames(facts.v2._source ?? "");
+    for (const fn of rust.functions) {
+      if (!fn.isPublic) continue;
+      if (API_CONVENTION_NAMES.has(fn.name)) continue;
+      if (fn.inTestConfig) continue;
+      if (referenced.has(fn.name)) continue;
+      issues.push({
+        ruleId: "rust/unused-pub-fn",
+        category: "logic",
+        severity: "low",
+        aiSpecific: true,
+        message: `Public function '${fn.name}' is not referenced anywhere in the file`,
+        line: fn.line,
+        column: fn.column,
+        advice: `Remove the function or call it somewhere. Rust's compiler doesn't warn on pub fns missing consumers unless \`#![warn(dead_code)]\` is set at the crate root. AI agents that iterate on a file often leave these behind \u2014 the most common AI-rotation signature for Rust after unused-imports.`
+      });
+    }
+    return issues;
+  }
+});
+function collectReferencedNames(source) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of source.matchAll(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+    out.add(m[1]);
+  }
+  return out;
+}
+
+// src/rules/rust/unwrap-in-production.ts
+init_parser_rust();
+var UNWRAP_METHODS = /* @__PURE__ */ new Set(["unwrap", "expect", "unwrap_or_else"]);
+var rustUnwrapInProductionRule = createRule({
+  id: "rust/unwrap-in-production",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: true,
+  description: ".unwrap() / .expect() called outside of #[cfg(test)] / #[test] scope",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2?.rustFile) return issues;
+    const source = facts.v2._source ?? "";
+    if (!source) return issues;
+    const tree = parseRust(source);
+    if (!tree) return issues;
+    const testScopes = /* @__PURE__ */ new Set();
+    for (const fn of facts.v2.rustFile.functions) {
+      if (fn.inTestConfig && fn.name) testScopes.add(fn.name);
+    }
+    collectUnwrapIssues(tree.rootNode, testScopes, issues);
+    return issues;
+  }
+});
+function collectUnwrapIssues(node, testScopes, issues) {
+  if (node.type === "call_expression") {
+    const fn = node.childForFieldName("function");
+    if (fn && fn.type === "field_expression") {
+      const field = fn.childForFieldName("field");
+      if (field && field.type === "field_identifier" && UNWRAP_METHODS.has(field.text)) {
+        if (!isInsideTestFunction2(node, testScopes)) {
+          issues.push({
+            ruleId: "rust/unwrap-in-production",
+            category: "logic",
+            severity: "medium",
+            aiSpecific: true,
+            message: `'.${field.text}()' called in production code \u2014 panic risk on Err/None`,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            advice: `Replace with '?' (early-return on Err), '.map_err(...)' for conversion, or an explicit 'match'. '.${field.text}()' is fine in tests \u2014 wrap with '#[cfg(test)]' or move into a '#[cfg(test)] mod tests' block to suppress.`
+          });
+        }
+      }
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child) collectUnwrapIssues(child, testScopes, issues);
+  }
+}
+function isInsideTestFunction2(node, testScopes) {
+  for (let p = node.parent; p; p = p.parent) {
+    if (p.type === "function_item") {
+      const nameField = p.childForFieldName("name");
+      const name = nameField?.text;
+      if (name && testScopes.has(name)) return true;
+      if (p.text.startsWith("#[test]") || p.text.startsWith("#[cfg(test)]")) return true;
+      return false;
+    }
+    if (p.type === "source_file") return false;
+  }
+  return false;
+}
+
 // src/rules/security/dangerous-cors.ts
 var HEADER_LITERAL_RE = /['"]Access-Control-Allow-Origin['"]\s*[,:=]\s*['"]\*['"]/g;
 var CORS_BLOCK_RE = /\bcors\s*\(\s*\{([^}]*)\}\s*\)/g;
@@ -38976,6 +39871,216 @@ function isTautologicalAssertion(hit) {
   return false;
 }
 
+// src/rules/ts/enum-vs-as-const.ts
+var ENUM_DECL_REGEX = /^[ \t]*(?:export\s+)?(?:const\s+)?enum\s+[A-Z_][A-Za-z0-9_]*\s*\{/gm;
+var tsEnumVsAsConstRule = createRule({
+  id: "ts/enum-vs-as-const",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Uses `enum` \u2014 modern TS prefers `as const` objects",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let match;
+    ENUM_DECL_REGEX.lastIndex = 0;
+    while ((match = ENUM_DECL_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, match.index).split("\n").length;
+      issues.push({
+        ruleId: "ts/enum-vs-as-const",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `'enum' is an AI / older-TS pattern \u2014 prefer 'as const' for a frozen object literal`,
+        line,
+        column: match[0].indexOf("enum") + 1,
+        advice: 'Replace `enum Foo { A, B }` with `const Foo = { A: "A", B: "B" } as const` (or `const Foo = ["A", "B"] as const`). Modern TS style guides (Google, TS-eslint) prefer `as const` because enums have surprising runtime semantics. Reference: ts/enum-vs-as-const v0.19.'
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/ts/excessive-type-assertion.ts
+var DEFAULT_MAX = 3;
+var FN_DECL_REGEX = /^[ \t]*(?:export\s+)?(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*\([^)]*\)\s*[^{]*\{|^\s*(?:export\s+)?(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*=\s*(?:async\s+)?\([^)]*\)\s*(?::\s*[^=]+)?\s*=>\s*\{|^\s*(?:public|private|protected|static|async|abstract|readonly|\s)*\s*[A-Za-z_$][\w$]*\s*\([^)]*\)\s*:\s*[^{]*\{/gm;
+var AS_REGEX = /(?<![\w$])as\s+(?!const)([A-Z][\w$.,<>\[\]|&]*)/g;
+var tsExcessiveTypeAssertionRule = createRule({
+  id: "ts/excessive-type-assertion",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Function with >3 `as` type assertions \u2014 likely AI fighting the type system",
+  create(_context) {
+    return { maxAssertionsPerFunction: DEFAULT_MAX };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let match;
+    FN_DECL_REGEX.lastIndex = 0;
+    while ((match = FN_DECL_REGEX.exec(source)) !== null) {
+      const startIdx = match.index;
+      const openBraceIdx = source.indexOf("{", startIdx);
+      if (openBraceIdx < 0) continue;
+      let depth = 1;
+      let i = openBraceIdx + 1;
+      while (i < source.length && depth > 0) {
+        const ch = source[i];
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+        i++;
+      }
+      const body = source.slice(openBraceIdx, i);
+      const line = source.slice(0, startIdx).split("\n").length;
+      let asCount = 0;
+      const seen = /* @__PURE__ */ new Set();
+      let asMatch;
+      AS_REGEX.lastIndex = 0;
+      while ((asMatch = AS_REGEX.exec(body)) !== null) {
+        const captured = asMatch[1];
+        if (seen.has(captured)) continue;
+        seen.add(captured);
+        asCount++;
+      }
+      if (asCount > context.maxAssertionsPerFunction) {
+        issues.push({
+          ruleId: "ts/excessive-type-assertion",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `Function has ${asCount} 'as' assertions (max ${context.maxAssertionsPerFunction}) \u2014 likely AI fighting the type system`,
+          line,
+          column: 1,
+          advice: "More than 3 `as` assertions in a function is a strong signal that the type is wrong, not the code. Fix the type definition (or use a type guard) instead of bypassing the type system. Reference: ts/excessive-type-assertion v0.19."
+        });
+      }
+    }
+    return issues;
+  }
+});
+
+// src/rules/ts/import-type-misuse.ts
+var INLINE_TYPE_IMPORT_REGEX = /^[ \t]*import\s*\{[^}]*\btype\s+[A-Za-z_]/gm;
+var tsImportTypeMisuseRule = createRule({
+  id: "ts/import-type-misuse",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Inline `import { type X }` \u2014 prefer `import type { X }` for clarity",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let match;
+    INLINE_TYPE_IMPORT_REGEX.lastIndex = 0;
+    while ((match = INLINE_TYPE_IMPORT_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, match.index).split("\n").length;
+      issues.push({
+        ruleId: "ts/import-type-misuse",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: "Inline `type` in a value import \u2014 split into a separate `import type` statement",
+        line,
+        column: match[0].indexOf("type") + 1,
+        advice: 'Use `import type { X } from "..."` instead of `import { type X } from "..."`. The inline form is valid but the split form is more common in real codebases and makes the type-only intent unambiguous. Reference: ts/import-type-misuse v0.19.'
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/ts/never-vs-unknown.ts
+var NEVER_RETURN_REGEX = /^[ \t]*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)[^{]*:\s*(?:Promise<)?never\b[^{]*\{/gm;
+var THROW_OR_LOOP_REGEX = /\b(?:throw\b|while\s*\(|for\s*\(|process\.exit\b|System\.exit\b)/;
+var tsNeverVsUnknownRule = createRule({
+  id: "ts/never-vs-unknown",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Return type `: never` but body has no throw / loop / exit \u2014 likely AI misuse",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let match;
+    NEVER_RETURN_REGEX.lastIndex = 0;
+    while ((match = NEVER_RETURN_REGEX.exec(source)) !== null) {
+      const fnName = match[1];
+      const startIdx = match.index;
+      const line = source.slice(0, startIdx).split("\n").length;
+      const openBraceIdx = source.indexOf("{", startIdx);
+      if (openBraceIdx < 0) continue;
+      let depth = 1;
+      let i = openBraceIdx + 1;
+      while (i < source.length && depth > 0) {
+        const ch = source[i];
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+        i++;
+      }
+      const body = source.slice(openBraceIdx, i);
+      if (THROW_OR_LOOP_REGEX.test(body)) continue;
+      issues.push({
+        ruleId: "ts/never-vs-unknown",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Function '${fnName}' returns 'never' but its body has no throw, loop, or exit \u2014 likely AI misuse`,
+        line,
+        column: match[0].indexOf("never") + 1,
+        advice: 'The `never` return type means "this function never returns". Reserve it for functions that always throw, always loop, or always exit. For "impossible" branches, use a concrete type (`void`, `Error`, `unknown`) and an exhaustive check. Reference: ts/never-vs-unknown v0.19.'
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/ts/optional-chain-overuse.ts
+var DEFAULT_MIN_CHAIN_LENGTH = 5;
+var tsOptionalChainOveruseRule = createRule({
+  id: "ts/optional-chain-overuse",
+  category: "logic",
+  severity: "low",
+  aiSpecific: true,
+  description: "Optional chaining (?.) used 5+ times in a single chain \u2014 AI tends to chain rather than narrow",
+  create(_context) {
+    return { minChainLength: DEFAULT_MIN_CHAIN_LENGTH };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const expressions = facts.v2.logic?.logicalExpressions;
+    if (!expressions) return issues;
+    for (const expression of expressions) {
+      if (expression.depth >= context.minChainLength && expression.isOptionalChainLike) {
+        issues.push({
+          ruleId: "ts/optional-chain-overuse",
+          category: "logic",
+          severity: "low",
+          aiSpecific: true,
+          message: `Optional chain depth ${expression.depth} \u2014 break with an intermediate variable or guard clause`,
+          line: expression.line,
+          column: expression.column,
+          advice: "Long optional chains are an AI pattern. Use a guard clause (`if (!value) return`) or intermediate variables to make the narrowing explicit. Reference: ts/optional-chain-overuse v0.19."
+        });
+      }
+    }
+    return issues;
+  }
+});
+
 // src/rules/typo/calc-fontsize.ts
 var FONT_SIZE_RE = /\bfont-size\s*:\s*[^;]*\bcalc\s*\(/i;
 var calcFontsizeRule = createRule({
@@ -40516,6 +41621,10 @@ var builtinRules = [
   expiredCodeExampleRule,
   staleFunctionReferenceRule,
   stalePackageReferenceRule,
+  dupIdenticalBlockRule,
+  goErrorWrapWithoutContextRule,
+  goNilSliceVsEmptyRule,
+  goStructTagInconsistencyRule,
   gapMonopolyRule,
   mathElementUniformityRule,
   mathGridUniformityRule,
@@ -40525,7 +41634,6 @@ var builtinRules = [
   ghostDefensiveRule,
   heapsDeviationRule,
   keyPropMissingRule,
-  ksDistributionShiftRule,
   mathAnyDensityRule,
   mathConsoleLogStormRule,
   mathGiniClassUsageRule,
@@ -40540,6 +41648,10 @@ var builtinRules = [
   halsteadAnomalyRule,
   terminologyDriftRule,
   uxPatternFragmentationRule,
+  rustStringlyTypedRule,
+  rustTodoMacroRule,
+  rustUnusedPubFnRule,
+  rustUnwrapInProductionRule,
   dangerousCorsRule,
   evalRule,
   exposedEnvVarRule,
@@ -40555,6 +41667,11 @@ var builtinRules = [
   fakePlaceholderRule,
   missingEdgeCaseRule,
   weakAssertionRule,
+  tsEnumVsAsConstRule,
+  tsExcessiveTypeAssertionRule,
+  tsImportTypeMisuseRule,
+  tsNeverVsUnknownRule,
+  tsOptionalChainOveruseRule,
   calcFontsizeRule,
   calcRawPxRule,
   clampOffscaleRule,
@@ -40614,6 +41731,22 @@ var RuleRegistry = class {
     if (!filter) return list;
     return list.filter((r) => filter.kind === "ai" ? r.aiSpecific : !r.aiSpecific);
   }
+  /** v0.18.8: remove every rule where `predicate(rule)` returns true.
+   *  Used by focused calibration scripts to scan a single category
+   *  without instantiating all 99 rules. */
+  removeWhere(predicate) {
+    let removed = 0;
+    for (const [id, rule] of this.rules) {
+      if (predicate(rule)) {
+        this.rules.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  all() {
+    return Array.from(this.rules.values());
+  }
   createContexts(config, filePath, cwd, hotspotIssues = []) {
     const context = {
       config,
@@ -40634,1044 +41767,1943 @@ var RuleRegistry = class {
 
 // src/rules/signal-strength.json
 var signal_strength_default = {
-  "logic/math-console-log-storm": {
-    recall: 7e-3,
-    fpRate: 1e-3,
-    ratio: 6.71,
-    precision: 0.8968,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "ai/any-density": {
+    recall: 6e-3,
+    fpRate: 37e-4,
+    ratio: 175.31,
+    precision: 0.6523,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=1678, FP=193, P=89.7%, FPR=0.10%, lift=6.7. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1760, FP=938, P=65.2%, FPR=0.37%, lift=175.31. v7 was USEFUL (TP=1313, FP=758, lift=153.41). v8 was USEFUL (TP=447, FP=180).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 153.41,
+    _v7Recall: 55e-4,
+    _v7FpRate: 41e-4,
+    _v7Precision: 0.634,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 271.97
   },
-  "logic/math-any-density": {
-    recall: 16e-4,
-    fpRate: 13e-4,
-    ratio: 1.17,
-    precision: 0.6035,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "NOISY",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. NOISY \u2014 TP=376, FP=247, P=60.4%, FPR=0.13%, lift=1.2. aiSpecific=True.",
-    defaultOff: true,
-    aiSpecific: true
+  "ai/comment-ratio": {
+    recall: 0.2771,
+    fpRate: 0.1578,
+    ratio: 4.26,
+    precision: 0.6721,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=81513, FP=39766, P=67.2%, FPR=15.78%, lift=4.26. v7 was USEFUL (TP=60308, FP=29876, lift=4.11). v8 was USEFUL (TP=21205, FP=9890).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 4.11,
+    _v7Recall: 0.2545,
+    _v7FpRate: 0.1629,
+    _v7Precision: 0.6687,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 4.73
   },
-  "logic/boundary-violation": {
-    recall: 0.0263,
-    fpRate: 0.0175,
-    ratio: 1.5,
-    precision: 0.6601,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=6282, FP=3235, P=66.0%, FPR=1.75%, lift=1.5. aiSpecific=False.",
-    aiSpecific: false
+  "ai/compression-profile": {
+    recall: 0.3478,
+    fpRate: 0.1488,
+    ratio: 4.92,
+    precision: 0.7318,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=102328, FP=37511, P=73.2%, FPR=14.88%, lift=4.92. v7 was USEFUL (TP=75031, FP=27473, lift=4.89). v8 was USEFUL (TP=27297, FP=10038).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 4.89,
+    _v7Recall: 0.3166,
+    _v7FpRate: 0.1498,
+    _v7Precision: 0.732,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 5
   },
-  "logic/reactive-hook-soup": {
-    recall: 38e-4,
+  "ai/console-debug-storm": {
+    recall: 73e-4,
     fpRate: 9e-4,
-    ratio: 4.29,
-    precision: 0.8476,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 949.21,
+    precision: 0.9,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=901, FP=162, P=84.8%, FPR=0.09%, lift=4.3. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=2150, FP=239, P=90.0%, FPR=0.09%, lift=949.21. v7 was USEFUL (TP=1912, FP=175, lift=960.19). v8 was USEFUL (TP=238, FP=64).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 960.19,
+    _v7Recall: 81e-4,
+    _v7FpRate: 1e-3,
+    _v7Precision: 0.9161,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 845.55
   },
-  "logic/optimistic-no-rollback": {
-    recall: 12e-4,
-    fpRate: 3e-4,
-    ratio: 3.61,
-    precision: 0.824,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "ai/default-react-stack": {
+    recall: 1e-3,
+    fpRate: 0,
+    ratio: 251225.49,
+    precision: 0.9966,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=281, FP=60, P=82.4%, FPR=0.03%, lift=3.6. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=294, FP=1, P=99.7%, FPR=0.00%, lift=251225.49. v7 was USEFUL (TP=231, FP=1, lift=182622.43). v8 was USEFUL (TP=63, FP=0). v0.19 default-on (explicit defaultOff: false): P 99.7% / 251k lift \u2014 core AI fingerprint.",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 182622.43,
+    _v7Recall: 1e-3,
+    _v7FpRate: 0,
+    _v7Precision: 0.9957,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999,
+    defaultOff: false
   },
-  "logic/zombie-state": {
-    recall: 1e-4,
-    fpRate: 0,
-    ratio: 9.26,
-    precision: 0.9231,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "ai/errors-near-eof": {
+    recall: 0.0948,
+    fpRate: 0.052,
+    ratio: 13.09,
+    precision: 0.6803,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=24, FP=2, P=92.3%, FPR=0.00%, lift=9.3. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=27874, FP=13097, P=68.0%, FPR=5.20%, lift=13.09. v7 was USEFUL (TP=16673, FP=10112, lift=11.29). v8 was USEFUL (TP=11201, FP=2985).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 11.29,
+    _v7Recall: 0.0704,
+    _v7FpRate: 0.0551,
+    _v7Precision: 0.6225,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 18.16
   },
-  "logic/math-gini-class-usage": {
-    recall: 13e-4,
+  "ai/fetch-default-overuse": {
+    recall: 27e-4,
     fpRate: 3e-4,
-    ratio: 5.09,
-    precision: 0.8683,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 2679.84,
+    precision: 0.9036,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=310, FP=47, P=86.8%, FPR=0.03%, lift=5.1. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=797, FP=85, P=90.4%, FPR=0.03%, lift=2679.84. v7 was USEFUL (TP=666, FP=76, lift=2166.14). v8 was USEFUL (TP=131, FP=9).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 2166.14,
+    _v7Recall: 28e-4,
+    _v7FpRate: 4e-4,
+    _v7Precision: 0.8976,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 7139.19
   },
-  "visual/math-color-cluster": {
-    recall: 2e-4,
+  "ai/library-reinvention": {
+    recall: 3e-4,
     fpRate: 0,
-    ratio: 8.95,
-    precision: 0.9206,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 47415.05,
+    precision: 0.9405,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=58, FP=5, P=92.1%, FPR=0.00%, lift=9.0. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=79, FP=5, P=94.0%, FPR=0.00%, lift=47415.05. v7 was USEFUL (TP=64, FP=5, lift=34024.44). v8 was USEFUL (TP=15, FP=0).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 34024.44,
+    _v7Recall: 3e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.9275,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "visual/math-default-font": {
-    recall: 13e-4,
-    fpRate: 4e-4,
-    ratio: 3.4,
-    precision: 0.8151,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=313, FP=71, P=81.5%, FPR=0.04%, lift=3.4. aiSpecific=True.",
-    aiSpecific: true
-  },
-  "visual/math-gradient-hue-rotation": {
+  "ai/log-rank-histogram": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Munsell, A. H. (1905), *A Color Notation*, Munsell Color Company; Itten, J. (1961), *The Art of Color*, Van Nostrand Reinhold. (Munsell color space + Itten color wheel \u2014 hue rotation analysis.)",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=OK, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "OK",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "visual/math-rounded-entropy": {
-    recall: 37e-4,
-    fpRate: 3e-4,
-    ratio: 10.9,
-    precision: 0.9339,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=876, FP=62, P=93.4%, FPR=0.03%, lift=10.9. aiSpecific=True.",
-    aiSpecific: true
+  "ai/markdown-leakage": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 10003.17,
+    precision: 0.3571,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=5, FP=9, P=35.7%, FPR=0.00%, lift=10003.17. v7 was USEFUL (TP=5, FP=2, lift=65504.64). v8 was INVERTED (TP=0, FP=7).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 65504.64,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0.7143,
+    _v8Verdict: "INVERTED",
+    _v8Lift: 0
   },
-  "visual/math-font-entropy": {
-    recall: 45e-4,
-    fpRate: 13e-4,
-    ratio: 3.32,
-    precision: 0.8114,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "ai/renyi-profile": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 5251.67,
+    precision: 0.25,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=4, FP=12, P=25.0%, FPR=0.00%, lift=5251.67. v7 was OK (TP=3, FP=9, lift=5094.81). v8 was OK (TP=1, FP=3).",
+    aiSpecific: true,
+    _v7Verdict: "OK",
+    _v7Lift: 5094.81,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0.25,
+    _v8Verdict: "OK",
+    _v8Lift: 5722.25
+  },
+  "ai/segment-surprisal-cv": {
+    recall: 0.2019,
+    fpRate: 0.0787,
+    ratio: 9.52,
+    precision: 0.7495,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=1067, FP=248, P=81.1%, FPR=0.13%, lift=3.3. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=59390, FP=19849, P=75.0%, FPR=7.87%, lift=9.52. v7 was USEFUL (TP=43498, FP=14983, lift=9.11). v8 was USEFUL (TP=15892, FP=4866).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 9.11,
+    _v7Recall: 0.1836,
+    _v7FpRate: 0.0817,
+    _v7Precision: 0.7438,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 10.8
   },
-  "visual/math-spacing-entropy": {
-    recall: 18e-4,
+  "ai/state-default-overuse": {
+    recall: 3e-3,
     fpRate: 6e-4,
-    ratio: 3.01,
-    precision: 0.7959,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 1315.06,
+    precision: 0.8451,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=425, FP=109, P=79.6%, FPR=0.06%, lift=3.0. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=884, FP=162, P=84.5%, FPR=0.06%, lift=1315.06. v7 was USEFUL (TP=701, FP=158, lift=947.32). v8 was USEFUL (TP=183, FP=4).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 947.32,
+    _v7Recall: 3e-3,
+    _v7FpRate: 9e-4,
+    _v7Precision: 0.8161,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 16799.55
   },
-  "visual/clamp-soup": {
+  "ai/tailwind-color-overuse": {
+    recall: 0.0264,
+    fpRate: 38e-4,
+    ratio: 230.97,
+    precision: 0.8888,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=7752, FP=970, P=88.9%, FPR=0.38%, lift=230.97. v7 was USEFUL (TP=5169, FP=958, lift=161.52). v8 was USEFUL (TP=2583, FP=12).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 161.52,
+    _v7Recall: 0.0218,
+    _v7FpRate: 52e-4,
+    _v7Precision: 0.8436,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 5695.79
+  },
+  "ai/text-like-ratio": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 201664,
+    precision: 0.8,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=4, FP=1, P=80.0%, FPR=0.00%, lift=201664.00. v7 was USEFUL (TP=3, FP=1, lift=137559.75). v8 was USEFUL (TP=1, FP=0).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 137559.75,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0.75,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
+  },
+  "ai/whitespace-regularity": {
+    recall: 0.0733,
+    fpRate: 0.0677,
+    ratio: 8.25,
+    precision: 0.5583,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=21567, FP=17061, P=55.8%, FPR=6.77%, lift=8.25. v7 was USEFUL (TP=17466, FP=13438, lift=7.71). v8 was USEFUL (TP=4101, FP=3623).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 7.71,
+    _v7Recall: 0.0737,
+    _v7FpRate: 0.0733,
+    _v7Precision: 0.5652,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 10.06
+  },
+  "arch/astro-island-leak": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: W3C (2023), CSS Values and Units Module Level 4, W3C CR-css-values-4-20231218. (W3C clamp() spec \u2014 overuse is a code-smell, not a feature.)",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
   "component/giant-component": {
-    recall: 0.0176,
-    fpRate: 77e-4,
-    ratio: 2.3,
-    precision: 0.7485,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    recall: 0.0181,
+    fpRate: 59e-4,
+    ratio: 132.31,
+    precision: 0.7815,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=4205, FP=1413, P=74.8%, FPR=0.77%, lift=2.3. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=5326, FP=1489, P=78.2%, FPR=0.59%, lift=132.31. v7 was USEFUL (TP=4205, FP=1413, lift=97.16). v8 was USEFUL (TP=1121, FP=76).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 97.16,
+    _v7Recall: 0.0177,
+    _v7FpRate: 77e-4,
+    _v7Precision: 0.7485,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 846.15
+  },
+  "component/multiple-components-per-file": {
+    recall: 0.0751,
+    fpRate: 0.0423,
+    ratio: 15.96,
+    precision: 0.6747,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=22103, FP=10655, P=67.5%, FPR=4.23%, lift=15.96. v7 was USEFUL (TP=16288, FP=9589, lift=12.04). v8 was USEFUL (TP=5815, FP=1066).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 12.04,
+    _v7Recall: 0.0687,
+    _v7FpRate: 0.0523,
+    _v7Precision: 0.6294,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 54.44
   },
   "component/shadcn-prop-mismatch": {
-    recall: 13e-4,
+    recall: 16e-4,
     fpRate: 1e-4,
-    ratio: 10.1,
-    precision: 0.929,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 9990.98,
+    precision: 0.9512,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=314, FP=24, P=92.9%, FPR=0.01%, lift=10.1. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=468, FP=24, P=95.1%, FPR=0.01%, lift=9990.98. v7 was USEFUL (TP=314, FP=24, lift=7099.57). v8 was USEFUL (TP=154, FP=0). v0.19 default-on (explicit defaultOff: false): P 95.1% / 9990x lift \u2014 UI bug.",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 7099.57,
+    _v7Recall: 13e-4,
+    _v7FpRate: 1e-4,
+    _v7Precision: 0.929,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999,
+    defaultOff: false
   },
-  "layout/math-grid-uniformity": {
-    recall: 3e-4,
-    fpRate: 2e-4,
-    ratio: 1.72,
-    precision: 0.6907,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "OK",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. OK \u2014 TP=67, FP=30, P=69.1%, FPR=0.02%, lift=1.7. aiSpecific=True.",
-    aiSpecific: true
-  },
-  "layout/math-element-uniformity": {
-    recall: 28e-4,
-    fpRate: 12e-4,
-    ratio: 2.28,
-    precision: 0.7475,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "context/import-path-mismatch": {
+    recall: 0.0681,
+    fpRate: 0.0167,
+    ratio: 49.48,
+    precision: 0.8263,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=666, FP=225, P=74.7%, FPR=0.12%, lift=2.3. aiSpecific=True.",
-    aiSpecific: true
-  },
-  "typo/math-button-label-uniformity": {
-    recall: 2e-4,
-    fpRate: 1e-4,
-    ratio: 1.36,
-    precision: 0.6379,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=37, FP=21, P=63.8%, FPR=0.01%, lift=1.4. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "perf/css-bloat": {
-    recall: 0.0117,
-    fpRate: 32e-4,
-    ratio: 3.64,
-    precision: 0.8252,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=2790, FP=591, P=82.5%, FPR=0.32%, lift=3.6. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "wcag/focus-appearance": {
-    recall: 26e-4,
-    fpRate: 1e-4,
-    ratio: 19.68,
-    precision: 0.9623,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=612, FP=24, P=96.2%, FPR=0.01%, lift=19.7. aiSpecific=False.",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=20032, FP=4210, P=82.6%, FPR=1.67%, lift=49.48. v7 was USEFUL (TP=17672, FP=4202, lift=35.26). v8 was USEFUL (TP=2360, FP=8).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 35.26,
+    _v7Recall: 0.0746,
+    _v7FpRate: 0.0229,
+    _v7Precision: 0.8079,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 8554.38
   },
-  "wcag/target-size": {
+  "db/duplicate-index": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: W3C (2018), Web Content Accessibility Guidelines (WCAG) 2.1, Success Criterion 2.5.5 (Target Size); Fitts, P. M. (1954), \u2018The Information Capacity of the Human Motor System in Controlling the Amplitude of Movement\u2019, J. Exp. Psychol. 47(6):381-391. (WCAG 2.5.5 + Fitts's Law \u2014 minimum 24\xD724 CSS px tap target.)",
-    aiSpecific: false
-  },
-  "component/multiple-components-per-file": {
-    recall: 0.0681,
-    fpRate: 0.052,
-    ratio: 1.31,
-    precision: 0.6294,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=16288, FP=9589, P=62.9%, FPR=5.20%, lift=1.3. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "context/import-path-mismatch": {
-    recall: 0.0739,
-    fpRate: 0.0228,
-    ratio: 3.25,
-    precision: 0.8079,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=17672, FP=4202, P=80.8%, FPR=2.28%, lift=3.2. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "logic/key-prop-missing": {
-    recall: 17e-4,
-    fpRate: 14e-4,
-    ratio: 1.28,
-    precision: 0.6246,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=416, FP=250, P=62.5%, FPR=0.14%, lift=1.3. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "logic/math-variable-name-entropy": {
-    recall: 2e-4,
-    fpRate: 1e-4,
-    ratio: 1.07,
-    precision: 0.5806,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=36, FP=26, P=58.1%, FPR=0.01%, lift=1.1. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "security/public-admin-route": {
-    recall: 28e-4,
-    fpRate: 78e-4,
-    ratio: 0.4,
-    precision: 0.2251,
-    lastCalibratedAt: "2026-06-26T22:30:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v4 corpus (2026-06-25): 95,599 neg + 76,550 pos (frontend, TS/TSX/JS/JSX). INVERTED \u2014 TP=217, FP=747, P=22.5%, FPR=0.78%, lift=0.4. [v0.12.2: reclassified to HYGIENE because rule is aiSpecific: false]",
-    defaultOff: true,
-    aiSpecific: false
-  },
-  "security/unsafe-html-render": {
-    recall: 13e-4,
-    fpRate: 9e-4,
-    ratio: 1.5,
-    precision: 0.661,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=312, FP=160, P=66.1%, FPR=0.09%, lift=1.5. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "visual/naturalness-anomaly": {
-    recall: 0.1645,
-    fpRate: 0.0617,
-    ratio: 2.67,
-    precision: 0.7755,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=39319, FP=11382, P=77.6%, FPR=6.17%, lift=2.7. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "perf/halstead-anomaly": {
+  "db/enum-sprawl": {
     recall: 0,
     fpRate: 0,
-    ratio: 2.32,
-    precision: 0.75,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=3, FP=1, P=75.0%, FPR=0.00%, lift=2.3. aiSpecific=True.",
-    aiSpecific: true
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "arch/astro-island-leak": {
+  "db/missing-fk-index": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Hevery, M. (2022), \u2018Islands Architecture: A New Pattern for Server-Component Frameworks\u2019, ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages & Applications (OOPSLA), invited talk; Astro Documentation (2023), https://docs.astro.build. (Astro Islands architecture \u2014 client JS should not leak into server components.)",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "logic/qwik-hook-leak": {
+  "db/missing-not-null": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Hevery, M. (2022), \u2018Qwik: A Resumable JavaScript Framework\u2019, ACM SIGPLAN OOPSLA companion; Builder.io Technical Report. (Qwik resumability \u2014 serializing state avoids hydration cost.)",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "test/missing-edge-case": {
+  "db/naming-inconsistency": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Myers, G. J. (1979), *The Art of Software Testing*, Wiley-Interscience (canonical boundary value analysis reference); Beizer, B. (1990), *Software Testing Techniques*, 2nd ed., Van Nostrand Reinhold. (Boundary value analysis \u2014 empty / zero / max / null / type-boundary cases.)",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "typo/calc-fontsize": {
+  "db/sql-concat": {
+    recall: 5e-4,
+    fpRate: 1e-4,
+    ratio: 7511.26,
+    precision: 0.8343,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=141, FP=28, P=83.4%, FPR=0.01%, lift=7511.26. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=141, FP=28).",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 2046.08
+  },
+  "dead/dead-branch": {
+    recall: 2e-4,
+    fpRate: 4e-4,
+    ratio: 1080.68,
+    precision: 0.4244,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 (v0.18.9): v85 verdict=OK, v7 was DORMANT, v8 was OK. v0.18.8 v8a first measurement (1000 files): see docs/research/v0.18.8-dead-rules-measurement.md.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 294.38
+  },
+  "dead/unreachable": {
+    recall: 1e-4,
+    fpRate: 6e-4,
+    ratio: 153.14,
+    precision: 0.0966,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 (v0.18.9): v85 verdict=OK, v7 was DORMANT, v8 was OK. v0.18.8 v8a first measurement (1000 files): see docs/research/v0.18.8-dead-rules-measurement.md.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 41.71
+  },
+  "dead/unused-import": {
+    recall: 0.0379,
+    fpRate: 0.0222,
+    ratio: 30.06,
+    precision: 0.6662,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 (v0.18.9): v85 verdict=USEFUL, v7 was DORMANT, v8 was USEFUL. v0.18.8 v8a first measurement (1000 files): see docs/research/v0.18.8-dead-rules-measurement.md.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 8.19
+  },
+  "dead/unused-local": {
+    recall: 0.0477,
+    fpRate: 74e-4,
+    ratio: 120.18,
+    precision: 0.8834,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 (v0.18.9): v85 verdict=USEFUL, v7 was DORMANT, v8 was USEFUL. v0.18.8 v8a first measurement (1000 files): see docs/research/v0.18.8-dead-rules-measurement.md. v0.19 default-on (explicit defaultOff: false): P 88.3% / FPR 0.74% / 120x lift \u2014 code hygiene.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 32.74,
+    defaultOff: false
+  },
+  "dead/unused-parameter": {
+    recall: 8e-4,
+    fpRate: 27e-4,
+    ratio: 98,
+    precision: 0.2628,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 (v0.18.9): v85 verdict=OK, v7 was DORMANT, v8 was OK. v0.18.8 v8a first measurement (1000 files): see docs/research/v0.18.8-dead-rules-measurement.md.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 26.7
+  },
+  "docs/broken-link": {
+    recall: 14e-4,
+    fpRate: 23e-4,
+    ratio: 178.13,
+    precision: 0.4155,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=418, FP=588, P=41.6%, FPR=0.23%, lift=178.13. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was OK (TP=418, FP=588).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 48.52
+  },
+  "docs/expired-code-example": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "INVERTED",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=0, FP=3, P=0.0%, FPR=0.00%, lift=0.00. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was INVERTED (TP=0, FP=3).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "INVERTED",
+    _v8Lift: 0,
+    defaultOff: true
+  },
+  "docs/stale-function-reference": {
+    recall: 26e-4,
+    fpRate: 5e-4,
+    ratio: 1638.47,
+    precision: 0.8515,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=751, FP=131, P=85.1%, FPR=0.05%, lift=1638.47. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=751, FP=131).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 446.32
+  },
+  "docs/stale-package-reference": {
+    recall: 2e-4,
+    fpRate: 4e-4,
+    ratio: 939.43,
+    precision: 0.3429,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=48, FP=92, P=34.3%, FPR=0.04%, lift=939.43. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was OK (TP=48, FP=92).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 255.9
+  },
+  "dup/identical-block": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Marcotte, E. (2016), *Responsive Design: Patterns & Principles*, A Book Apart; Brown, J. (2018), *Every Layout*, self-published (rel='https://every-layout.dev'). (Fluid typography via clamp(min, preferred, max).)",
-    aiSpecific: false
+    _calibrationNote: "v0.19: new rule, not yet calibrated. v8.5 calibration does not run dup/* rules. Scheduled for v0.20 calibration on near-dup corpus.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "typo/clamp-offscale": {
+  "go/error-wrap-without-context": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: W3C (2023), CSS Values 4 \xA77.2 (Functional Notations: clamp()); Brown, J. (2018), *Every Layout*. (CSS clamp() \u2014 off-scale (negative, >10rem) values are typos.)",
-    aiSpecific: false
+    _calibrationNote: "v0.19: new rule (fmt.Errorf wrap with generic message \u2014 needs operation context). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "typo/math-cta-vocabulary": {
+  "go/nil-slice-vs-empty": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Cialdini, R. B. (1984), *Influence: The Psychology of Persuasion*, Harper Business; Krug, S. (2000), *Don't Make Me Think*, 2nd ed., New Riders. (CTA wording \u2014 vague labels reduce click-through per Cialdini commitment/consistency.)",
-    aiSpecific: true
+    _calibrationNote: "v0.19: new rule (Variable declared nil slice but assigned empty slice). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "layout/forced-layout": {
+  "go/struct-tag-inconsistency": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Mozilla Developer Network (2023), CSS Grid Layout, https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_grid_layout; W3C (2023), CSS Grid Layout Module Level 3, W3C CR-css-grid-3-20231218. (CSS Grid spec \u2014 forced layout is a fallback hack, not the idiomatic approach.)",
-    aiSpecific: true
+    _calibrationNote: "v0.19: new rule (Struct fields mix json tag styles). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "visual/generic-centering": {
+  "layout/forced-layout": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-25T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.10.1 ship \u2014 not in v4 per-rule table. Default-off until calibration data lands. Backed by: Wertheimer, M. (1923), \u2018Untersuchungen zur Lehre von der Gestalt II\u2019, Psychologische Forschung 4:301-350; M\xFCller-Brockmann, J. (1981), *Grid Systems in Graphic Design*, Niggli. (Gestalt centering + grid systems \u2014 generic centering is anti-grid.)",
-    aiSpecific: true
-  },
-  "product/terminology-drift": {
-    recall: 85e-4,
-    fpRate: 28e-4,
-    ratio: 3,
-    precision: 0.7956,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=2028, FP=521, P=79.6%, FPR=0.28%, lift=3.0. aiSpecific=False.",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "product/ux-pattern-fragmentation": {
-    recall: 1e-4,
-    fpRate: 0,
-    ratio: 3.09,
-    precision: 0.8,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "layout/gap-monopoly": {
+    recall: 3e-4,
+    fpRate: 1e-4,
+    ratio: 8859.33,
+    precision: 0.8083,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=32, FP=8, P=80.0%, FPR=0.00%, lift=3.1. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=97, FP=23, P=80.8%, FPR=0.01%, lift=8859.33. v7 was USEFUL (TP=88, FP=23, lift=6322.11). v8 was USEFUL (TP=9, FP=0).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 6322.11,
+    _v7Recall: 4e-4,
+    _v7FpRate: 1e-4,
+    _v7Precision: 0.7928,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "security/sql-construction": {
-    recall: 3e-3,
-    fpRate: 18e-4,
-    ratio: 1.63,
-    precision: 0.6788,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "OK",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. OK \u2014 TP=710, FP=336, P=67.9%, FPR=0.18%, lift=1.6. aiSpecific=True.",
-    aiSpecific: true
+  "layout/math-element-uniformity": {
+    recall: 29e-4,
+    fpRate: 1e-3,
+    ratio: 770.74,
+    precision: 0.7705,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=846, FP=252, P=77.0%, FPR=0.10%, lift=770.74. v7 was USEFUL (TP=666, FP=225, lift=609.32). v8 was USEFUL (TP=180, FP=27).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 609.32,
+    _v7Recall: 28e-4,
+    _v7FpRate: 12e-4,
+    _v7Precision: 0.7475,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 2211.5
   },
-  "security/missing-auth-check": {
-    recall: 63e-4,
-    fpRate: 4e-4,
-    ratio: 15.3,
-    precision: 0.9247,
-    lastCalibratedAt: "2026-06-26T22:30:00Z",
+  "layout/math-grid-uniformity": {
+    recall: 3e-4,
+    fpRate: 1e-4,
+    ratio: 5839.98,
+    precision: 0.7182,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v4 corpus (2026-06-25): 95,599 neg + 76,550 pos (frontend, TS/TSX/JS/JSX). USEFUL \u2014 TP=479, FP=39, P=92.5%, FPR=0.04%, lift=15.3.",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=79, FP=31, P=71.8%, FPR=0.01%, lift=5839.98. v7 was USEFUL (TP=67, FP=30, lift=4222.91). v8 was USEFUL (TP=12, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 4222.91,
+    _v7Recall: 3e-4,
+    _v7FpRate: 2e-4,
+    _v7Precision: 0.6907,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 63384.92
   },
-  "security/dangerous-cors": {
-    recall: 5e-4,
-    fpRate: 5e-4,
-    ratio: 1.05,
-    precision: 0.5758,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "NOISY",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. NOISY \u2014 TP=114, FP=84, P=57.6%, FPR=0.05%, lift=1.0. aiSpecific=True.",
-    defaultOff: true,
-    aiSpecific: true
+  "layout/spacing-grid": {
+    recall: 2e-4,
+    fpRate: 2e-4,
+    ratio: 4051.29,
+    precision: 0.6429,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=72, FP=40, P=64.3%, FPR=0.02%, lift=4051.29. v7 was USEFUL (TP=39, FP=15, lift=8831.00). v8 was USEFUL (TP=33, FP=25).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 8831,
+    _v7Recall: 2e-4,
+    _v7FpRate: 1e-4,
+    _v7Precision: 0.7222,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 1562.77
   },
-  "test/duplicate-setup": {
-    recall: 1e-4,
+  "logic/bayesian-conditional": {
+    recall: 0,
     fpRate: 0,
-    ratio: 3.6,
-    precision: 0.8235,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "logic/boundary-violation": {
+    recall: 0.0274,
+    fpRate: 0.0137,
+    ratio: 51.32,
+    precision: 0.7006,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=14, FP=3, P=82.4%, FPR=0.00%, lift=3.6. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=8051, FP=3441, P=70.1%, FPR=1.37%, lift=51.32. v7 was USEFUL (TP=6282, FP=3235, lift=37.42). v8 was USEFUL (TP=1769, FP=206).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 37.42,
+    _v7Recall: 0.0265,
+    _v7FpRate: 0.0176,
+    _v7Precision: 0.6601,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 298.57
   },
   "logic/ghost-defensive": {
     recall: 1e-4,
     fpRate: 0,
-    ratio: 5.79,
-    precision: 0.8824,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 112035.56,
+    precision: 0.8889,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=15, FP=2, P=88.2%, FPR=0.00%, lift=5.8. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=16, FP=2, P=88.9%, FPR=0.00%, lift=112035.56. v7 was USEFUL (TP=15, FP=2, lift=80917.50). v8 was USEFUL (TP=1, FP=0). v0.19 default-on (explicit defaultOff: false): P 88.9% / 112k lift \u2014 code smell.",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 80917.5,
+    _v7Recall: 1e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.8824,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999,
+    defaultOff: false
   },
-  "typo/calc-raw-px": {
-    recall: 0,
-    fpRate: 0,
-    ratio: 2.32,
-    precision: 0.75,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=3, FP=1, P=75.0%, FPR=0.00%, lift=2.3. aiSpecific=False.",
-    aiSpecific: false
+  "logic/heaps-deviation": {
+    recall: 0.0126,
+    fpRate: 0.0178,
+    ratio: 25.54,
+    precision: 0.4536,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=3716, FP=4477, P=45.4%, FPR=1.78%, lift=25.54. v7 was USEFUL (TP=2924, FP=2430, lift=41.22). v8 was OK (TP=792, FP=2047).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 41.22,
+    _v7Recall: 0.0123,
+    _v7FpRate: 0.0132,
+    _v7Precision: 0.5461,
+    _v8Verdict: "OK",
+    _v8Lift: 9.36
   },
-  "security/fail-open-auth": {
-    recall: 0,
-    fpRate: 0,
-    ratio: 99.99,
-    precision: 1,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "logic/key-prop-missing": {
+    recall: 16e-4,
+    fpRate: 11e-4,
+    ratio: 574.52,
+    precision: 0.629,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=1, FP=0, P=100.0%, FPR=0.00%, lift=inf. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=468, FP=276, P=62.9%, FPR=0.11%, lift=574.52. v7 was USEFUL (TP=416, FP=250, lift=458.26). v8 was USEFUL (TP=52, FP=26).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 458.26,
+    _v7Recall: 18e-4,
+    _v7FpRate: 14e-4,
+    _v7Precision: 0.6246,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 1760.69
   },
-  "wcag/focus-obscured": {
-    recall: 33e-4,
-    fpRate: 9e-4,
-    ratio: 3.51,
-    precision: 0.82,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=797, FP=175, P=82.0%, FPR=0.09%, lift=3.5. aiSpecific=False.",
-    aiSpecific: false
+  "logic/math-any-density": {
+    recall: 17e-4,
+    fpRate: 13e-4,
+    ratio: 464.59,
+    precision: 0.6027,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=496, FP=327, P=60.3%, FPR=0.13%, lift=464.59. v7 was USEFUL (TP=376, FP=247, lift=448.16). v8 was USEFUL (TP=120, FP=80).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 448.16,
+    _v7Recall: 16e-4,
+    _v7FpRate: 13e-4,
+    _v7Precision: 0.6035,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 515
   },
-  "visual/arbitrary-escape": {
-    recall: 25e-4,
-    fpRate: 9e-4,
-    ratio: 2.74,
-    precision: 0.7802,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "logic/math-console-log-storm": {
+    recall: 65e-4,
+    fpRate: 11e-4,
+    ratio: 794.4,
+    precision: 0.8729,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=600, FP=169, P=78.0%, FPR=0.09%, lift=2.7. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1903, FP=277, P=87.3%, FPR=0.11%, lift=794.40. v7 was USEFUL (TP=1678, FP=193, lift=852.30). v8 was USEFUL (TP=225, FP=84).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 852.3,
+    _v7Recall: 71e-4,
+    _v7FpRate: 11e-4,
+    _v7Precision: 0.8968,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 595.24
   },
-  "security/hardcoded-secret": {
+  "logic/math-gini-class-usage": {
     recall: 13e-4,
-    fpRate: 7e-4,
-    ratio: 1.72,
-    precision: 0.6899,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "OK",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. OK \u2014 TP=307, FP=138, P=69.0%, FPR=0.07%, lift=1.7. aiSpecific=True.",
-    aiSpecific: true
-  },
-  "visual/radius-scale-violation": {
-    recall: 4e-4,
-    fpRate: 0,
-    ratio: 24.7,
-    precision: 0.9697,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=96, FP=3, P=97.0%, FPR=0.00%, lift=24.7. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "test/fake-placeholder": {
-    recall: 53e-4,
-    fpRate: 19e-4,
-    ratio: 2.82,
-    precision: 0.7854,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    fpRate: 2e-4,
+    ratio: 4648.6,
+    precision: 0.8852,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=1259, FP=344, P=78.5%, FPR=0.19%, lift=2.8. aiSpecific=True.",
-    aiSpecific: true
-  },
-  "security/exposed-env-var": {
-    recall: 6e-4,
-    fpRate: 7e-4,
-    ratio: 0.9,
-    precision: 0.5387,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=146, FP=125, P=53.9%, FPR=0.07%, lift=0.9. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "perf/cls-image": {
-    recall: 2e-4,
-    fpRate: 3e-4,
-    ratio: 0.8,
-    precision: 0.5104,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=49, FP=47, P=51.0%, FPR=0.03%, lift=0.8. aiSpecific=False.",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=370, FP=48, P=88.5%, FPR=0.02%, lift=4648.60. v7 was USEFUL (TP=310, FP=47, lift=3388.64). v8 was USEFUL (TP=60, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 3388.64,
+    _v7Recall: 13e-4,
+    _v7FpRate: 3e-4,
+    _v7Precision: 0.8683,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 67541.31
   },
-  "layout/gap-monopoly": {
-    recall: 4e-4,
-    fpRate: 1e-4,
-    ratio: 2.95,
-    precision: 0.7928,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=88, FP=23, P=79.3%, FPR=0.01%, lift=3.0. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "visual/spacing-scale-violation": {
-    recall: 83e-4,
-    fpRate: 39e-4,
-    ratio: 2.13,
-    precision: 0.7342,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=1981, FP=717, P=73.4%, FPR=0.39%, lift=2.1. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "visual/inline-style-dominance": {
-    recall: 96e-4,
-    fpRate: 66e-4,
-    ratio: 1.46,
-    precision: 0.6535,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=2303, FP=1221, P=65.4%, FPR=0.66%, lift=1.5. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "layout/spacing-grid": {
+  "logic/math-variable-name-entropy": {
     recall: 2e-4,
     fpRate: 1e-4,
-    ratio: 2.01,
-    precision: 0.7222,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=39, FP=15, P=72.2%, FPR=0.01%, lift=2.0. aiSpecific=False.",
-    aiSpecific: false
-  },
-  "wcag/dragging-movements": {
-    recall: 0,
-    fpRate: 0,
-    ratio: 0.51,
-    precision: 0.4,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=2, FP=3, P=40.0%, FPR=0.00%, lift=0.5. aiSpecific=False.",
-    aiSpecific: false
+    ratio: 4548.81,
+    precision: 0.6316,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=60, FP=35, P=63.2%, FPR=0.01%, lift=4548.81. v7 was USEFUL (TP=36, FP=26, lift=4096.07). v8 was USEFUL (TP=24, FP=9).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 4096.07,
+    _v7Recall: 2e-4,
+    _v7FpRate: 1e-4,
+    _v7Precision: 0.5806,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 5548.85
   },
-  "test/weak-assertion": {
-    recall: 0.0414,
-    fpRate: 86e-4,
-    ratio: 4.83,
-    precision: 0.8622,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "logic/optimistic-no-rollback": {
+    recall: 12e-4,
+    fpRate: 2e-4,
+    ratio: 3523.57,
+    precision: 0.8527,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=9906, FP=1583, P=86.2%, FPR=0.86%, lift=4.8. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=353, FP=61, P=85.3%, FPR=0.02%, lift=3523.57. v7 was USEFUL (TP=281, FP=60, lift=2519.02). v8 was USEFUL (TP=72, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 2519.02,
+    _v7Recall: 12e-4,
+    _v7FpRate: 3e-4,
+    _v7Precision: 0.824,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 67726.36
   },
-  "logic/bayesian-conditional": {
+  "logic/qwik-hook-leak": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-27T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.12.0 ship \u2014 new Bayesian LR-combiner rule (Bento et al. 2024 *Neurocomputing*). Default-off until v0.12 corpus re-calibration lands. Threshold P(AI|fires) \u2265 0.7; posterior computed from per-rule likelihood ratios.",
-    aiSpecific: true
-  },
-  "logic/heaps-deviation": {
-    recall: 0.0122,
-    fpRate: 0.0132,
-    ratio: 0.93,
-    precision: 0.5461,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=2924, FP=2430, P=54.6%, FPR=1.32%, lift=0.9. aiSpecific=False.",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "logic/ks-distribution-shift": {
-    recall: 0.6375,
-    fpRate: 0.338,
-    ratio: 1.89,
-    precision: 0.7096,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=152391, FP=62358, P=71.0%, FPR=33.80%, lift=1.9. aiSpecific=False.",
-    aiSpecific: false
+  "logic/reactive-hook-soup": {
+    recall: 41e-4,
+    fpRate: 6e-4,
+    ratio: 1370.15,
+    precision: 0.8805,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1194, FP=162, P=88.1%, FPR=0.06%, lift=1370.15. v7 was USEFUL (TP=901, FP=162, lift=959.64). v8 was USEFUL (TP=293, FP=0).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 959.64,
+    _v7Recall: 38e-4,
+    _v7FpRate: 9e-4,
+    _v7Precision: 0.8476,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
   "logic/zipf-slope-anomaly": {
-    recall: 0.0156,
-    fpRate: 87e-4,
-    ratio: 1.79,
-    precision: 0.6983,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "HYGIENE",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. HYGIENE \u2014 TP=3718, FP=1606, P=69.8%, FPR=0.87%, lift=1.8. aiSpecific=False.",
-    aiSpecific: false
+    recall: 0.0168,
+    fpRate: 0.0111,
+    ratio: 57.13,
+    precision: 0.6369,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=4928, FP=2810, P=63.7%, FPR=1.11%, lift=57.13. v7 was USEFUL (TP=3718, FP=1606, lift=79.75). v8 was USEFUL (TP=1210, FP=1204).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 79.75,
+    _v7Recall: 0.0157,
+    _v7FpRate: 88e-4,
+    _v7Precision: 0.6983,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 28.59
   },
-  "ai/markdown-leakage": {
-    recall: 0,
+  "logic/zombie-state": {
+    recall: 1e-4,
     fpRate: 0,
-    ratio: 1.93,
-    precision: 0.7143,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "OK",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. OK \u2014 TP=5, FP=2, P=71.4%, FPR=0.00%, lift=1.9. aiSpecific=True.",
-    aiSpecific: true
+    ratio: 119891.71,
+    precision: 0.9512,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=39, FP=2, P=95.1%, FPR=0.00%, lift=119891.71. v7 was USEFUL (TP=24, FP=2, lift=84652.15). v8 was USEFUL (TP=15, FP=0).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 84652.15,
+    _v7Recall: 1e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.9231,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "ai/comment-ratio": {
-    recall: 0.2523,
-    fpRate: 0.1619,
-    ratio: 1.56,
-    precision: 0.6687,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "OK",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. OK \u2014 TP=60308, FP=29876, P=66.9%, FPR=16.19%, lift=1.6. aiSpecific=True.",
-    aiSpecific: true
+  "perf/cls-image": {
+    recall: 2e-4,
+    fpRate: 2e-4,
+    ratio: 2895.78,
+    precision: 0.5514,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=59, FP=48, P=55.1%, FPR=0.02%, lift=2895.78. v7 was USEFUL (TP=49, FP=47, lift=1991.85). v8 was USEFUL (TP=10, FP=1).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 1991.85,
+    _v7Recall: 2e-4,
+    _v7FpRate: 3e-4,
+    _v7Precision: 0.5104,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 62424.55
   },
-  "ai/whitespace-regularity": {
-    recall: 0.0731,
-    fpRate: 0.0728,
-    ratio: 1,
-    precision: 0.5652,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "NOISY",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. NOISY \u2014 TP=17466, FP=13438, P=56.5%, FPR=7.28%, lift=1.0. aiSpecific=True.",
-    defaultOff: true,
-    aiSpecific: true
+  "perf/css-bloat": {
+    recall: 0.0126,
+    fpRate: 24e-4,
+    ratio: 365.63,
+    precision: 0.8616,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=3697, FP=594, P=86.2%, FPR=0.24%, lift=365.63. v7 was USEFUL (TP=2790, FP=591, lift=256.10). v8 was USEFUL (TP=907, FP=3).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 256.1,
+    _v7Recall: 0.0118,
+    _v7FpRate: 32e-4,
+    _v7Precision: 0.8252,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 22813.54
   },
-  "ai/text-like-ratio": {
+  "perf/halstead-anomaly": {
     recall: 0,
     fpRate: 0,
-    ratio: 2.32,
-    precision: 0.75,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 75624,
+    precision: 0.6,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=3, FP=1, P=75.0%, FPR=0.00%, lift=2.3. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=3, FP=2, P=60.0%, FPR=0.00%, lift=75624.00. v7 was USEFUL (TP=3, FP=1, lift=137559.75). v8 was INVERTED (TP=0, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 137559.75,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0.75,
+    _v8Verdict: "INVERTED",
+    _v8Lift: 0
   },
-  "ai/errors-near-eof": {
-    recall: 0.0697,
-    fpRate: 0.0548,
-    ratio: 1.27,
-    precision: 0.6225,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "NOISY",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. NOISY \u2014 TP=16673, FP=10112, P=62.2%, FPR=5.48%, lift=1.3. aiSpecific=True.",
-    defaultOff: true,
-    aiSpecific: true
+  "product/terminology-drift": {
+    recall: 91e-4,
+    fpRate: 21e-4,
+    ratio: 397.75,
+    precision: 0.8347,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=2671, FP=529, P=83.5%, FPR=0.21%, lift=397.75. v7 was USEFUL (TP=2028, FP=521, lift=280.09). v8 was USEFUL (TP=643, FP=8).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 280.09,
+    _v7Recall: 86e-4,
+    _v7FpRate: 28e-4,
+    _v7Precision: 0.7956,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 8477.9
   },
-  "ai/any-density": {
-    recall: 55e-4,
-    fpRate: 41e-4,
-    ratio: 1.34,
-    precision: 0.634,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "NOISY",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. NOISY \u2014 TP=1313, FP=758, P=63.4%, FPR=0.41%, lift=1.3. aiSpecific=True.",
-    defaultOff: true,
-    aiSpecific: true
+  "product/ux-pattern-fragmentation": {
+    recall: 1e-4,
+    fpRate: 0,
+    ratio: 22864.4,
+    precision: 0.8163,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=40, FP=9, P=81.6%, FPR=0.00%, lift=22864.40. v7 was USEFUL (TP=32, FP=8, lift=18341.30). v8 was USEFUL (TP=8, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 18341.3,
+    _v7Recall: 1e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.8,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 61037.33
   },
-  "ai/renyi-profile": {
-    recall: 0,
+  "rust/stringly-typed": {
+    recall: 2e-4,
     fpRate: 0,
-    ratio: 0.26,
-    precision: 0.25,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
-    verdict: "INVERTED",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. INVERTED \u2014 TP=3, FP=9, P=25.0%, FPR=0.00%, lift=0.3. aiSpecific=True.",
-    defaultOff: true,
-    aiSpecific: true
+    ratio: 24735.12,
+    precision: 0.8831,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=68, FP=9, P=88.3%, FPR=0.00%, lift=24735.12. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=68, FP=9).",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 6737.89
   },
-  "ai/log-rank-histogram": {
+  "rust/todo-macro": {
+    recall: 1e-4,
+    fpRate: 7e-4,
+    ratio: 210.08,
+    precision: 0.1392,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=27, FP=167, P=13.9%, FPR=0.07%, lift=210.08. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was OK (TP=27, FP=167).",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 57.23
+  },
+  "rust/unused-pub-fn": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-27T00:00:00Z",
+    ratio: 10803.43,
+    precision: 0.3,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "OK",
-    _calibrationNote: "v0.13.0 stub: rule implemented per Gehrmann 2019 GLTR; calibration on v7 corpus pending. v0.13.0: marked OK (peer-reviewed math backing; lift=0 because v7 calibration has not been run yet \u2014 will be re-evaluated).",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=3, FP=7, P=30.0%, FPR=0.00%, lift=10803.43. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was OK (TP=3, FP=7).",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 2942.87
   },
-  "ai/segment-surprisal-cv": {
-    recall: 0.182,
-    fpRate: 0.0812,
-    ratio: 2.24,
-    precision: 0.7438,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "rust/unwrap-in-production": {
+    recall: 8e-3,
+    fpRate: 77e-4,
+    ratio: 70.81,
+    precision: 0.5475,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=43498, FP=14983, P=74.4%, FPR=8.12%, lift=2.2. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=2358, FP=1949, P=54.7%, FPR=0.77%, lift=70.81. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=2358, FP=1949).",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 19.29
   },
-  "ai/compression-profile": {
-    recall: 0.3139,
-    fpRate: 0.1489,
-    ratio: 2.11,
-    precision: 0.732,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "security/dangerous-cors": {
+    recall: 5e-4,
+    fpRate: 4e-4,
+    ratio: 1721.87,
+    precision: 0.6079,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=75031, FP=27473, P=73.2%, FPR=14.89%, lift=2.1. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=138, FP=89, P=60.8%, FPR=0.04%, lift=1721.87. v7 was USEFUL (TP=114, FP=84, lift=1257.16). v8 was USEFUL (TP=24, FP=5).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 1257.16,
+    _v7Recall: 5e-4,
+    _v7FpRate: 5e-4,
+    _v7Precision: 0.5758,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 11365.57
   },
-  "ai/tailwind-color-overuse": {
-    recall: 0.0216,
-    fpRate: 52e-4,
-    ratio: 4.16,
-    precision: 0.8436,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "security/eval": {
+    recall: 1e-4,
+    fpRate: 2e-4,
+    ratio: 1929.18,
+    precision: 0.4286,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=42, FP=56, P=42.9%, FPR=0.02%, lift=1929.18. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was OK (TP=42, FP=56).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "OK",
+    _v8Lift: 525.51
+  },
+  "security/exposed-env-var": {
+    recall: 6e-4,
+    fpRate: 5e-4,
+    ratio: 1055.81,
+    precision: 0.5696,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=5169, FP=958, P=84.4%, FPR=0.52%, lift=4.2. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=180, FP=136, P=57.0%, FPR=0.05%, lift=1055.81. v7 was USEFUL (TP=146, FP=125, lift=790.50). v8 was USEFUL (TP=34, FP=11).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 790.5,
+    _v7Recall: 6e-4,
+    _v7FpRate: 7e-4,
+    _v7Precision: 0.5387,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 4716.52
   },
-  "ai/default-react-stack": {
-    recall: 1e-3,
+  "security/fail-open-auth": {
+    recall: 0,
     fpRate: 0,
-    ratio: 99.99,
-    precision: 0.9957,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 99999,
+    precision: 1,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=231, FP=1, P=99.6%, FPR=0.00%, lift=178.3. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1, FP=0, P=100.0%, FPR=0.00%, lift=inf. v7 was USEFUL (TP=1, FP=0, lift=inf). v8 was DORMANT (TP=0, FP=0). v0.19 default-on (explicit defaultOff: false): P 100% / inf lift \u2014 security must always be on.",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 99999,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 1,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: false
   },
-  "ai/library-reinvention": {
-    recall: 3e-4,
+  "security/hardcoded-secret": {
+    recall: 14e-4,
+    fpRate: 6e-4,
+    ratio: 1269.08,
+    precision: 0.735,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=405, FP=146, P=73.5%, FPR=0.06%, lift=1269.08. v7 was USEFUL (TP=307, FP=138, lift=916.92). v8 was USEFUL (TP=98, FP=8).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 916.92,
+    _v7Recall: 13e-4,
+    _v7FpRate: 8e-4,
+    _v7Precision: 0.6899,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 7935.57
+  },
+  "security/localstorage-token": {
+    recall: 1e-4,
     fpRate: 0,
-    ratio: 9.88,
-    precision: 0.9275,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+    ratio: 99999,
+    precision: 1,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=64, FP=5, P=92.8%, FPR=0.00%, lift=9.9. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=17, FP=0, P=100.0%, FPR=0.00%, lift=inf. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=17, FP=0).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "ai/state-default-overuse": {
-    recall: 29e-4,
-    fpRate: 9e-4,
-    ratio: 3.42,
-    precision: 0.8161,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "security/missing-auth-check": {
+    recall: 5e-4,
+    fpRate: 0,
+    ratio: 99999,
+    precision: 1,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=701, FP=158, P=81.6%, FPR=0.09%, lift=3.4. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=157, FP=0, P=100.0%, FPR=0.00%, lift=inf. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=157, FP=0).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "ai/fetch-default-overuse": {
-    recall: 28e-4,
-    fpRate: 4e-4,
-    ratio: 6.76,
-    precision: 0.8976,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "security/public-admin-route": {
+    recall: 38e-4,
+    fpRate: 38e-4,
+    ratio: 142.2,
+    precision: 0.5376,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=666, FP=76, P=89.8%, FPR=0.04%, lift=6.8. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1108, FP=953, P=53.8%, FPR=0.38%, lift=142.20. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=1108, FP=953).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 38.74
   },
-  "ai/console-debug-storm": {
-    recall: 8e-3,
-    fpRate: 9e-4,
-    ratio: 8.43,
-    precision: 0.9161,
-    lastCalibratedAt: "2026-06-27T12:00:00Z",
+  "security/sql-construction": {
+    recall: 32e-4,
+    fpRate: 15e-4,
+    ratio: 485.42,
+    precision: 0.7183,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "USEFUL",
-    _calibrationNote: "v7 corpus re-calibration (2026-06-27, min-date=2025-01-01): 184488 neg + 239054 pos. USEFUL \u2014 TP=1912, FP=175, P=91.6%, FPR=0.09%, lift=8.4. aiSpecific=True.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=951, FP=373, P=71.8%, FPR=0.15%, lift=485.42. v7 was USEFUL (TP=710, FP=336, lift=370.52). v8 was USEFUL (TP=241, FP=37).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 370.52,
+    _v7Recall: 3e-3,
+    _v7FpRate: 18e-4,
+    _v7Precision: 0.6788,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 1608.86
   },
-  "db/missing-fk-index": {
-    recall: 0,
+  "security/target-blank-no-noopener": {
+    recall: 4e-4,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: PostgreSQL Global Development Group (2024), *PostgreSQL 16 Documentation \xA75.4 (Constraints)*, https://www.postgresql.org/docs/16/ddl-constraints.html; Squawk (2023), *Postgres linter rules*, https://github.com/sqllabs/squawk, rule `require-index-for-fk`. (Foreign key columns need a matching index \u2014 sequential scan on parent delete is a canonical Postgres anti-pattern.)",
-    aiSpecific: false
+    ratio: 26141.63,
+    precision: 0.9333,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=126, FP=9, P=93.3%, FPR=0.00%, lift=26141.63. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=126, FP=9).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 7121.02
   },
-  "db/duplicate-index": {
-    recall: 0,
+  "security/unsafe-html-render": {
+    recall: 13e-4,
+    fpRate: 11e-4,
+    ratio: 513.12,
+    precision: 0.574,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=380, FP=282, P=57.4%, FPR=0.11%, lift=513.12. v7 was USEFUL (TP=312, FP=160, lift=757.74). v8 was OK (TP=68, FP=122).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 757.74,
+    _v7Recall: 13e-4,
+    _v7FpRate: 9e-4,
+    _v7Precision: 0.661,
+    _v8Verdict: "OK",
+    _v8Lift: 201.44
+  },
+  "test/duplicate-setup": {
+    recall: 1e-4,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: PostgreSQL Global Development Group (2024), *PostgreSQL 16 Documentation \xA711.2 (Index Types)*; Heroku Postgres Team (2018), *Efficient Use of PostgreSQL Indexes*. (Duplicate indexes silently double write cost without read benefit \u2014 Postgres does not warn.)",
-    aiSpecific: false
+    ratio: 51016.19,
+    precision: 0.8095,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=17, FP=4, P=81.0%, FPR=0.00%, lift=51016.19. v7 was USEFUL (TP=14, FP=3, lift=50348.67). v8 was USEFUL (TP=3, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 50348.67,
+    _v7Recall: 1e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.8235,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 51500.25
   },
-  "db/missing-not-null": {
+  "test/fake-placeholder": {
+    recall: 51e-4,
+    fpRate: 15e-4,
+    ratio: 547.47,
+    precision: 0.8014,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1489, FP=369, P=80.1%, FPR=0.15%, lift=547.47. v7 was USEFUL (TP=1259, FP=344, lift=418.76). v8 was USEFUL (TP=230, FP=25).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 418.76,
+    _v7Recall: 53e-4,
+    _v7FpRate: 19e-4,
+    _v7Precision: 0.7854,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 2477.4
+  },
+  "test/missing-edge-case": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: PostgreSQL Global Development Group (2024), *PostgreSQL 16 Documentation \xA75.4.1 (Check Constraints)*; Kleppmann, M. (2017), *Designing Data-Intensive Applications*, O'Reilly, ch.4 (NULL semantics in RDBMS). (Required-identifier columns without NOT NULL produce silent NULL inserts \u2014 canonical AI SQL smell.)",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "db/enum-sprawl": {
+  "test/weak-assertion": {
+    recall: 0.0417,
+    fpRate: 67e-4,
+    ratio: 131.62,
+    precision: 0.8793,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=12263, FP=1684, P=87.9%, FPR=0.67%, lift=131.62. v7 was USEFUL (TP=9906, FP=1583, lift=99.90). v8 was USEFUL (TP=2357, FP=101).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 99.9,
+    _v7Recall: 0.0418,
+    _v7FpRate: 86e-4,
+    _v7Precision: 0.8622,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 651.94
+  },
+  "ts/enum-vs-as-const": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: PostgreSQL Global Development Group (2024), *PostgreSQL 16 Documentation \xA78.7 (Enumerated Types)*; Borkowski, A. (2022), *PostgreSQL enum types: when to use them and when not to*, pgconfig.org. (Enums with >12 values are brittle to extend and hard to localize \u2014 lookup table is the standard replacement.)",
-    aiSpecific: false
+    _calibrationNote: "v0.19: new rule (Uses `enum` \u2014 modern TS prefers `as const`). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "db/naming-inconsistency": {
+  "ts/excessive-type-assertion": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: PostgreSQL Global Development Group (2024), *PostgreSQL 16 Documentation \xA74.1.1 (Identifiers and Key Words)*; pgsql-hackers (2018), *Re: snake_case vs camelCase in Postgres identifiers*. (snake_case is the Postgres convention; mixing styles in the same schema breaks ORM generators.)",
-    aiSpecific: false
+    _calibrationNote: "v0.19: new rule (Function with >3 `as` assertions \u2014 AI fighting the type system). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "db/sql-concat": {
+  "ts/import-type-misuse": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: OWASP Foundation (2021), *OWASP Top 10 \u2014 A03:2021 Injection*, https://owasp.org/Top10/A03_2021-Injection/; OWASP Foundation (2017), *SQL Injection Prevention Cheat Sheet*. (Template-literal SQL with ${...} interpolation is the #1 SQL injection vector in AI-generated TypeScript code.)",
-    aiSpecific: true
+    _calibrationNote: "v0.19: new rule (Inline `import { type X }` \u2014 prefer separate `import type`). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "dead/unused-import": {
+  "ts/never-vs-unknown": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.18.5 ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The first of 5 planned `dead/*` rules (this one + dead/unused-local + dead/unused-parameter + dead/dead-branch + dead/unreachable). The pattern is the canonical AI-iteration rot: the model adds an import when introducing a feature, then rewrites the function later without cleaning up. Most real-world tsconfig.json files have `noUnusedLocals: false`, so tsc never fires.",
-    aiSpecific: true
+    _calibrationNote: "v0.19: new rule (Return type `never` but body has no throw/loop/exit). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "dead/unused-local": {
+  "ts/optional-chain-overuse": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
+    ratio: 1,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The second of 5 planned `dead/*` rules. Muchnick 1997 Ch. 13 'liveness analysis' (textbook compiler optimization).",
-    aiSpecific: true
+    _calibrationNote: "v0.19: new rule (Optional chain depth >= 5 \u2014 AI chains ?. rather than narrowing). Not yet calibrated. Scheduled for v9 calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "dead/unused-parameter": {
+  "typo/calc-fontsize": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The third of 5 planned `dead/*` rules. AI agents add parameters when introducing features, then rewrite the function without removing parameters the new code does not need.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "dead/dead-branch": {
+  "typo/calc-raw-px": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The fourth of 5 planned `dead/*` rules. AI-iteration signature: feature flag toggled to a constant, or wrapper from a previous refactor.",
-    aiSpecific: true
+    ratio: 210066.67,
+    precision: 0.8333,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=5, FP=1, P=83.3%, FPR=0.00%, lift=210066.67. v7 was USEFUL (TP=3, FP=1, lift=137559.75). v8 was USEFUL (TP=2, FP=0).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 137559.75,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0.75,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "dead/unreachable": {
+  "typo/clamp-offscale": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The fifth of 5 planned `dead/*` rules. AI-iteration signature: model added an early return for a new error path, then forgot the rest of the function body was still sitting below it.",
-    aiSpecific: true
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "docs/stale-package-reference": {
+  "typo/math-button-label-uniformity": {
+    recall: 1e-4,
+    fpRate: 1e-4,
+    ratio: 6894.19,
+    precision: 0.629,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=39, FP=23, P=62.9%, FPR=0.01%, lift=6894.19. v7 was USEFUL (TP=37, FP=21, lift=5571.66). v8 was USEFUL (TP=2, FP=2).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 5571.66,
+    _v7Recall: 2e-4,
+    _v7FpRate: 1e-4,
+    _v7Precision: 0.6379,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 17166.75
+  },
+  "typo/math-cta-vocabulary": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: Meng, M. et al. (2020), *The Cost of Fixing Code Documentation: An Empirical Study on Open-Source Software*, ICSE 2020; Aghajani, E. et al. (2019), *Software documentation: a practitioners' perspective*, ICSE 2019. (Doc references to undeclared packages are copy-paste rot from previous projects \u2014 high-signal doc drift.)",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "docs/stale-function-reference": {
-    recall: 0,
+  "typo/placeholder-text": {
+    recall: 1e-4,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: Meng, M. et al. (2020), *The Cost of Fixing Code Documentation*; Chen, Z. et al. (2022), *An Empirical Study on Code Documentation Adequacy*, MSR 2022. (Doc callouts to non-existent exports \u2014 readers copy-paste and hit a runtime error.)",
-    aiSpecific: false
+    ratio: 17330.5,
+    precision: 0.6875,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=22, FP=10, P=68.8%, FPR=0.00%, lift=17330.50. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=22, FP=10).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 4720.86
   },
-  "docs/expired-code-example": {
+  "visual/arbitrary-escape": {
+    recall: 26e-4,
+    fpRate: 7e-4,
+    ratio: 1219.67,
+    precision: 0.8177,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=758, FP=169, P=81.8%, FPR=0.07%, lift=1219.67. v7 was USEFUL (TP=600, FP=169, lift=846.78). v8 was USEFUL (TP=158, FP=0).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 846.78,
+    _v7Recall: 25e-4,
+    _v7FpRate: 9e-4,
+    _v7Precision: 0.7802,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
+  },
+  "visual/clamp-soup": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: Parnas, D.L. (2010), *Precise Documentation: The Key to Better Software*, Springer (canonical doc-correctness argument); Chen, Z. et al. (2022). (Fenced code examples with broken imports erode trust in the entire docs site.)",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "docs/broken-link": {
+  "visual/generic-centering": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: Nielsen, J. (2000), *Designing Web Usability*, New Riders (broken links as a top-5 trust erosion signal); Google Search Central (2024), *Crawl errors documentation*, https://developers.google.com/search/docs/crawling-indexing. (Broken internal links cost SEO crawl budget and reader trust.)",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "security/eval": {
-    recall: 0,
+  "visual/inline-style-dominance": {
+    recall: 0.0103,
+    fpRate: 52e-4,
+    ratio: 134.59,
+    precision: 0.6983,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=3028, FP=1308, P=69.8%, FPR=0.52%, lift=134.59. v7 was USEFUL (TP=2303, FP=1221, lift=98.17). v8 was USEFUL (TP=725, FP=87).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 98.17,
+    _v7Recall: 97e-4,
+    _v7FpRate: 67e-4,
+    _v7Precision: 0.6535,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 704.71
+  },
+  "visual/math-color-cluster": {
+    recall: 2e-4,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.16.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: OWASP Foundation (2021), *OWASP Top 10 \u2014 A03:2021 Injection*; Mozilla Developer Network (2024), *eval() \u2014 MDN Web Docs*, https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval (Security Considerations). (eval() and new Function() are RCE vectors if the input is ever attacker-controlled.)",
-    aiSpecific: false
+    ratio: 46814.86,
+    precision: 0.9286,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=65, FP=5, P=92.9%, FPR=0.00%, lift=46814.86. v7 was USEFUL (TP=58, FP=5, lift=33771.28). v8 was USEFUL (TP=7, FP=0).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 33771.28,
+    _v7Recall: 2e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.9206,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
   },
-  "security/localstorage-token": {
+  "visual/math-default-font": {
+    recall: 16e-4,
+    fpRate: 3e-4,
+    ratio: 3035.16,
+    precision: 0.8669,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=469, FP=72, P=86.7%, FPR=0.03%, lift=3035.16. v7 was USEFUL (TP=313, FP=71, lift=2105.64). v8 was USEFUL (TP=156, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 2105.64,
+    _v7Recall: 13e-4,
+    _v7FpRate: 4e-4,
+    _v7Precision: 0.8151,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 68229.63
+  },
+  "visual/math-font-entropy": {
+    recall: 52e-4,
+    fpRate: 1e-3,
+    ratio: 869.95,
+    precision: 0.8593,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1521, FP=249, P=85.9%, FPR=0.10%, lift=869.95. v7 was USEFUL (TP=1067, FP=248, lift=600.09). v8 was USEFUL (TP=454, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 600.09,
+    _v7Recall: 45e-4,
+    _v7FpRate: 14e-4,
+    _v7Precision: 0.8114,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 68516.08
+  },
+  "visual/math-gradient-hue-rotation": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.16.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: OWASP Foundation (2021), *OWASP Top 10 \u2014 A07:2021 Identification and Authentication Failures*; OWASP Foundation (2022), *HTML5 Security Cheat Sheet \xA72.1 (Local Storage)*. (JWT/access/refresh tokens in localStorage are readable by any XSS payload \u2014 issue as httpOnly cookies instead.)",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   },
-  "security/target-blank-no-noopener": {
-    recall: 0,
+  "visual/math-rounded-entropy": {
+    recall: 38e-4,
+    fpRate: 2e-4,
+    ratio: 3785.45,
+    precision: 0.9461,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=1105, FP=63, P=94.6%, FPR=0.02%, lift=3785.45. v7 was USEFUL (TP=876, FP=62, lift=2762.74). v8 was USEFUL (TP=229, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 2762.74,
+    _v7Recall: 37e-4,
+    _v7FpRate: 3e-4,
+    _v7Precision: 0.9339,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 68368.45
+  },
+  "visual/math-spacing-entropy": {
+    recall: 18e-4,
+    fpRate: 4e-4,
+    ratio: 1898.99,
+    precision: 0.8287,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=532, FP=110, P=82.9%, FPR=0.04%, lift=1898.99. v7 was USEFUL (TP=425, FP=109, lift=1339.22). v8 was USEFUL (TP=107, FP=1).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 1339.22,
+    _v7Recall: 18e-4,
+    _v7FpRate: 6e-4,
+    _v7Precision: 0.7959,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 68031.19
+  },
+  "visual/naturalness-anomaly": {
+    recall: 0.1729,
+    fpRate: 0.0687,
+    ratio: 10.86,
+    precision: 0.746,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=50852, FP=17316, P=74.6%, FPR=6.87%, lift=10.86. v7 was USEFUL (TP=39319, FP=11382, lift=12.50). v8 was USEFUL (TP=11533, FP=5934).",
+    aiSpecific: true,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 12.5,
+    _v7Recall: 0.1659,
+    _v7FpRate: 0.0621,
+    _v7Precision: 0.7755,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 7.64
+  },
+  "visual/radius-scale-violation": {
+    recall: 4e-4,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: 'v0.16.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: OWASP Foundation (2022), *HTML5 Security Cheat Sheet \xA72.3 (Tabnabbing)*; WHATWG (2024), *HTML Living Standard \u2014 Link types: noopener*. (target="_blank" without rel="noopener" lets the linked page control window.opener \u2014 reverse tabnabbing.)',
-    aiSpecific: false
+    ratio: 82131.33,
+    precision: 0.9774,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=130, FP=3, P=97.7%, FPR=0.00%, lift=82131.33. v7 was USEFUL (TP=96, FP=3, lift=59285.01). v8 was USEFUL (TP=34, FP=0). v0.19 default-on (explicit defaultOff: false): P 97.7% / 82k lift \u2014 UI consistency.",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 59285.01,
+    _v7Recall: 4e-4,
+    _v7FpRate: 0,
+    _v7Precision: 0.9697,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999,
+    defaultOff: false
   },
-  "wcag/missing-alt": {
+  "visual/spacing-scale-violation": {
+    recall: 86e-4,
+    fpRate: 28e-4,
+    ratio: 273.97,
+    precision: 0.7792,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=2531, FP=717, P=77.9%, FPR=0.28%, lift=273.97. v7 was USEFUL (TP=1981, FP=717, lift=187.83). v8 was USEFUL (TP=550, FP=0).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 187.83,
+    _v7Recall: 84e-4,
+    _v7FpRate: 39e-4,
+    _v7Precision: 0.7342,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 99999
+  },
+  "wcag/dragging-movements": {
     recall: 0,
     fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
-    verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: 'v0.16.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: W3C (2023), *Web Content Accessibility Guidelines (WCAG) 2.2 \u2014 1.1.1 Non-text Content*, https://www.w3.org/TR/WCAG22/. (Every <img> needs alt text. Decorative: alt="". Informative: describe the image.)',
-    aiSpecific: false
+    ratio: 33610.67,
+    precision: 0.4,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "OK",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=2, FP=3, P=40.0%, FPR=0.00%, lift=33610.67. v7 was OK (TP=2, FP=3, lift=24455.07). v8 was DORMANT (TP=0, FP=0).",
+    aiSpecific: false,
+    _v7Verdict: "OK",
+    _v7Lift: 24455.07,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0.4,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1
   },
-  "typo/placeholder-text": {
+  "wcag/focus-appearance": {
+    recall: 28e-4,
+    fpRate: 1e-4,
+    ratio: 8397.24,
+    precision: 0.966,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=825, FP=29, P=96.6%, FPR=0.01%, lift=8397.24. v7 was USEFUL (TP=612, FP=24, lift=7353.82). v8 was USEFUL (TP=213, FP=5).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 7353.82,
+    _v7Recall: 26e-4,
+    _v7FpRate: 1e-4,
+    _v7Precision: 0.9623,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 13418.41
+  },
+  "wcag/focus-obscured": {
+    recall: 33e-4,
+    fpRate: 7e-4,
+    ratio: 1214.21,
+    precision: 0.8478,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=980, FP=176, P=84.8%, FPR=0.07%, lift=1214.21. v7 was USEFUL (TP=797, FP=175, lift=859.38). v8 was USEFUL (TP=183, FP=1).",
+    aiSpecific: false,
+    _v7Verdict: "USEFUL",
+    _v7Lift: 859.38,
+    _v7Recall: 34e-4,
+    _v7FpRate: 1e-3,
+    _v7Precision: 0.82,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 68293.81
+  },
+  "wcag/missing-alt": {
+    recall: 11e-4,
+    fpRate: 7e-4,
+    ratio: 935.33,
+    precision: 0.6456,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "USEFUL",
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=317, FP=174, P=64.6%, FPR=0.07%, lift=935.33. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was USEFUL (TP=317, FP=174).",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "USEFUL",
+    _v8Lift: 254.79
+  },
+  "wcag/target-size": {
     recall: 0,
     fpRate: 0,
     ratio: 0,
     precision: 0,
-    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
     verdict: "DORMANT",
-    defaultOff: true,
-    _calibrationNote: "v0.16.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: Nielsen, J. (2000), *Designing Web Usability* (placeholder copy as a top-10 trust erosion signal); Krug, S. (2000), *Don't Make Me Think*, 2nd ed. (TODO/placeholder text in shipped UI signals incomplete work.)",
-    aiSpecific: false
+    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): rule did not fire on v8.5 corpus (252080 neg + 294178 pos = 546258 files). Preserved v7 data. v7 verdict=DORMANT, v7 lift=0, v7 recall=0, v7 FPR=0, v7 precision=0.",
+    aiSpecific: false,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 0,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
   }
 };
 
@@ -41710,7 +43742,6 @@ async function scanFile(filePath, config, registry, cwd = process.cwd()) {
     ".kt",
     ".kts",
     ".dart",
-    ".rs",
     ".cpp",
     ".cc",
     ".cxx",