outcome-cli 1.0.0

package/src/eval/validators.property.test.ts

@@ -0,0 +1,1118 @@
+/**
+ * Property-based tests for Buying Intent Validation
+ *
+ * **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+ * **Validates: Requirements 8.1**
+ *
+ * Property 14: Buying Intent Validation
+ * *For any* message string, the buying intent validator SHALL return true
+ * if and only if the message contains at least one of the keywords:
+ * "pricing", "demo", "next steps".
+ */
+
+import { describe, test, expect } from 'vitest';
+import * as fc from 'fast-check';
+import { validateBuyingIntent, validateCompanySize, validateRole } from './validators.js';
+
+/** The standard buying intent keywords per Requirements 8.1 */
+const BUYING_INTENT_KEYWORDS = ['pricing', 'demo', 'next steps'];
+
+describe('Buying Intent Validation - Property Tests', () => {
+  // **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+  test('messages containing at least one keyword are valid', () => {
+    fc.assert(
+      fc.property(
+        fc.string(),
+        fc.constantFrom(...BUYING_INTENT_KEYWORDS),
+        fc.string(),
+        (prefix, keyword, suffix) => {
+          // Construct a message that definitely contains the keyword
+          const message = `${prefix}${keyword}${suffix}`;
+          const result = validateBuyingIntent(message, BUYING_INTENT_KEYWORDS);
+          expect(result.valid).toBe(true);
+          expect(result.errors).toHaveLength(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+  test('messages without any keywords are invalid', () => {
+    // Generate strings that definitely don't contain any keywords
+    const noKeywordStringArb = fc
+      .string()
+      .filter((s) => {
+        const lower = s.toLowerCase();
+        return !BUYING_INTENT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+      });
+
+    fc.assert(
+      fc.property(noKeywordStringArb, (message) => {
+        const result = validateBuyingIntent(message, BUYING_INTENT_KEYWORDS);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+  test('keyword matching is case-insensitive', () => {
+    // Generate case variations of keywords
+    const caseVariationArb = fc
+      .constantFrom(...BUYING_INTENT_KEYWORDS)
+      .chain((keyword) =>
+        fc.array(fc.boolean(), { minLength: keyword.length, maxLength: keyword.length }).map(
+          (upperFlags) =>
+            keyword
+              .split('')
+              .map((char, i) => (upperFlags[i] ? char.toUpperCase() : char.toLowerCase()))
+              .join('')
+        )
+      );
+
+    fc.assert(
+      fc.property(fc.string(), caseVariationArb, fc.string(), (prefix, keyword, suffix) => {
+        const message = `${prefix}${keyword}${suffix}`;
+        const result = validateBuyingIntent(message, BUYING_INTENT_KEYWORDS);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(fc.string(), (message) => {
+        const result1 = validateBuyingIntent(message, BUYING_INTENT_KEYWORDS);
+        const result2 = validateBuyingIntent(message, BUYING_INTENT_KEYWORDS);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+  test('empty message without keywords is invalid', () => {
+    const result = validateBuyingIntent('', BUYING_INTENT_KEYWORDS);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 14: Buying Intent Validation**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(fc.string(), (message) => {
+        const result = validateBuyingIntent(message, BUYING_INTENT_KEYWORDS);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+});
+
+
+/**
+ * Property-based tests for Company Size Validation
+ *
+ * **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+ * **Validates: Requirements 8.2**
+ *
+ * Property 15: Company Size Validation
+ * *For any* company size value, the company size validator SHALL return true
+ * if and only if the value is greater than or equal to 50.
+ */
+
+/** The minimum company size threshold per Requirements 8.2 */
+const MINIMUM_COMPANY_SIZE = 50;
+
+describe('Company Size Validation - Property Tests', () => {
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('company sizes >= minimum are valid', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: MINIMUM_COMPANY_SIZE, max: 1000000 }),
+        (size) => {
+          const result = validateCompanySize(size, MINIMUM_COMPANY_SIZE);
+          expect(result.valid).toBe(true);
+          expect(result.errors).toHaveLength(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('company sizes < minimum are invalid', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: MINIMUM_COMPANY_SIZE - 1 }),
+        (size) => {
+          const result = validateCompanySize(size, MINIMUM_COMPANY_SIZE);
+          expect(result.valid).toBe(false);
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('boundary value: exactly minimum is valid', () => {
+    const result = validateCompanySize(MINIMUM_COMPANY_SIZE, MINIMUM_COMPANY_SIZE);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('boundary value: one below minimum is invalid', () => {
+    const result = validateCompanySize(MINIMUM_COMPANY_SIZE - 1, MINIMUM_COMPANY_SIZE);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 1000000 }),
+        (size) => {
+          const result1 = validateCompanySize(size, MINIMUM_COMPANY_SIZE);
+          const result2 = validateCompanySize(size, MINIMUM_COMPANY_SIZE);
+          expect(result1.valid).toBe(result2.valid);
+          expect(result1.errors).toEqual(result2.errors);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 1000000 }),
+        (size) => {
+          const result = validateCompanySize(size, MINIMUM_COMPANY_SIZE);
+          // Result must have valid boolean and errors array
+          expect(typeof result.valid).toBe('boolean');
+          expect(Array.isArray(result.errors)).toBe(true);
+          // If valid, errors should be empty; if invalid, errors should have content
+          if (result.valid) {
+            expect(result.errors).toHaveLength(0);
+          } else {
+            expect(result.errors.length).toBeGreaterThan(0);
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 15: Company Size Validation**
+  test('works with different minimum thresholds', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 10000 }),
+        fc.integer({ min: 0, max: 100000 }),
+        (minimum, size) => {
+          const result = validateCompanySize(size, minimum);
+          // The property: valid iff size >= minimum
+          expect(result.valid).toBe(size >= minimum);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});
+
+
+/**
+ * Property-based tests for Role Exclusion Validation
+ *
+ * **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+ * **Validates: Requirements 8.3**
+ *
+ * Property 16: Role Exclusion Validation
+ * *For any* role string, the role validator SHALL return true
+ * if and only if the role (case-insensitive) is not "intern" or "student".
+ */
+
+/** The excluded roles per Requirements 8.3 */
+const EXCLUDED_ROLES = ['intern', 'student'];
+
+describe('Role Exclusion Validation - Property Tests', () => {
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('roles not in excluded list are valid', () => {
+    // Generate role strings that are not excluded
+    const validRoleArb = fc
+      .string({ minLength: 1 })
+      .filter((role) => {
+        const lowerRole = role.toLowerCase().trim();
+        return !EXCLUDED_ROLES.some((excluded) => lowerRole === excluded.toLowerCase());
+      });
+
+    fc.assert(
+      fc.property(validRoleArb, (role) => {
+        const result = validateRole(role, EXCLUDED_ROLES);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('excluded roles are invalid', () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...EXCLUDED_ROLES),
+        (role) => {
+          const result = validateRole(role, EXCLUDED_ROLES);
+          expect(result.valid).toBe(false);
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('role matching is case-insensitive', () => {
+    // Generate case variations of excluded roles
+    const caseVariationArb = fc
+      .constantFrom(...EXCLUDED_ROLES)
+      .chain((role) =>
+        fc.array(fc.boolean(), { minLength: role.length, maxLength: role.length }).map(
+          (upperFlags) =>
+            role
+              .split('')
+              .map((char, i) => (upperFlags[i] ? char.toUpperCase() : char.toLowerCase()))
+              .join('')
+        )
+      );
+
+    fc.assert(
+      fc.property(caseVariationArb, (role) => {
+        const result = validateRole(role, EXCLUDED_ROLES);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(fc.string(), (role) => {
+        const result1 = validateRole(role, EXCLUDED_ROLES);
+        const result2 = validateRole(role, EXCLUDED_ROLES);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(fc.string(), (role) => {
+        const result = validateRole(role, EXCLUDED_ROLES);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('common valid roles pass validation', () => {
+    const validRoles = [
+      'Engineering Manager',
+      'Software Engineer',
+      'CEO',
+      'CTO',
+      'Product Manager',
+      'Director',
+      'VP of Sales',
+      'Founder',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...validRoles), (role) => {
+        const result = validateRole(role, EXCLUDED_ROLES);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('roles containing excluded words as substrings are valid', () => {
+    // Roles that contain "intern" or "student" as substrings but are not exact matches
+    const substringRoles = [
+      'Internal Affairs',
+      'International Sales',
+      'Student Affairs Director',
+      'Internship Coordinator',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...substringRoles), (role) => {
+        const result = validateRole(role, EXCLUDED_ROLES);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 16: Role Exclusion Validation**
+  test('whitespace-trimmed excluded roles are invalid', () => {
+    // Excluded roles with leading/trailing whitespace
+    const paddedExcludedRoles = [
+      '  intern',
+      'intern  ',
+      '  intern  ',
+      '  student',
+      'student  ',
+      '  student  ',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...paddedExcludedRoles), (role) => {
+        const result = validateRole(role, EXCLUDED_ROLES);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+});
+
+
+/**
+ * Property-based tests for Message Length Validation
+ *
+ * **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+ * **Validates: Requirements 8.4**
+ *
+ * Property 17: Message Length Validation
+ * *For any* message string, the message length validator SHALL return true
+ * if and only if the word count is greater than or equal to 20.
+ */
+
+import { validateMessageLength } from './validators.js';
+
+/** The minimum word count per Requirements 8.4 */
+const MINIMUM_WORD_COUNT = 20;
+
+describe('Message Length Validation - Property Tests', () => {
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('messages with >= minimum words are valid', () => {
+    // Generate arrays of words with at least MINIMUM_WORD_COUNT words
+    const validMessageArb = fc
+      .array(fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0 && !/\s/.test(s)), {
+        minLength: MINIMUM_WORD_COUNT,
+        maxLength: 100,
+      })
+      .map((words) => words.join(' '));
+
+    fc.assert(
+      fc.property(validMessageArb, (message) => {
+        const result = validateMessageLength(message, MINIMUM_WORD_COUNT);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('messages with < minimum words are invalid', () => {
+    // Generate arrays of words with fewer than MINIMUM_WORD_COUNT words
+    const shortMessageArb = fc
+      .array(fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0 && !/\s/.test(s)), {
+        minLength: 0,
+        maxLength: MINIMUM_WORD_COUNT - 1,
+      })
+      .map((words) => words.join(' '));
+
+    fc.assert(
+      fc.property(shortMessageArb, (message) => {
+        const result = validateMessageLength(message, MINIMUM_WORD_COUNT);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('boundary value: exactly minimum words is valid', () => {
+    const words = Array(MINIMUM_WORD_COUNT).fill('word');
+    const message = words.join(' ');
+    const result = validateMessageLength(message, MINIMUM_WORD_COUNT);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('boundary value: one below minimum words is invalid', () => {
+    const words = Array(MINIMUM_WORD_COUNT - 1).fill('word');
+    const message = words.join(' ');
+    const result = validateMessageLength(message, MINIMUM_WORD_COUNT);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(fc.string(), (message) => {
+        const result1 = validateMessageLength(message, MINIMUM_WORD_COUNT);
+        const result2 = validateMessageLength(message, MINIMUM_WORD_COUNT);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(fc.string(), (message) => {
+        const result = validateMessageLength(message, MINIMUM_WORD_COUNT);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('empty message is invalid', () => {
+    const result = validateMessageLength('', MINIMUM_WORD_COUNT);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('whitespace-only message is invalid', () => {
+    fc.assert(
+      fc.property(
+        fc.array(fc.constantFrom(' ', '\t', '\n', '\r'), { minLength: 1, maxLength: 50 }).map(
+          (chars) => chars.join('')
+        ),
+        (whitespace) => {
+          const result = validateMessageLength(whitespace, MINIMUM_WORD_COUNT);
+          expect(result.valid).toBe(false);
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 17: Message Length Validation**
+  test('works with different minimum thresholds', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 50 }),
+        fc.array(fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0 && !/\s/.test(s)), {
+          minLength: 0,
+          maxLength: 100,
+        }),
+        (minWords, words) => {
+          const message = words.join(' ');
+          const result = validateMessageLength(message, minWords);
+          // The property: valid iff word count >= minWords
+          expect(result.valid).toBe(words.length >= minWords);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});
+
+
+/**
+ * Property-based tests for Email Syntax Validation
+ *
+ * **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+ * **Validates: Requirements 8.5**
+ *
+ * Property 18: Email Syntax Validation
+ * *For any* email string, the email validator SHALL return true
+ * if and only if the string matches a valid email syntax pattern.
+ */
+
+import { validateEmail } from './validators.js';
+
+/**
+ * Custom arbitrary for emails matching the validator's regex pattern:
+ * /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+ */
+const validEmailArb = fc
+  .tuple(
+    // Local part: alphanumeric, dots, underscores, percent, plus, hyphens
+    fc.stringMatching(/^[a-zA-Z0-9._%+-]+$/).filter((s) => s.length > 0),
+    // Domain: alphanumeric and hyphens with dots
+    fc.stringMatching(/^[a-zA-Z0-9-]+$/).filter((s) => s.length > 0),
+    // TLD: at least 2 alphabetic characters
+    fc.stringMatching(/^[a-zA-Z]{2,6}$/)
+  )
+  .map(([local, domain, tld]) => `${local}@${domain}.${tld}`);
+
+describe('Email Syntax Validation - Property Tests', () => {
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('valid email addresses pass validation', () => {
+    fc.assert(
+      fc.property(validEmailArb, (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('strings without @ symbol are invalid', () => {
+    const noAtSymbolArb = fc.string().filter((s) => !s.includes('@'));
+
+    fc.assert(
+      fc.property(noAtSymbolArb, (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('strings with multiple @ symbols are invalid', () => {
+    // Generate strings with at least 2 @ symbols
+    const multipleAtArb = fc
+      .tuple(fc.string(), fc.string(), fc.string())
+      .map(([a, b, c]) => `${a}@${b}@${c}`);
+
+    fc.assert(
+      fc.property(multipleAtArb, (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('strings without domain TLD are invalid', () => {
+    // Generate strings with @ but no dot in domain
+    const noDotDomainArb = fc
+      .tuple(
+        fc.stringMatching(/^[a-zA-Z0-9._%+-]+$/),
+        fc.stringMatching(/^[a-zA-Z0-9-]+$/)
+      )
+      .filter(([local, domain]) => local.length > 0 && domain.length > 0)
+      .map(([local, domain]) => `${local}@${domain}`);
+
+    fc.assert(
+      fc.property(noDotDomainArb, (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(fc.string(), (email) => {
+        const result1 = validateEmail(email);
+        const result2 = validateEmail(email);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(fc.string(), (email) => {
+        const result = validateEmail(email);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('empty string is invalid', () => {
+    const result = validateEmail('');
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('common valid email formats pass validation', () => {
+    const validEmails = [
+      'user@example.com',
+      'user.name@example.com',
+      'user+tag@example.com',
+      'user_name@example.co.uk',
+      'user123@subdomain.example.org',
+      'first.last@company.io',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...validEmails), (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('common invalid email formats fail validation', () => {
+    const invalidEmails = [
+      'plainaddress',
+      '@missinglocal.com',
+      'missing@.com',
+      'missing@domain.',
+      'spaces in@email.com',
+      'email@domain',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...invalidEmails), (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 18: Email Syntax Validation**
+  test('TLD must be at least 2 characters', () => {
+    // Generate emails with single-character TLDs
+    const shortTldArb = fc
+      .tuple(
+        fc.stringMatching(/^[a-zA-Z0-9._%+-]+$/).filter((s) => s.length > 0),
+        fc.stringMatching(/^[a-zA-Z0-9-]+$/).filter((s) => s.length > 0),
+        fc.stringMatching(/^[a-zA-Z]$/)
+      )
+      .map(([local, domain, tld]) => `${local}@${domain}.${tld}`);
+
+    fc.assert(
+      fc.property(shortTldArb, (email) => {
+        const result = validateEmail(email);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+});
+
+/**
+ * Property-based tests for LinkedIn URL Validation
+ *
+ * **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+ * **Validates: Requirements 1.1**
+ *
+ * Property 1: Tournament validator completeness
+ * *For any* LinkedIn URL string, the LinkedIn validator SHALL return true
+ * if and only if the URL starts with "https://www.linkedin.com/in/".
+ */
+
+import { validateLinkedIn, validateLeadGenPrecision } from './validators.js';
+
+/** The required LinkedIn URL prefix per Requirements 2.7, 4.6 */
+const LINKEDIN_PREFIX = 'https://www.linkedin.com/in/';
+
+describe('LinkedIn URL Validation - Property Tests', () => {
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('URLs with correct prefix are valid', () => {
+    // Generate LinkedIn URLs with the correct prefix
+    const validLinkedInArb = fc
+      .string({ minLength: 1 })
+      .map((suffix) => `${LINKEDIN_PREFIX}${suffix}`);
+
+    fc.assert(
+      fc.property(validLinkedInArb, (linkedIn) => {
+        const result = validateLinkedIn(linkedIn);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('URLs without correct prefix are invalid', () => {
+    // Generate URLs that don't start with the correct prefix
+    const invalidLinkedInArb = fc
+      .string()
+      .filter((url) => !url.startsWith(LINKEDIN_PREFIX));
+
+    fc.assert(
+      fc.property(invalidLinkedInArb, (linkedIn) => {
+        const result = validateLinkedIn(linkedIn);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors[0]).toContain('Invalid LinkedIn URL');
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(fc.string(), (linkedIn) => {
+        const result1 = validateLinkedIn(linkedIn);
+        const result2 = validateLinkedIn(linkedIn);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(fc.string(), (linkedIn) => {
+        const result = validateLinkedIn(linkedIn);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('empty string is invalid', () => {
+    const result = validateLinkedIn('');
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('common valid LinkedIn URLs pass validation', () => {
+    const validLinkedInUrls = [
+      'https://www.linkedin.com/in/johndoe',
+      'https://www.linkedin.com/in/jane-smith-123',
+      'https://www.linkedin.com/in/user_name',
+      'https://www.linkedin.com/in/first-last-456789',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...validLinkedInUrls), (linkedIn) => {
+        const result = validateLinkedIn(linkedIn);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('common invalid LinkedIn URLs fail validation', () => {
+    const invalidLinkedInUrls = [
+      'http://www.linkedin.com/in/johndoe', // http instead of https
+      'https://linkedin.com/in/johndoe', // missing www
+      'https://www.linkedin.com/johndoe', // missing /in/
+      'https://www.facebook.com/johndoe', // wrong domain
+      'www.linkedin.com/in/johndoe', // missing protocol
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...invalidLinkedInUrls), (linkedIn) => {
+        const result = validateLinkedIn(linkedIn);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('prefix matching is case-sensitive', () => {
+    // Generate case variations of the prefix (should all be invalid except exact match)
+    const caseVariations = [
+      'HTTPS://WWW.LINKEDIN.COM/IN/',
+      'https://WWW.linkedin.com/in/',
+      'https://www.LINKEDIN.com/in/',
+      'https://www.linkedin.COM/in/',
+      'https://www.linkedin.com/IN/',
+    ];
+
+    fc.assert(
+      fc.property(fc.constantFrom(...caseVariations), fc.string(), (prefix, suffix) => {
+        const linkedIn = `${prefix}${suffix}`;
+        const result = validateLinkedIn(linkedIn);
+        // Only the exact prefix should be valid
+        if (prefix === LINKEDIN_PREFIX) {
+          expect(result.valid).toBe(true);
+        } else {
+          expect(result.valid).toBe(false);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+});
+
+
+/**
+ * Property-based tests for Lead Generation Precision Validation
+ *
+ * **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+ * **Validates: Requirements 1.1**
+ *
+ * Property 1: Tournament validator completeness (continued)
+ * *For any* lead generation artifact, the composite validator SHALL return true
+ * if and only if ALL criteria are met: valid email, company size >= 50, 
+ * non-excluded role, and valid LinkedIn URL.
+ */
+
+/** Lead generation artifact arbitrary for property testing */
+const leadGenArtifactArb = fc.record({
+  email: fc.emailAddress(),
+  companySize: fc.integer({ min: 1, max: 10000 }),
+  role: fc.string({ minLength: 1, maxLength: 50 }),
+  linkedIn: fc.string({ minLength: 1, maxLength: 100 }),
+});
+
+/** Valid lead generation artifact arbitrary */
+const validLeadGenArtifactArb = fc.record({
+  email: fc.emailAddress(),
+  companySize: fc.integer({ min: 50, max: 10000 }),
+  role: fc.string({ minLength: 1, maxLength: 50 }).filter((role) => {
+    const lowerRole = role.toLowerCase().trim();
+    return !['intern', 'student'].includes(lowerRole);
+  }),
+  linkedIn: fc.string({ minLength: 1 }).map((suffix) => `${LINKEDIN_PREFIX}${suffix}`),
+});
+
+describe('Lead Generation Precision Validation - Property Tests', () => {
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('artifacts meeting all criteria are valid', () => {
+    fc.assert(
+      fc.property(validLeadGenArtifactArb, (artifact) => {
+        const result = validateLeadGenPrecision(artifact);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('artifacts with invalid email are invalid', () => {
+    const invalidEmailArtifactArb = validLeadGenArtifactArb.map((artifact) => ({
+      ...artifact,
+      email: 'invalid-email-format', // Invalid email
+    }));
+
+    fc.assert(
+      fc.property(invalidEmailArtifactArb, (artifact) => {
+        const result = validateLeadGenPrecision(artifact);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors.some((error) => error.includes('Invalid email format'))).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('artifacts with company size < 50 are invalid', () => {
+    const smallCompanyArtifactArb = validLeadGenArtifactArb.map((artifact) => ({
+      ...artifact,
+      companySize: fc.sample(fc.integer({ min: 1, max: 49 }), 1)[0], // Company size < 50
+    }));
+
+    fc.assert(
+      fc.property(smallCompanyArtifactArb, (artifact) => {
+        const result = validateLeadGenPrecision(artifact);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors.some((error) => error.includes('Company too small'))).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('artifacts with excluded roles are invalid', () => {
+    const excludedRoleArtifactArb = validLeadGenArtifactArb.map((artifact) => ({
+      ...artifact,
+      role: fc.sample(fc.constantFrom('intern', 'student', 'INTERN', 'Student'), 1)[0], // Excluded role
+    }));
+
+    fc.assert(
+      fc.property(excludedRoleArtifactArb, (artifact) => {
+        const result = validateLeadGenPrecision(artifact);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors.some((error) => error.includes('Invalid role'))).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('artifacts with invalid LinkedIn URL are invalid', () => {
+    const invalidLinkedInArtifactArb = validLeadGenArtifactArb.map((artifact) => ({
+      ...artifact,
+      linkedIn: 'https://www.facebook.com/profile', // Invalid LinkedIn URL
+    }));
+
+    fc.assert(
+      fc.property(invalidLinkedInArtifactArb, (artifact) => {
+        const result = validateLeadGenPrecision(artifact);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors.some((error) => error.includes('Invalid LinkedIn URL'))).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(leadGenArtifactArb, (artifact) => {
+        const result1 = validateLeadGenPrecision(artifact);
+        const result2 = validateLeadGenPrecision(artifact);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(leadGenArtifactArb, (artifact) => {
+        const result = validateLeadGenPrecision(artifact);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('multiple validation errors are accumulated', () => {
+    // Create an artifact that fails all validations
+    const allInvalidArtifact = {
+      email: 'invalid-email',
+      companySize: 10, // Too small
+      role: 'intern', // Excluded role
+      linkedIn: 'https://www.facebook.com/profile', // Invalid LinkedIn
+    };
+
+    const result = validateLeadGenPrecision(allInvalidArtifact);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBe(4); // Should have 4 errors (one for each validation)
+    expect(result.errors.some((error) => error.includes('Invalid email format'))).toBe(true);
+    expect(result.errors.some((error) => error.includes('Company too small'))).toBe(true);
+    expect(result.errors.some((error) => error.includes('Invalid role'))).toBe(true);
+    expect(result.errors.some((error) => error.includes('Invalid LinkedIn URL'))).toBe(true);
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('boundary value: company size exactly 50 is valid', () => {
+    const boundaryArtifact = {
+      email: 'user@example.com',
+      companySize: 50, // Exactly at boundary
+      role: 'Manager',
+      linkedIn: 'https://www.linkedin.com/in/user',
+    };
+
+    const result = validateLeadGenPrecision(boundaryArtifact);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  // **Feature: launch-readiness-checklist, Property 1: Tournament validator completeness**
+  test('boundary value: company size 49 is invalid', () => {
+    const boundaryArtifact = {
+      email: 'user@example.com',
+      companySize: 49, // Just below boundary
+      role: 'Manager',
+      linkedIn: 'https://www.linkedin.com/in/user',
+    };
+
+    const result = validateLeadGenPrecision(boundaryArtifact);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors.some((error) => error.includes('Company too small'))).toBe(true);
+  });
+});