slopbrick 0.18.9 → 0.19.0

package/dist/index.cjs

@@ -36,7 +36,7 @@ var VERSION;
 var init_header = __esm({
   "src/types/_header.ts"() {
     "use strict";
-    VERSION = "0.18.9";
+    VERSION = "0.19.0";
   }
 });
 
@@ -31353,6 +31353,246 @@ var init_broken_link = __esm({
   }
 });
 
+// src/rules/dup/identical-block.ts
+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 crypto, WINDOW_SIZE, MIN_NORMALIZED_LENGTH, HASH_PREFIX_LENGTH, DEDUP_CACHE, dupIdenticalBlockRule;
+var init_identical_block = __esm({
+  "src/rules/dup/identical-block.ts"() {
+    "use strict";
+    crypto = __toESM(require("crypto"), 1);
+    init_rule();
+    WINDOW_SIZE = 10;
+    MIN_NORMALIZED_LENGTH = 40;
+    HASH_PREFIX_LENGTH = 16;
+    DEDUP_CACHE = /* @__PURE__ */ new Map();
+    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, GENERIC_PREFIX_REGEX, goErrorWrapWithoutContextRule;
+var init_error_wrap_without_context = __esm({
+  "src/rules/go/error-wrap-without-context.ts"() {
+    "use strict";
+    init_rule();
+    ERR_WRAP_REGEX = /fmt\.Errorf\(\s*"((?:[^"\\]|\\.)*)"\s*,\s*([^)]+)\)/g;
+    GENERIC_PREFIX_REGEX = /^\s*(?:error|err|failed|wrap(?:ping)?|invalid)\s*(?::\s*)?%w\b/i;
+    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, EMPTY_SLICE_ASSIGN_REGEX, goNilSliceVsEmptyRule;
+var init_nil_slice_vs_empty = __esm({
+  "src/rules/go/nil-slice-vs-empty.ts"() {
+    "use strict";
+    init_rule();
+    NIL_SLICE_DECL_REGEX = /^[\t ]*var\s+([A-Za-z_][A-Za-z0-9_]*)\s+\[\][\w.*]+\b/gm;
+    EMPTY_SLICE_ASSIGN_REGEX = /^[\t ]*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:\[\][\w.*]*\{\}|make\(\[\][\w.*]*)/gm;
+    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, goStructTagInconsistencyRule;
+var init_struct_tag_inconsistency = __esm({
+  "src/rules/go/struct-tag-inconsistency.ts"() {
+    "use strict";
+    init_rule();
+    JSON_TAG_REGEX = /`json:"([^",]+)(?:,([^"]+))?"`/g;
+    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, gapMonopolyRule;
 var init_gap_monopoly = __esm({
@@ -38641,91 +38881,6 @@ var init_key_prop_missing = __esm({
   }
 });
 
-// src/rules/logic/ks-distribution-shift.ts
-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 MIN_SAMPLES_PER_FEATURE, ksDistributionShiftRule;
-var init_ks_distribution_shift = __esm({
-  "src/rules/logic/ks-distribution-shift.ts"() {
-    "use strict";
-    init_rule();
-    init_dist2();
-    init_corpus_baselines2();
-    MIN_SAMPLES_PER_FEATURE = 20;
-    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, MIN_ABSOLUTE, COLON, ANY_KEYWORD, ANY_TYPE_RE, MSG_FRAGMENT, RULE_DESCRIPTION, RULE_MESSAGE, RULE_ADVICE, mathAnyDensityRule;
 var init_math_any_density = __esm({
@@ -38795,13 +38950,13 @@ var init_math_any_density = __esm({
 });
 
 // src/rules/logic/math-console-log-storm.ts
-var WINDOW_SIZE, STORM_THRESHOLD, CONSOLE_LOG_RE, mathConsoleLogStormRule;
+var WINDOW_SIZE2, STORM_THRESHOLD, CONSOLE_LOG_RE, mathConsoleLogStormRule;
 var init_math_console_log_storm = __esm({
   "src/rules/logic/math-console-log-storm.ts"() {
     "use strict";
     init_rule();
     init_utils();
-    WINDOW_SIZE = 30;
+    WINDOW_SIZE2 = 30;
     STORM_THRESHOLD = 5;
     CONSOLE_LOG_RE = /\bconsole\.log\s*\(/g;
     mathConsoleLogStormRule = createRule({
@@ -38832,7 +38987,7 @@ var init_math_console_log_storm = __esm({
           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;
@@ -38846,7 +39001,7 @@ var init_math_console_log_storm = __esm({
             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."
@@ -41670,6 +41825,251 @@ var init_weak_assertion = __esm({
   }
 });
 
+// src/rules/ts/enum-vs-as-const.ts
+var ENUM_DECL_REGEX, tsEnumVsAsConstRule;
+var init_enum_vs_as_const = __esm({
+  "src/rules/ts/enum-vs-as-const.ts"() {
+    "use strict";
+    init_rule();
+    ENUM_DECL_REGEX = /^[ \t]*(?:export\s+)?(?:const\s+)?enum\s+[A-Z_][A-Za-z0-9_]*\s*\{/gm;
+    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, FN_DECL_REGEX, AS_REGEX, tsExcessiveTypeAssertionRule;
+var init_excessive_type_assertion = __esm({
+  "src/rules/ts/excessive-type-assertion.ts"() {
+    "use strict";
+    init_rule();
+    DEFAULT_MAX = 3;
+    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;
+    AS_REGEX = /(?<![\w$])as\s+(?!const)([A-Z][\w$.,<>\[\]|&]*)/g;
+    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, tsImportTypeMisuseRule;
+var init_import_type_misuse = __esm({
+  "src/rules/ts/import-type-misuse.ts"() {
+    "use strict";
+    init_rule();
+    INLINE_TYPE_IMPORT_REGEX = /^[ \t]*import\s*\{[^}]*\btype\s+[A-Za-z_]/gm;
+    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, THROW_OR_LOOP_REGEX, tsNeverVsUnknownRule;
+var init_never_vs_unknown = __esm({
+  "src/rules/ts/never-vs-unknown.ts"() {
+    "use strict";
+    init_rule();
+    NEVER_RETURN_REGEX = /^[ \t]*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)[^{]*:\s*(?:Promise<)?never\b[^{]*\{/gm;
+    THROW_OR_LOOP_REGEX = /\b(?:throw\b|while\s*\(|for\s*\(|process\.exit\b|System\.exit\b)/;
+    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, tsOptionalChainOveruseRule;
+var init_optional_chain_overuse = __esm({
+  "src/rules/ts/optional-chain-overuse.ts"() {
+    "use strict";
+    init_rule();
+    DEFAULT_MIN_CHAIN_LENGTH = 5;
+    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, calcFontsizeRule;
 var init_calc_fontsize = __esm({
@@ -45811,6 +46211,10 @@ var init_builtins = __esm({
     init_expired_code_example();
     init_stale_function_reference();
     init_stale_package_reference();
+    init_identical_block();
+    init_error_wrap_without_context();
+    init_nil_slice_vs_empty();
+    init_struct_tag_inconsistency();
     init_gap_monopoly();
     init_math_element_uniformity();
     init_math_grid_uniformity();
@@ -45820,7 +46224,6 @@ var init_builtins = __esm({
     init_ghost_defensive();
     init_heaps_deviation();
     init_key_prop_missing();
-    init_ks_distribution_shift();
     init_math_any_density();
     init_math_console_log_storm();
     init_math_gini_class_usage();
@@ -45854,6 +46257,11 @@ var init_builtins = __esm({
     init_fake_placeholder();
     init_missing_edge_case();
     init_weak_assertion();
+    init_enum_vs_as_const();
+    init_excessive_type_assertion();
+    init_import_type_misuse();
+    init_never_vs_unknown();
+    init_optional_chain_overuse();
     init_calc_fontsize();
     init_calc_raw_px();
     init_clamp_offscale();
@@ -45916,6 +46324,10 @@ var init_builtins = __esm({
       expiredCodeExampleRule,
       staleFunctionReferenceRule,
       stalePackageReferenceRule,
+      dupIdenticalBlockRule,
+      goErrorWrapWithoutContextRule,
+      goNilSliceVsEmptyRule,
+      goStructTagInconsistencyRule,
       gapMonopolyRule,
       mathElementUniformityRule,
       mathGridUniformityRule,
@@ -45925,7 +46337,6 @@ var init_builtins = __esm({
       ghostDefensiveRule,
       heapsDeviationRule,
       keyPropMissingRule,
-      ksDistributionShiftRule,
       mathAnyDensityRule,
       mathConsoleLogStormRule,
       mathGiniClassUsageRule,
@@ -45959,6 +46370,11 @@ var init_builtins = __esm({
       fakePlaceholderRule,
       missingEdgeCaseRule,
       weakAssertionRule,
+      tsEnumVsAsConstRule,
+      tsExcessiveTypeAssertionRule,
+      tsImportTypeMisuseRule,
+      tsNeverVsUnknownRule,
+      tsOptionalChainOveruseRule,
       calcFontsizeRule,
       calcRawPxRule,
       clampOffscaleRule,
@@ -48040,7 +48456,7 @@ var init_signal_strength = __esm({
         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,
@@ -48048,7 +48464,8 @@ var init_signal_strength = __esm({
         _v7FpRate: 0,
         _v7Precision: 0.9957,
         _v8Verdict: "USEFUL",
-        _v8Lift: 99999
+        _v8Lift: 99999,
+        defaultOff: false
       },
       "ai/errors-near-eof": {
         recall: 0.0948,
@@ -48297,7 +48714,7 @@ var init_signal_strength = __esm({
         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,
@@ -48305,7 +48722,8 @@ var init_signal_strength = __esm({
         _v7FpRate: 1e-4,
         _v7Precision: 0.929,
         _v8Verdict: "USEFUL",
-        _v8Lift: 99999
+        _v8Lift: 99999,
+        defaultOff: false
       },
       "context/import-path-mismatch": {
         recall: 0.0681,
@@ -48489,7 +48907,7 @@ var init_signal_strength = __esm({
         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,
@@ -48497,7 +48915,8 @@ var init_signal_strength = __esm({
         _v7FpRate: 0,
         _v7Precision: 0,
         _v8Verdict: "USEFUL",
-        _v8Lift: 32.74
+        _v8Lift: 32.74,
+        defaultOff: false
       },
       "dead/unused-parameter": {
         recall: 8e-4,
@@ -48585,6 +49004,78 @@ var init_signal_strength = __esm({
         _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,
@@ -48713,7 +49204,7 @@ var init_signal_strength = __esm({
         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,
@@ -48721,7 +49212,8 @@ var init_signal_strength = __esm({
         _v7FpRate: 0,
         _v7Precision: 0.8824,
         _v8Verdict: "USEFUL",
-        _v8Lift: 99999
+        _v8Lift: 99999,
+        defaultOff: false
       },
       "logic/heaps-deviation": {
         recall: 0.0126,
@@ -48757,24 +49249,6 @@ var init_signal_strength = __esm({
         _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,
@@ -49140,7 +49614,7 @@ var init_signal_strength = __esm({
         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,
@@ -49148,7 +49622,8 @@ var init_signal_strength = __esm({
         _v7FpRate: 0,
         _v7Precision: 1,
         _v8Verdict: "DORMANT",
-        _v8Lift: 1
+        _v8Lift: 1,
+        defaultOff: false
       },
       "security/hardcoded-secret": {
         recall: 14e-4,
@@ -49338,6 +49813,96 @@ var init_signal_strength = __esm({
         _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,
@@ -49640,7 +50205,7 @@ var init_signal_strength = __esm({
         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,
@@ -49648,7 +50213,8 @@ var init_signal_strength = __esm({
         _v7FpRate: 0,
         _v7Precision: 0.9697,
         _v8Verdict: "USEFUL",
-        _v8Lift: 99999
+        _v8Lift: 99999,
+        defaultOff: false
       },
       "visual/spacing-scale-violation": {
         recall: 86e-4,
@@ -56730,7 +57296,19 @@ var RULE_HINTS = {
   "rust/unused-pub-fn": "Remove the function or call it. Rust's compiler doesn't warn on `pub fn` references unless `#![warn(dead_code)]` is set at the crate root. AI agents leave these behind during iterative refactors.",
   "rust/unwrap-in-production": "Replace `.unwrap()` / `.expect()` with `?` (early-return on Err), `.map_err(...)` for error conversion, or an explicit `match`. They panic in production; reserve them for `#[cfg(test)]` or `#[test]` scopes.",
   "rust/todo-macro": "Implement the function body or remove the stub. `todo!()` / `unimplemented!()` both expand to `panic!()`, so a hit at runtime crashes the program. Move them into a `#[cfg(test)] mod tests` block to suppress.",
-  "rust/stringly-typed": 'Replace the `String` / `&str` parameter with the typed enum that already exists in the file. Stringly-typed APIs lose type information at the boundary \u2014 typos (`"Click"` vs `"click"`) only fail at runtime.'
+  "rust/stringly-typed": 'Replace the `String` / `&str` parameter with the typed enum that already exists in the file. Stringly-typed APIs lose type information at the boundary \u2014 typos (`"Click"` vs `"click"`) only fail at runtime.',
+  // v0.19.0 — TypeScript-specific rules
+  "ts/optional-chain-overuse": "Break long `?.` chains with an intermediate variable or guard clause (`if (!value) return;`). Long chains hide the type-narrowing that should be explicit. AI agents chain `?.` to avoid null checks.",
+  "ts/enum-vs-as-const": "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.",
+  "ts/import-type-misuse": "Use `import type { X } from '...'` instead of `import { type X } from '...'`. The split form is more common in real codebases and makes the type-only intent unambiguous.",
+  "ts/never-vs-unknown": "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.",
+  "ts/excessive-type-assertion": "More than 3 `as` assertions in one 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.",
+  // v0.19.0 — Go-specific rules
+  "go/error-wrap-without-context": 'Use `fmt.Errorf("opening config: %w", err)` not `fmt.Errorf("error: %w", err)`. Real Go errors include the failing operation. See golang.org/wiki/CodeReviewComments#error-strings.',
+  "go/struct-tag-inconsistency": '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).',
+  "go/nil-slice-vs-empty": "Either declare as `var x = []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.",
+  // v0.19.0 — Duplication detector
+  "dup/identical-block": "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."
 };
 
 // src/cli/commands/explain.ts