monkeybrain-runtime 1.0.0__py3-none-any.whl

src/plasticity/seed/benchmark_generator.py

@@ -0,0 +1,105 @@
+"""Benchmark Dataset Generator — generates test datasets for benchmarking.
+
+Generates:
+- Intent Classification benchmarks
+- Workflow Selection benchmarks
+- Capability Resolution benchmarks
+- End-to-End Request benchmarks
+- Ground Truth Labels
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class BenchmarkEntry:
+    """A single benchmark entry."""
+    
+    entry_id: str = field(default_factory=lambda: f"bench-{uuid4().hex[:8]}")
+    category: str = ""
+    input_data: dict[str, Any] = field(default_factory=dict)
+    expected_output: dict[str, Any] = field(default_factory=dict)
+    ground_truth: dict[str, Any] = field(default_factory=dict)
+    difficulty: str = "medium"  # easy | medium | hard
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+INTENT_BENCHMARKS = [
+    {"input": "Show me batch records", "expected_intent": "batch_record", "difficulty": "easy"},
+    {"input": "What is the OEE for Tablet Line A?", "expected_intent": "production_kpi", "difficulty": "easy"},
+    {"input": "Create a new work order for maintenance", "expected_intent": "work_order_create", "difficulty": "medium"},
+    {"input": "Why did the batch fail quality inspection?", "expected_intent": "decision_intelligence", "difficulty": "hard"},
+    {"input": "Approve the change control request", "expected_intent": "approval_create", "difficulty": "medium"},
+    {"input": "Show me the plant hierarchy", "expected_intent": "plant_topology", "difficulty": "easy"},
+    {"input": "What SOPs are assigned to this workstation?", "expected_intent": "sop_compliance", "difficulty": "medium"},
+    {"input": "Simulate what happens if we increase throughput", "expected_intent": "simulation", "difficulty": "hard"},
+    {"input": "How many workers are on shift?", "expected_intent": "count", "difficulty": "easy"},
+    {"input": "Search for calibration procedures", "expected_intent": "knowledge_base", "difficulty": "easy"},
+]
+
+WORKFLOW_BENCHMARKS = [
+    {"input": "batch_record", "expected_capabilities": ["resolve_entity", "retrieve", "format"], "difficulty": "easy"},
+    {"input": "production_kpi", "expected_capabilities": ["resolve_entity", "retrieve", "analyze", "format"], "difficulty": "medium"},
+    {"input": "simulation", "expected_capabilities": ["resolve_entity", "predict", "simulate", "format"], "difficulty": "hard"},
+]
+
+
+class BenchmarkGenerator:
+    """Generates benchmark datasets for testing.
+    
+    Generates deterministic datasets with ground truth labels.
+    """
+    
+    def __init__(self, seed: int = 42):
+        self._seed = seed
+        self._benchmarks: list[BenchmarkEntry] = []
+    
+    def generate_intent_benchmarks(self) -> list[BenchmarkEntry]:
+        entries = []
+        for item in INTENT_BENCHMARKS:
+            entry = BenchmarkEntry(
+                category="intent_classification",
+                input_data={"question": item["input"]},
+                expected_output={"intent": item["expected_intent"]},
+                ground_truth={"intent": item["expected_intent"], "confidence_threshold": 0.5},
+                difficulty=item["difficulty"],
+            )
+            entries.append(entry)
+            self._benchmarks.append(entry)
+        return entries
+    
+    def generate_workflow_benchmarks(self) -> list[BenchmarkEntry]:
+        entries = []
+        for item in WORKFLOW_BENCHMARKS:
+            entry = BenchmarkEntry(
+                category="workflow_selection",
+                input_data={"intent": item["input"]},
+                expected_output={"capabilities": item["expected_capabilities"]},
+                ground_truth={"capabilities": item["expected_capabilities"]},
+                difficulty=item["difficulty"],
+            )
+            entries.append(entry)
+            self._benchmarks.append(entry)
+        return entries
+    
+    def generate_all(self) -> list[BenchmarkEntry]:
+        entries = []
+        entries.extend(self.generate_intent_benchmarks())
+        entries.extend(self.generate_workflow_benchmarks())
+        return entries
+    
+    def summary(self) -> dict:
+        by_category = {}
+        by_difficulty = {}
+        for b in self._benchmarks:
+            by_category[b.category] = by_category.get(b.category, 0) + 1
+            by_difficulty[b.difficulty] = by_difficulty.get(b.difficulty, 0) + 1
+        return {
+            "total": len(self._benchmarks),
+            "by_category": by_category,
+            "by_difficulty": by_difficulty,
+        }

src/plasticity/seed/event_generator.py

@@ -0,0 +1,122 @@
+"""Event Generator — generates realistic runtime events.
+
+Generates:
+- Production Events
+- Machine Events
+- Sensor Events
+- Maintenance Events
+- Quality Events
+- Workflow Events
+"""
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class Event:
+    """A generated event."""
+    
+    event_id: str = field(default_factory=lambda: f"evt-{uuid4().hex[:8]}")
+    event_type: str = ""
+    entity_type: str = ""
+    entity_id: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    source: str = "seed_generator"
+
+
+EVENT_TYPES = {
+    "production": ["batch_started", "batch_completed", "batch_failed", "step_completed", "step_failed"],
+    "machine": ["machine_started", "machine_stopped", "machine_fault", "machine_maintenance"],
+    "sensor": ["reading", "threshold_breach", "anomaly_detected", "calibration_due"],
+    "maintenance": ["pm_scheduled", "pm_completed", "cm_created", "cm_completed"],
+    "quality": ["deviation_created", "capa_created", "oos_result", "inspection_completed"],
+    "workflow": ["workflow_started", "workflow_completed", "workflow_failed", "capability_invoked"],
+}
+
+
+class EventGenerator:
+    """Generates realistic runtime events.
+    
+    Generates deterministic events based on entity data.
+    """
+    
+    def __init__(self, seed: int = 42):
+        self._rng = random.Random(seed)
+        self._events: list[Event] = []
+    
+    def generate_machine_events(self, machines: list[dict[str, Any]], count: int = 50) -> list[Event]:
+        events = []
+        for _ in range(min(count, len(machines) * 3)):
+            machine = self._rng.choice(machines)
+            event_type = self._rng.choice(EVENT_TYPES["machine"])
+            event = Event(
+                event_type=event_type,
+                entity_type="machine",
+                entity_id=machine["id"],
+                data={
+                    "machine_name": machine.get("name", ""),
+                    "status": machine.get("status", ""),
+                    "reading": self._rng.uniform(20, 100),
+                },
+            )
+            events.append(event)
+            self._events.append(event)
+        return events
+    
+    def generate_batch_events(self, batches: list[dict[str, Any]], count: int = 30) -> list[Event]:
+        events = []
+        for _ in range(min(count, len(batches) * 2)):
+            batch = self._rng.choice(batches)
+            event_type = self._rng.choice(EVENT_TYPES["production"])
+            event = Event(
+                event_type=event_type,
+                entity_type="batch",
+                entity_id=batch["id"],
+                data={
+                    "batch_number": batch.get("batch_number", ""),
+                    "status": batch.get("status", ""),
+                },
+            )
+            events.append(event)
+            self._events.append(event)
+        return events
+    
+    def generate_sensor_events(self, machines: list[dict[str, Any]], count: int = 100) -> list[Event]:
+        events = []
+        for _ in range(min(count, len(machines) * 5)):
+            machine = self._rng.choice(machines)
+            event_type = self._rng.choice(EVENT_TYPES["sensor"])
+            event = Event(
+                event_type=event_type,
+                entity_type="sensor",
+                entity_id=f"{machine['id']}-SENSOR",
+                data={
+                    "machine_id": machine["id"],
+                    "metric": self._rng.choice(["temperature", "pressure", "vibration", "humidity"]),
+                    "value": self._rng.uniform(0, 100),
+                    "unit": self._rng.choice(["°C", "bar", "mm/s", "%"]),
+                },
+            )
+            events.append(event)
+            self._events.append(event)
+        return events
+    
+    def generate_all_events(self, hierarchy: dict[str, Any]) -> list[Event]:
+        events = []
+        events.extend(self.generate_machine_events(hierarchy.get("machines", []), 50))
+        events.extend(self.generate_batch_events(hierarchy.get("batches", []), 30))
+        events.extend(self.generate_sensor_events(hierarchy.get("machines", []), 100))
+        return events
+    
+    def summary(self) -> dict:
+        by_type = {}
+        for e in self._events:
+            by_type[e.event_type] = by_type.get(e.event_type, 0) + 1
+        return {"total": len(self._events), "by_type": by_type}

src/plasticity/seed/scenario_builder.py

@@ -0,0 +1,134 @@
+"""Scenario Builder — generates complete test scenarios.
+
+Supports:
+- Small Factory
+- Medium Factory
+- Enterprise Factory
+- Failure Scenarios
+- Maintenance Scenarios
+- Quality Incidents
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from src.plasticity.seed.seed_data import SeedConfig, SeedGenerator
+
+
+@dataclass
+class Scenario:
+    """A complete test scenario."""
+    
+    scenario_id: str = field(default_factory=lambda: f"scenario-{uuid4().hex[:8]}")
+    name: str = ""
+    description: str = ""
+    config: SeedConfig = field(default_factory=SeedConfig)
+    data: dict[str, Any] = field(default_factory=dict)
+    events: list[dict[str, Any]] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class ScenarioBuilder:
+    """Builds complete test scenarios.
+    
+    Generates deterministic datasets for:
+    - Benchmarking
+    - Development
+    - Testing
+    - Demonstrations
+    """
+    
+    def __init__(self):
+        self._scenarios: dict[str, Scenario] = {}
+    
+    def small_factory(self) -> Scenario:
+        config = SeedConfig(
+            plant_count=1,
+            lines_per_plant=2,
+            stages_per_line=3,
+            workstations_per_stage=3,
+            machines_per_workstation=1,
+            workers_per_plant=10,
+            batches_per_line=5,
+        )
+        return self._build_scenario("small_factory", "Small Factory", config)
+    
+    def medium_factory(self) -> Scenario:
+        config = SeedConfig(
+            plant_count=1,
+            lines_per_plant=4,
+            stages_per_line=4,
+            workstations_per_stage=5,
+            machines_per_workstation=2,
+            workers_per_plant=30,
+            batches_per_line=15,
+        )
+        return self._build_scenario("medium_factory", "Medium Factory", config)
+    
+    def enterprise_factory(self) -> Scenario:
+        config = SeedConfig(
+            plant_count=3,
+            lines_per_plant=6,
+            stages_per_line=5,
+            workstations_per_stage=8,
+            machines_per_workstation=3,
+            workers_per_plant=100,
+            batches_per_line=50,
+        )
+        return self._build_scenario("enterprise_factory", "Enterprise Factory", config)
+    
+    def failure_scenario(self) -> Scenario:
+        scenario = self.medium_factory()
+        scenario.name = "Failure Scenario"
+        scenario.description = "Factory with equipment failures"
+        scenario.events = [
+            {"type": "equipment_failure", "machine_id": "MCH-001", "severity": "critical"},
+            {"type": "batch_failure", "batch_id": "BAT-001", "reason": "quality_deviation"},
+            {"type": "maintenance_overdue", "machine_id": "MCH-003", "days_overdue": 30},
+        ]
+        return scenario
+    
+    def maintenance_scenario(self) -> Scenario:
+        scenario = self.medium_factory()
+        scenario.name = "Maintenance Scenario"
+        scenario.description = "Factory with maintenance activities"
+        scenario.events = [
+            {"type": "pm_scheduled", "machine_id": "MCH-001", "pm_type": "preventive"},
+            {"type": "calibration_due", "machine_id": "MCH-002", "due_date": "2026-07-01"},
+            {"type": "work_order_created", "type": "maintenance", "priority": "high"},
+        ]
+        return scenario
+    
+    def quality_incident_scenario(self) -> Scenario:
+        scenario = self.medium_factory()
+        scenario.name = "Quality Incident"
+        scenario.description = "Factory with quality deviations"
+        scenario.events = [
+            {"type": "deviation", "batch_id": "BAT-001", "severity": "major"},
+            {"type": "capa_created", "deviation_id": "DEV-001", "type": "corrective"},
+            {"type": "oos_result", "test": "dissolution", "result": 78.5, "spec": 80.0},
+        ]
+        return scenario
+    
+    def _build_scenario(self, name: str, description: str, config: SeedConfig) -> Scenario:
+        generator = SeedGenerator(config)
+        data = generator.generate_full_hierarchy()
+        
+        scenario = Scenario(
+            name=name,
+            description=description,
+            config=config,
+            data=data,
+            metadata=generator.summary(),
+        )
+        self._scenarios[scenario.scenario_id] = scenario
+        return scenario
+    
+    def get_scenario(self, scenario_id: str) -> Scenario | None:
+        return self._scenarios.get(scenario_id)
+    
+    def list_scenarios(self) -> list[Scenario]:
+        return list(self._scenarios.values())

