outcome-cli 1.0.0

package/src/outcomes/swarm_planner.property.test.ts

@@ -0,0 +1,370 @@
+/**
+ * Property-based tests for Planner Output Validity
+ *
+ * **Feature: mvp-unified-engine, Property 3: Planner Output Validity**
+ * **Validates: Requirements 3.2, 3.4, 3.5**
+ *
+ * Property 3: Planner Output Validity
+ * *For any* Planner agent output, the tasks array SHALL contain between 1 and 100 tasks with unique IDs.
+ */
+
+import { describe, test, expect } from 'vitest';
+import * as fc from 'fast-check';
+import {
+  validatePlannerOutput,
+  validateUniqueTaskIds,
+  validateTaskSchema,
+  validatePlannerOutputComplete,
+  type PlannerOutputInput,
+  type PlannerTaskInput,
+} from '../eval/validators.js';
+import {
+  PLANNER_MIN_TASKS,
+  PLANNER_MAX_TASKS,
+  REQUIRED_TASK_FIELDS,
+} from './swarm_planner.js';
+
+/**
+ * Arbitrary for generating valid PlannerTask objects
+ */
+const validTaskArb: fc.Arbitrary<PlannerTaskInput> = fc.record({
+  id: fc.uuid(),
+  description: fc.string({ minLength: 1, maxLength: 200 }),
+  input: fc.dictionary(fc.string({ minLength: 1, maxLength: 20 }), fc.jsonValue()),
+  expectedOutput: fc.option(fc.dictionary(fc.string({ minLength: 1, maxLength: 20 }), fc.jsonValue()), { nil: undefined }),
+  priority: fc.option(fc.integer({ min: 0, max: 100 }), { nil: undefined }),
+});
+
+/**
+ * Arbitrary for generating valid PlannerOutput objects with unique task IDs
+ */
+const validPlannerOutputArb = (minTasks: number = 1, maxTasks: number = 100): fc.Arbitrary<PlannerOutputInput> =>
+  fc.integer({ min: minTasks, max: maxTasks }).chain((taskCount) =>
+    fc.tuple(
+      fc.array(fc.uuid(), { minLength: taskCount, maxLength: taskCount }).map((ids) => [...new Set(ids)]),
+      fc.array(fc.string({ minLength: 1, maxLength: 200 }), { minLength: taskCount, maxLength: taskCount }),
+      fc.array(fc.dictionary(fc.string({ minLength: 1, maxLength: 20 }), fc.jsonValue()), { minLength: taskCount, maxLength: taskCount }),
+    ).chain(([ids, descriptions, inputs]) => {
+      // Ensure we have enough unique IDs
+      const uniqueIds = [...new Set(ids)];
+      const actualCount = Math.min(uniqueIds.length, descriptions.length, inputs.length);
+      if (actualCount < minTasks) {
+        // Generate additional unique IDs if needed
+        while (uniqueIds.length < minTasks) {
+          uniqueIds.push(`task-${uniqueIds.length}-${Date.now()}`);
+        }
+      }
+      const tasks: PlannerTaskInput[] = uniqueIds.slice(0, Math.min(actualCount, maxTasks)).map((id, i) => ({
+        id,
+        description: descriptions[i] || `Task ${i}`,
+        input: inputs[i] || {},
+      }));
+      return fc.record({
+        tasks: fc.constant(tasks),
+        estimatedTimeMs: fc.integer({ min: 1000, max: 3600000 }),
+        reasoning: fc.string({ minLength: 1, maxLength: 500 }),
+      });
+    })
+  );
+
+describe('Planner Output Validity - Property Tests', () => {
+  // **Feature: mvp-unified-engine, Property 3: Planner Output Validity**
+  // **Validates: Requirements 3.2, 3.5**
+  describe('validatePlannerOutput - Task Array Bounds', () => {
+    test('outputs with 1-100 tasks are valid', () => {
+      fc.assert(
+        fc.property(
+          validPlannerOutputArb(PLANNER_MIN_TASKS, PLANNER_MAX_TASKS),
+          (output) => {
+            const result = validatePlannerOutput(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('outputs with 0 tasks are invalid', () => {
+      const emptyOutput: PlannerOutputInput = {
+        tasks: [],
+        estimatedTimeMs: 1000,
+        reasoning: 'Empty output',
+      };
+      const result = validatePlannerOutput(emptyOutput, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0]).toContain('too small');
+    });
+
+    test('outputs with >100 tasks are invalid', () => {
+      fc.assert(
+        fc.property(
+          fc.integer({ min: 101, max: 200 }),
+          (taskCount) => {
+            const tasks: PlannerTaskInput[] = Array.from({ length: taskCount }, (_, i) => ({
+              id: `task-${i}`,
+              description: `Task ${i}`,
+              input: {},
+            }));
+            const output: PlannerOutputInput = {
+              tasks,
+              estimatedTimeMs: 1000,
+              reasoning: 'Too many tasks',
+            };
+            const result = validatePlannerOutput(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.errors[0]).toContain('too large');
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('boundary: exactly 1 task is valid', () => {
+      const output: PlannerOutputInput = {
+        tasks: [{ id: 'task-1', description: 'Single task', input: {} }],
+        estimatedTimeMs: 1000,
+        reasoning: 'Single task',
+      };
+      const result = validatePlannerOutput(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('boundary: exactly 100 tasks is valid', () => {
+      const tasks: PlannerTaskInput[] = Array.from({ length: 100 }, (_, i) => ({
+        id: `task-${i}`,
+        description: `Task ${i}`,
+        input: {},
+      }));
+      const output: PlannerOutputInput = {
+        tasks,
+        estimatedTimeMs: 1000,
+        reasoning: 'Max tasks',
+      };
+      const result = validatePlannerOutput(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  // **Feature: mvp-unified-engine, Property 3: Planner Output Validity**
+  // **Validates: Requirements 3.4**
+  describe('validateUniqueTaskIds - No Duplicate IDs', () => {
+    test('outputs with unique task IDs are valid', () => {
+      fc.assert(
+        fc.property(
+          validPlannerOutputArb(1, 50),
+          (output) => {
+            const result = validateUniqueTaskIds(output);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('outputs with duplicate task IDs are invalid', () => {
+      fc.assert(
+        fc.property(
+          fc.integer({ min: 2, max: 20 }),
+          fc.uuid(),
+          (taskCount, duplicateId) => {
+            const tasks: PlannerTaskInput[] = Array.from({ length: taskCount }, (_, i) => ({
+              id: i === 0 || i === 1 ? duplicateId : `task-${i}`,
+              description: `Task ${i}`,
+              input: {},
+            }));
+            const output: PlannerOutputInput = {
+              tasks,
+              estimatedTimeMs: 1000,
+              reasoning: 'Duplicate IDs',
+            };
+            const result = validateUniqueTaskIds(output);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.errors[0]).toContain('Duplicate task IDs');
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('single task always has unique ID', () => {
+      fc.assert(
+        fc.property(
+          fc.uuid(),
+          fc.string({ minLength: 1 }),
+          (id, description) => {
+            const output: PlannerOutputInput = {
+              tasks: [{ id, description, input: {} }],
+              estimatedTimeMs: 1000,
+              reasoning: 'Single task',
+            };
+            const result = validateUniqueTaskIds(output);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+  });
+
+  // **Feature: mvp-unified-engine, Property 3: Planner Output Validity**
+  // **Validates: Requirements 3.3**
+  describe('validateTaskSchema - Required Fields', () => {
+    test('tasks with all required fields are valid', () => {
+      fc.assert(
+        fc.property(
+          validPlannerOutputArb(1, 20),
+          (output) => {
+            const result = validateTaskSchema(output, [...REQUIRED_TASK_FIELDS]);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('tasks missing id field are invalid', () => {
+      const output: PlannerOutputInput = {
+        tasks: [
+          { id: '', description: 'Task 1', input: {} } as PlannerTaskInput,
+          { description: 'Task 2', input: {} } as unknown as PlannerTaskInput,
+        ],
+        estimatedTimeMs: 1000,
+        reasoning: 'Missing id',
+      };
+      const result = validateTaskSchema(output, [...REQUIRED_TASK_FIELDS]);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    test('tasks missing description field are invalid', () => {
+      const output: PlannerOutputInput = {
+        tasks: [
+          { id: 'task-1', input: {} } as unknown as PlannerTaskInput,
+        ],
+        estimatedTimeMs: 1000,
+        reasoning: 'Missing description',
+      };
+      const result = validateTaskSchema(output, [...REQUIRED_TASK_FIELDS]);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    test('tasks missing input field are invalid', () => {
+      const output: PlannerOutputInput = {
+        tasks: [
+          { id: 'task-1', description: 'Task 1' } as unknown as PlannerTaskInput,
+        ],
+        estimatedTimeMs: 1000,
+        reasoning: 'Missing input',
+      };
+      const result = validateTaskSchema(output, [...REQUIRED_TASK_FIELDS]);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    test('tasks with non-string id are invalid', () => {
+      const output = {
+        tasks: [
+          { id: 123, description: 'Task 1', input: {} },
+        ],
+        estimatedTimeMs: 1000,
+        reasoning: 'Non-string id',
+      } as unknown as PlannerOutputInput;
+      const result = validateTaskSchema(output, [...REQUIRED_TASK_FIELDS]);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    test('tasks with non-object input are invalid', () => {
+      const output = {
+        tasks: [
+          { id: 'task-1', description: 'Task 1', input: 'not an object' },
+        ],
+        estimatedTimeMs: 1000,
+        reasoning: 'Non-object input',
+      } as unknown as PlannerOutputInput;
+      const result = validateTaskSchema(output, [...REQUIRED_TASK_FIELDS]);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  // **Feature: mvp-unified-engine, Property 3: Planner Output Validity**
+  // **Validates: Requirements 3.2, 3.3, 3.4, 3.5**
+  describe('validatePlannerOutputComplete - Composite Validation', () => {
+    test('valid outputs pass all validations', () => {
+      fc.assert(
+        fc.property(
+          validPlannerOutputArb(1, 50),
+          (output) => {
+            const result = validatePlannerOutputComplete(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('validation is deterministic - same input produces same output', () => {
+      fc.assert(
+        fc.property(
+          validPlannerOutputArb(1, 20),
+          (output) => {
+            const result1 = validatePlannerOutputComplete(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+            const result2 = validatePlannerOutputComplete(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+            expect(result1.valid).toBe(result2.valid);
+            expect(result1.errors).toEqual(result2.errors);
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('validation result structure is correct', () => {
+      fc.assert(
+        fc.property(
+          validPlannerOutputArb(1, 20),
+          (output) => {
+            const result = validatePlannerOutputComplete(output, PLANNER_MIN_TASKS, PLANNER_MAX_TASKS);
+            expect(typeof result.valid).toBe('boolean');
+            expect(Array.isArray(result.errors)).toBe(true);
+            if (result.valid) {
+              expect(result.errors).toHaveLength(0);
+            }
+          }
+        ),
+        { numRuns: 100 }
+      );
+    });
+
+    test('null/undefined output is invalid', () => {
+      const result1 = validatePlannerOutputComplete(null as unknown as PlannerOutputInput);
+      expect(result1.valid).toBe(false);
+      expect(result1.errors.length).toBeGreaterThan(0);
+
+      const result2 = validatePlannerOutputComplete(undefined as unknown as PlannerOutputInput);
+      expect(result2.valid).toBe(false);
+      expect(result2.errors.length).toBeGreaterThan(0);
+    });
+
+    test('output without tasks array is invalid', () => {
+      const output = {
+        estimatedTimeMs: 1000,
+        reasoning: 'No tasks',
+      } as unknown as PlannerOutputInput;
+      const result = validatePlannerOutputComplete(output);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/outcomes/swarm_planner.ts

@@ -0,0 +1,96 @@
+/**
+ * Swarm Planner Outcome
+ *
+ * Defines success criteria for the Planner agent that decomposes
+ * high-level goals into atomic parallel tasks for Swarm execution.
+ *
+ * @module outcomes/swarm_planner
+ */
+
+import type { Outcome } from './outcome.schema.js';
+
+/**
+ * Represents a single task decomposed by the Planner agent.
+ */
+export interface PlannerTask {
+  /** Unique task identifier */
+  id: string;
+  /** Human-readable description */
+  description: string;
+  /** Input data for the worker */
+  input: Record<string, unknown>;
+  /** Expected output schema (optional) */
+  expectedOutput?: Record<string, unknown>;
+  /** Priority (lower = higher priority) */
+  priority?: number;
+}
+
+/**
+ * Output produced by the Planner agent.
+ */
+export interface PlannerOutput {
+  /** Array of decomposed tasks */
+  tasks: PlannerTask[];
+  /** Estimated total execution time in ms */
+  estimatedTimeMs: number;
+  /** Reasoning for decomposition */
+  reasoning: string;
+}
+
+/**
+ * Constraints for the Planner outcome.
+ */
+export const PLANNER_MAX_ATTEMPTS = 1;
+export const PLANNER_TIME_LIMIT_MS = 60000;
+export const PLANNER_COST_CEILING = 1.0;
+export const PLANNER_MIN_TASKS = 1;
+export const PLANNER_MAX_TASKS = 100;
+export const PLANNER_PAYOUT_AMOUNT = 5.0;
+
+/**
+ * Required fields for each task in the Planner output.
+ */
+export const REQUIRED_TASK_FIELDS = ['id', 'description', 'input'] as const;
+
+/**
+ * Swarm Planner Outcome Definition
+ *
+ * Success criteria:
+ * 1. Valid task array (1-100 tasks)
+ * 2. No duplicate task IDs
+ * 3. Each task has required fields (id, description, input)
+ *
+ * @see Requirements 3.1, 3.2, 3.3, 3.4, 3.5
+ */
+export const swarmPlannerOutcome: Outcome = {
+  name: 'swarm_planner',
+  description: 'Decompose high-level goal into atomic parallel tasks for Swarm execution',
+  payoutAmount: PLANNER_PAYOUT_AMOUNT,
+  maxAttempts: PLANNER_MAX_ATTEMPTS,
+  timeLimitMs: PLANNER_TIME_LIMIT_MS,
+  successCriteria: [
+    {
+      name: 'valid_task_array',
+      validator: 'validatePlannerOutput',
+      params: { minTasks: PLANNER_MIN_TASKS, maxTasks: PLANNER_MAX_TASKS },
+    },
+    {
+      name: 'no_duplicate_ids',
+      validator: 'validateUniqueTaskIds',
+      params: {},
+    },
+    {
+      name: 'valid_task_schema',
+      validator: 'validateTaskSchema',
+      params: { requiredFields: [...REQUIRED_TASK_FIELDS] },
+    },
+  ],
+  failureReasons: [
+    'Task array is empty or exceeds maximum (1-100 tasks required)',
+    'Duplicate task IDs found',
+    'Task missing required fields (id, description, input)',
+    'Invalid task structure',
+  ],
+};
+
+export default swarmPlannerOutcome;

package/src/outcomes/web_extraction.ts

@@ -0,0 +1,234 @@
+/**
+ * Web Extraction Outcome - Outcome type for OmniBridge web bounties
+ *
+ * Defines outcomes for web-based data extraction tasks that use
+ * OmniBridge's Ghost-API for transparent DOM interaction.
+ *
+ * @module outcomes/web_extraction
+ * @see Requirements 3.1-3.6, 7.1-7.6
+ */
+
+import type { Outcome } from './outcome.schema.js';
+
+/**
+ * Extended outcome type for web extraction bounties.
+ */
+export interface WebExtractionOutcome extends Outcome {
+  /** Outcome type identifier */
+  type: 'web_extraction';
+  /** Target URL for extraction */
+  targetUrl: string;
+  /** Goal description in plain English */
+  goalDescription: string;
+  /** Expected output schema (optional, will be inferred) */
+  outputSchema?: Record<string, unknown>;
+  /** Required authentication domain */
+  authDomain?: string;
+  /** Allowed actions for capability token */
+  allowedActions?: string[];
+  /** Blocked actions for capability token */
+  blockedActions?: string[];
+}
+
+/**
+ * Type guard to check if an outcome is a web extraction outcome.
+ *
+ * @param outcome - Outcome to check
+ * @returns True if the outcome is a web extraction outcome
+ */
+export function isWebExtractionOutcome(outcome: Outcome): outcome is WebExtractionOutcome {
+  return 'type' in outcome && (outcome as WebExtractionOutcome).type === 'web_extraction';
+}
+
+/**
+ * Creates a web extraction outcome.
+ *
+ * @param config - Configuration for the web extraction outcome
+ * @returns WebExtractionOutcome
+ *
+ * @example
+ * const outcome = createWebExtractionOutcome({
+ *   name: 'fetch_invoices',
+ *   description: 'Extract invoice data from portal',
+ *   payoutAmount: 50,
+ *   targetUrl: 'https://portal.example.com/invoices',
+ *   goalDescription: 'Fetch all unpaid invoices from the last 30 days',
+ * });
+ */
+export function createWebExtractionOutcome(config: {
+  name: string;
+  description: string;
+  payoutAmount: number;
+  maxAttempts?: number;
+  timeLimitMs?: number;
+  targetUrl: string;
+  goalDescription: string;
+  outputSchema?: Record<string, unknown>;
+  authDomain?: string;
+  allowedActions?: string[];
+  blockedActions?: string[];
+}): WebExtractionOutcome {
+  return {
+    name: config.name,
+    description: config.description,
+    payoutAmount: config.payoutAmount,
+    maxAttempts: config.maxAttempts ?? 3,
+    timeLimitMs: config.timeLimitMs ?? 300000, // 5 minutes default
+    successCriteria: [
+      {
+        name: 'data_extracted',
+        validator: 'validateWebExtraction',
+        params: {
+          targetUrl: config.targetUrl,
+          goalDescription: config.goalDescription,
+          outputSchema: config.outputSchema,
+        },
+      },
+    ],
+    failureReasons: [
+      'extraction_failed',
+      'authentication_failed',
+      'schema_drift',
+      'timeout',
+      'hallucination_detected',
+    ],
+    type: 'web_extraction',
+    targetUrl: config.targetUrl,
+    goalDescription: config.goalDescription,
+    outputSchema: config.outputSchema,
+    authDomain: config.authDomain,
+    allowedActions: config.allowedActions ?? ['read', 'navigate', 'extract'],
+    blockedActions: config.blockedActions ?? ['delete', 'modify', 'change_password'],
+  };
+}
+
+/**
+ * Example web extraction outcomes for testing.
+ */
+export const WEB_EXTRACTION_OUTCOMES = {
+  /**
+   * Invoice extraction from a billing portal.
+   */
+  fetchInvoices: createWebExtractionOutcome({
+    name: 'fetch_invoices',
+    description: 'Extract invoice data from billing portal',
+    payoutAmount: 50,
+    targetUrl: 'https://billing.example.com/invoices',
+    goalDescription: 'Fetch all unpaid invoices from the last 30 days with amounts and due dates',
+    outputSchema: {
+      type: 'object',
+      properties: {
+        invoices: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              amount: { type: 'number' },
+              dueDate: { type: 'string' },
+              status: { type: 'string' },
+            },
+          },
+        },
+        total: { type: 'number' },
+      },
+    },
+    authDomain: 'billing.example.com',
+  }),
+
+  /**
+   * Lead data extraction from CRM.
+   */
+  extractLeads: createWebExtractionOutcome({
+    name: 'extract_leads',
+    description: 'Extract lead information from CRM system',
+    payoutAmount: 100,
+    targetUrl: 'https://crm.example.com/leads',
+    goalDescription: 'Extract all leads with company name, contact info, and status',
+    outputSchema: {
+      type: 'object',
+      properties: {
+        leads: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              company: { type: 'string' },
+              contact: { type: 'string' },
+              email: { type: 'string' },
+              status: { type: 'string' },
+            },
+          },
+        },
+        count: { type: 'number' },
+      },
+    },
+    authDomain: 'crm.example.com',
+  }),
+
+  /**
+   * Product pricing extraction from competitor site.
+   */
+  scrapeCompetitorPricing: createWebExtractionOutcome({
+    name: 'scrape_competitor_pricing',
+    description: 'Extract product pricing from competitor website',
+    payoutAmount: 75,
+    targetUrl: 'https://competitor.example.com/products',
+    goalDescription: 'Extract all product names, prices, and availability status',
+    outputSchema: {
+      type: 'object',
+      properties: {
+        products: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              price: { type: 'number' },
+              currency: { type: 'string' },
+              available: { type: 'boolean' },
+            },
+          },
+        },
+        lastUpdated: { type: 'string' },
+      },
+    },
+    // No auth required for public site
+  }),
+
+  /**
+   * AI Sales Tools Dataset - Verified company dataset for founders/ops teams.
+   * First wedge for Outcome-Verified Marketplace (Fiverr/Upwork 2.0).
+   */
+  aiSalesToolsDataset: createWebExtractionOutcome({
+    name: 'ai_sales_tools_dataset_v1',
+    description: 'Extract verified AI sales tools companies with domain, category, and sources',
+    payoutAmount: 150,
+    targetUrl: 'https://www.producthunt.com/topics/sales',
+    goalDescription: 'Extract at least 25 AI sales tools companies with name, domain, category, and source URLs. Deduplicate by domain.',
+    outputSchema: {
+      type: 'object',
+      properties: {
+        companies: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              domain: { type: 'string' },
+              category: { type: 'string' },
+              sourceUrls: { 
+                type: 'array',
+                items: { type: 'string' }
+              },
+            },
+            required: ['name', 'domain', 'category', 'sourceUrls'],
+          },
+        },
+        generatedAt: { type: 'string' },
+      },
+      required: ['companies', 'generatedAt'],
+    },
+    // No auth required for public directories
+  }),
+};