slopbrick 0.18.9 → 0.19.0

package/dist/engine/worker.js

@@ -5435,76 +5435,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) {
@@ -36234,6 +36164,218 @@ var brokenLinkRule = createRule({
   }
 });
 
+// src/rules/dup/identical-block.ts
+import * as crypto from "crypto";
+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({
@@ -37021,82 +37163,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;
@@ -37158,7 +37224,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({
@@ -37189,7 +37255,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;
@@ -37203,7 +37269,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."
@@ -39007,7 +39073,7 @@ var unsafeHtmlRenderRule = createRule({
 });
 
 // src/rules/test/utils.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function isTestFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
   if (/(^|\/)__tests__\//.test(normalized)) return true;
@@ -39167,7 +39233,7 @@ function extractSetupBlocks(source, minLines = 3) {
     }).trim();
     const lineCount = rawBody.split("\n").length;
     if (lineCount < minLines) continue;
-    const bodyHash = createHash2("sha1").update(normalizedBody).digest("hex");
+    const bodyHash = createHash3("sha1").update(normalizedBody).digest("hex");
     const { line, column } = lineColumnOf(source, m.index);
     hits.push({
       kind,
@@ -39777,6 +39843,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({
@@ -41317,6 +41593,10 @@ var builtinRules = [
   expiredCodeExampleRule,
   staleFunctionReferenceRule,
   stalePackageReferenceRule,
+  dupIdenticalBlockRule,
+  goErrorWrapWithoutContextRule,
+  goNilSliceVsEmptyRule,
+  goStructTagInconsistencyRule,
   gapMonopolyRule,
   mathElementUniformityRule,
   mathGridUniformityRule,
@@ -41326,7 +41606,6 @@ var builtinRules = [
   ghostDefensiveRule,
   heapsDeviationRule,
   keyPropMissingRule,
-  ksDistributionShiftRule,
   mathAnyDensityRule,
   mathConsoleLogStormRule,
   mathGiniClassUsageRule,
@@ -41360,6 +41639,11 @@ var builtinRules = [
   fakePlaceholderRule,
   missingEdgeCaseRule,
   weakAssertionRule,
+  tsEnumVsAsConstRule,
+  tsExcessiveTypeAssertionRule,
+  tsImportTypeMisuseRule,
+  tsNeverVsUnknownRule,
+  tsOptionalChainOveruseRule,
   calcFontsizeRule,
   calcRawPxRule,
   clampOffscaleRule,
@@ -41530,7 +41814,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,
@@ -41538,7 +41822,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,
@@ -41787,7 +42072,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,
@@ -41795,7 +42080,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,
@@ -41979,7 +42265,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,
@@ -41987,7 +42273,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,
@@ -42075,6 +42362,78 @@ 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
+  },
   "layout/forced-layout": {
     recall: 0,
     fpRate: 0,
@@ -42203,7 +42562,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,
@@ -42211,7 +42570,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 0.8824,
     _v8Verdict: "USEFUL",
-    _v8Lift: 99999
+    _v8Lift: 99999,
+    defaultOff: false
   },
   "logic/heaps-deviation": {
     recall: 0.0126,
@@ -42247,24 +42607,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,
@@ -42630,7 +42972,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,
@@ -42638,7 +42980,8 @@ var signal_strength_default = {
     _v7FpRate: 0,
     _v7Precision: 1,
     _v8Verdict: "DORMANT",
-    _v8Lift: 1
+    _v8Lift: 1,
+    defaultOff: false
   },
   "security/hardcoded-secret": {
     recall: 14e-4,
@@ -42828,6 +43171,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,
@@ -43130,7 +43563,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,
@@ -43138,7 +43571,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,