feat: add 3 remaining slop rules (#17) (#18)

## Summary

Completes the production audit rule set from #14. Adds the 3 remaining
rules:

- **`vacuous_property`** (should-fail): Detects `fc.property` callbacks
with `return true` paths that bypass assertions (2a), and
`fc.constant`-only generators with zero input variation (2b)
- **`no_production_call`** (should-fail): Detects tests that call no
imported production function — only builtins, operators, or language
guarantees. Includes `parseImports()` helper for import tracking.
- **`impossible_assertion`** (should-fail): Detects assertions that are
mathematically impossible to fail, e.g.
`expect(x.length).toBeGreaterThanOrEqual(0)`

Updates total rule count from 15 to 18 across presets, SKILL.md, and
pattern reference.

## Test plan

- [x] 17 new tests covering all 3 rules + `parseImports` helper
- [x] All 369 tests pass across 9 skills
- [x] Biome check clean
- [x] Preset count assertions updated from 15 to 18
- [x] SKILL.md Violation Rules table and What To Protect table updated
- [x] references/patterns.md updated with before/after examples
(patterns 16-18)

Closes #17

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: apankov1

skills/slop-test-detector/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: slop-test-detector
-description: "Static analyzer that detects 15 slop patterns in test code — tests that compile and pass but catch zero bugs."
+description: "Static analyzer that detects 18 slop patterns in test code — tests that compile and pass but catch zero bugs."
 ---
 
 # Slop Test Detector
@@ -36,6 +36,9 @@ Before auditing or generating tests, identify which slop patterns apply:
 | Tests vary their inputs | Do sibling tests exercise different code paths? | `no_input_variation`, `duplicate_assertion_set` |
 | Assertions test computed values | Are assertions checking results, not echoing construction literals? | `literal_roundtrip`, `schema_success_only` |
 | Assertions always execute | Can the test pass without any assertion running? | `conditional_assertion` |
+| Property tests are meaningful | Do fc.property callbacks assert on all paths with varied inputs? | `vacuous_property` |
+| Tests exercise production code | Does the test call an imported function, not just builtins? | `no_production_call` |
+| Assertions can actually fail | Is the assertion mathematically capable of failing? | `impossible_assertion` |
 
 ---
 
@@ -64,6 +67,7 @@ import {
   formatReport,
   formatReportJSON,
   getPreset,
+  parseImports,
   parseTestFile,
 } from './slop-detector.ts';
 ```
@@ -76,9 +80,9 @@ Three built-in presets control which rules are active:
 
 | Preset | Rules | Default threshold | Use case |
 |--------|-------|-------------------|----------|
-| `balanced` | 10 rules (no defect-comment rules) | 80 | **Default.** Conservative, low noise |
-| `strict` | All 12 rules | 90 | Teams that enforce `// Defect:` comments |
-| `advisory` | All 12 rules | 0 | Report everything, fail nothing |
+| `balanced` | 16 rules (no defect-comment rules) | 80 | **Default.** Conservative, low noise |
+| `strict` | All 18 rules | 90 | Teams that enforce `// Defect:` comments |
+| `advisory` | All 18 rules | 0 | Report everything, fail nothing |
 
 ```typescript
 import { getPreset } from './slop-detector.ts';
@@ -188,6 +192,9 @@ score = max(0, round(100 × (1 - weightedFindings / testCount)))
 | `literal_roundtrip` | Assertion compares `obj.field` to the same literal used to construct `obj` | should-fail | on |
 | `schema_success_only` | `safeParse()` result checked for `.success` but never `.data` or `.error.issues` | should-fail | on |
 | `conditional_assertion` | All assertions are inside `if`/`switch` blocks — test may silently pass | must-fail | on |
+| `vacuous_property` | `fc.property` callback has `return true` path with zero assertions, or all generators are `fc.constant` | should-fail | on |
+| `no_production_call` | Test body calls no imported production function — only builtins or language guarantees | should-fail | on |
+| `impossible_assertion` | Assertion is mathematically impossible to fail (e.g., `.length >= 0`) | should-fail | on |
 
 **opt-in** rules are only active in the `strict` preset. Use `getPreset('strict')` or add them to a custom `enabledRules` set.
 

skills/slop-test-detector/references/patterns.md

@@ -1,6 +1,6 @@
 # Slop Patterns Reference
 
-All 15 slop patterns with before (slop) and after (fixed) examples.
+All 18 slop patterns with before (slop) and after (fixed) examples.
 
 ---
 
@@ -352,3 +352,101 @@ it("handles results", () => {
   assert.equal(results[0].status, "ok");
 });
 ```
+
+---
+
+### 16. vacuous_property
+
+**Before (slop)** — `return true` path with zero assertions (2a):
+```typescript
+it('priority correctness', () => {
+  fc.assert(
+    fc.property(gameKindGen, eventTypeGen, (gameKind, eventType) => {
+      if (hasGameSpecific && isPlatformEvent) {
+        expect(result).toEqual(gameSpecificMeta);
+        return true;
+      }
+      return true;  // most inputs hit this path — 0 assertions
+    }),
+  );
+});
+```
+
+**Before (slop)** — zero-variation generators (2b):
+```typescript
+it('default constructor', () => {
+  fc.assert(
+    fc.property(fc.constant(undefined), (_ignored) => {
+      const chain = new EventHashChain();
+      expect(chain.getSemanticHash()).toBeUndefined();
+      // fc.constant = same test every run
+    }),
+  );
+});
+```
+
+**After (fixed)** — assert on all paths with real generators:
+```typescript
+it('priority correctness', () => {
+  fc.assert(
+    fc.property(gameKindGen, eventTypeGen, (gameKind, eventType) => {
+      const result = resolvePriority(gameKind, eventType);
+      expect(result).toBeDefined();
+      expect(typeof result.priority).toBe('number');
+    }),
+  );
+});
+```
+
+---
+
+### 17. no_production_call
+
+**Before (slop)** — test only exercises builtins, no production function called:
+```typescript
+it('expert-level weights must always yield negative net score', () => {
+  fc.assert(
+    fc.property(
+      fc.integer({ min: -100, max: -50 }),
+      fc.integer({ min: 20, max: 49 }),
+      (breakingPenalty, creationBonus) => {
+        const netScore = breakingPenalty + creationBonus;
+        return netScore < 0;  // pure arithmetic — no production function
+      },
+    ),
+  );
+});
+```
+
+**After (fixed)** — call the actual scoring function:
+```typescript
+it('expert-level weights must always yield negative net score', () => {
+  fc.assert(
+    fc.property(
+      fc.integer({ min: -100, max: -50 }),
+      fc.integer({ min: 20, max: 49 }),
+      (breakingPenalty, creationBonus) => {
+        const score = computeNetScore(breakingPenalty, creationBonus);
+        return score < 0;
+      },
+    ),
+  );
+});
+```
+
+---
+
+### 18. impossible_assertion
+
+**Before (slop)** — assertion that is mathematically impossible to fail:
+```typescript
+expect(Object.keys(aliasToCanonical).length).toBeGreaterThanOrEqual(0);
+// .length is always >= 0 — this CANNOT fail
+```
+
+**After (fixed)** — assert on a specific expected length:
+```typescript
+expect(Object.keys(aliasToCanonical).length).toBeGreaterThanOrEqual(1);
+// or assert the exact count:
+expect(Object.keys(aliasToCanonical)).toHaveLength(5);
+```