slopbrick 0.18.9 → 0.20.0

package/dist/engine/worker.cjs

@@ -6,9 +6,6 @@ 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 });
@@ -31,408 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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, {
@@ -440,8 +35,8 @@ __export(worker_exports, {
 });
 module.exports = __toCommonJS(worker_exports);
 var import_node_worker_threads = require("worker_threads");
-var import_node_path11 = require("path");
-var import_node_path12 = require("path");
+var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 
 // ../engine/dist/index.js
 var import_promises = require("fs/promises");
@@ -5463,76 +5058,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) {
@@ -7332,8 +6857,396 @@ function dispatchNode(node, parent, path, vctx) {
   return false;
 }
 
+// src/engine/parser-rust.ts
+var import_tree_sitter = __toESM(require("tree-sitter"), 1);
+var import_tree_sitter_rust = __toESM(require("tree-sitter-rust"), 1);
+var cachedParser = null;
+var rustLanguage = null;
+var loadError = null;
+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 };
+  }
+}
+var forcedFailure = null;
+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;
+}
+
+// src/engine/visitors/rust.ts
+var 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"
+];
+var SERVICE_SUFFIX_GROUP = `(?:${SERVICE_SUFFIXES.join("|")})`;
+var RUST_SERVICE_STRUCT_RE = new RegExp(
+  `^(?:pub(?:\\(crate\\)|\\(super\\))?\\s+)?struct\\s+(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
+  "gm"
+);
+var RUST_SERVICE_IMPL_RE = new RegExp(
+  `^impl(?:<[^>]+>)?\\s+(?:${SERVICE_SUFFIX_GROUP}\\s+for\\s+)?(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
+  "gm"
+);
+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;
+}
+
 // 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]+)?)-(.+)$/;
@@ -35177,125 +35090,17 @@ var unusedParameterRule = createRule({
 });
 
 // src/rules/docs/broken-link.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
-
-// src/engine/doc-freshness.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = require("path");
-var import_globby2 = require("globby");
-
-// src/mcp/patterns.ts
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
 
-// src/engine/discover.ts
-var import_globby = require("globby");
-var import_minimatch = require("minimatch");
-var import_node_path = require("path");
-var import_node_fs = require("fs");
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte", ".astro", ".html"]);
-var BACKEND_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".py",
-  ".go",
-  // v0.14.0
-  ".swift",
-  ".kt",
-  ".kts",
-  ".dart",
-  ".rs",
-  ".cpp",
-  ".cc",
-  ".cxx",
-  ".c",
-  ".h",
-  ".hpp",
-  ".hxx",
-  ".java",
-  ".rb",
-  ".php"
-]);
-var ALL_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ...SOURCE_EXTENSIONS,
-  ...BACKEND_EXTENSIONS
-]);
-
-// src/config/conventions.ts
+// src/engine/doc-freshness.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
-
-// src/mcp/patterns.ts
-var ESM_IMPORT_RE = /(?:^|\n)\s*(?:import\s+(?:type\s+)?(?:[\w*${},\s]+\s+from\s+)?|import\s+|export\s+(?:type\s+)?[\w*${},\s]+\s+from\s+)(['"])([^'"]+)\1/g;
-var DYNAMIC_IMPORT_RE = /import\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
-var COMMONJS_REQUIRE_RE = /require\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
-function extractImports(source) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  const push = (spec) => {
-    if (spec.startsWith(".") || spec.startsWith("/")) return;
-    if (seen.has(spec)) return;
-    seen.add(spec);
-    out.push(spec);
-  };
-  for (const re of [ESM_IMPORT_RE, DYNAMIC_IMPORT_RE, COMMONJS_REQUIRE_RE]) {
-    re.lastIndex = 0;
-    let m;
-    while ((m = re.exec(source)) !== null) {
-      push(m[2]);
-    }
-  }
-  return out;
-}
-
-// src/rules/docs/expired-code-example.ts
-var CODE_LANGS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "javascript", "typescript"]);
-function stripSubpath(spec) {
-  if (spec.startsWith("@")) return spec.split("/").slice(0, 2).join("/");
-  return spec.split("/")[0] ?? spec;
-}
-var expiredCodeExampleRule = createRule({
-  id: "docs/expired-code-example",
-  category: "docs",
-  severity: "medium",
-  aiSpecific: false,
-  description: "A fenced code example imports a package that is not declared in package.json.",
-  create(context) {
-    return { ...context, packages: declaredPackages(context.cwd) };
-  },
-  analyze(context, facts) {
-    const issues = [];
-    const source = facts.v2?._source;
-    if (!source) return issues;
-    const packages = declaredPackages(context.cwd);
-    const packageName = context.packageName;
-    if (packageName) packages.add(packageName);
-    const blocks = extractFencedCodeBlocks(source);
-    for (const block of blocks) {
-      if (!CODE_LANGS.has(block.lang)) continue;
-      if (block.body.split("\n").length < 2) continue;
-      const imports = extractImports(block.body);
-      for (const imp of imports) {
-        const pkgName = stripSubpath(imp);
-        if (packages.has(pkgName)) continue;
-        issues.push({
-          ruleId: "docs/expired-code-example",
-          category: "docs",
-          severity: "medium",
-          aiSpecific: false,
-          message: `Code example imports \`${imp}\` but \`${pkgName}\` is not in package.json.`,
-          line: block.line,
-          column: block.column,
-          advice: `Add \`${pkgName}\` to package.json or update the example.`
-        });
-      }
-    }
-    return issues;
-  }
-});
+var import_globby = require("globby");
 
 // src/rules/docs/stale-function-reference.ts
