outcome-cli 1.0.0

package/src/outcomes/README.md

@@ -0,0 +1,75 @@
+# Outcomes Module
+
+The Outcomes module defines business outcomes as code. An **Outcome** is a declarative, deterministic definition of a business goal including success criteria, payout amount, and constraints.
+
+## Key Concepts
+
+- **Outcome**: A complete definition of what success looks like, including payout and limits
+- **SuccessCriterion**: A single verifiable condition that must be met
+- **Validator**: A pure function that evaluates whether a criterion is satisfied
+
+## Interfaces
+
+### Outcome
+
+```typescript
+interface Outcome {
+  name: string;              // Unique identifier
+  description: string;       // Human-readable description
+  payoutAmount: number;      // Payment on success (dollars)
+  maxAttempts: number;       // Max attempts per agent
+  timeLimitMs: number;       // Time limit (milliseconds)
+  successCriteria: SuccessCriterion[];  // All must pass
+  failureReasons: string[];  // Predefined failure messages
+}
+```
+
+### SuccessCriterion
+
+```typescript
+interface SuccessCriterion {
+  name: string;                    // Criterion identifier
+  validator: string;               // Validator function name
+  params: Record<string, unknown>; // Validator parameters
+}
+```
+
+## Usage
+
+```typescript
+import { Outcome, validateOutcome, isOutcome } from './outcome.schema.js';
+
+// Define an outcome
+const myOutcome: Outcome = {
+  name: 'qualified_lead',
+  description: 'Generate a qualified sales lead',
+  payoutAmount: 250,
+  maxAttempts: 5,
+  timeLimitMs: 300000,
+  successCriteria: [
+    { name: 'valid_email', validator: 'validateEmail', params: {} }
+  ],
+  failureReasons: ['Invalid email', 'Company too small']
+};
+
+// Validate before use
+const result = validateOutcome(myOutcome);
+if (!result.valid) {
+  console.error('Invalid outcome:', result.errors);
+}
+
+// Type guard usage
+if (isOutcome(unknownData)) {
+  // unknownData is now typed as Outcome
+}
+```
+
+## Requirements Reference
+
+- **Requirement 1.1**: Outcomes require name, payout, max attempts, time limit, success criteria, failure reasons
+- **Requirement 1.2**: Outcomes are validated against schema before execution
+
+## Files
+
+- `outcome.schema.ts` - Type definitions and validation
+- `qualified_sales_interest.ts` - Demo outcome implementation

package/src/outcomes/acquire-pilot-customer.ts

