slopbrick 0.25.1 → 0.26.0

package/dist/index.cjs

@@ -36,7 +36,7 @@ var VERSION;
 var init_header = __esm({
   "src/types/_header.ts"() {
     "use strict";
-    VERSION = "0.25.1";
+    VERSION = "0.26.0";
   }
 });
 
@@ -30704,6 +30704,55 @@ var init_arraylist_vs_linkedlist = __esm({
   }
 });
 
+// src/rules/java/builder-overuse.ts
+var BUILDER_ANNOTATION_REGEX, FIELD_DECL_REGEX, DEFAULT_FIELD_COUNT_CAP, javaBuilderOveruseRule;
+var init_builder_overuse = __esm({
+  "src/rules/java/builder-overuse.ts"() {
+    "use strict";
+    init_rule();
+    BUILDER_ANNOTATION_REGEX = /@Builder\b/;
+    FIELD_DECL_REGEX = /(?:private|public|protected)\s+(?:final\s+)?[\w<>,\s]+\s+(\w+)\s*[=;]/g;
+    DEFAULT_FIELD_COUNT_CAP = 3;
+    javaBuilderOveruseRule = createRule({
+      id: "java/builder-overuse",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      description: "@Builder on a class with few fields \u2014 plain constructor is simpler",
+      create(_context) {
+        return { fieldCountCap: DEFAULT_FIELD_COUNT_CAP };
+      },
+      analyze(context, facts) {
+        const issues = [];
+        const source = facts.v2?._source;
+        if (!source) return issues;
+        if (!/\.java$/i.test(facts.filePath)) return issues;
+        BUILDER_ANNOTATION_REGEX.lastIndex = 0;
+        const builderMatch = BUILDER_ANNOTATION_REGEX.exec(source);
+        if (!builderMatch) return issues;
+        const firstBuilderLine = source.slice(0, builderMatch.index).split("\n").length;
+        FIELD_DECL_REGEX.lastIndex = 0;
+        let fieldCount = 0;
+        while (FIELD_DECL_REGEX.exec(source) !== null) {
+          fieldCount++;
+        }
+        if (fieldCount > context.fieldCountCap) return issues;
+        issues.push({
+          ruleId: "java/builder-overuse",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `@Builder on a class with ${fieldCount} field(s) \u2014 plain constructor is simpler`,
+          line: firstBuilderLine,
+          column: 1,
+          advice: "Use a plain constructor for classes with \u2264 3 fields. AI agents default to @Builder because their training data emphasizes the pattern. Builder adds Lombok dependency and a Builder inner class for every annotated class. Reference: java/builder-overuse v0.26.0."
+        });
+        return issues;
+      }
+    });
+  }
+});
+
 // src/rules/java/empty-catch-block.ts
 var SINGLE_LINE_EMPTY_CATCH_REGEX, javaEmptyCatchBlockRule;
 var init_empty_catch_block = __esm({
@@ -30746,6 +30795,65 @@ var init_empty_catch_block = __esm({
   }
 });
 
+// src/rules/java/immutable-collection-preference.ts
+var IMMUTABLE_REGEX, MUTABLE_REGEX, DEFAULT_IMMUTABLE_THRESHOLD, DEFAULT_MUTABLE_CAP, javaImmutableCollectionPreferenceRule;
+var init_immutable_collection_preference = __esm({
+  "src/rules/java/immutable-collection-preference.ts"() {
+    "use strict";
+    init_rule();
+    IMMUTABLE_REGEX = /\b(List|Map|Set)\.of\s*\(/g;
+    MUTABLE_REGEX = /new\s+(ArrayList|HashMap|HashSet|LinkedList|TreeMap)\s*[<(]/g;
+    DEFAULT_IMMUTABLE_THRESHOLD = 5;
+    DEFAULT_MUTABLE_CAP = 1;
+    javaImmutableCollectionPreferenceRule = createRule({
+      id: "java/immutable-collection-preference",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      description: "Immutable factory method over-use \u2014 prefer mutable when collection will be modified",
+      create(_context) {
+        return {
+          immutableThreshold: DEFAULT_IMMUTABLE_THRESHOLD,
+          mutableCap: DEFAULT_MUTABLE_CAP
+        };
+      },
+      analyze(context, facts) {
+        const issues = [];
+        const source = facts.v2?._source;
+        if (!source) return issues;
+        if (!/\.java$/i.test(facts.filePath)) return issues;
+        IMMUTABLE_REGEX.lastIndex = 0;
+        let immutableCount = 0;
+        let firstIdx = 0;
+        let m;
+        while ((m = IMMUTABLE_REGEX.exec(source)) !== null) {
+          immutableCount++;
+          if (firstIdx === 0) firstIdx = m.index;
+        }
+        if (immutableCount < context.immutableThreshold) return issues;
+        MUTABLE_REGEX.lastIndex = 0;
+        let mutableCount = 0;
+        while ((m = MUTABLE_REGEX.exec(source)) !== null) {
+          mutableCount++;
+        }
+        if (mutableCount > context.mutableCap) return issues;
+        const line = source.slice(0, firstIdx).split("\n").length;
+        issues.push({
+          ruleId: "java/immutable-collection-preference",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `${immutableCount} immutable factory calls (List/Map/Set.of) with only ${mutableCount} mutable collection \u2014 likely over-preferring immutability`,
+          line,
+          column: 1,
+          advice: "Prefer mutable collections (new ArrayList<>()) when the collection will be modified later. AI agents default to List.of/Map.of/Set.of because their training data emphasizes functional-style Java. Reference: java/immutable-collection-preference v0.26.0."
+        });
+        return issues;
+      }
+    });
+  }
+});
+
 // src/rules/java/legacy-date-api.ts
 var LEGACY_IMPORT_REGEX, LEGACY_USAGE_REGEX, CALENDAR_GET_INSTANCE_REGEX, javaLegacyDateApiRule;
 var init_legacy_date_api = __esm({
@@ -30822,6 +30930,59 @@ var init_legacy_date_api = __esm({
   }
 });
 
+// src/rules/java/optional-overuse.ts
+var OR_ELSE_THROW_REGEX, NULL_CHECK_REGEX, DEFAULT_THRESHOLD, javaOptionalOveruseRule;
+var init_optional_overuse = __esm({
+  "src/rules/java/optional-overuse.ts"() {
+    "use strict";
+    init_rule();
+    OR_ELSE_THROW_REGEX = /\.orElseThrow\s*\(/g;
+    NULL_CHECK_REGEX = /Objects\.requireNonNull\s*\(|if\s*\([^)]*==\s*null\)\s*(?:throw|return)/g;
+    DEFAULT_THRESHOLD = 2;
+    javaOptionalOveruseRule = createRule({
+      id: "java/optional-overuse",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      description: "Optional chain over-use \u2014 null check or Objects.requireNonNull is faster",
+      create(_context) {
+        return { threshold: DEFAULT_THRESHOLD };
+      },
+      analyze(context, facts) {
+        const issues = [];
+        const source = facts.v2?._source;
+        if (!source) return issues;
+        if (!/\.java$/i.test(facts.filePath)) return issues;
+        OR_ELSE_THROW_REGEX.lastIndex = 0;
+        let orElseThrowCount = 0;
+        let firstIdx = 0;
+        let m;
+        while ((m = OR_ELSE_THROW_REGEX.exec(source)) !== null) {
+          orElseThrowCount++;
+          if (firstIdx === 0) firstIdx = m.index;
+        }
+        if (orElseThrowCount < context.threshold) return issues;
+        NULL_CHECK_REGEX.lastIndex = 0;
+        const nullCheckCount = (source.match(NULL_CHECK_REGEX) ?? []).length;
+        const optionalRatio = orElseThrowCount / Math.max(orElseThrowCount + nullCheckCount, 1);
+        if (optionalRatio < 0.6) return issues;
+        const line = source.slice(0, firstIdx).split("\n").length;
+        issues.push({
+          ruleId: "java/optional-overuse",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `${orElseThrowCount} .orElseThrow() calls with ${nullCheckCount} null checks \u2014 Optional chain over-use`,
+          line,
+          column: 1,
+          advice: 'Use Objects.requireNonNull(x, "msg") for null checks; reserve Optional for return values. AI agents default to Optional chains because their training data emphasizes null-safety. Real Java code uses null checks in hot paths. Reference: java/optional-overuse v0.26.0.'
+        });
+        return issues;
+      }
+    });
+  }
+});
+
 // src/rules/java/raw-type-overuse.ts
 var RAW_TYPE_REGEX, javaRawTypeOveruseRule;
 var init_raw_type_overuse = __esm({
@@ -30865,6 +31026,75 @@ var init_raw_type_overuse = __esm({
   }
 });
 
+// src/rules/java/stream-overuse.ts
+var STREAM_OPS, DEFAULT_CHAIN_THRESHOLD, javaStreamOveruseRule;
+var init_stream_overuse = __esm({
+  "src/rules/java/stream-overuse.ts"() {
+    "use strict";
+    init_rule();
+    STREAM_OPS = [
+      ".map(",
+      ".filter(",
+      ".flatMap(",
+      ".collect(",
+      ".reduce(",
+      ".sorted(",
+      ".distinct(",
+      ".limit(",
+      ".skip(",
+      ".anyMatch(",
+      ".allMatch(",
+      ".noneMatch(",
+      ".findFirst(",
+      ".findAny("
+    ];
+    DEFAULT_CHAIN_THRESHOLD = 3;
+    javaStreamOveruseRule = createRule({
+      id: "java/stream-overuse",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      description: "Stream API chain over-use \u2014 for-loop is faster for simple transformations",
+      create(_context) {
+        return { chainThreshold: DEFAULT_CHAIN_THRESHOLD };
+      },
+      analyze(context, facts) {
+        const issues = [];
+        const source = facts.v2?._source;
+        if (!source) return issues;
+        if (!/\.java$/i.test(facts.filePath)) return issues;
+        const lines = source.split("\n");
+        const streamOpPattern = new RegExp(STREAM_OPS.map((op) => op.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+        let firstOffendingLine = 0;
+        let firstOffendingCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          if (line.trim().startsWith("//") || line.trim().startsWith("*")) continue;
+          const matches = line.match(streamOpPattern);
+          if (matches && matches.length >= context.chainThreshold) {
+            if (firstOffendingLine === 0) {
+              firstOffendingLine = i + 1;
+              firstOffendingCount = matches.length;
+            }
+          }
+        }
+        if (firstOffendingLine === 0) return issues;
+        issues.push({
+          ruleId: "java/stream-overuse",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `${firstOffendingCount} stream operations on a single line \u2014 for-loop is faster`,
+          line: firstOffendingLine,
+          column: 1,
+          advice: "Prefer a for-loop for simple transformations. AI agents default to Stream API chains because their training data emphasizes functional-style Java. Stream chains allocate intermediate objects; for small collections, a for-loop is faster and more readable. Reference: java/stream-overuse v0.26.0."
+        });
+        return issues;
+      }
+    });
+  }
+});
+
 // src/rules/java/string-concat-loop.ts
 var STRING_CONCAT_REGEX, javaStringConcatLoopRule;
 var init_string_concat_loop = __esm({
@@ -30909,13 +31139,13 @@ var init_string_concat_loop = __esm({
 });
 
 // src/rules/java/system-out-println.ts
-var PRINTLN_REGEX, DEFAULT_THRESHOLD, javaSystemOutPrintlnRule;
+var PRINTLN_REGEX, DEFAULT_THRESHOLD2, javaSystemOutPrintlnRule;
 var init_system_out_println = __esm({
   "src/rules/java/system-out-println.ts"() {
     "use strict";
     init_rule();
     PRINTLN_REGEX = /System\.out\.println\s*\(/g;
-    DEFAULT_THRESHOLD = 1;
+    DEFAULT_THRESHOLD2 = 1;
     javaSystemOutPrintlnRule = createRule({
       id: "java/system-out-println",
       category: "typo",
@@ -30923,7 +31153,7 @@ var init_system_out_println = __esm({
       aiSpecific: true,
       description: "System.out.println in production code \u2014 use a logger (SLF4J, Log4j, etc.)",
       create(_context) {
-        return { threshold: DEFAULT_THRESHOLD };
+        return { threshold: DEFAULT_THRESHOLD2 };
       },
       analyze(context, facts) {
         const issues = [];
@@ -30958,6 +31188,63 @@ var init_system_out_println = __esm({
   }
 });
 
+// src/rules/java/verbose-javadoc.ts
+var TAG_REGEX, DEFAULT_TAG_THRESHOLD, DEFAULT_BODY_LENGTH_CAP, javaVerboseJavadocRule;
+var init_verbose_javadoc = __esm({
+  "src/rules/java/verbose-javadoc.ts"() {
+    "use strict";
+    init_rule();
+    TAG_REGEX = /@(param|return|throws)\b/g;
+    DEFAULT_TAG_THRESHOLD = 3;
+    DEFAULT_BODY_LENGTH_CAP = 5;
+    javaVerboseJavadocRule = createRule({
+      id: "java/verbose-javadoc",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      description: "Excessive Javadoc tags on trivial methods \u2014 over-documentation is an AI fingerprint",
+      create(_context) {
+        return {
+          tagThreshold: DEFAULT_TAG_THRESHOLD,
+          bodyLengthCap: DEFAULT_BODY_LENGTH_CAP
+        };
+      },
+      analyze(context, facts) {
+        const issues = [];
+        const source = facts.v2?._source;
+        if (!source) return issues;
+        if (!/\.java$/i.test(facts.filePath)) return issues;
+        TAG_REGEX.lastIndex = 0;
+        let tagCount = 0;
+        let firstTagLine = 0;
+        let m;
+        while ((m = TAG_REGEX.exec(source)) !== null) {
+          tagCount++;
+          if (firstTagLine === 0) {
+            firstTagLine = source.slice(0, m.index).split("\n").length;
+          }
+        }
+        if (tagCount < context.tagThreshold) return issues;
+        const lineCount = source.split("\n").length;
+        const tagDensity = tagCount / Math.max(lineCount, 1);
+        if (tagDensity < 0.05) return issues;
+        if (lineCount > 200) return issues;
+        issues.push({
+          ruleId: "java/verbose-javadoc",
+          category: "typo",
+          severity: "low",
+          aiSpecific: true,
+          message: `${tagCount} Javadoc tags in ${lineCount} lines (density ${(tagDensity * 100).toFixed(1)}%) \u2014 likely over-documented`,
+          line: firstTagLine,
+          column: 1,
+          advice: "Skip Javadoc on trivial methods (getters, setters, builders). AI agents default to over-documentation because their training data has countless textbook Javadoc examples. Real Java code limits Javadoc to public API surface. Reference: java/verbose-javadoc v0.26.0."
+        });
+        return issues;
+      }
+    });
+  }
+});
+
 // src/rules/kotlin/coroutine-global-scope.ts
 var GLOBAL_SCOPE_REGEX, kotlinCoroutineGlobalScopeRule;
 var init_coroutine_global_scope = __esm({
@@ -31122,13 +31409,13 @@ var init_object_singleton_misuse = __esm({
 });
 
 // src/rules/kotlin/println-debug.ts
-var PRINTLN_REGEX2, DEFAULT_THRESHOLD2, kotlinPrintlnDebugRule;
+var PRINTLN_REGEX2, DEFAULT_THRESHOLD3, kotlinPrintlnDebugRule;
 var init_println_debug = __esm({
   "src/rules/kotlin/println-debug.ts"() {
     "use strict";
     init_rule();
     PRINTLN_REGEX2 = /^\s*println\s*\(/gm;
-    DEFAULT_THRESHOLD2 = 1;
+    DEFAULT_THRESHOLD3 = 1;
     kotlinPrintlnDebugRule = createRule({
       id: "kotlin/println-debug",
       category: "typo",
@@ -31136,7 +31423,7 @@ var init_println_debug = __esm({
       aiSpecific: true,
       description: "println(...) in production code \u2014 use Timber, android.util.Log, or an SLF4J facade",
       create(_context) {
-        return { threshold: DEFAULT_THRESHOLD2 };
+        return { threshold: DEFAULT_THRESHOLD3 };
       },
       analyze(context, facts) {
         const issues = [];
@@ -40841,13 +41128,13 @@ var init_implicitly_unwrapped_optional = __esm({
 });
 
 // src/rules/swift/print-debug.ts
-var PRINT_REGEX, DEFAULT_THRESHOLD3, swiftPrintDebugRule;
+var PRINT_REGEX, DEFAULT_THRESHOLD4, swiftPrintDebugRule;
 var init_print_debug = __esm({
   "src/rules/swift/print-debug.ts"() {
     "use strict";
     init_rule();
     PRINT_REGEX = /\bprint\s*\(/g;
-    DEFAULT_THRESHOLD3 = 1;
+    DEFAULT_THRESHOLD4 = 1;
     swiftPrintDebugRule = createRule({
       id: "swift/print-debug",
       category: "typo",
@@ -40855,7 +41142,7 @@ var init_print_debug = __esm({
       aiSpecific: true,
       description: "print(...) in production Swift \u2014 use Logger (os.log) for level-controlled output",
       create(_context) {
-        return { threshold: DEFAULT_THRESHOLD3 };
+        return { threshold: DEFAULT_THRESHOLD4 };
       },
       analyze(context, facts) {
         const issues = [];
@@ -46606,11 +46893,16 @@ var init_builtins = __esm({
     init_nil_slice_vs_empty();
     init_struct_tag_inconsistency();
     init_arraylist_vs_linkedlist();
+    init_builder_overuse();
     init_empty_catch_block();
+    init_immutable_collection_preference();
     init_legacy_date_api();
+    init_optional_overuse();
     init_raw_type_overuse();
+    init_stream_overuse();
     init_string_concat_loop();
     init_system_out_println();
+    init_verbose_javadoc();
     init_coroutine_global_scope();
     init_data_class_defaults_overuse();
     init_object_singleton_misuse();
@@ -46741,11 +47033,16 @@ var init_builtins = __esm({
       goNilSliceVsEmptyRule,
       goStructTagInconsistencyRule,
       javaArraylistVsLinkedlistRule,
+      javaBuilderOveruseRule,
       javaEmptyCatchBlockRule,
+      javaImmutableCollectionPreferenceRule,
       javaLegacyDateApiRule,
+      javaOptionalOveruseRule,
       javaRawTypeOveruseRule,
+      javaStreamOveruseRule,
       javaStringConcatLoopRule,
       javaSystemOutPrintlnRule,
+      javaVerboseJavadocRule,
       kotlinCoroutineGlobalScopeRule,
       kotlinDataClassDefaultsOveruseRule,
       kotlinObjectSingletonMisuseRule,
@@ -49984,6 +50281,86 @@ var init_signal_strength = __esm({
         _v9Precision: 0.0657,
         defaultOff: true
       },
+      "java/verbose-javadoc": {
+        recall: 0,
+        fpRate: 0,
+        ratio: 1,
+        precision: 0,
+        lastCalibratedAt: "2026-07-03T00:00:00Z",
+        verdict: "DORMANT",
+        _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a small Java file (< 200 lines) has 3+ Javadoc tags with density >= 0.05. Calibration pending v9 Java corpus re-run; placeholder values until then. v0.20.0: anti-pattern design was wrong (humans write more Javadoc on trivial methods because their training data has it). v0.26.0: redesigned as positive signal (AI over-documents trivial methods). Reference: java/verbose-javadoc v0.26.0.",
+        aiSpecific: true,
+        _v9Verdict: "DORMANT",
+        _v9Lift: 1,
+        _v9Recall: 0,
+        _v9FpRate: 0,
+        _v9Precision: 0,
+        defaultOff: true
+      },
+      "java/optional-overuse": {
+        recall: 0,
+        fpRate: 0,
+        ratio: 1,
+        precision: 0,
+        lastCalibratedAt: "2026-07-03T00:00:00Z",
+        verdict: "DORMANT",
+        _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a Java file has 2+ .orElseThrow() calls AND 0 Objects.requireNonNull()/null checks (optionalRatio > 0.6). Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI chains Optional.ofNullable().orElseThrow() where null checks would be cleaner). Reference: java/optional-overuse v0.26.0.",
+        aiSpecific: true,
+        _v9Verdict: "DORMANT",
+        _v9Lift: 1,
+        _v9Recall: 0,
+        _v9FpRate: 0,
+        _v9Precision: 0,
+        defaultOff: true
+      },
+      "java/immutable-collection-preference": {
+        recall: 0,
+        fpRate: 0,
+        ratio: 1,
+        precision: 0,
+        lastCalibratedAt: "2026-07-03T00:00:00Z",
+        verdict: "DORMANT",
+        _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a Java file has 5+ List.of/Map.of/Set.of calls AND < 1 new ArrayList/HashMap/HashSet/LinkedList/TreeMap calls. Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI defaults to immutable factory methods). Reference: java/immutable-collection-preference v0.26.0.",
+        aiSpecific: true,
+        _v9Verdict: "DORMANT",
+        _v9Lift: 1,
+        _v9Recall: 0,
+        _v9FpRate: 0,
+        _v9Precision: 0,
+        defaultOff: true
+      },
+      "java/builder-overuse": {
+        recall: 0,
+        fpRate: 0,
+        ratio: 1,
+        precision: 0,
+        lastCalibratedAt: "2026-07-03T00:00:00Z",
+        verdict: "DORMANT",
+        _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when @Builder annotation (Lombok) is used on a class with <= 3 fields. Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI defaults to Builder pattern even for simple data classes). Reference: java/builder-overuse v0.26.0.",
+        aiSpecific: true,
+        _v9Verdict: "DORMANT",
+        _v9Lift: 1,
+        _v9Recall: 0,
+        _v9FpRate: 0,
+        _v9Precision: 0,
+        defaultOff: true
+      },
+      "java/stream-overuse": {
+        recall: 0,
+        fpRate: 0,
+        ratio: 1,
+        precision: 0,
+        lastCalibratedAt: "2026-07-03T00:00:00Z",
+        verdict: "DORMANT",
+        _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a single line has 3+ Stream API operations (.map, .filter, .flatMap, .collect, .reduce, .sorted, .distinct, .limit, .skip, .anyMatch, .allMatch, .noneMatch, .findFirst, .findAny). Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI chains Stream API for everything). Reference: java/stream-overuse v0.26.0.",
+        aiSpecific: true,
+        _v9Verdict: "DORMANT",
+        _v9Lift: 1,
+        _v9Recall: 0,
+        _v9FpRate: 0,
+        _v9Precision: 0,
+        defaultOff: true
+      },
       "java/raw-type-overuse": {
         recall: 0.1093,
         fpRate: 0.2041,
@@ -59601,6 +59978,11 @@ var RULE_HINTS = {
   "java/legacy-date-api": "Replace `java.util.Date` / `Calendar` with `java.time` (`LocalDate`, `LocalDateTime`, `Instant`, `ZonedDateTime`). java.time is immutable and thread-safe. AI agents default to the legacy API.",
   "java/raw-type-overuse": "Replace raw `List` / `Map` / `Set` with the parameterized form. Raw types disable generic type checking (Effective Java, Item 23). AI agents default to raw types when unsure of the correct generic parameters.",
   "java/string-concat-loop": "Declare a `StringBuilder` outside the loop: `StringBuilder sb = new StringBuilder(); sb.append(...);` then `return sb.toString();` after. String concat in a loop is O(n\xB2).",
+  "java/verbose-javadoc": "Skip Javadoc on trivial methods (getters, setters, builders). AI over-documents; real Java limits Javadoc to public API surface. (v0.26.0 \u2014 DORMANT.)",
+  "java/optional-overuse": "Use Objects.requireNonNull(x) for null checks; reserve Optional for return values. AI chains .ofNullable().orElseThrow() where null checks suffice. (v0.26.0 \u2014 DORMANT.)",
+  "java/immutable-collection-preference": "Prefer mutable (new ArrayList<>()) when the collection will be modified. AI defaults to List.of/Map.of/Set.of; real Java uses mutable. (v0.26.0 \u2014 DORMANT.)",
+  "java/builder-overuse": "Use a plain constructor for classes with \u2264 3 fields. AI defaults to @Builder; Builder adds Lombok dep and a Builder inner class per class. (v0.26.0 \u2014 DORMANT.)",
+  "java/stream-overuse": "Prefer a for-loop for simple transformations. AI chains Stream API for everything; for small collections a for-loop is faster. (v0.26.0 \u2014 DORMANT.)",
   // v0.24.0 — Kotlin rules (DORMANT until v9 Kotlin corpus calibration)
   "kotlin/data-class-defaults-overuse": "Audit which fields are genuinely optional. Real Kotlin uses defaults sparingly (1-2 callbacks, the rest required). v0.24.0 \u2014 DORMANT until v9 calibration.",
   "kotlin/coroutine-global-scope": "Replace with `viewModelScope.launch { ... }`, `lifecycleScope.launch { ... }`, or `coroutineScope { ... }`. GlobalScope bypasses cancellation. (v0.24.0 \u2014 DORMANT.)",