-var import_node_fs4 = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
 var RESERVED = /* @__PURE__ */ new Set([
   // JS reserved words
   "true",
@@ -35868,29 +35673,29 @@ var SOURCE_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs",
 var SOURCE_ROOTS = ["src", "lib", "app", "components"];
 var CAP = 200;
 function walk(dir, out, cap) {
-  if (!(0, import_node_fs4.existsSync)(dir) || out.length >= cap) return;
+  if (!(0, import_node_fs.existsSync)(dir) || out.length >= cap) return;
   let entries;
   try {
-    entries = (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true });
+    entries = (0, import_node_fs.readdirSync)(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (out.length >= cap) return;
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const full = (0, import_node_path4.join)(dir, entry.name);
+    const full = (0, import_node_path.join)(dir, entry.name);
     if (entry.isDirectory()) walk(full, out, cap);
-    else if (entry.isFile() && SOURCE_EXTS.has((0, import_node_path4.extname)(entry.name))) out.push(full);
+    else if (entry.isFile() && SOURCE_EXTS.has((0, import_node_path.extname)(entry.name))) out.push(full);
   }
 }
 function collectExports(cwd) {
   const out = /* @__PURE__ */ new Set();
   const files = [];
-  for (const root of SOURCE_ROOTS) walk((0, import_node_path4.join)(cwd, root), files, CAP);
+  for (const root of SOURCE_ROOTS) walk((0, import_node_path.join)(cwd, root), files, CAP);
   for (const file of files) {
     let source;
     try {
-      source = (0, import_node_fs4.readFileSync)(file, "utf-8");
+      source = (0, import_node_fs.readFileSync)(file, "utf-8");
     } catch {
       continue;
     }
@@ -36153,38 +35958,6 @@ function extractInlineCodeSpans(source) {
   }
   return hits;
 }
-function extractFencedCodeBlocks(source) {
-  const blocks = [];
-  const lines = source.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const fenceMatch = /^```(\w*)\s*$/.exec(line);
-    if (!fenceMatch) {
-      i++;
-      continue;
-    }
-    const lang = fenceMatch[1] ?? "";
-    const startLine = i + 1;
-    const bodyLines = [];
-    i++;
-    while (i < lines.length) {
-      if (/^```\s*$/.test(lines[i] ?? "")) {
-        i++;
-        break;
-      }
-      bodyLines.push(lines[i] ?? "");
-      i++;
-    }
-    blocks.push({
-      lang,
-      body: bodyLines.join("\n"),
-      line: startLine,
-      column: 1
-    });
-  }
-  return blocks;
-}
 function extractMarkdownLinks(source) {
   const hits = [];
   const re = /(?<!\!)\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
@@ -36201,10 +35974,10 @@ function extractMarkdownLinks(source) {
 }
 function declaredPackages(cwd) {
   const out = /* @__PURE__ */ new Set();
-  const pkgPath = (0, import_node_path5.join)(cwd, "package.json");
-  if (!(0, import_node_fs5.existsSync)(pkgPath)) return out;
+  const pkgPath = (0, import_node_path2.join)(cwd, "package.json");
+  if (!(0, import_node_fs2.existsSync)(pkgPath)) return out;
   try {
-    const raw = (0, import_node_fs5.readFileSync)(pkgPath, "utf-8");
+    const raw = (0, import_node_fs2.readFileSync)(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     for (const k of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
       const v = pkg[k];
@@ -36234,7 +36007,7 @@ var brokenLinkRule = createRule({
     const source = facts.v2?._source;
     if (!source) return issues;
     const links = extractMarkdownLinks(source);
-    const docDir = (0, import_node_path6.dirname)((0, import_node_path6.resolve)(context.cwd, context.filePath));
+    const docDir = (0, import_node_path3.dirname)((0, import_node_path3.resolve)(context.cwd, context.filePath));
     for (const link of links) {
       const target = link.target;
       if (target.startsWith("http://") || target.startsWith("https://")) continue;
@@ -36244,8 +36017,8 @@ var brokenLinkRule = createRule({
       if (target.startsWith("/")) continue;
       const filePart = target.split("#")[0] ?? target;
       if (filePart === "") continue;
-      const resolved = (0, import_node_path6.join)(docDir, filePart);
-      if ((0, import_node_fs6.existsSync)(resolved)) continue;
+      const resolved = (0, import_node_path3.join)(docDir, filePart);
+      if ((0, import_node_fs3.existsSync)(resolved)) continue;
       issues.push({
         ruleId: "docs/broken-link",
         category: "docs",
@@ -36262,6 +36035,466 @@ 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/java/arraylist-vs-linkedlist.ts
+var NEW_LINKED_LIST_REGEX = /new\s+LinkedList\s*</g;
+var javaArraylistVsLinkedlistRule = createRule({
+  id: "java/arraylist-vs-linkedlist",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "new LinkedList<>() \u2014 use ArrayList (Effective Java, Item 28)",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let m;
+    NEW_LINKED_LIST_REGEX.lastIndex = 0;
+    while ((m = NEW_LINKED_LIST_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/arraylist-vs-linkedlist",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `new LinkedList at line ${line} \u2014 use ArrayList instead`,
+        line,
+        column: 1,
+        advice: "Replace `new LinkedList<>()` with `new ArrayList<>()`. LinkedList is rarely the right choice (worse cache locality, 5x more memory per element, O(n) indexed access). Joshua Bloch (Effective Java, Item 28) recommends ArrayList unless you specifically need a Deque. AI agents default to LinkedList because of textbook examples. Reference: java/arraylist-vs-linkedlist v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/empty-catch-block.ts
+var SINGLE_LINE_EMPTY_CATCH_REGEX = /catch\s*\([^)]*\)\s*\{\s*\}/g;
+var javaEmptyCatchBlockRule = createRule({
+  id: "java/empty-catch-block",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: true,
+  description: "Empty catch block \u2014 silently swallows exceptions",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let m;
+    SINGLE_LINE_EMPTY_CATCH_REGEX.lastIndex = 0;
+    while ((m = SINGLE_LINE_EMPTY_CATCH_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/empty-catch-block",
+        category: "logic",
+        severity: "medium",
+        aiSpecific: true,
+        message: `Empty catch block at line ${line} \u2014 exception is silently swallowed`,
+        line,
+        column: 1,
+        advice: 'Log the exception (`log.error("...", e)`), re-throw it, or both. Empty catch blocks hide bugs. The pattern is common in AI-generated code that wants to look defensive. Reference: java/empty-catch-block v0.20.'
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/legacy-date-api.ts
+var LEGACY_IMPORT_REGEX = /^import\s+(?:static\s+)?java\.(?:util|sql)\.(?:Date|Calendar|GregorianCalendar)\s*;/gm;
+var LEGACY_USAGE_REGEX = /\bnew\s+(?:Date|GregorianCalendar)\s*\(/g;
+var CALENDAR_GET_INSTANCE_REGEX = /Calendar\.getInstance\s*\(/g;
+var javaLegacyDateApiRule = createRule({
+  id: "java/legacy-date-api",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Legacy java.util.Date / Calendar \u2014 use java.time (JSR-310) from Java 8+",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const flagged = /* @__PURE__ */ new Set();
+    let m;
+    LEGACY_IMPORT_REGEX.lastIndex = 0;
+    while ((m = LEGACY_IMPORT_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      flagged.add(line);
+      issues.push({
+        ruleId: "java/legacy-date-api",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Legacy date import at line ${line} \u2014 use java.time (JSR-310) from Java 8+`,
+        line,
+        column: 1,
+        advice: "Replace `java.util.Date` / `java.util.Calendar` with `java.time` (`LocalDate`, `LocalDateTime`, `Instant`, `ZonedDateTime`). java.time is immutable, thread-safe, and has a much better API. AI agents default to the legacy API because their training data predates Java 8 (2014). Reference: java/legacy-date-api v0.20."
+      });
+    }
+    LEGACY_USAGE_REGEX.lastIndex = 0;
+    while ((m = LEGACY_USAGE_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      if (flagged.has(line)) continue;
+      issues.push({
+        ruleId: "java/legacy-date-api",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `new Date() / GregorianCalendar at line ${line} \u2014 use java.time`,
+        line,
+        column: 1,
+        advice: "Replace with `LocalDate.now()`, `Instant.now()`, or `ZonedDateTime.now()`. Reference: java/legacy-date-api v0.20."
+      });
+    }
+    CALENDAR_GET_INSTANCE_REGEX.lastIndex = 0;
+    while ((m = CALENDAR_GET_INSTANCE_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      if (flagged.has(line)) continue;
+      issues.push({
+        ruleId: "java/legacy-date-api",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Calendar.getInstance() at line ${line} \u2014 use java.time`,
+        line,
+        column: 1,
+        advice: "Replace with `LocalDate.now()` (date-only) or `ZonedDateTime.now()`. Reference: java/legacy-date-api v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/raw-type-overuse.ts
+var RAW_TYPE_REGEX = /\b(List|Map|Set|Collection|Iterable)\s+(?![<A-Z])(\w+)/g;
+var javaRawTypeOveruseRule = createRule({
+  id: "java/raw-type-overuse",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Raw type usage (List, Map, Set) \u2014 use generics (Effective Java, Item 23)",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let m;
+    RAW_TYPE_REGEX.lastIndex = 0;
+    while ((m = RAW_TYPE_REGEX.exec(source)) !== null) {
+      const typeName = m[1];
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/raw-type-overuse",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Raw type ${typeName} at line ${line} \u2014 add type parameters`,
+        line,
+        column: 1,
+        advice: `Replace raw \`${typeName}\` with \`${typeName}<...>\`. Raw types disable generic type checking. Effective Java, Item 23: 'Don't use raw types in new code'. AI agents default to raw types when unsure of the correct generic parameters. Reference: java/raw-type-overuse v0.20.`
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/string-concat-loop.ts
+var STRING_CONCAT_REGEX = /(\b\w+)\s*=\s*\1\s*\+\s*[^;]+;|(\b\w+)\s*\+=\s*['"`]/g;
+var javaStringConcatLoopRule = createRule({
+  id: "java/string-concat-loop",
+  category: "perf",
+  severity: "low",
+  aiSpecific: true,
+  description: "String concatenation in a loop \u2014 use StringBuilder",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\b(for|while|do)\b/.test(source)) return issues;
+    let m;
+    STRING_CONCAT_REGEX.lastIndex = 0;
+    while ((m = STRING_CONCAT_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/string-concat-loop",
+        category: "perf",
+        severity: "low",
+        aiSpecific: true,
+        message: `String concatenation in a loop at line ${line} \u2014 use StringBuilder`,
+        line,
+        column: 1,
+        advice: "Declare a `StringBuilder` outside the loop: `StringBuilder sb = new StringBuilder(); sb.append(...);` then `return sb.toString();` after the loop. String concatenation in a loop is O(n\xB2) \u2014 each iteration copies the prior string. AI agents concatenate strings in loops because of training-data examples. Reference: java/string-concat-loop v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/system-out-println.ts
+var PRINTLN_REGEX = /System\.out\.println\s*\(/g;
+var DEFAULT_THRESHOLD = 1;
+var javaSystemOutPrintlnRule = createRule({
+  id: "java/system-out-println",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "System.out.println in production code \u2014 use a logger (SLF4J, Log4j, etc.)",
+  create(_context) {
+    return { threshold: DEFAULT_THRESHOLD };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const matches = [];
+    let m;
+    PRINTLN_REGEX.lastIndex = 0;
+    while ((m = PRINTLN_REGEX.exec(source)) !== null) {
+      matches.push(m.index);
+    }
+    if (matches.length <= context.threshold) return issues;
+    const cap = Math.min(matches.length, 10);
+    for (let i = 0; i < cap; i++) {
+      const idx = matches[i];
+      const line = source.slice(0, idx).split("\n").length;
+      issues.push({
+        ruleId: "java/system-out-println",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `System.out.println at line ${line} \u2014 use a logger for production output`,
+        line,
+        column: 1,
+        advice: "Replace with `private static final Logger log = LoggerFactory.getLogger(...);` then `log.info(...)`. AI agents default to println because their training data has countless textbook examples. Real Java code uses a logger. Reference: java/system-out-println v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
 // src/rules/layout/gap-monopoly.ts
 var GAP_RE = /\bgap(?:-x|-y)?-(\d+)\b/g;
 var gapMonopolyRule = createRule({
@@ -36614,16 +36847,16 @@ var DEFAULT_CONFIG = {
 };
 
 // src/config/detect/monorepo.ts
-var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
 
 // src/config/detect/styling.ts
-var import_node_fs8 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
 
 // src/config/detect/stack.ts
-var import_node_fs9 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
 
 // src/config/presets.ts
 var REACT_ONLY_RULES = {
@@ -36672,8 +36905,8 @@ var FRAMEWORK_PRESETS = {
 };
 
 // src/config/load.ts
-var import_node_fs10 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
 var import_node_module = require("module");
 
 // src/engine/logger.ts
@@ -36695,6 +36928,10 @@ function setLoggerQuiet(quiet) {
   logger = createLogger(quiet);
 }
 
+// src/config/conventions.ts
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
+
 // src/config/init.ts
 var STRICTNESS_PRESETS = {
   strict: {
@@ -37049,82 +37286,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;
@@ -37186,7 +37347,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({
@@ -37217,7 +37378,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;
@@ -37231,7 +37392,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."
@@ -38136,7 +38297,6 @@ function scanForStringlyParams(paramText) {
 }
 
 // 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",
@@ -38272,7 +38432,6 @@ function collectReferencedNames(source) {
 }
 
 // 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",
@@ -39409,7 +39568,7 @@ function looksRealistic(value) {
 
 // src/rules/test/missing-edge-case.ts
 var import_core4 = require("@swc/core");
-var import_node_fs11 = require("fs");
+var import_node_fs9 = require("fs");
 var MAX_PER_FILE = 20;
 var missingEdgeCaseRule = createRule({
   id: "test/missing-edge-case",
@@ -39431,7 +39590,7 @@ var missingEdgeCaseRule = createRule({
     const testFileSources = /* @__PURE__ */ new Map();
     for (const testFile of discoverTestFiles(cwd)) {
       try {
-        testFileSources.set(testFile, (0, import_node_fs11.readFileSync)(testFile, "utf-8"));
+        testFileSources.set(testFile, (0, import_node_fs9.readFileSync)(testFile, "utf-8"));
       } catch {
       }
     }
@@ -39685,8 +39844,8 @@ function discoverTestFiles(cwd) {
   const found = [];
   for (const root of roots) {
     const abs = `${cwd}/${root}`;
-    if (!(0, import_node_fs11.existsSync)(abs)) continue;
-    walk2(abs, found, import_node_fs11.readdirSync, import_node_fs11.statSync);
+    if (!(0, import_node_fs9.existsSync)(abs)) continue;
+    walk2(abs, found, import_node_fs9.readdirSync, import_node_fs9.statSync);
     if (found.length > 200) break;
   }
   return found;
@@ -39805,6 +39964,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({
@@ -41342,9 +41711,18 @@ var builtinRules = [
   unusedLocalRule,
   unusedParameterRule,
   brokenLinkRule,
-  expiredCodeExampleRule,
   staleFunctionReferenceRule,
   stalePackageReferenceRule,
+  dupIdenticalBlockRule,
+  goErrorWrapWithoutContextRule,
+  goNilSliceVsEmptyRule,
+  goStructTagInconsistencyRule,
+  javaArraylistVsLinkedlistRule,
+  javaEmptyCatchBlockRule,
+  javaLegacyDateApiRule,
+  javaRawTypeOveruseRule,
+  javaStringConcatLoopRule,
+  javaSystemOutPrintlnRule,
   gapMonopolyRule,
   mathElementUniformityRule,
   mathGridUniformityRule,
@@ -41354,7 +41732,6 @@ var builtinRules = [
   ghostDefensiveRule,
   heapsDeviationRule,
   keyPropMissingRule,
-  ksDistributionShiftRule,
   mathAnyDensityRule,
   mathConsoleLogStormRule,
   mathGiniClassUsageRule,
@@ -41388,6 +41765,11 @@ var builtinRules = [
   fakePlaceholderRule,
   missingEdgeCaseRule,
   weakAssertionRule,
+  tsEnumVsAsConstRule,
+  tsExcessiveTypeAssertionRule,
+  tsImportTypeMisuseRule,
+  tsNeverVsUnknownRule,
+  tsOptionalChainOveruseRule,
   calcFontsizeRule,
   calcRawPxRule,
   clampOffscaleRule,
@@ -41558,7 +41940,7 @@ var signal_strength_default = {
     precision: 0.9966,
     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=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).",
+    _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,
@@ -41566,7 +41948,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 0.9957,
     _v8Verdict: "USEFUL",
-    _v8Lift: 99999
+    _v8Lift: 99999,
+    defaultOff: false
   },
   "ai/errors-near-eof": {
     recall: 0.0948,
@@ -41815,7 +42198,7 @@ var signal_strength_default = {
     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=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).",
+    _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,
@@ -41823,7 +42206,8 @@ var signal_strength_default = {
     _v7FpRate: 1e-4,
     _v7Precision: 0.929,
     _v8Verdict: "USEFUL",
-    _v8Lift: 99999
+    _v8Lift: 99999,
+    defaultOff: false
   },
   "context/import-path-mismatch": {
     recall: 0.0681,
@@ -42007,7 +42391,7 @@ var signal_strength_default = {
     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.",
+    _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,
@@ -42015,7 +42399,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 0,
     _v8Verdict: "USEFUL",
-    _v8Lift: 32.74
+    _v8Lift: 32.74,
+    defaultOff: false
   },
   "dead/unused-parameter": {
     recall: 8e-4,
@@ -42051,24 +42436,6 @@ var signal_strength_default = {
     _v8Verdict: "OK",
     _v8Lift: 48.52
   },
-  "docs/expired-code-example": {
-    recall: 0,
-    fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    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,
@@ -42103,6 +42470,186 @@ var signal_strength_default = {
     _v8Verdict: "OK",
     _v8Lift: 255.9
   },
+  "dup/identical-block": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "go/error-wrap-without-context": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "go/nil-slice-vs-empty": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "go/struct-tag-inconsistency": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "java/arraylist-vs-linkedlist": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (new LinkedList<>() \u2014 use ArrayList (Effective Java Item 28)). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/empty-catch-block": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (Empty catch block \u2014 silently swallows exceptions). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/legacy-date-api": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (Legacy java.util.Date / Calendar \u2014 use java.time (JSR-310)). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/raw-type-overuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (Raw type usage \u2014 use generics). DORMANT until v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/string-concat-loop": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (String concat in loop \u2014 use StringBuilder). DORMANT until v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/system-out-println": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (System.out.println in production code \u2014 use a logger). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
   "layout/forced-layout": {
     recall: 0,
     fpRate: 0,
@@ -42231,7 +42778,7 @@ var signal_strength_default = {
     precision: 0.8889,
     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=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).",
+    _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,
@@ -42239,7 +42786,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 0.8824,
     _v8Verdict: "USEFUL",
-    _v8Lift: 99999
+    _v8Lift: 99999,
+    defaultOff: false
   },
   "logic/heaps-deviation": {
     recall: 0.0126,
@@ -42275,24 +42823,6 @@ var signal_strength_default = {
     _v8Verdict: "USEFUL",
     _v8Lift: 1760.69
   },
-  "logic/ks-distribution-shift": {
-    recall: 0.6889,
-    fpRate: 0.4411,
-    ratio: 1.46,
-    precision: 0.6457,
-    lastCalibratedAt: "2026-07-01T00:00:00Z",
-    verdict: "NOISY",
-    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=202658, FP=111193, P=64.6%, FPR=44.11%, lift=1.46. v7 was USEFUL (TP=152391, FP=62358, lift=2.09). v8 was INVERTED (TP=50267, FP=48835).",
-    aiSpecific: false,
-    _v7Verdict: "USEFUL",
-    _v7Lift: 2.09,
-    _v7Recall: 0.6431,
-    _v7FpRate: 0.34,
-    _v7Precision: 0.7096,
-    _v8Verdict: "INVERTED",
-    _v8Lift: 0.71,
-    defaultOff: true
-  },
   "logic/math-any-density": {
     recall: 17e-4,
     fpRate: 13e-4,
@@ -42658,7 +43188,7 @@ var signal_strength_default = {
     precision: 1,
     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=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).",
+    _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,
@@ -42666,7 +43196,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 1,
     _v8Verdict: "DORMANT",
-    _v8Lift: 1
+    _v8Lift: 1,
+    defaultOff: false
   },
   "security/hardcoded-secret": {
     recall: 14e-4,
@@ -42856,6 +43387,96 @@ var signal_strength_default = {
     _v8Verdict: "USEFUL",
     _v8Lift: 651.94
   },
+  "ts/enum-vs-as-const": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "ts/excessive-type-assertion": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "ts/import-type-misuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "ts/never-vs-unknown": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
+  "ts/optional-chain-overuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _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
+  },
   "typo/calc-fontsize": {
     recall: 0,
     fpRate: 0,
@@ -43158,7 +43779,7 @@ var signal_strength_default = {
     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).",
+    _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,
@@ -43166,7 +43787,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 0.9697,
     _v8Verdict: "USEFUL",
-    _v8Lift: 99999
+    _v8Lift: 99999,
+    defaultOff: false
   },
   "visual/spacing-scale-violation": {
     recall: 86e-4,
@@ -43284,7 +43906,7 @@ function loadSignalStrength() {
 function buildParserCacheConfig(cwd) {
   const envVal = process.env.SLOP_AUDIT_CACHE;
   const enabled = envVal === "1" || envVal === "true";
-  const root = process.env.SLOP_AUDIT_CACHE_ROOT ?? (0, import_node_path12.join)(cwd, ".slopbrick", "cache", "ast");
+  const root = process.env.SLOP_AUDIT_CACHE_ROOT ?? (0, import_node_path10.join)(cwd, ".slopbrick", "cache", "ast");
   return { enabled, root };
 }
 function applyRuleOverrides(issues, rules) {
@@ -43302,7 +43924,7 @@ function applyRuleOverrides(issues, rules) {
 }
 async function scanFile(filePath, config, registry, cwd = process.cwd()) {
   const cache = buildParserCacheConfig(cwd);
-  const ext = (0, import_node_path11.extname)(filePath).toLowerCase();
+  const ext = (0, import_node_path9.extname)(filePath).toLowerCase();
   const UNSUPPORTED_LANGS = /* @__PURE__ */ new Set([
     ".swift",
     ".kt",