@@ -0,0 +1,297 @@
+/**
+ * Acquire Pilot Customer Outcome
+ *
+ * Outcome definition for the Snowdevil Hunter Squad campaign.
+ * Agents compete to find and convert B2B SaaS founders into
+ * WAI Championship pilot customers.
+ *
+ * @module outcomes/acquire-pilot-customer
+ */
+
+import type { Outcome } from './outcome.schema.js';
+
+/**
+ * Payout amount for successfully acquiring a pilot customer.
+ * Set to $50 as per Requirements 1.5.
+ */
+export const PILOT_PAYOUT_AMOUNT = 50;
+
+/**
+ * Maximum number of attempts per day per agent.
+ * Set to 50 as per Requirements 1.6.
+ */
+export const PILOT_MAX_ATTEMPTS = 50;
+
+/**
+ * Time limit for achieving the outcome (24 hours in milliseconds).
+ */
+export const PILOT_TIME_LIMIT_MS = 86400000;
+
+/**
+ * Keywords that indicate positive reply intent.
+ * Reply must contain at least one of these keywords.
+ */
+export const POSITIVE_REPLY_KEYWORDS = ['interested', 'demo', 'call', 'yes', 'tell me more'];
+
+/**
+ * Pain signals indicating Sales/SDR hiring activity.
+ */
+export const PAIN_SIGNALS = ['hiring_sdr', 'hiring_sales', 'sales_pain_tweet'];
+
+/**
+ * Minimum message length for outreach validation.
+ */
+export const MIN_OUTREACH_LENGTH = 50;
+
+/**
+ * Maximum message length for outreach validation.
+ */
+export const MAX_OUTREACH_LENGTH = 500;
+
+// ============================================================================
+// Validators
+// ============================================================================
+
+/**
+ * Email regex pattern based on RFC 5322 simplified.
+ */
+const EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+
+/**
+ * LinkedIn profile URL pattern.
+ */
+const LINKEDIN_REGEX = /^https?:\/\/(www\.)?linkedin\.com\/in\/[a-zA-Z0-9_-]+\/?$/;
+
+/**
+ * Validates contact information (email or LinkedIn URL).
+ *
+ * @param contact - The contact string to validate
+ * @param params - Validation parameters
+ * @returns True if contact is valid email or LinkedIn URL
+ *
+ * @example
+ * validateContactInfo('john@example.com', { requireEmail: true, allowLinkedIn: true }) // true
+ * validateContactInfo('https://linkedin.com/in/johndoe', { requireEmail: false, allowLinkedIn: true }) // true
+ */
+export function validateContactInfo(
+  contact: string,
+  params: { requireEmail?: boolean; allowLinkedIn?: boolean }
+): boolean {
+  if (typeof contact !== 'string' || contact.trim() === '') {
+    return false;
+  }
+
+  const trimmedContact = contact.trim();
+  const isValidEmail = EMAIL_REGEX.test(trimmedContact);
+  const isValidLinkedIn = LINKEDIN_REGEX.test(trimmedContact);
+
+  if (params.requireEmail && !params.allowLinkedIn) {
+    return isValidEmail;
+  }
+
+  if (params.allowLinkedIn) {
+    return isValidEmail || isValidLinkedIn;
+  }
+
+  return isValidEmail;
+}
+
+/**
+ * Validates pain signal detection for Sales/SDR hiring.
+ *
+ * @param companyData - Object containing job listings or signals
+ * @param params - Validation parameters with signal keywords
+ * @returns True if at least one pain signal is detected
+ *
+ * @example
+ * validatePainSignal({ jobListings: ['SDR Manager', 'Sales Rep'] }, { signals: ['hiring_sdr'] }) // true
+ */
+export function validatePainSignal(
+  companyData: { jobListings?: string[]; signals?: string[] },
+  params: { signals: string[] }
+): boolean {
+  if (typeof companyData !== 'object' || companyData === null) {
+    return false;
+  }
+
+  const painKeywords = [
+    'sdr',
+    'sales development',
+    'bdr',
+    'business development representative',
+    'account executive',
+    'sales rep',
+    'sales representative',
+    'hiring sales',
+    'hiring sdr',
+  ];
+
+  // Check job listings for pain signals
+  if (Array.isArray(companyData.jobListings)) {
+    for (const listing of companyData.jobListings) {
+      if (typeof listing === 'string') {
+        const lowerListing = listing.toLowerCase();
+        for (const keyword of painKeywords) {
+          if (lowerListing.includes(keyword)) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  // Check explicit signals
+  if (Array.isArray(companyData.signals)) {
+    for (const signal of companyData.signals) {
+      if (typeof signal === 'string' && params.signals.includes(signal)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Validates outreach message requirements.
+ *
+ * @param message - The outreach message to validate
+ * @param params - Validation parameters
+ * @returns True if message meets length and personalization requirements
+ *
+ * @example
+ * validateOutreachSent('Hello John from Acme Corp...', { minLength: 50, maxLength: 500, requirePersonalization: true }) // depends on length
+ */
+export function validateOutreachSent(
+  message: string,
+  params: { minLength: number; maxLength: number; requirePersonalization: boolean }
+): boolean {
+  if (typeof message !== 'string') {
+    return false;
+  }
+
+  const trimmedMessage = message.trim();
+  const length = trimmedMessage.length;
+
+  // Check length constraints
+  if (length < params.minLength || length > params.maxLength) {
+    return false;
+  }
+
+  // Check for personalization if required
+  if (params.requirePersonalization) {
+    // Look for personalization tokens: names, company references, specific details
+    const personalizationPatterns = [
+      /\b(hi|hello|hey)\s+[A-Z][a-z]+/i, // Greeting with name
+      /\byour\s+(company|team|product|business)/i, // Company reference
+      /\b(you|your)\s+(tweeted|posted|mentioned|said)/i, // Social reference
+      /\bI\s+(saw|noticed|read)\s+(you|your)/i, // Personal observation
+      /\b[A-Z][a-z]+\s+(Corp|Inc|LLC|Ltd|Company)/i, // Company name
+    ];
+
+    const hasPersonalization = personalizationPatterns.some((pattern) => pattern.test(trimmedMessage));
+    if (!hasPersonalization) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Validates positive reply detection.
+ *
+ * @param reply - The reply message to validate
+ * @param params - Validation parameters with positive keywords
+ * @returns True if reply contains positive intent keywords
+ *
+ * @example
+ * validatePositiveReply('Yes, I am interested in a demo', { keywords: ['interested', 'demo'] }) // true
+ */
+export function validatePositiveReply(reply: string, params: { keywords: string[] }): boolean {
+  if (typeof reply !== 'string' || reply.trim() === '') {
+    return false;
+  }
+
+  const lowerReply = reply.toLowerCase();
+
+  for (const keyword of params.keywords) {
+    if (lowerReply.includes(keyword.toLowerCase())) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// ============================================================================
+// Outcome Definition
+// ============================================================================
+
+/**
+ * Acquire Pilot Customer Outcome Definition
+ *
+ * Success requires meeting ALL 4 criteria:
+ * 1. Valid contact information (email or LinkedIn URL)
+ * 2. Pain signal verified (Sales/SDR hiring activity)
+ * 3. Outreach message sent (50-500 chars, personalized)
+ * 4. Positive reply received (contains interest keywords)
+ *
+ * @see Requirements 1.1, 1.2, 1.3, 1.4, 1.5, 1.6
+ */
+export const acquirePilotCustomerOutcome: Outcome = {
+  name: 'acquire_pilot_customer',
+  description:
+    'Find and convert a B2B SaaS founder into a WAI Championship pilot customer by identifying pain signals, sending personalized outreach, and receiving a positive reply.',
+  payoutAmount: PILOT_PAYOUT_AMOUNT,
+  maxAttempts: PILOT_MAX_ATTEMPTS,
+  timeLimitMs: PILOT_TIME_LIMIT_MS,
+  successCriteria: [
+    {
+      // Requirement 1.1: Validate email or LinkedIn URL format
+      name: 'valid_contact',
+      validator: 'validateContactInfo',
+      params: {
+        requireEmail: true,
+        allowLinkedIn: true,
+      },
+    },
+    {
+      // Requirement 1.2: Check for Sales/SDR hiring signals
+      name: 'pain_verified',
+      validator: 'validatePainSignal',
+      params: {
+        signals: PAIN_SIGNALS,
+      },
+    },
+    {
+      // Requirement 1.3: Confirm personalized message generation
+      name: 'outreach_sent',
+      validator: 'validateOutreachSent',
+      params: {
+        minLength: MIN_OUTREACH_LENGTH,
+        maxLength: MAX_OUTREACH_LENGTH,
+        requirePersonalization: true,
+      },
+    },
+    {
+      // Requirement 1.4: Detect positive reply as win condition
+      name: 'positive_reply',
+      validator: 'validatePositiveReply',
+      params: {
+        keywords: POSITIVE_REPLY_KEYWORDS,
+      },
+    },
+  ],
+  failureReasons: [
+    'invalid_contact',
+    'no_pain_signal',
+    'outreach_rejected',
+    'no_reply',
+    'negative_reply',
+    'budget_exceeded',
+    'rate_limited',
+  ],
+};
+
+export default acquirePilotCustomerOutcome;

package/src/outcomes/code-delivery-outcomes.ts

@@ -0,0 +1,89 @@
+/**
+ * Code Delivery Outcomes - Outcome-based code generation definitions
+ *
+ * Defines outcome schemas for feature implementation, refactor, and test generation
+ * using deterministic validators (tests/build/lint/benchmark/security).
+ */
+import type { Outcome } from './outcome.schema.js';
+
+const DEFAULT_PAYOUT = 300;
+const DEFAULT_MAX_ATTEMPTS = 5;
+const DEFAULT_TIME_LIMIT_MS = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_BENCH_P95_MS = 200;
+
+function buildCodeOutcome(
+  name: Outcome['name'],
+  description: string,
+  overrides: Partial<Outcome> & {
+    benchmarkP95Ms?: number;
+    allowWarnings?: boolean;
+  } = {}
+): Outcome {
+  const benchmarkP95Ms = overrides.benchmarkP95Ms ?? DEFAULT_BENCH_P95_MS;
+  const allowWarnings = overrides.allowWarnings ?? false;
+
+  return {
+    name,
+    description,
+    payoutAmount: overrides.payoutAmount ?? DEFAULT_PAYOUT,
+    maxAttempts: overrides.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+    timeLimitMs: overrides.timeLimitMs ?? DEFAULT_TIME_LIMIT_MS,
+    successCriteria: [
+      {
+        name: 'Tests pass',
+        validator: 'validateTestsPass',
+        params: { minPassRate: 1 },
+      },
+      {
+        name: 'Build succeeds',
+        validator: 'validateBuilds',
+        params: {},
+      },
+      {
+        name: 'Lint clean',
+        validator: 'validateLintClean',
+        params: { allowWarnings },
+      },
+      {
+        name: 'Benchmark within threshold',
+        validator: 'validateBenchmark',
+        params: { p95ThresholdMs: benchmarkP95Ms },
+      },
+      {
+        name: 'Security scan clean',
+        validator: 'validateSecurityScan',
+        params: { maxSeverity: 'high' },
+      },
+    ],
+    failureReasons: [
+      'Tests failing or below pass rate',
+      'Build fails',
+      'Lint errors (or warnings when not allowed)',
+      'Performance regression above threshold',
+      'Security scan has blocking findings',
+    ],
+  };
+}
+
+export const featureImplementationOutcome: Outcome = buildCodeOutcome(
+  'feature_implementation',
+  'Implements a feature with passing tests, clean build, lint, performance, and security gates.'
+);
+
+export const refactorTaskOutcome: Outcome = buildCodeOutcome(
+  'refactor_task',
+  'Refactors code while preserving correctness and performance, with clean build/lint/tests.',
+  { allowWarnings: false, benchmarkP95Ms: 250 }
+);
+
+export const testGenerationOutcome: Outcome = buildCodeOutcome(
+  'test_generation',
+  'Generates automated tests that pass, with clean build/lint and acceptable performance.',
+  { allowWarnings: true, benchmarkP95Ms: 300 }
+);
+
+export const CODE_DELIVERY_OUTCOMES: Record<string, Outcome> = {
+  feature_implementation: featureImplementationOutcome,
+  refactor_task: refactorTaskOutcome,
+  test_generation: testGenerationOutcome,
+};