src/plasticity/seed/seed_data.py

@@ -0,0 +1,206 @@
+"""Seed Data — deterministic domain data generation.
+
+All data generated from existing domain models.
+No direct database manipulation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import random
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class SeedConfig:
+    """Configuration for data seeding."""
+    
+    seed: int = 42
+    plant_count: int = 1
+    lines_per_plant: int = 3
+    stages_per_line: int = 4
+    workstations_per_stage: int = 5
+    machines_per_workstation: int = 2
+    workers_per_plant: int = 20
+    batches_per_line: int = 10
+    work_orders_per_batch: int = 3
+    sops_per_plant: int = 15
+    
+    def deterministic_hash(self) -> str:
+        config_str = f"{self.seed}:{self.plant_count}:{self.lines_per_plant}"
+        return hashlib.md5(config_str.encode()).hexdigest()[:8]
+
+
+PLANT_NAMES = [
+    "Tablet Manufacturing Plant", "Capsule Production Facility",
+    "Injection Molding Center", "Packaging & Distribution Hub",
+    "API Synthesis Plant", "Biotech Manufacturing Suite",
+]
+
+LINE_NAMES = ["Tablet Line A", "Tablet Line B", "Capsule Line A", "Capsule Line B", "Packaging Line 1", "Packaging Line 2"]
+STAGE_NAMES = ["Dispensing", "Granulation", "Compression", "Coating", "Packaging", "Inspection", "Blending", "Milling"]
+WORKER_ROLES = ["Operator", "Technician", "Engineer", "Supervisor", "QA Inspector", "Maintenance Tech"]
+MACHINE_TYPES = ["Tablet Press", "Coating Pan", "Blender", "Granulator", "Packaging Machine", "Inspection Camera"]
+BATCH_STATUSES = ["planned", "in_progress", "completed", "on_hold", "failed"]
+WORK_ORDER_STATUSES = ["open", "assigned", "in_progress", "completed", "on_hold"]
+
+
+class SeedGenerator:
+    """Deterministic seed data generator.
+    
+    Generates realistic domain data from configuration.
+    """
+    
+    def __init__(self, config: SeedConfig | None = None):
+        self._config = config or SeedConfig()
+        self._rng = random.Random(self._config.seed)
+    
+    @property
+    def config(self) -> SeedConfig:
+        return self._config
+    
+    def generate_plants(self) -> list[dict[str, Any]]:
+        plants = []
+        for i in range(self._config.plant_count):
+            plants.append({
+                "id": f"PLT-{i+1:03d}",
+                "name": PLANT_NAMES[i % len(PLANT_NAMES)],
+                "status": "active",
+                "code": f"PLT{i+1:03d}",
+            })
+        return plants
+    
+    def generate_lines(self, plant_id: str) -> list[dict[str, Any]]:
+        lines = []
+        for i in range(self._config.lines_per_plant):
+            lines.append({
+                "id": f"{plant_id}-LINE-{i+1:03d}",
+                "plant_id": plant_id,
+                "name": LINE_NAMES[i % len(LINE_NAMES)],
+                "status": "active",
+            })
+        return lines
+    
+    def generate_stages(self, line_id: str) -> list[dict[str, Any]]:
+        stages = []
+        for i in range(self._config.stages_per_line):
+            stages.append({
+                "id": f"{line_id}-STG-{i+1:03d}",
+                "line_id": line_id,
+                "name": STAGE_NAMES[i % len(STAGE_NAMES)],
+                "order": i + 1,
+                "status": "active",
+            })
+        return stages
+    
+    def generate_workstations(self, stage_id: str) -> list[dict[str, Any]]:
+        workstations = []
+        for i in range(self._config.workstations_per_stage):
+            workstations.append({
+                "id": f"{stage_id}-WS-{i+1:03d}",
+                "stage_id": stage_id,
+                "name": f"Workstation {i+1}",
+                "status": "active",
+            })
+        return workstations
+    
+    def generate_machines(self, workstation_id: str) -> list[dict[str, Any]]:
+        machines = []
+        for i in range(self._config.machines_per_workstation):
+            machines.append({
+                "id": f"{workstation_id}-MCH-{i+1:03d}",
+                "workstation_id": workstation_id,
+                "name": f"{MACHINE_TYPES[i % len(MACHINE_TYPES)]} {i+1}",
+                "type": MACHINE_TYPES[i % len(MACHINE_TYPES)],
+                "status": "operational",
+            })
+        return machines
+    
+    def generate_workers(self, plant_id: str) -> list[dict[str, Any]]:
+        workers = []
+        for i in range(self._config.workers_per_plant):
+            workers.append({
+                "id": f"{plant_id}-WRK-{i+1:03d}",
+                "plant_id": plant_id,
+                "name": f"Worker {i+1}",
+                "role": WORKER_ROLES[i % len(WORKER_ROLES)],
+                "status": "active",
+            })
+        return workers
+    
+    def generate_batches(self, line_id: str) -> list[dict[str, Any]]:
+        batches = []
+        for i in range(self._config.batches_per_line):
+            batches.append({
+                "id": f"{line_id}-BAT-{i+1:03d}",
+                "line_id": line_id,
+                "batch_number": f"BATCH-{self._rng.randint(10000, 99999)}",
+                "status": self._rng.choice(BATCH_STATUSES),
+                "product": f"Product {self._rng.choice(['A', 'B', 'C'])}",
+            })
+        return batches
+    
+    def generate_work_orders(self, batch_id: str) -> list[dict[str, Any]]:
+        work_orders = []
+        for i in range(self._config.work_orders_per_batch):
+            work_orders.append({
+                "id": f"{batch_id}-WO-{i+1:03d}",
+                "batch_id": batch_id,
+                "title": f"Work Order {i+1}",
+                "status": self._rng.choice(WORK_ORDER_STATUSES),
+                "type": self._rng.choice(["production", "maintenance", "quality"]),
+            })
+        return work_orders
+    
+    def generate_full_hierarchy(self) -> dict[str, Any]:
+        """Generate complete entity hierarchy."""
+        plants = self.generate_plants()
+        all_lines = []
+        all_stages = []
+        all_workstations = []
+        all_machines = []
+        all_workers = []
+        all_batches = []
+        all_work_orders = []
+        
+        for plant in plants:
+            lines = self.generate_lines(plant["id"])
+            all_lines.extend(lines)
+            all_workers.extend(self.generate_workers(plant["id"]))
+            
+            for line in lines:
+                stages = self.generate_stages(line["id"])
+                all_stages.extend(stages)
+                batches = self.generate_batches(line["id"])
+                all_batches.extend(batches)
+                
+                for stage in stages:
+                    workstations = self.generate_workstations(stage["id"])
+                    all_workstations.extend(workstations)
+                    
+                    for ws in workstations:
+                        all_machines.extend(self.generate_machines(ws["id"]))
+                
+                for batch in batches:
+                    all_work_orders.extend(self.generate_work_orders(batch["id"]))
+        
+        return {
+            "plants": plants,
+            "lines": all_lines,
+            "stages": all_stages,
+            "workstations": all_workstations,
+            "machines": all_machines,
+            "workers": all_workers,
+            "batches": all_batches,
+            "work_orders": all_work_orders,
+        }
+    
+    def summary(self) -> dict:
+        hierarchy = self.generate_full_hierarchy()
+        return {
+            "config_hash": self._config.deterministic_hash(),
+            "entities": {k: len(v) for k, v in hierarchy.items()},
+            "total": sum(len(v) for v in hierarchy.values()),
+        }

src/plasticity/seed/seeder.py

@@ -0,0 +1,122 @@
+"""Seeder — deterministic data seeding framework.
+
+Generates complete grounded datasets for:
+- Benchmarking
+- Development
+- Testing
+- Demonstrations
+- Regression validation
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from src.plasticity.seed.seed_data import SeedConfig, SeedGenerator
+from src.plasticity.seed.scenario_builder import ScenarioBuilder, Scenario
+from src.plasticity.seed.event_generator import EventGenerator, Event
+from src.plasticity.seed.benchmark_generator import BenchmarkGenerator, BenchmarkEntry
+
+
+class Seeder:
+    """Deterministic data seeding framework.
+    
+    All data generated from existing domain models.
+    No direct database manipulation.
+    """
+    
+    def __init__(self, config: SeedConfig | None = None):
+        self._config = config or SeedConfig()
+        self._generator = SeedGenerator(self._config)
+        self._scenarios = ScenarioBuilder()
+        self._events = EventGenerator(self._config.seed)
+        self._benchmarks = BenchmarkGenerator(self._config.seed)
+    
+    def seed_small(self) -> dict[str, Any]:
+        """Seed a small factory."""
+        scenario = self._scenarios.small_factory()
+        events = self._events.generate_all_events(scenario.data)
+        benchmarks = self._benchmarks.generate_all()
+        
+        return {
+            "scenario": scenario.name,
+            "data": scenario.data,
+            "events": [e.__dict__ for e in events],
+            "benchmarks": [b.__dict__ for b in benchmarks],
+            "summary": {
+                "entities": {k: len(v) for k, v in scenario.data.items()},
+                "events": len(events),
+                "benchmarks": len(benchmarks),
+            },
+        }
+    
+    def seed_medium(self) -> dict[str, Any]:
+        """Seed a medium factory."""
+        scenario = self._scenarios.medium_factory()
+        events = self._events.generate_all_events(scenario.data)
+        benchmarks = self._benchmarks.generate_all()
+        
+        return {
+            "scenario": scenario.name,
+            "data": scenario.data,
+            "events": [e.__dict__ for e in events],
+            "benchmarks": [b.__dict__ for b in benchmarks],
+            "summary": {
+                "entities": {k: len(v) for k, v in scenario.data.items()},
+                "events": len(events),
+                "benchmarks": len(benchmarks),
+            },
+        }
+    
+    def seed_enterprise(self) -> dict[str, Any]:
+        """Seed an enterprise factory."""
+        scenario = self._scenarios.enterprise_factory()
+        events = self._events.generate_all_events(scenario.data)
+        benchmarks = self._benchmarks.generate_all()
+        
+        return {
+            "scenario": scenario.name,
+            "data": scenario.data,
+            "events": [e.__dict__ for e in events],
+            "benchmarks": [b.__dict__ for b in benchmarks],
+            "summary": {
+                "entities": {k: len(v) for k, v in scenario.data.items()},
+                "events": len(events),
+                "benchmarks": len(benchmarks),
+            },
+        }
+    
+    def seed_failure(self) -> dict[str, Any]:
+        """Seed a failure scenario."""
+        scenario = self._scenarios.failure_scenario()
+        events = self._events.generate_all_events(scenario.data)
+        events.extend([Event(event_type=e["type"], entity_type="event", entity_id=e.get("machine_id", ""), data=e) for e in scenario.events])
+        
+        return {
+            "scenario": scenario.name,
+            "data": scenario.data,
+            "events": [e.__dict__ for e in events],
+            "summary": {
+                "entities": {k: len(v) for k, v in scenario.data.items()},
+                "events": len(events),
+                "failure_events": len(scenario.events),
+            },
+        }
+    
+    def seed_benchmarks(self) -> dict[str, Any]:
+        """Seed benchmark datasets only."""
+        benchmarks = self._benchmarks.generate_all()
+        return {
+            "benchmarks": [b.__dict__ for b in benchmarks],
+            "summary": self._benchmarks.summary(),
+        }
+    
+    def summary(self) -> dict:
+        return {
+            "config": {
+                "seed": self._config.seed,
+                "plant_count": self._config.plant_count,
+                "lines_per_plant": self._config.lines_per_plant,
+            },
+            "generator": self._generator.summary(),
+        }