Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,5 @@
+venv/
+.venv/
+env/
+__pycache__/
+*.pyc

Dockerfile

@@ -0,0 +1,34 @@
+# HarFeast OpenEnv - HF Spaces / Docker deployment
+# Build: docker build -t harfeast-env .
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy project files
+COPY harfeast_env /app/harfeast_env
+COPY harfeast_openenv /app/harfeast_openenv
+COPY harfeast_world /app/harfeast_world
+COPY harfeast_synthetic_world_generator.py /app/
+
+# Generate world if missing (e.g. harfeast_world not committed)
+RUN python /app/harfeast_synthetic_world_generator.py --output-dir /app/harfeast_world 2>/dev/null || true
+
+# Optional: generate augmented dataset (200+ task variations) for RL training
+# Uncomment to enable HARFEAST_WORLDS_BASE:
+# RUN python /app/harfeast_synthetic_world_generator.py --batch 40 --output-dir /app/harfeast_worlds
+
+# Install dependencies
+RUN pip install --no-cache-dir openenv-core>=0.2.1 fastapi uvicorn
+
+ENV HARFEAST_WORLD_PATH=/app/harfeast_world
+# ENV HARFEAST_WORLDS_BASE=/app/harfeast_worlds
+ENV PYTHONPATH=/app
+ENV ENABLE_WEB_INTERFACE=true
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+EXPOSE 8000
+CMD ["uvicorn", "harfeast_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,37 @@
+---
+title: HarFeast Env
+emoji: "\U0001F33E"
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 8000
+base_path: /web
+pinned: false
+tags:
+  - openenv
+---
+
+# HarFeast OpenEnv Environment
+
+RL training environment for management consulting tasks, built for the [OpenEnv Hackathon](https://github.com/meta-pytorch/OpenEnv) (Mercor APEX-Agents sub-theme).
+
+An LLM agent navigates files, spreadsheets, and data tools to solve 14 multi-step analytical tasks about a fictional food manufacturing company. Answers are scored against deterministic rubrics.
+
+## Actions
+
+| Action | Description |
+|--------|-------------|
+| `files.list` | List files/directories |
+| `files.read` | Read text documents |
+| `spreadsheet.read_range` | Read CSV rows/columns |
+| `data.filter` | Filter rows by condition |
+| `data.group_by` | Group + aggregate |
+| `data.add_columns` | Derived columns |
+| `data.compute` | Math expression eval |
+| `submit` | Submit final answer (scored against rubric) |
+
+## Links
+
+- [APEX-Agents Dataset](https://huggingface.co/datasets/mercor/apex-agents)
+- [Archipelago Eval](https://github.com/Mercor-Intelligence/archipelago)
+- [APEX-Agents Paper](https://arxiv.org/abs/2601.14242)

harfeast_env/README.md

@@ -0,0 +1,53 @@
+# HarFeast Environment
+
+Management consulting RL environment for OpenEnv. Agents explore CSV data, text documents, run filters/aggregations, and submit answers scored by rubric.
+
+## Actions (8)
+
+- **files.list(path)** - List files in data/ or documents/
+- **files.read(path)** - Read text documents
+- **spreadsheet.read_range(file, range)** - Read CSV (columns, 1:10, all)
+- **data.filter(dataset, column, operator, value)** - Filter rows
+- **data.group_by(dataset, column, aggregation, target_column)** - Aggregate
+- **data.add_columns(dataset, new_column, expression)** - Derived columns
+- **data.compute(expression)** - Math calculator
+- **submit(answer)** - Submit final answer; episode ends; rubric scores 0-100
+
+## Action format (JSON)
+
+```json
+{"action": "files.list", "path": "."}
+{"action": "data.filter", "dataset": "employee_survey.csv", "column": "training_received", "operator": "eq", "value": "Yes"}
+{"action": "submit", "answer": "The count is 1202. Excellent: 14%, Good: 41%..."}
+```
+
+## Usage
+
+```python
+from harfeast_env import HarFeastEnv, HarFeastAction
+import json
+
+# Connect to HF Space
+client = HarFeastEnv(base_url="https://YOUR-USERNAME-harfeast-env.hf.space")
+
+# Reset (load task)
+result = client.reset()
+print(result.observation.observation)  # Task prompt
+
+# Step - send action as JSON string
+action = HarFeastAction(action_json=json.dumps({"action": "files.list", "path": "."}))
+result = client.step(action)
+print(result.observation.observation)
+print(result.reward, result.done)
+
+client.close()
+```
+
+## Local run
+
+```bash
+cd /path/to/harfeast_apex_openenv_hackathon
+python -m uvicorn harfeast_env.server.app:app --host 0.0.0.0 --port 8000
+```
+
+Then: `HarFeastEnv(base_url="http://localhost:8000")`

harfeast_env/__init__.py

@@ -0,0 +1,9 @@
+"""
+HarFeast OpenEnv - Management consulting RL environment.
+Compatible with OpenEnv 0.2.1 for HF Spaces deployment.
+"""
+
+from harfeast_env.models import HarFeastAction, HarFeastObservation
+from harfeast_env.client import HarFeastEnv
+
+__all__ = ["HarFeastAction", "HarFeastObservation", "HarFeastEnv"]

harfeast_env/client.py

@@ -0,0 +1,46 @@
+"""
+HarFeast Environment Client.
+Connects to HarFeast OpenEnv server via WebSocket/HTTP.
+"""
+
+from typing import Any, Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+from openenv.core.env_client import EnvClient
+from harfeast_env.models import HarFeastAction, HarFeastObservation
+
+
+class HarFeastEnv(EnvClient[HarFeastAction, HarFeastObservation, State]):
+    """
+    Client for the HarFeast management consulting environment.
+    """
+
+    def _step_payload(self, action: HarFeastAction) -> Dict[str, Any]:
+        """Convert HarFeastAction to JSON payload."""
+        return {"action_json": action.action_json}
+
+    def _parse_result(self, payload: Dict) -> StepResult[HarFeastObservation]:
+        """Parse server response into StepResult."""
+        obs_data = payload.get("observation", {})
+        observation = HarFeastObservation(
+            observation=obs_data.get("observation", ""),
+            prompt=obs_data.get("prompt", ""),
+            step_count=obs_data.get("step_count", 0),
+            datasets_available=obs_data.get("datasets_available", "[]"),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """Parse state from server."""
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

harfeast_env/models.py

@@ -0,0 +1,57 @@
+"""
+Data models for the HarFeast Environment.
+Actions are JSON-serialized calls: {"action": "files.list", "path": "."}
+"""
+
+from pydantic import Field
+
+from openenv.core.env_server.types import Action, Observation
+
+
+class HarFeastAction(Action):
+    """
+    Action for HarFeast - JSON string encoding the action call.
+    Example: '{"action": "files.list", "path": "."}'
+    """
+
+    action_json: str = Field(
+        ...,
+        min_length=2,
+        description="JSON action: {\"action\": \"<name>\", ...params}. "
+        "Actions: files.list, files.read, spreadsheet.read_range, "
+        "data.filter, data.group_by, data.add_columns, data.compute, submit",
+    )
+
+
+class HarFeastObservation(Observation):
+    """Observation from HarFeast - text result + metadata."""
+
+    observation: str = Field(
+        ...,
+        description="Text output from the action (file list, table, confirmation, etc.)",
+    )
+    prompt: str = Field(
+        default="",
+        description="Current task prompt",
+    )
+    step_count: int = Field(
+        default=0,
+        ge=0,
+        description="Number of steps taken",
+    )
+    datasets_available: str = Field(
+        default="[]",
+        description="JSON list of filtered dataset names available for chaining",
+    )
+    done: bool = Field(
+        default=False,
+        description="Whether the episode has ended",
+    )
+    reward: float = Field(
+        default=0.0,
+        description="Rubric score (0-100) when done, else 0",
+    )
+    metadata: dict = Field(
+        default_factory=dict,
+        description="Extra info (action_taken, last_error, task_id)",
+    )

harfeast_env/openenv.yaml

@@ -0,0 +1,6 @@
+spec_version: 1
+name: harfeast_env
+type: space
+runtime: fastapi
+app: harfeast_env.server.app:app
+port: 8000

harfeast_env/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "harfeast-env"
+version = "0.1.0"
+description = "HarFeast management consulting RL environment - OpenEnv compatible"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core>=0.2.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["harfeast_env", "harfeast_openenv"]

harfeast_env/server/__init__.py

@@ -0,0 +1 @@
+# HarFeast server module

harfeast_env/server/app.py

@@ -0,0 +1,65 @@
+"""
+FastAPI application for HarFeast Environment.
+Exposes the environment over HTTP/WebSocket for OpenEnv clients.
+"""
+
+import os
+import sys
+
+_project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from openenv.core.env_server.http_server import create_app
+from harfeast_env.models import HarFeastAction, HarFeastObservation
+from harfeast_env.server.harfeast_environment import HarFeastEnvironment
+
+WORLD_PATH = os.environ.get("HARFEAST_WORLD_PATH") or os.path.join(_project_root, "harfeast_world")
+WORLDS_BASE = os.environ.get("HARFEAST_WORLDS_BASE")
+
+
+def _env_factory():
+    return HarFeastEnvironment(world_path=WORLD_PATH, worlds_base=WORLDS_BASE)
+
+
+app = create_app(
+    _env_factory,
+    HarFeastAction,
+    HarFeastObservation,
+    env_name="harfeast_env",
+)
+
+
+@app.get("/")
+def root():
+    return {
+        "name": "HarFeast OpenEnv",
+        "description": "Management consulting RL environment with 14 APEX-style analytical tasks",
+        "version": "0.1.0",
+        "tasks": 14,
+        "tools": [
+            "files.list", "files.read", "spreadsheet.read_range",
+            "data.filter", "data.group_by", "data.add_columns",
+            "data.compute", "submit",
+        ],
+        "endpoints": {
+            "info": "/info",
+            "reset": "/reset",
+            "step": "/step",
+            "health": "/health",
+        },
+    }
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+def main():
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

harfeast_env/server/harfeast_environment.py

@@ -0,0 +1,100 @@
+"""
+HarFeast Environment - OpenEnv server implementation.
+Management consulting tasks with file, spreadsheet, and data actions.
+"""
+
+import json
+import os
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+# Import our core logic - use path relative to project root
+import sys
+_project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from harfeast_openenv.environment import HarFeastOpenEnv
+from harfeast_openenv.schemas import StepResult
+from harfeast_env.models import HarFeastAction, HarFeastObservation
+
+
+class HarFeastEnvironment(Environment[HarFeastAction, HarFeastObservation, State]):
+    """
+    OpenEnv wrapper for HarFeast management consulting environment.
+    Supports files.list, files.read, spreadsheet.read_range, data actions, submit.
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = False  # Session state (filtered datasets)
+
+    def __init__(self, world_path: str | None = None, worlds_base: str | None = None):
+        self._world_path = world_path or os.path.join(_project_root, "harfeast_world")
+        self._worlds_base = (worlds_base or os.environ.get("HARFEAST_WORLDS_BASE") or "").strip() or None
+        self._env = HarFeastOpenEnv(
+            world_path=self._world_path,
+            worlds_base=os.path.abspath(self._worlds_base) if self._worlds_base else None,
+        )
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+
+    def reset(
+        self,
+        seed: int | None = None,
+        episode_id: str | None = None,
+        task_id: str | None = None,
+        **kwargs,
+    ) -> HarFeastObservation:
+        """Reset environment and load a task. Supports task_index for augmented dataset."""
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        result: StepResult = self._env.reset(
+            seed=seed,
+            task_id=task_id or kwargs.get("task_id"),
+            task_index=kwargs.get("task_index"),
+            **{k: v for k, v in kwargs.items() if k not in ("task_id", "task_index")},
+        )
+        return self._step_result_to_obs(result)
+
+    def step(
+        self,
+        action: HarFeastAction,
+        timeout_s: float | None = None,
+        **kwargs,
+    ) -> HarFeastObservation:
+        """Execute action (action_json) and return observation."""
+        try:
+            action_dict = json.loads(action.action_json)
+        except json.JSONDecodeError as e:
+            return HarFeastObservation(
+                observation=f"Invalid action JSON: {e}",
+                prompt=self._env._prompt,
+                step_count=self._env._step_count,
+                datasets_available=json.dumps(list(self._env._filtered_datasets.keys())),
+                done=False,
+                reward=0.0,
+                metadata={"error": str(e)},
+            )
+        result: StepResult = self._env.step(action_dict)
+        self._state.step_count = result.step_count
+        return self._step_result_to_obs(result)
+
+    def _step_result_to_obs(self, r: StepResult) -> HarFeastObservation:
+        """Convert our StepResult to HarFeastObservation."""
+        return HarFeastObservation(
+            observation=r.observation,
+            prompt=r.prompt,
+            step_count=r.step_count,
+            datasets_available=json.dumps(r.info.get("datasets_available", [])),
+            done=r.done,
+            reward=r.reward,
+            metadata={
+                "action_taken": r.info.get("action_taken"),
+                "last_error": r.info.get("last_error"),
+                "task_id": self._env.state.get("task_id"),
+            },
+        )
+
+    @property
+    def state(self) -> State:
+        """Current episode state."""
+        return self._state

harfeast_openenv/__init__.py

@@ -0,0 +1,5 @@
+"""HarFeast OpenEnv - Management consulting RL environment."""
+
+from harfeast_openenv.environment import HarFeastOpenEnv
+
+__all__ = ["HarFeastOpenEnv"]

harfeast_openenv/actions.py

@@ -0,0 +1,480 @@
+"""Action handlers for HarFeast OpenEnv."""
+
+import ast
+import csv
+import json
+import operator
+import os
+import re
+from collections import defaultdict
+from statistics import median as stat_median
+
+from .schemas import ActionResult
+
+
+# ── Observation size limits ──────────────────────────────────────
+MAX_TABLE_ROWS = 20
+
+# ── Safe arithmetic evaluator (replaces eval) ────────────────────
+_SAFE_BINOPS = {
+    ast.Add: operator.add, ast.Sub: operator.sub,
+    ast.Mult: operator.mul, ast.Div: operator.truediv,
+}
+
+def _safe_eval_expr(node, namespace=None):
+    """Evaluate an AST node containing only arithmetic on numbers (and optionally named vars)."""
+    if isinstance(node, ast.Expression):
+        return _safe_eval_expr(node.body, namespace)
+    if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+        return node.value
+    if isinstance(node, ast.BinOp) and type(node.op) in _SAFE_BINOPS:
+        left = _safe_eval_expr(node.left, namespace)
+        right = _safe_eval_expr(node.right, namespace)
+        return _SAFE_BINOPS[type(node.op)](left, right)
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
+        return -_safe_eval_expr(node.operand, namespace)
+    if isinstance(node, ast.Name) and namespace is not None:
+        if node.id in namespace:
+            return namespace[node.id]
+        raise ValueError(f"Unknown variable: {node.id}")
+    raise ValueError(f"Unsupported expression element: {ast.dump(node)}")
+MAX_DOCUMENT_CHARS = 2000
+def handle_files_list(world_path: str, path: str = ".") -> ActionResult:
+    """
+    List files and directories at the given path.
+    Path can be ".", "data", "documents", or a subpath like "documents".
+    """
+    base = os.path.normpath(os.path.join(world_path, path))
+    if not os.path.isdir(base):
+        return ActionResult(
+            observation=f"Path '{path}' does not exist or is not a directory.",
+            success=False,
+            error=f"Invalid path: {path}",
+        )
+    
+    # Ensure we don't escape world_path
+    world_abs = os.path.abspath(world_path)
+    base_abs = os.path.abspath(base)
+    if not base_abs.startswith(world_abs):
+        return ActionResult(
+            observation="Access denied: path outside world directory.",
+            success=False,
+            error="Path traversal not allowed",
+        )
+    
+    items = sorted(os.listdir(base))
+    files = []
+    for name in items:
+        full = os.path.join(base, name)
+        if os.path.isfile(full):
+            files.append({"name": name, "type": "file"})
+        else:
+            files.append({"name": name + "/", "type": "directory"})
+    
+    return ActionResult(
+        observation=json.dumps({"path": path, "items": files}, indent=2),
+    )
+
+
+def handle_files_read(world_path: str, path: str) -> ActionResult:
+    """
+    Read a text document. Only allows .txt files in documents/.
+    Rejects CSV paths with a message to use spreadsheet.read_range.
+    """
+    # Normalize path: accept "scrap_rate_report.txt", "documents/scrap_rate_report.txt", etc.
+    path = path.strip().lstrip("/")
+    if not path.startswith("documents"):
+        path = "documents/" + path
+    
+    full_path = os.path.normpath(os.path.join(world_path, path))
+    
+    # Security: ensure within world_path
+    world_abs = os.path.abspath(world_path)
+    full_abs = os.path.abspath(full_path)
+    if not full_abs.startswith(world_abs):
+        return ActionResult(
+            observation="Access denied: path outside world directory.",
+            success=False,
+            error="Path traversal not allowed",
+        )
+    
+    # Reject CSV files
+    if path.endswith(".csv") or "data/" in path:
+        return ActionResult(
+            observation=(
+                "CSV files cannot be read with files.read. "
+                "Use spreadsheet.read_range(file, range) to read CSV data."
+            ),
+            success=False,
+            error="Use spreadsheet.read_range for CSV files",
+        )
+    
+    if not os.path.isfile(full_path):
+        return ActionResult(
+            observation=f"File not found: {path}",
+            success=False,
+            error=f"File not found: {path}",
+        )
+    
+    try:
+        with open(full_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        if len(content) > MAX_DOCUMENT_CHARS:
+            total = len(content)
+            content = content[:MAX_DOCUMENT_CHARS] + (
+                f"\n\n[Truncated — showing first {MAX_DOCUMENT_CHARS} of {total} characters.]"
+            )
+        return ActionResult(observation=content)
+    except Exception as e:
+        return ActionResult(
+            observation=f"Error reading file: {e}",
+            success=False,
+            error=str(e),
+        )
+
+
+def _resolve_csv_path(world_path: str, file_or_dataset: str) -> str:
+    """Resolve file/dataset name to full CSV path. Reject path traversal."""
+    file_or_dataset = file_or_dataset.strip()
+    if not file_or_dataset.lower().endswith(".csv"):
+        file_or_dataset = file_or_dataset + ".csv"
+    if not file_or_dataset.lower().startswith("data"):
+        file_or_dataset = "data/" + file_or_dataset.lstrip("/")
+    full = os.path.normpath(os.path.join(world_path, file_or_dataset))
+    world_abs = os.path.abspath(world_path)
+    full_abs = os.path.abspath(full)
+    if not full_abs.startswith(world_abs) or not full_abs.endswith(".csv"):
+        raise ValueError(f"Invalid path: {file_or_dataset}")
+    return full
+
+
+def _load_csv_rows(path: str) -> tuple[list[str], list[dict]]:
+    """Load CSV as (columns, rows)."""
+    with open(path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        columns = reader.fieldnames or []
+        rows = list(reader)
+    return columns, rows
+
+
+def _get_table(world_path: str, dataset: str, filtered_datasets: dict) -> tuple[list[str], list[dict]]:
+    """Load table (columns, rows) from CSV file or filtered dataset."""
+    if dataset in filtered_datasets:
+        stored = filtered_datasets[dataset]
+        cols = stored["columns"]
+        rows = [dict(r) for r in stored["rows"]]
+        return cols, rows
+    path = _resolve_csv_path(world_path, dataset)
+    return _load_csv_rows(path)
+
+
+def _format_table(columns: list[str], rows: list[dict], max_rows: int | None = None) -> str:
+    """Format as text table. Defaults to MAX_TABLE_ROWS."""
+    if max_rows is None:
+        max_rows = MAX_TABLE_ROWS
+    if not rows:
+        return " | ".join(columns) + "\n(0 rows)"
+    lines = [" | ".join(columns)]
+    for r in rows[:max_rows]:
+        lines.append(" | ".join(str(r.get(c, "")) for c in columns))
+    if len(rows) > max_rows:
+        lines.append(f"\n[Showing {max_rows} of {len(rows)} rows. Use data.filter to narrow results.]")
+    return "\n".join(lines)
+
+
+def handle_spreadsheet_read_range(
+    world_path: str,
+    file: str,
+    range_spec: str,
+) -> ActionResult:
+    """
+    Read rows from a CSV file.
+    range: "columns" (headers only), "1:10" (rows 1-10), "all" (everything).
+    """
+    try:
+        path = _resolve_csv_path(world_path, file)
+    except ValueError as e:
+        return ActionResult(observation=str(e), success=False, error=str(e))
+    if not os.path.isfile(path):
+        return ActionResult(
+            observation=f"File not found: {file}",
+            success=False,
+            error=f"File not found: {file}",
+        )
+    try:
+        columns, rows = _load_csv_rows(path)
+    except Exception as e:
+        return ActionResult(
+            observation=f"Error reading CSV: {e}",
+            success=False,
+            error=str(e),
+        )
+    range_spec = str(range_spec).strip().lower()
+    if range_spec == "columns":
+        obs = json.dumps({"columns": columns}, indent=2)
+        return ActionResult(observation=obs)
+    if range_spec == "all":
+        table = _format_table(columns, rows)
+        return ActionResult(observation=table)
+    # Parse "1:10" format (1-indexed inclusive)
+    m = re.match(r"(\d+)\s*:\s*(\d+)", range_spec)
+    if m:
+        start, end = int(m.group(1)), int(m.group(2))
+        start = max(1, start)
+        end = min(len(rows), end)
+        if start > end:
+            return ActionResult(
+                observation="Invalid range: start > end",
+                success=False,
+                error="Invalid range",
+            )
+        subset = rows[start - 1 : end]
+        table = _format_table(columns, subset, max_rows=len(subset))
+        return ActionResult(observation=table)
+    return ActionResult(
+        observation=f"Invalid range: '{range_spec}'. Use 'columns', 'all', or 'start:end' (e.g. '1:10').",
+        success=False,
+        error="Invalid range",
+    )
+
+
+def _try_float(x: str) -> float | str:
+    """Try to parse as float, else return string."""
+    try:
+        return float(x)
+    except (ValueError, TypeError):
+        return str(x).strip()
+
+
+def _row_matches(row: dict, column: str, op: str, compare_val: float | str) -> bool:
+    """Check if row matches filter."""
+    raw = row.get(column, "")
+    is_numeric = isinstance(compare_val, (int, float))
+    if op == "contains":
+        return str(compare_val).lower() in str(raw).lower()
+    if is_numeric:
+        try:
+            cell = float(raw) if raw != "" else float("nan")
+        except (ValueError, TypeError):
+            return False
+    else:
+        cell = str(raw).strip()
+    if op == "eq":
+        return cell == compare_val
+    if op == "neq":
+        return cell != compare_val
+    if op == "gt":
+        return is_numeric and cell > compare_val
+    if op == "lt":
+        return is_numeric and cell < compare_val
+    if op == "gte":
+        return is_numeric and cell >= compare_val
+    if op == "lte":
+        return is_numeric and cell <= compare_val
+    return False
+
+
+def handle_data_filter(
+    world_path: str,
+    dataset: str,
+    column: str,
+    operator: str,
+    value: str,
+    filtered_datasets: dict,
+) -> ActionResult:
+    """
+    Filter rows. Operators: eq, neq, gt, lt, gte, lte, contains.
+    Stores result as filtered_0, filtered_1, ... in filtered_datasets.
+    """
+    try:
+        columns, rows = _get_table(world_path, dataset, filtered_datasets)
+    except Exception as e:
+        return ActionResult(observation=str(e), success=False, error=str(e))
+    if column not in columns:
+        return ActionResult(
+            observation=f"Column '{column}' not found. Available: {columns}",
+            success=False,
+            error=f"Column not found: {column}",
+        )
+    op = operator.strip().lower()
+    if op not in ("eq", "neq", "gt", "lt", "gte", "lte", "contains"):
+        return ActionResult(
+            observation=f"Unknown operator: {operator}. Use: eq, neq, gt, lt, gte, lte, contains.",
+            success=False,
+            error=f"Unknown operator: {operator}",
+        )
+    compare_val = str(value).strip() if op == "contains" else _try_float(value)
+    try:
+        filtered = [r for r in rows if _row_matches(r, column, op, compare_val)]
+    except Exception as e:
+        return ActionResult(
+            observation=f"Filter error: {e}",
+            success=False,
+            error=str(e),
+        )
+    next_idx = len([k for k in filtered_datasets if k.startswith("filtered_")])
+    store_name = f"filtered_{next_idx}"
+    filtered_datasets[store_name] = {"columns": columns, "rows": filtered}
+    return ActionResult(
+        observation=json.dumps({"rows": len(filtered), "stored_as": store_name}, indent=2),
+    )
+
+
+def handle_data_group_by(
+    world_path: str,
+    dataset: str,
+    column: str,
+    aggregation: str,
+    target_column: str,
+    filtered_datasets: dict,
+) -> ActionResult:
+    """Group by column and aggregate target_column. Aggregations: sum, mean, median, count, min, max."""
+    try:
+        columns, rows = _get_table(world_path, dataset, filtered_datasets)
+    except Exception as e:
+        return ActionResult(observation=str(e), success=False, error=str(e))
+    if column not in columns:
+        return ActionResult(
+            observation=f"Column '{column}' not found. Available: {columns}",
+            success=False,
+            error=f"Column not found: {column}",
+        )
+    if target_column not in columns:
+        return ActionResult(
+            observation=f"Column '{target_column}' not found. Available: {columns}",
+            success=False,
+            error=f"Column not found: {target_column}",
+        )
+    agg = aggregation.strip().lower()
+    if agg not in ("sum", "mean", "median", "count", "min", "max"):
+        return ActionResult(
+            observation=f"Unknown aggregation: {aggregation}. Use: sum, mean, median, count, min, max.",
+            success=False,
+            error=f"Unknown aggregation: {aggregation}",
+        )
+    try:
+        groups: dict[str, list[float]] = defaultdict(list)
+        for r in rows:
+            key = str(r.get(column, ""))
+            raw = r.get(target_column, "")
+            try:
+                val = float(raw)
+            except (ValueError, TypeError):
+                if agg == "count":
+                    val = 1
+                else:
+                    continue
+            groups[key].append(val)
+        result_rows = []
+        for key in sorted(groups.keys()):
+            vals = groups[key]
+            if agg == "sum":
+                v = sum(vals)
+            elif agg == "mean":
+                v = sum(vals) / len(vals) if vals else 0
+            elif agg == "median":
+                v = stat_median(vals) if vals else 0
+            elif agg == "count":
+                v = len(vals)
+            elif agg == "min":
+                v = min(vals) if vals else 0
+            else:  # max
+                v = max(vals) if vals else 0
+            result_rows.append({column: key, f"{agg}({target_column})": round(v, 2) if isinstance(v, float) else v})
+        table = _format_table([column, f"{agg}({target_column})"], result_rows, max_rows=1000)
+        return ActionResult(observation=table)
+    except Exception as e:
+        return ActionResult(
+            observation=f"Group-by error: {e}",
+            success=False,
+            error=str(e),
+        )
+
+
+def handle_data_add_columns(
+    world_path: str,
+    dataset: str,
+    new_column: str,
+    expression: str,
+    filtered_datasets: dict,
+) -> ActionResult:
+    """Create derived column from expression (e.g. 'a + b + c')."""
+    try:
+        columns, rows = _get_table(world_path, dataset, filtered_datasets)
+    except Exception as e:
+        return ActionResult(observation=str(e), success=False, error=str(e))
+    # Restrict expression to column names and arithmetic
+    allowed = set("abcdefghijklmnopqrstuvwxyz_0123456789.+-*/() ")
+    if not all(c in allowed for c in expression.lower().replace(" ", "")):
+        return ActionResult(
+            observation="Expression may only contain column names and +, -, *, /, (, ).",
+            success=False,
+            error="Invalid expression",
+        )
+    # Verify all names in expression are columns
+    try:
+        tree = ast.parse(expression, mode="eval")
+        names = {node.id for node in ast.walk(tree) if isinstance(node, ast.Name)}
+        for n in names:
+            if n not in columns:
+                return ActionResult(
+                    observation=f"Column '{n}' in expression not found. Available: {columns}",
+                    success=False,
+                    error=f"Column not found: {n}",
+                )
+    except SyntaxError as e:
+        return ActionResult(
+            observation=f"Invalid expression syntax: {e}",
+            success=False,
+            error=str(e),
+        )
+    try:
+        new_rows = []
+        for r in rows:
+            row = dict(r)
+            ns = {}
+            for c in columns:
+                v = _try_float(row.get(c, ""))
+                ns[c] = v if isinstance(v, (int, float)) else 0
+            try:
+                row[new_column] = round(_safe_eval_expr(tree, namespace=ns), 2)
+            except Exception:
+                row[new_column] = 0
+            new_rows.append(row)
+        new_columns = columns + [new_column]
+        next_idx = len([k for k in filtered_datasets if k.startswith("filtered_")])
+        store_name = f"filtered_{next_idx}"
+        filtered_datasets[store_name] = {"columns": new_columns, "rows": new_rows}
+        return ActionResult(
+            observation=json.dumps({"rows": len(new_rows), "stored_as": store_name, "new_column": new_column}, indent=2),
+        )
+    except Exception as e:
+        return ActionResult(
+            observation=f"Expression error: {e}",
+            success=False,
+            error=str(e),
+        )
+
+
+def handle_data_compute(expression: str) -> ActionResult:
+    """Evaluate a math expression. Only numbers and +, -, *, /, (, )."""
+    expr = expression.strip()
+    safe_pattern = re.compile(r"^[\d\s+\-*/().]+$")
+    if not safe_pattern.match(expr):
+        return ActionResult(
+            observation="Expression may only contain numbers and +, -, *, /, (, ).",
+            success=False,
+            error="Invalid expression",
+        )
+    try:
+        tree = ast.parse(expr, mode="eval")
+        result = _safe_eval_expr(tree)
+        if isinstance(result, float) and not result.is_integer():
+            return ActionResult(observation=str(round(result, 2)))
+        return ActionResult(observation=str(result))
+    except Exception as e:
+        return ActionResult(
+            observation=f"Compute error: {e}",
+            success=False,
+            error=str(e),
+        )

harfeast_openenv/environment.py

@@ -0,0 +1,351 @@
+"""HarFeast OpenEnv environment."""
+
+import json
+import os
+import random
+from .rubric import score_answer
+from .schemas import ActionResult, StepResult, parse_action
+from . import actions
+
+
+class HarFeastOpenEnv:
+    """
+    OpenEnv environment for HarFeast management consulting tasks.
+    Phase 1-3: files, spreadsheet, data actions, submit with rubric scoring.
+    """
+
+    def __init__(self, world_path: str | None = None, worlds_base: str | None = None):
+        """
+        Args:
+            world_path: Single world directory (harfeast_world or world_XXXX).
+            worlds_base: Base dir with manifest.json + all_tasks.json for augmented dataset.
+                        When set, reset() samples from all task instances.
+        """
+        self._worlds_base = os.path.abspath(worlds_base) if worlds_base else None
+        self._all_tasks: list[dict] = []
+        if self._worlds_base:
+            at_path = os.path.join(self._worlds_base, "all_tasks.json")
+            if os.path.isfile(at_path):
+                with open(at_path) as f:
+                    self._all_tasks = json.load(f)
+
+        self.world_path = world_path or os.path.join(
+            os.path.dirname(__file__), "..", "harfeast_world"
+        )
+        self.world_path = os.path.abspath(self.world_path)
+
+        self._task: dict | None = None
+        self._tasks: list = []
+        self._prompt: str = ""
+        self._step_count: int = 0
+        self._done: bool = False
+        self._submitted_answer: str | None = None
+        self._rubric_score: float | None = None
+        self._filtered_datasets: dict = {}
+        self._rng: random.Random | None = None
+        self._history: list[dict] = []
+
+        self.CONTEXT_WINDOW_STEPS = 8
+        self.MAX_STEPS = 20
+
+    @property
+    def state(self) -> dict:
+        """Current environment state."""
+        return {
+            "task_id": self._task["task_id"] if self._task else None,
+            "task_name": self._task["task_name"] if self._task else None,
+            "prompt": self._prompt,
+            "step_count": self._step_count,
+            "done": self._done,
+            "submitted_answer": self._submitted_answer,
+            "rubric_score": self._rubric_score,
+            "filtered_datasets": list(self._filtered_datasets.keys()),
+            "history": self._history,
+        }
+
+    def reset(
+        self,
+        task_id: str | None = None,
+        seed: int | None = None,
+        **kwargs,
+    ) -> StepResult:
+        """
+        Reset environment and load a task.
+        If task_id is None, pick a random task.
+        """
+        self._step_count = 0
+        self._done = False
+        self._submitted_answer = None
+        self._rubric_score = None
+        self._filtered_datasets = {}
+        self._rng = random.Random(seed) if seed is not None else random.Random()
+        self._history = []
+        # Augmented dataset: sample from all_tasks or use specific task_index
+        task_index = kwargs.get("task_index")
+        if self._all_tasks:
+            if task_index is not None and 0 <= task_index < len(self._all_tasks):
+                entry = self._all_tasks[task_index]
+            else:
+                entry = self._rng.choice(self._all_tasks)
+            wp = entry["world_path"]
+            if not os.path.isabs(wp):
+                # e.g. "./harfeast_worlds/world_0000" -> world_0000
+                wp = os.path.join(self._worlds_base, os.path.basename(wp.rstrip("/")))
+            self.world_path = os.path.abspath(wp)
+            tasks_path = os.path.join(self.world_path, "tasks.json")
+            with open(tasks_path) as f:
+                self._tasks = json.load(f)
+            self._task = next(t for t in self._tasks if t["task_id"] == entry["task_id"])
+        else:
+            # Single world
+            tasks_path = os.path.join(self.world_path, "tasks.json")
+            if not os.path.isfile(tasks_path):
+                raise FileNotFoundError(f"Tasks not found: {tasks_path}. Run world generator first.")
+            with open(tasks_path, "r", encoding="utf-8") as f:
+                self._tasks = json.load(f)
+            if task_id:
+                matches = [t for t in self._tasks if t["task_id"] == task_id]
+                if not matches:
+                    raise ValueError(f"Task not found: {task_id}")
+                self._task = matches[0]
+            else:
+                self._task = self._rng.choice(self._tasks)
+        
+        self._prompt = self._task["prompt"]
+        
+        return StepResult(
+            observation=f"Task: {self._task['task_name']}\n\nPrompt:\n{self._prompt}\n\nYou can use files.list(path), files.read(path), or other actions. What would you like to do?",
+            prompt=self._prompt,
+            step_count=0,
+            done=False,
+            reward=0.0,
+            info={"task_id": self._task["task_id"], "action_taken": "reset"},
+        )
+
+    def step(self, action: dict | str) -> StepResult:
+        """
+        Execute one action and return the result.
+        Action format: {"action": "files.list", "path": "."} or JSON string.
+        """
+        if self._task is None:
+            return StepResult(
+                observation="No task loaded. Call reset() before step().",
+                prompt="",
+                step_count=0,
+                done=True,
+                reward=0.0,
+                info={"action_taken": "none", "last_error": "reset() not called"},
+            )
+        if self._done:
+            return StepResult(
+                observation="Episode already ended. Call reset() to start a new episode.",
+                prompt=self._prompt,
+                step_count=self._step_count,
+                done=True,
+                reward=self._rubric_score or 0.0,
+                info={"action_taken": "none", "last_error": "Episode already ended"},
+            )
+        if self._step_count >= self.MAX_STEPS:
+            self._done = True
+            return self._make_step_result(
+                observation=f"Episode terminated: reached {self.MAX_STEPS} step limit without submitting.",
+                action_taken="timeout"
+            )
+
+        
+        try:
+            name, params = parse_action(action)
+        except (ValueError, json.JSONDecodeError) as e:
+            return self._make_step_result(
+                observation=f"Invalid action format: {e}",
+                action_taken="parse_error",
+                success=False,
+                last_error=str(e),
+            )
+        
+        # Dispatch to handler
+        result = self._dispatch(name, params)
+        self._step_count += 1
+        # Record in history for training context reconstruction
+        self._history.append({
+            "step": self._step_count,
+            "action": {"action": name, **params},
+            "observation": result.observation,
+            "success": result.success,
+        })
+        step_result = self._make_step_result(
+            observation=result.observation,
+            action_taken=name,
+            success=result.success,
+            last_error=result.error,
+        )
+        if name == "submit":
+            step_result.info["rubric_score"] = self._rubric_score
+        return step_result
+
+    def _dispatch(self, name: str, params: dict) -> ActionResult:
+        """Dispatch action to handler."""
+        if name == "files.list":
+            path = params.get("path", ".")
+            return actions.handle_files_list(self.world_path, path)
+        
+        if name == "files.read":
+            path = params.get("path")
+            if path is None:
+                return ActionResult(
+                    observation="files.read requires 'path' parameter.",
+                    success=False,
+                    error="Missing path",
+                )
+            return actions.handle_files_read(self.world_path, path)
+        
+        # Phase 2: spreadsheet and data actions
+        if name == "spreadsheet.read_range":
+            file = params.get("file")
+            range_spec = params.get("range", "columns")
+            if file is None:
+                return ActionResult(
+                    observation="spreadsheet.read_range requires 'file' parameter.",
+                    success=False,
+                    error="Missing file",
+                )
+            return actions.handle_spreadsheet_read_range(self.world_path, file, range_spec)
+        
+        if name == "data.filter":
+            dataset = params.get("dataset")
+            column = params.get("column")
+            operator = params.get("operator")
+            value = params.get("value")
+            if None in (dataset, column, operator, value):
+                return ActionResult(
+                    observation="data.filter requires dataset, column, operator, value.",
+                    success=False,
+                    error="Missing parameters",
+                )
+            return actions.handle_data_filter(
+                self.world_path, dataset, column, operator, str(value), self._filtered_datasets
+            )
+        
+        if name == "data.group_by":
+            dataset = params.get("dataset")
+            column = params.get("column")
+            aggregation = params.get("aggregation")
+            target_column = params.get("target_column")
+            if None in (dataset, column, aggregation, target_column):
+                return ActionResult(
+                    observation="data.group_by requires dataset, column, aggregation, target_column.",
+                    success=False,
+                    error="Missing parameters",
+                )
+            return actions.handle_data_group_by(
+                self.world_path, dataset, column, aggregation, target_column, self._filtered_datasets
+            )
+        
+        if name == "data.add_columns":
+            dataset = params.get("dataset")
+            new_column = params.get("new_column")
+            expression = params.get("expression")
+            if None in (dataset, new_column, expression):
+                return ActionResult(
+                    observation="data.add_columns requires dataset, new_column, expression.",
+                    success=False,
+                    error="Missing parameters",
+                )
+            return actions.handle_data_add_columns(
+                self.world_path, dataset, new_column, expression, self._filtered_datasets
+            )
+        
+        if name == "data.compute":
+            expression = params.get("expression")
+            if expression is None:
+                return ActionResult(
+                    observation="data.compute requires 'expression' parameter.",
+                    success=False,
+                    error="Missing expression",
+                )
+            return actions.handle_data_compute(str(expression))
+        if name == "submit":
+            answer = params.get("answer")
+            if answer is None or (isinstance(answer, str) and not answer.strip()):
+                return ActionResult(
+                    observation="submit requires non-empty 'answer' parameter.",
+                    success=False,
+                    error="Missing answer",
+                )
+            answer_text = str(answer).strip()
+            rubric_list = self._task.get("rubric", [])
+            score, results = score_answer(answer_text, rubric_list)
+            self._submitted_answer = answer_text
+            self._rubric_score = score
+            self._done = True
+            passed = sum(1 for _, p in results if p)
+            total = len(results)
+            obs = (
+                f"Episode ended. Rubric score: {score:.1f}% ({passed}/{total} criteria met).\n"
+                f"Details:\n" + "\n".join(f"  {'✓' if p else '✗'} {c[:70]}{'...' if len(c) > 70 else ''}" for c, p in results)
+            )
+            return ActionResult(observation=obs)
+        
+        return ActionResult(
+            observation=f"Unknown action: {name}. Valid actions: files.list, files.read, spreadsheet.read_range, data.filter, data.group_by, data.add_columns, data.compute, submit.",
+            success=False,
+            error=f"Unknown action: {name}",
+        )
+
+
+    def _build_context_summary(self) -> str:
+        """Compact summary of the episode so far, prepended to every observation."""
+        if not self._history or not self._task:
+            return ""
+
+        lines = [f"=== Task: {self._task['task_name']} ==="]
+        prompt_short = self._prompt[:200] + "..." if len(self._prompt) > 200 else self._prompt
+        lines.append(prompt_short)
+
+        total = len(self._history)
+
+        if total > self.CONTEXT_WINDOW_STEPS:
+            older = total - self.CONTEXT_WINDOW_STEPS
+            lines.append(f"=== Context ({older} earlier steps omitted) ===")
+            recent = self._history[-self.CONTEXT_WINDOW_STEPS:]
+        else:
+            lines.append(f"=== Context (steps 1-{total}) ===")
+            recent = self._history
+
+        for entry in recent:
+            action = entry["action"]
+            action_name = action.get("action", "?")
+            obs = entry["observation"]
+            if len(obs) > 300:
+                obs_short = obs[:300] + "..."
+            else:
+                obs_short = obs
+            obs_short = " ".join(obs_short.split())
+            lines.append(f"  Step {entry['step']}: {action_name} → {obs_short}")
+
+        ds = list(self._filtered_datasets.keys())
+        if ds:
+            lines.append(f"  Available datasets: {', '.join(ds)}")
+
+        lines.append("=== Current ===")
+        return "\n".join(lines) + "\n"
+
+
+    def _make_step_result(self, observation, action_taken, success=True, last_error=None):
+        """Build StepResult from action outcome."""
+        # Prepend history context so the agent always has full episode context
+        context = self._build_context_summary()
+        full_observation = context + observation
+
+        return StepResult(
+            observation=full_observation,
+            prompt=self._prompt,
+            step_count=self._step_count,
+            done=self._done,
+            reward=self._rubric_score if self._done else 0.0,
+            info={
+                "action_taken": action_taken,
+                "datasets_available": list(self._filtered_datasets.keys()),
+                "last_error": last_error,
+            },
+        )

harfeast_openenv/rewards.py

@@ -0,0 +1,102 @@
+"""
+GDPO-style decomposed reward functions for HarFeast GRPO training.
+
+Three independent reward signals, each normalized independently by TRL's
+GRPOTrainer when passed as a list to reward_funcs. This is equivalent to
+NVIDIA's GDPO (Jan 2026) multi-signal normalization.
+
+Signature: reward_func(completions: list[list[dict]], **kwargs) -> list[float]
+  - completions[i] = [{"role": "assistant", "content": "..."}]
+  - kwargs include dataset columns: "rubric" (JSON-serialized list of criteria)
+"""
+
+import json
+import re
+from .rubric import score_answer
+
+
+def _extract_text(completions):
+    """Extract plain text from TRL chat-format completions."""
+    texts = []
+    for comp in completions:
+        if isinstance(comp, list) and comp:
+            texts.append(comp[-1].get("content", ""))
+        elif isinstance(comp, str):
+            texts.append(comp)
+        else:
+            texts.append("")
+    return texts
+
+
+def _extract_answer(text):
+    """Pull the answer portion after 'Answer:' if present."""
+    if "Answer:" in text:
+        return text.split("Answer:")[-1].strip()
+    return text.strip()
+
+
+def reward_correctness(completions, **kwargs):
+    """
+    Signal 1: Rubric correctness (0.0 - 1.0).
+    Scores each completion against task rubric criteria using deterministic
+    substring matching. This is the primary learning signal.
+    """
+    texts = _extract_text(completions)
+    rubric_strs = kwargs.get("rubric", [])
+    rewards = []
+    for i, text in enumerate(texts):
+        answer = _extract_answer(text)
+        try:
+            rubric = json.loads(rubric_strs[i]) if i < len(rubric_strs) else []
+        except (json.JSONDecodeError, TypeError):
+            rubric = []
+        if not rubric:
+            rewards.append(0.0)
+            continue
+        score, _ = score_answer(answer, rubric)
+        rewards.append(score / 100.0)
+    return rewards
+
+
+def reward_format(completions, **kwargs):
+    """
+    Signal 2: Format compliance (0.0 or 1.0).
+    Checks that the completion follows the expected output structure:
+    contains 'Answer:', includes at least one number, reasonable length.
+    """
+    texts = _extract_text(completions)
+    rewards = []
+    for text in texts:
+        score = 0.0
+        has_answer_prefix = "Answer:" in text or "answer:" in text.lower()
+        has_number = bool(re.search(r"\d+\.?\d*", text))
+        reasonable_length = 50 <= len(text) <= 3000
+        if has_answer_prefix and has_number and reasonable_length:
+            score = 1.0
+        elif has_number and reasonable_length:
+            score = 0.5
+        rewards.append(score)
+    return rewards
+
+
+def reward_completeness(completions, **kwargs):
+    """
+    Signal 3: Numeric completeness (0.0 - 1.0).
+    Measures how many distinct numeric values appear in the answer relative
+    to the number of rubric criteria. Rewards specificity: an answer with
+    concrete numbers for every criterion scores higher.
+    """
+    texts = _extract_text(completions)
+    rubric_strs = kwargs.get("rubric", [])
+    rewards = []
+    for i, text in enumerate(texts):
+        answer = _extract_answer(text)
+        try:
+            rubric = json.loads(rubric_strs[i]) if i < len(rubric_strs) else []
+        except (json.JSONDecodeError, TypeError):
+            rubric = []
+        n_criteria = max(len(rubric), 1)
+        numbers = set(re.findall(r"\b\d[\d,.]*\d\b|\b\d+\b", answer))
+        ratio = min(len(numbers) / n_criteria, 1.0)
+        rewards.append(round(ratio, 3))
+    return rewards

harfeast_openenv/rubric.py

@@ -0,0 +1,89 @@
+"""Rubric scoring for HarFeast OpenEnv."""
+
+import re
+from typing import Sequence
+
+
+def _extract_expected_value(criterion: str) -> str | None:
+    """
+    Extract the expected value from a rubric criterion.
+    Pattern: "States that ... is VALUE" or "States that ... VALUE"
+    """
+    # Match " is X" or " is $X" at the end
+    m = re.search(r"\s+is\s+(.+)$", criterion)
+    if m:
+        return m.group(1).strip().strip('"')
+    return None
+
+
+def _normalize_for_match(value: str) -> list[str]:
+    """
+    Return variants of the value to check against the answer.
+    Handles numbers with commas, percentages, etc.
+    """
+    value = value.strip()
+    variants = [value]
+    # Remove commas from numbers
+    no_commas = value.replace(",", "")
+    if no_commas != value:
+        variants.append(no_commas)
+    # For percentages: "14%" -> also accept "14" and "14 percent"
+    if value.endswith("%"):
+        num_part = value[:-1].strip()
+        variants.extend([num_part, f"{num_part}%", f"{num_part} percent"])
+        # Remove trailing .0 for whole numbers
+        if "." in num_part and num_part.endswith("0"):
+            variants.append(num_part.rstrip("0").rstrip("."))
+    # For dollar amounts: "$21,953,848,911" -> also without $
+    if value.startswith("$"):
+        variants.append(value[1:].strip())
+        variants.append(value[1:].replace(",", ""))
+    # For decimals like 87.00% - accept 87
+    if "%" in value and "." in value:
+        num_part = value.replace("%", "").strip()
+        try:
+            f = float(num_part)
+            if f == int(f):
+                variants.append(str(int(f)))
+        except ValueError:
+            pass
+    return list(dict.fromkeys(variants))  # dedupe preserving order
+
+
+def _answer_contains_value(answer: str, expected: str) -> bool:
+    """Check if answer contains the expected value (or a normalized variant)."""
+    answer_lower = answer.lower()
+    variants = _normalize_for_match(expected)
+    for v in variants:
+        if not v:
+            continue
+        # Case-insensitive for text; exact substring for numbers
+        if v.lower() in answer_lower:
+            return True
+        # For numbers, also check without leading zeros
+        if v.isdigit() and str(int(v)) in answer:
+            return True
+    return False
+
+
+def score_answer(answer: str, rubric: Sequence[str]) -> tuple[float, list[tuple[str, bool]]]:
+    """
+    Score an answer against rubric criteria.
+    Returns (score_0_to_100, list of (criterion, passed)).
+    """
+    if not rubric:
+        return 100.0, []
+    results = []
+    for criterion in rubric:
+        expected = _extract_expected_value(criterion)
+        if expected is None:
+            # No " is X" pattern - fall back to substring of criterion
+            # e.g. "States that X" - check if key phrase appears
+            key = criterion.replace("States that ", "").strip()
+            passed = key.lower() in answer.lower()
+        else:
+            passed = _answer_contains_value(answer, expected)
+        results.append((criterion, passed))
+    passed_count = sum(1 for _, p in results if p)
+    score = (passed_count / len(rubric)) * 100.0
+    return round(score, 1), results

harfeast_openenv/schemas.py

@@ -0,0 +1,40 @@
+"""Action and observation schemas for HarFeast OpenEnv."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ActionResult:
+    """Result of executing an action."""
+    observation: str
+    success: bool = True
+    error: str | None = None
+
+
+@dataclass
+class StepResult:
+    """Result returned by environment.step()."""
+    observation: str
+    prompt: str
+    step_count: int
+    done: bool
+    reward: float
+    info: dict[str, Any] = field(default_factory=dict)
+
+
+def parse_action(action: dict | str) -> tuple[str, dict]:
+    """
+    Parse action from dict or JSON string.
+    Returns (action_name, params).
+    """
+    if isinstance(action, str):
+        import json
+        action = json.loads(action)
+    
+    if not isinstance(action, dict) or "action" not in action:
+        raise ValueError("Action must be a dict with 'action' key")
+    
+    name = action["action"]
+    params = {k: v for k, v in action.items() if k != "action"}
+    return name, params

harfeast_synthetic_world_generator.py

@@ -0,0 +1,1454 @@
+"""
+HarFeast Synthetic World Generator
+Generates all data sources, computes ground truth, and produces task prompts + rubrics
+for an APEX-style management consulting RL environment.
+
+Supports parameterized generation for 200-500+ distinct task instances (RL scalability).
+
+Usage:
+    python harfeast_synthetic_world_generator.py [--seed 42] [--output-dir ./world]
+    python harfeast_synthetic_world_generator.py --batch 40 --output-dir ./harfeast_worlds
+"""
+
+import random
+import csv
+import json
+import os
+import math
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Optional
+
+# =============================================================================
+# WORLD CONFIG - Parameterized variations
+# =============================================================================
+
+# Plant pool: (city, state) - one per state group. Order: IL, WI, IA, OH, MI.
+# Tasks 5/9 need plants[0]=IL, plants[1]=WI, plants[2]=IA
+PLANT_POOL_IL = ["Rockford", "Peoria", "Springfield", "Champaign", "Bloomington"]
+PLANT_POOL_WI = ["Madison", "Milwaukee", "Green Bay", "Kenosha", "Racine"]
+PLANT_POOL_IA = ["Cedar Rapids", "Des Moines", "Davenport", "Sioux City", "Iowa City"]
+PLANT_POOL_OH = ["Toledo", "Columbus", "Cleveland", "Cincinnati", "Akron"]
+PLANT_POOL_MI = ["Kalamazoo", "Lansing", "Detroit", "Grand Rapids", "Flint"]
+
+
+@dataclass
+class WorldConfig:
+    """Configuration for a single world variation."""
+    seed: int = 42
+    n_employees: int = 3000
+    plants: tuple = field(default_factory=lambda: (
+        "Rockford, Illinois", "Madison, Wisconsin", "Cedar Rapids, Iowa",
+        "Toledo, Ohio", "Kalamazoo, Michigan",
+    ))
+    target_scrap_pct: float = 4.0
+    scrap_range_max_pct: float = 7.0
+    training_received_weight: float = 0.4
+    frito_lay_reduction_pct: float = 30.0
+    wage_scale: float = 1.0
+    # Aptean report: add small noise to growth numbers
+    aptean_noise: float = 0.0
+
+
+def sample_world_config(rng: random.Random, seed: int) -> WorldConfig:
+    """Sample a random world configuration for variation."""
+    il = rng.choice(PLANT_POOL_IL) + ", Illinois"
+    wi = rng.choice(PLANT_POOL_WI) + ", Wisconsin"
+    ia = rng.choice(PLANT_POOL_IA) + ", Iowa"
+    oh = rng.choice(PLANT_POOL_OH) + ", Ohio"
+    mi = rng.choice(PLANT_POOL_MI) + ", Michigan"
+    plants = (il, wi, ia, oh, mi)
+
+    target = rng.choice([3.5, 4.0, 4.5])
+    range_max = target + rng.choice([2.5, 3.0, 3.5])
+
+    return WorldConfig(
+        seed=seed,
+        n_employees=rng.randint(2000, 5000),
+        plants=plants,
+        target_scrap_pct=target,
+        scrap_range_max_pct=range_max,
+        training_received_weight=rng.uniform(0.35, 0.5),
+        frito_lay_reduction_pct=rng.choice([28.0, 30.0, 32.0]),
+        wage_scale=rng.uniform(0.95, 1.05),
+        aptean_noise=rng.uniform(0, 0.5),
+    )
+
+
+def _plant_divisions(plants: tuple) -> dict:
+    """Build plant->census_division map. IA=West North Central, rest=East North Central."""
+    div = {}
+    for i, p in enumerate(plants):
+        div[p] = "West North Central" if i == 2 else "East North Central"
+    return div
+
+ROLES = [
+    "Production/Manufacturing Operator",
+    "Quality Control/Quality Assurance",
+    "Maintenance Technician",
+    "Production Supervisor/Team Lead",
+    "Supply Chain/Logistics Coordinator",
+    "Demand Planning/Forecasting",
+    "Administrative/Support Staff",
+    "Plant Management",
+]
+
+ROLE_TYPES = {
+    "Production/Manufacturing Operator": "Front-line",
+    "Quality Control/Quality Assurance": "Front-line",
+    "Maintenance Technician": "Front-line",
+    "Production Supervisor/Team Lead": "Supervisor/Team Lead",
+    "Supply Chain/Logistics Coordinator": "Back-office/Support",
+    "Demand Planning/Forecasting": "Back-office/Support",
+    "Administrative/Support Staff": "Back-office/Support",
+    "Plant Management": "Management",
+}
+
+PRODUCT_FAMILIES = ["Canned Vegetables", "Condiments", "Sauces"]
+EQUIPMENT_TYPES = ["Mixer", "Filler", "Sealer", "Conveyor", "Boiler", "Pasteurizer", "Labeler"]
+TRAINING_QUALITY_OPTIONS = [
+    "Excellent- comprehensive and very helpful",
+    "Good- adequate for most needs",
+    "Fair- some gaps or inconsistencies",
+    "Poor - insufficient or unhelpful",
+]
+
+# Base hourly wages by role (used for wage data file)
+BASE_WAGES = {
+    "Production/Manufacturing Operator": 18.50,
+    "Quality Control/Quality Assurance": 22.00,
+    "Maintenance Technician": 25.50,
+    "Production Supervisor/Team Lead": 28.00,
+    "Supply Chain/Logistics Coordinator": 24.00,
+    "Demand Planning/Forecasting": 30.00,
+    "Administrative/Support Staff": 20.00,
+    "Plant Management": 42.00,
+}
+
+# =============================================================================
+# DATA GENERATORS
+# =============================================================================
+
+def generate_employee_survey(rng, cfg: WorldConfig):
+    """Generate the main employee workforce survey dataset."""
+    employees = []
+    n = cfg.n_employees
+    plants = list(cfg.plants)
+    high_inefficiency_plants = list(cfg.plants[3:5])
+    willing_high, willing_low = cfg.plants[1], cfg.plants[0]
+
+    for i in range(n):
+        plant = rng.choice(plants)
+        role = rng.choice(ROLES)
+        role_type = ROLE_TYPES[role]
+        
+        # Inefficient hours - higher for Toledo/Kalamazoo
+        if plant in high_inefficiency_plants:
+            manual = round(rng.uniform(8, 30), 1)
+            searching = round(rng.uniform(4, 18), 1)
+            fixing = round(rng.uniform(3, 12), 1)
+        else:
+            manual = round(rng.uniform(0, 8), 1)
+            searching = round(rng.uniform(0, 5), 1)
+            fixing = round(rng.uniform(0, 4), 1)
+        
+        # Digital readiness varies by role type
+        base_readiness = {"Front-line": 4, "Back-office/Support": 6, 
+                          "Supervisor/Team Lead": 5, "Management": 7}
+        readiness = round(rng.gauss(base_readiness[role_type], 2), 1)
+        readiness = max(1, min(10, readiness))
+        
+        comfort = round(rng.gauss(5.5, 2), 1)
+        comfort = max(1, min(10, comfort))
+        
+        willing_pilot = rng.choice(["Yes", "No"])
+        training_days = rng.choice(["<1 day", "1-2 days", ">2 days"])
+        dedicated_time = rng.choice(["Yes", "No"])
+        
+        training_received = rng.choices(
+            ["Yes", "No"],
+            weights=[cfg.training_received_weight, 1 - cfg.training_received_weight],
+        )[0]
+        if training_received == "Yes":
+            quality = rng.choices(
+                TRAINING_QUALITY_OPTIONS,
+                weights=[0.16, 0.41, 0.33, 0.10]
+            )[0]
+        else:
+            quality = ""
+        
+        # Willingness to adopt - varies by plant (highest/lowest for Task 12)
+        if plant == willing_high:
+            willingness = round(rng.gauss(3.8, 0.8), 1)
+        elif plant == willing_low:
+            willingness = round(rng.gauss(2.5, 0.8), 1)
+        else:
+            willingness = round(rng.gauss(3.2, 0.9), 1)
+        willingness = max(1, min(5, willingness))
+        
+        base = BASE_WAGES[role] * cfg.wage_scale
+        hourly_wage = round(rng.gauss(base, 3), 2)
+        hourly_wage = max(12, hourly_wage)
+        
+        union_status = rng.choice(["Union", "Non-Union"])
+        
+        employees.append({
+            "employee_id": f"EMP-{i:04d}",
+            "plant": plant,
+            "role": role,
+            "role_type": role_type,
+            "digital_readiness_score": readiness,
+            "digital_comfort_score": comfort,
+            "willing_to_pilot": willing_pilot,
+            "training_days_willing": training_days,
+            "dedicated_training_time": dedicated_time,
+            "hours_manual_entry": manual,
+            "hours_searching_data": searching,
+            "hours_fixing_errors": fixing,
+            "hourly_wage": hourly_wage,
+            "training_received": training_received,
+            "training_quality": quality,
+            "willingness_to_adopt": willingness,
+            "union_status": union_status,
+        })
+    
+    return employees
+
+
+def generate_equipment_data(rng, cfg: WorldConfig):
+    """Generate plant equipment dataset. ~50 per plant."""
+    equipment = []
+    eq_id = 0
+    plants = cfg.plants
+    oee_base = {p: 0.78 - i * 0.02 + rng.uniform(-0.02, 0.02) for i, p in enumerate(plants)}
+    oee_base = {p: max(0.65, min(0.88, v)) for p, v in oee_base.items()}
+
+    for plant in plants:
+        n_equip = rng.randint(45, 55)
+        for j in range(n_equip):
+            pf = rng.choice(PRODUCT_FAMILIES)
+            et = rng.choice(EQUIPMENT_TYPES)
+            
+            scheduled = round(rng.uniform(1500, 5000))
+            actual = round(scheduled * rng.uniform(0.7, 0.98))
+            standard = round(scheduled * rng.uniform(0.85, 1.0))
+            labor = round(rng.uniform(500, 3000))
+            
+            # Scrap rates - most between 3-9%, some outliers
+            scrap = round(rng.uniform(0.03, 0.10), 4)
+            
+            oee = round(rng.gauss(oee_base[plant], 0.06), 4)
+            oee = max(0.45, min(0.95, oee))
+            
+            downtime = round(rng.uniform(50, 500))
+            units = rng.randint(100000, 600000)
+            cogs = round(rng.uniform(800, 2000), 2)
+            failure_cost = round(rng.uniform(5000, 50000), 2)
+            
+            equipment.append({
+                "equipment_id": f"EQ-{plant[:3].upper()}-{eq_id:03d}",
+                "plant": plant,
+                "product_family": pf,
+                "equipment_type": et,
+                "scheduled_hours": scheduled,
+                "actual_hours": actual,
+                "standard_hours": standard,
+                "labor_hours": labor,
+                "scrap_rate": scrap,
+                "oee": oee,
+                "unplanned_downtime_hours": downtime,
+                "units_produced": units,
+                "cogs_per_ton": cogs,
+                "failure_cost": failure_cost,
+            })
+            eq_id += 1
+    
+    return equipment
+
+
+def generate_quality_losses(rng, equipment):
+    """Generate quality losses data derived from equipment data."""
+    losses = []
+    for eq in equipment:
+        scrap_cost = round(eq["cogs_per_ton"] * eq["units_produced"] * eq["scrap_rate"] / 1000, 2)
+        failure = round(rng.uniform(2000, 30000), 2)
+        losses.append({
+            "equipment_id": eq["equipment_id"],
+            "plant": eq["plant"],
+            "product_family": eq["product_family"],
+            "scrap_cost": scrap_cost,
+            "unplanned_failure_cost": failure,
+        })
+    return losses
+
+
+def generate_plant_labor(rng, cfg: WorldConfig):
+    """Generate per-employee plant labor data for Tasks 5 and 9."""
+    labor = []
+    lab_id = 0
+    plant_divs = _plant_divisions(cfg.plants)
+
+    production_roles = [
+        "Production Operator", "Quality Inspector", "Maintenance Tech",
+        "Production Supervisor", "Line Lead", "Packaging Operator"
+    ]
+
+    for plant in cfg.plants[:3]:  # Tasks 5 and 9 only use IL, WI, IA plants
+        n_workers = rng.randint(15, 25)
+        for j in range(n_workers):
+            role = rng.choice(production_roles)
+            is_supervisor = "Supervisor" in role or "Lead" in role
+            wage = round(rng.gauss(22 if is_supervisor else 18, 2), 2)
+            wage = max(14, wage)
+            
+            labor.append({
+                "employee_id": f"LAB-{plant[:3].upper()}-{lab_id:03d}",
+                "plant": plant,
+                "role": role,
+                "hourly_wage": wage,
+                "annual_hours": 2080,
+                "union_status": rng.choice(["Union", "Non-Union"]),
+                "supervisor_type": "production" if is_supervisor else "non-production",
+                "census_division": plant_divs[plant],
+            })
+            lab_id += 1
+    
+    return labor
+
+
+def generate_bls_wages(cfg: WorldConfig):
+    """BLS wage benchmark data."""
+    s = cfg.wage_scale
+    return [
+        {"occupation": "All Occupations", "industry": "Food Manufacturing", "median_hourly_wage": round(19.76 * s, 2)},
+        {"occupation": "Production Workers", "industry": "Food Manufacturing", "median_hourly_wage": round(17.85 * s, 2)},
+        {"occupation": "Supervisors", "industry": "Food Manufacturing", "median_hourly_wage": round(28.50 * s, 2)},
+        {"occupation": "Maintenance", "industry": "Food Manufacturing", "median_hourly_wage": round(24.30 * s, 2)},
+        {"occupation": "Quality Control", "industry": "Food Manufacturing", "median_hourly_wage": round(21.15 * s, 2)},
+        {"occupation": "Logistics", "industry": "Food Manufacturing", "median_hourly_wage": round(22.80 * s, 2)},
+    ]
+
+
+def generate_attached_wages(cfg: WorldConfig):
+    """Client-provided updated wage data for Task 10."""
+    s = cfg.wage_scale
+    bases = [21.50, 25.80, 29.40, 33.20, 27.60, 35.10, 23.40, 48.50]
+    roles = list(ROLES)
+    return [{"role": r, "avg_hourly_salary": round(b * s, 2)} for r, b in zip(roles, bases)]
+
+
+def generate_oee_assumptions(cfg: WorldConfig, rng: random.Random):
+    """OEE improvement assumptions for Task 4."""
+    plants = cfg.plants
+    base_oee = [0.78, 0.76, 0.80, 0.73, 0.71]
+    improvements = [0.030, 0.028, 0.032, 0.025, 0.024]
+    start_years = [2025, 2025, 2025, 2026, 2026]
+    return [
+        {
+            "plant": p,
+            "current_annual_oee": round(base_oee[i] + rng.uniform(-0.02, 0.02), 4),
+            "annual_oee_improvement": round(improvements[i] + rng.uniform(-0.002, 0.002), 4),
+            "investment_start_year": start_years[i],
+            "world_class_oee_target": 0.85,
+        }
+        for i, p in enumerate(plants)
+    ]
+
+
+def generate_plant_sales(cfg: WorldConfig, rng: random.Random):
+    """Plant unit sales data for Task 11."""
+    plants = list(cfg.plants)
+    bases = [(16500000, 3.09), (20600000, 3.12), (4680000, 5.98), (4890000, 6.86), (6400000, 6.02)]
+    return [
+        {
+            "plant": p,
+            "current_unit_sales": int(b[0] * rng.uniform(0.85, 1.15)),
+            "price_per_unit": round(b[1] * rng.uniform(0.95, 1.05), 2),
+        }
+        for p, b in zip(plants, bases)
+    ]
+
+
+def generate_aptean_report(cfg: WorldConfig, rng: random.Random):
+    """Aptean industry report data for Task 11."""
+    base = [
+        ("IoT Sensors", 12.5, 4.2, "Top Investment to Date"),
+        ("Predictive Maintenance", 11.8, 3.9, "Top Planned 2024"),
+        ("Cloud ERP", 9.2, 5.1, "Top Investment to Date"),
+        ("Robotic Automation", 10.4, 3.5, "Top Planned 2024"),
+        ("AI Quality Control", 8.7, 4.8, "Top Investment to Date"),
+        ("Digital Twin", 7.3, 4.0, "Other"),
+        ("Supply Chain AI", 6.9, 3.2, "Other"),
+        ("Automated Scheduling", 8.1, 5.5, "Top Planned 2024"),
+        ("Warehouse Robotics", 7.8, 5.0, "Other"),
+        ("Advanced Analytics", 9.8, 4.5, "Top Investment to Date"),
+    ]
+    noise = cfg.aptean_noise
+    return [
+        {
+            "technology": t,
+            "users_growth": round(u + rng.uniform(-noise, noise), 1),
+            "non_users_growth": round(n + rng.uniform(-noise, noise), 1),
+            "category": c,
+        }
+        for t, u, n, c in base
+    ]
+
+
+# =============================================================================
+# TEXT DOCUMENT GENERATORS
+# =============================================================================
+
+def generate_scrap_report(cfg: WorldConfig):
+    target = cfg.target_scrap_pct
+    rmax = cfg.scrap_range_max_pct
+    return f"""HarFeast Food Group - Quality Standards: Scrap Rate Report
+==========================================================
+
+Acceptable scrap rate range: {target}% - {rmax}%
+Target scrap rate (minimum of acceptable range): {target}%
+
+Plants operating above {rmax}% require immediate corrective action and 
+must submit a remediation plan within 30 days. Quarterly reviews will 
+assess progress toward the target rate.
+
+The target scrap rate represents the minimum of the acceptable range 
+and should be used as the baseline for all cost-of-quality calculations.
+"""
+
+
+def generate_interviews():
+    interviews = {}
+    
+    interviews["sarah_jenkins"] = """Expert Interview Transcript - Sarah Jenkins, VP Operations
+Date: November 15, 2024
+
+Q: Of the digital levers evaluated, which would deliver the fastest and 
+biggest boost to HarFeast's Gross Margin?
+
+A: "We've evaluated several options including predictive maintenance, 
+automated scheduling, and IoT-based monitoring. In my assessment, 
+IoT Sensors for yield monitoring would deliver the fastest and most 
+significant boost to our Gross Margin. The real-time data on production 
+yield lets us catch quality issues at the source before they cascade 
+into scrap. I've seen it work at comparable food manufacturers with 
+measurable margin improvement within 6 months of deployment."
+"""
+    
+    interviews["david_chen"] = """Expert Interview Transcript - David Chen, Director of Manufacturing
+Date: November 16, 2024
+
+Q: What digital investment would have the fastest and largest impact 
+on HarFeast's profitability?
+
+A: "I've been looking at this from an operations standpoint. While 
+predictive maintenance is valuable long-term, the immediate winner 
+is IoT Sensors for yield optimization. The ability to monitor yield 
+in real-time across all product lines gives us immediate visibility 
+into where we're losing margin. Other levers like automated scheduling 
+help with throughput but don't directly attack gross margin the way 
+yield sensing does. IoT Sensors for yield is my top recommendation."
+"""
+    
+    interviews["mike_russo"] = """Expert Interview Transcript - Mike Russo, Head of Digital Transformation
+Date: November 17, 2024
+
+Q: Which digital lever should HarFeast prioritize for the fastest 
+margin improvement?
+
+A: "After analyzing all the options, I keep coming back to 
+IoT Sensors for yield. The ROI timeline is shortest — typically 
+4-8 months to see measurable improvement. Predictive maintenance 
+is a close second but has a longer implementation cycle. Cloud ERP 
+is foundational but doesn't directly move gross margin in the near 
+term. IoT Sensors for yield monitoring is the clear priority if 
+we want the fastest and biggest boost to Gross Margin."
+"""
+    
+    return interviews
+
+
+def generate_frito_lay_case(cfg: WorldConfig):
+    pct = int(cfg.frito_lay_reduction_pct)
+    return f"""Frito-Lay Digital Transformation Case Study
+=============================================
+
+Background: Frito-Lay North America, a division of PepsiCo, operates 
+over 30 manufacturing facilities producing snack foods including 
+Doritos, Cheetos, and Lay's potato chips.
+
+Initiative: In 2022, Frito-Lay deployed IoT-based predictive maintenance 
+sensors across their manufacturing network, focusing on high-throughput 
+production lines.
+
+Results: After 18 months of deployment, Frito-Lay achieved a {pct}% 
+reduction in unplanned downtime across all monitored production lines. 
+The improvement was consistent across facilities regardless of size 
+or product type.
+
+Key Success Factors:
+- Phased rollout starting with highest-volume lines
+- Integration with existing SCADA systems
+- Dedicated data analytics team for sensor data interpretation
+- Weekly review cadence with plant managers
+
+The {pct}% unplanned downtime reduction translated to approximately 
+$45M in annual cost savings across the network.
+"""
+
+
+def generate_aptean_report_text(aptean_data):
+    lines = ["Aptean Food & Beverage Manufacturing Technology Report 2024",
+             "=" * 60, "",
+             "Top Technology Investments and Revenue Impact Analysis", "",
+             f"{'Technology':<25} {'Users Growth':>15} {'Non-Users Growth':>18} {'Category':<28}",
+             "-" * 86]
+    for row in aptean_data:
+        lines.append(f"{row['technology']:<25} {row['users_growth']:>14.1f}% {row['non_users_growth']:>17.1f}% {row['category']:<28}")
+    
+    lines.extend(["", "",
+        "Note: 'Top Investment to Date' and 'Top Planned 2024' represent",
+        "investments explicitly identified by surveyed manufacturers as",
+        "their highest-priority technology initiatives."])
+    return "\n".join(lines)
+
+
+# =============================================================================
+# GROUND TRUTH COMPUTATION
+# =============================================================================
+
+def median(values):
+    """Compute median of a list of numbers."""
+    s = sorted(values)
+    n = len(s)
+    if n == 0:
+        return 0
+    if n % 2 == 1:
+        return s[n // 2]
+    return (s[n // 2 - 1] + s[n // 2]) / 2
+
+
+def percentile(values, p):
+    """Compute percentile using linear interpolation."""
+    s = sorted(values)
+    n = len(s)
+    if n == 0:
+        return 0
+    k = (n - 1) * p / 100
+    f = math.floor(k)
+    c = math.ceil(k)
+    if f == c:
+        return s[int(k)]
+    return s[f] * (c - k) + s[c] * (k - f)
+
+
+def compute_ground_truth(employees, equipment, quality_losses, plant_labor,
+                         bls_wages, attached_wages, oee_assumptions,
+                         plant_sales, aptean_data, cfg: WorldConfig):
+    """Compute ground truth answers for all 14 tasks."""
+    truth = {}
+    PLANTS = list(cfg.plants)
+    target_scrap = cfg.target_scrap_pct / 100
+    frito_lay_mult = 1 - cfg.frito_lay_reduction_pct / 100
+    
+    # =========================================================================
+    # TASK 1: High-priority employees for digital training rollout
+    # =========================================================================
+    # Conditions: above role_type median readiness, willing to pilot,
+    # >2 days training with dedicated time, above overall median comfort
+    
+    overall_median_comfort = median([e["digital_comfort_score"] for e in employees])
+    
+    role_type_readiness_medians = {}
+    by_rt = defaultdict(list)
+    for e in employees:
+        by_rt[e["role_type"]].append(e["digital_readiness_score"])
+    for rt, scores in by_rt.items():
+        role_type_readiness_medians[rt] = median(scores)
+    
+    high_priority = []
+    for e in employees:
+        if (e["digital_readiness_score"] > role_type_readiness_medians[e["role_type"]]
+            and e["willing_to_pilot"] == "Yes"
+            and e["training_days_willing"] == ">2 days"
+            and e["dedicated_training_time"] == "Yes"
+            and e["digital_comfort_score"] > overall_median_comfort):
+            high_priority.append(e)
+    
+    hp_count = len(high_priority)
+    hp_pct = round(hp_count / len(employees) * 100, 1)
+    
+    hp_inefficient = sum(e["hours_manual_entry"] + e["hours_searching_data"] + e["hours_fixing_errors"] for e in high_priority)
+    total_inefficient = sum(e["hours_manual_entry"] + e["hours_searching_data"] + e["hours_fixing_errors"] for e in employees)
+    hp_inefficient_pct = round(hp_inefficient / total_inefficient * 100, 1) if total_inefficient > 0 else 0
+    
+    hp_by_role_type = defaultdict(int)
+    for e in high_priority:
+        hp_by_role_type[e["role_type"]] += 1
+    
+    truth["task1"] = {
+        "high_priority_count": hp_count,
+        "high_priority_pct": hp_pct,
+        "hp_inefficient_hours": round(hp_inefficient, 0),
+        "hp_inefficient_pct": hp_inefficient_pct,
+        "hp_frontline": hp_by_role_type.get("Front-line", 0),
+        "hp_backoffice": hp_by_role_type.get("Back-office/Support", 0),
+        "hp_supervisor": hp_by_role_type.get("Supervisor/Team Lead", 0),
+        "hp_management": hp_by_role_type.get("Management", 0),
+    }
+    
+    # =========================================================================
+    # TASK 2: Adjusted Cost of Instability per plant
+    # =========================================================================
+    # Formula: Abnormal scrap cost / (Actual Scrap% - Target Scrap%)
+    plant_instability = {}
+    for plant in PLANTS:
+        plant_equip = [e for e in equipment if e["plant"] == plant]
+        total_abnormal_cost = 0
+        total_weighted_scrap = 0
+        total_units = 0
+        
+        for eq in plant_equip:
+            if eq["scrap_rate"] > target_scrap:
+                abnormal = eq["cogs_per_ton"] * eq["units_produced"] * (eq["scrap_rate"] - target_scrap)
+                total_abnormal_cost += abnormal
+            total_weighted_scrap += eq["scrap_rate"] * eq["units_produced"]
+            total_units += eq["units_produced"]
+        
+        avg_scrap = total_weighted_scrap / total_units if total_units > 0 else 0
+        denominator = avg_scrap - target_scrap
+        
+        if denominator > 0:
+            adjusted_cost = round(total_abnormal_cost / denominator)
+        else:
+            adjusted_cost = 0
+        
+        plant_instability[plant] = adjusted_cost
+    
+    truth["task2"] = plant_instability
+    
+    # =========================================================================
+    # TASK 3: Predictive maintenance impact on scrap rate
+    # =========================================================================
+    # Pilot on equipment where: scheduled_hours >= equipment_type median
+    # AND labor_hours >= plant median labor hours
+    # Apply 15% scrap reduction to qualifying equipment
+    
+    # Equipment type median scheduled hours
+    by_type = defaultdict(list)
+    for eq in equipment:
+        by_type[eq["equipment_type"]].append(eq["scheduled_hours"])
+    type_median_scheduled = {t: median(hrs) for t, hrs in by_type.items()}
+    
+    # Plant median labor hours
+    by_plant_labor = defaultdict(list)
+    for eq in equipment:
+        by_plant_labor[eq["plant"]].append(eq["labor_hours"])
+    plant_median_labor = {p: median(hrs) for p, hrs in by_plant_labor.items()}
+    
+    scrap_reduction = 0.15  # 15% reduction for qualifying equipment
+    
+    # Compute new scrap rates by product family
+    pf_data = defaultdict(lambda: {"total_units": 0, "total_scrap_units": 0})
+    for eq in equipment:
+        qualifies = (eq["scheduled_hours"] >= type_median_scheduled[eq["equipment_type"]]
+                     and eq["labor_hours"] >= plant_median_labor[eq["plant"]])
+        
+        scrap_units = eq["units_produced"] * eq["scrap_rate"]
+        if qualifies:
+            scrap_units *= (1 - scrap_reduction)
+        
+        pf_data[eq["product_family"]]["total_units"] += eq["units_produced"]
+        pf_data[eq["product_family"]]["total_scrap_units"] += scrap_units
+    
+    # Also compute original scrap units for avoidance calc
+    pf_original = defaultdict(lambda: {"total_units": 0, "total_scrap_units": 0})
+    for eq in equipment:
+        pf_original[eq["product_family"]]["total_units"] += eq["units_produced"]
+        pf_original[eq["product_family"]]["total_scrap_units"] += eq["units_produced"] * eq["scrap_rate"]
+    
+    task3 = {}
+    for pf in PRODUCT_FAMILIES:
+        new_rate = round(pf_data[pf]["total_scrap_units"] / pf_data[pf]["total_units"] * 100, 1)
+        avoided = round(pf_original[pf]["total_scrap_units"] - pf_data[pf]["total_scrap_units"])
+        task3[pf] = {"new_scrap_rate_pct": new_rate, "units_avoided": avoided}
+    
+    truth["task3"] = task3
+    
+    # =========================================================================
+    # TASK 4: Digital lever agreement + OEE projections
+    # =========================================================================
+    # Lever is "IoT Sensors for yield" (from interviews)
+    # Project OEE per plant until it exceeds world-class target
+    
+    task4 = {"digital_lever": "IoT Sensors for yield"}
+    for oee_row in oee_assumptions:
+        plant = oee_row["plant"]
+        oee = oee_row["current_annual_oee"]
+        improvement = oee_row["annual_oee_improvement"]
+        start_year = oee_row["investment_start_year"]
+        target = oee_row["world_class_oee_target"]
+        
+        year = start_year
+        while oee < target and year < 2040:
+            oee += improvement
+            year += 1
+        
+        if oee >= target:
+            task4[plant] = {
+                "first_year_exceeds": year,
+                "oee_at_that_year": round(oee, 4)
+            }
+    
+    truth["task4"] = task4
+    
+    # =========================================================================
+    # TASK 5: Total labor cost, efficiency gains, union demand
+    # =========================================================================
+    
+    task5 = {}
+    for plant in PLANTS[:3]:  # Only IL, WI, IA
+        plant_workers = [w for w in plant_labor if w["plant"] == plant]
+        
+        # Total annual labor cost
+        total_cost = sum(w["hourly_wage"] * w["annual_hours"] for w in plant_workers)
+        total_cost = round(total_cost)
+        
+        # Efficiency gains: 10% for West North Central, 20% for others
+        # But 5% for non-unionized production supervisors regardless
+        efficiency = 0
+        for w in plant_workers:
+            if w["union_status"] == "Non-Union" and w["supervisor_type"] == "production":
+                rate = 0.05
+            elif w["census_division"] == "West North Central":
+                rate = 0.10
+            else:
+                rate = 0.20
+            efficiency += w["hourly_wage"] * w["annual_hours"] * rate
+        efficiency = round(efficiency)
+        
+        # Union demand: 5% increase for union workers
+        union_increase = sum(
+            w["hourly_wage"] * w["annual_hours"] * 0.05
+            for w in plant_workers if w["union_status"] == "Union"
+        )
+        union_increase = round(union_increase)
+        
+        task5[plant] = {
+            "total_labor_cost": total_cost,
+            "efficiency_gains": efficiency,
+            "union_demand_increase": union_increase,
+        }
+    
+    truth["task5"] = task5
+    
+    # =========================================================================
+    # TASK 6: Average inefficient hours per plant
+    # =========================================================================
+    
+    plant_inefficient = defaultdict(list)
+    for e in employees:
+        total = e["hours_manual_entry"] + e["hours_searching_data"] + e["hours_fixing_errors"]
+        plant_inefficient[e["plant"]].append(total)
+    
+    task6 = {}
+    for plant in PLANTS:
+        avg = round(sum(plant_inefficient[plant]) / len(plant_inefficient[plant]), 1)
+        task6[plant] = avg
+    
+    sorted_plants = sorted(task6.items(), key=lambda x: x[1])
+    most_efficient = [p for p, v in sorted_plants if v == sorted_plants[0][1]]
+    least_efficient = sorted_plants[-1][0]
+    least_val = sorted_plants[-1][1]
+    most_val = sorted_plants[0][1]
+    pct_diff = round((least_val - most_val) / most_val * 100)
+    
+    truth["task6"] = {
+        "avg_by_plant": task6,
+        "most_efficient": most_efficient,
+        "least_efficient": least_efficient,
+        "pct_difference": pct_diff,
+    }
+    
+    # =========================================================================
+    # TASK 7: Average annual productivity loss per role
+    # =========================================================================
+    # Survey = 1 week. Annual = multiply by 52.
+    
+    role_losses = defaultdict(list)
+    for e in employees:
+        weekly_inefficient = e["hours_manual_entry"] + e["hours_searching_data"] + e["hours_fixing_errors"]
+        annual_loss = weekly_inefficient * 52 * e["hourly_wage"]
+        role_losses[e["role"]].append(annual_loss)
+    
+    task7 = {}
+    total_annual_loss = 0
+    for role in ROLES:
+        if role in role_losses:
+            avg = round(sum(role_losses[role]) / len(role_losses[role]))
+            task7[role] = avg
+            total_annual_loss += sum(role_losses[role])
+    
+    truth["task7"] = {
+        "avg_loss_by_role": task7,
+        "total_annual_loss": round(total_annual_loss),
+    }
+    
+    # =========================================================================
+    # TASK 8: High-priority canned vegetables equipment quality losses
+    # =========================================================================
+    # High-priority: canned veg with scrap_rate > 5% AND
+    # unplanned_downtime_hours > plant median for canned veg
+    
+    # Plant median downtime for canned vegetables
+    cv_by_plant = defaultdict(list)
+    for eq in equipment:
+        if eq["product_family"] == "Canned Vegetables":
+            cv_by_plant[eq["plant"]].append(eq["unplanned_downtime_hours"])
+    cv_plant_median = {p: median(hrs) for p, hrs in cv_by_plant.items()}
+    
+    hp_equip_ids = set()
+    for eq in equipment:
+        if (eq["product_family"] == "Canned Vegetables"
+            and eq["scrap_rate"] > 0.05
+            and eq["unplanned_downtime_hours"] > cv_plant_median.get(eq["plant"], 0)):
+            hp_equip_ids.add(eq["equipment_id"])
+    
+    hp_quality_loss = 0
+    total_cv_quality_loss = 0
+    for ql in quality_losses:
+        if ql["product_family"] == "Canned Vegetables":
+            loss = ql["scrap_cost"] + ql["unplanned_failure_cost"]
+            total_cv_quality_loss += loss
+            if ql["equipment_id"] in hp_equip_ids:
+                hp_quality_loss += loss
+    
+    hp_pct_of_cv = round(hp_quality_loss / total_cv_quality_loss * 100) if total_cv_quality_loss > 0 else 0
+    
+    truth["task8"] = {
+        "hp_quality_losses": round(hp_quality_loss),
+        "hp_pct_of_cv_losses": hp_pct_of_cv,
+    }
+    
+    # =========================================================================
+    # TASK 9: Labor variance for IL and WI plants
+    # =========================================================================
+    # Variance = Standard Hours - Actual Hours (positive = favorable)
+    # Dollar variance = Hours variance * BLS median wage
+    # Productivity Index = Actual Hours / Standard Hours
+    
+    bls_all_occ_wage = next(w["median_hourly_wage"] for w in bls_wages if w["occupation"] == "All Occupations")
+    
+    task9 = {}
+    for plant in PLANTS[:2]:
+        plant_equip = [eq for eq in equipment if eq["plant"] == plant]
+        total_standard = sum(eq["standard_hours"] for eq in plant_equip)
+        total_actual = sum(eq["actual_hours"] for eq in plant_equip)
+        
+        variance_hours = round(total_standard - total_actual, 2)
+        variance_dollars = round(variance_hours * bls_all_occ_wage, 2)
+        productivity_index = round(total_actual / total_standard, 2) if total_standard > 0 else 0
+        
+        task9[plant] = {
+            "variance_hours": variance_hours,
+            "variance_dollars": variance_dollars,
+            "productivity_index": productivity_index,
+        }
+    
+    truth["task9"] = task9
+    
+    # =========================================================================
+    # TASK 10: Updated productivity loss with attached wages
+    # =========================================================================
+    # Use attached wage data to get average hourly salary across all roles
+    # Then recompute annual productivity loss
+    
+    avg_hourly = round(sum(w["avg_hourly_salary"] for w in attached_wages) / len(attached_wages), 2)
+    
+    total_weekly_inefficient = sum(
+        e["hours_manual_entry"] + e["hours_searching_data"] + e["hours_fixing_errors"]
+        for e in employees
+    )
+    annual_loss = round(total_weekly_inefficient * 52 * avg_hourly / 1000) * 1000  # in 000s
+    
+    truth["task10"] = {
+        "avg_hourly_wage": avg_hourly,
+        "annual_productivity_loss": annual_loss,
+    }
+    
+    # =========================================================================
+    # TASK 11: Top 5 tech investments applied to plant sales
+    # =========================================================================
+    # Filter aptean: only "Top Investment to Date" or "Top Planned 2024"
+    # Compute difference: users_growth - non_users_growth
+    # Take top 5 by difference
+    # Apply cumulative growth to each plant's unit sales
+    
+    eligible = [a for a in aptean_data if a["category"] in ["Top Investment to Date", "Top Planned 2024"]]
+    for a in eligible:
+        a["growth_diff"] = a["users_growth"] - a["non_users_growth"]
+    eligible.sort(key=lambda x: x["growth_diff"], reverse=True)
+    top5 = eligible[:5]
+    
+    # Total growth multiplier = product of (1 + diff/100) for all 5
+    total_growth = 1.0
+    for tech in top5:
+        total_growth *= (1 + tech["growth_diff"] / 100)
+    
+    task11 = {}
+    for ps in plant_sales:
+        new_units = round(ps["current_unit_sales"] * total_growth)
+        new_revenue = round(new_units * ps["price_per_unit"])
+        task11[ps["plant"]] = {
+            "new_unit_sales": new_units,
+            "new_projected_sales": new_revenue,
+        }
+    
+    truth["task11"] = {
+        "top5_technologies": [t["technology"] for t in top5],
+        "plant_results": task11,
+    }
+    
+    # =========================================================================
+    # TASK 12: Willingness to adopt by plant and role, training costs
+    # =========================================================================
+    
+    # Plant-level willingness
+    plant_willingness = {}
+    for plant in PLANTS:
+        scores = [e["willingness_to_adopt"] for e in employees if e["plant"] == plant]
+        plant_willingness[plant] = round(sum(scores) / len(scores), 2)
+    
+    sorted_pw = sorted(plant_willingness.items(), key=lambda x: x[1])
+    lowest_plant = sorted_pw[0][0]
+    highest_plant = sorted_pw[-1][0]
+    
+    # Role willingness within those plants
+    def role_willingness_in_plant(plant):
+        by_role = defaultdict(list)
+        for e in employees:
+            if e["plant"] == plant:
+                by_role[e["role"]].append(e["willingness_to_adopt"])
+        return {r: round(sum(s)/len(s), 2) for r, s in by_role.items()}
+    
+    lowest_plant_roles = role_willingness_in_plant(lowest_plant)
+    highest_plant_roles = role_willingness_in_plant(highest_plant)
+    
+    lowest_role_in_lowest = min(lowest_plant_roles.items(), key=lambda x: x[1])
+    highest_role_in_highest = max(highest_plant_roles.items(), key=lambda x: x[1])
+    
+    # Training preferences and costs
+    # Preferred training: most common training_days_willing for each role in each plant
+    def training_info(plant, role):
+        emps = [e for e in employees if e["plant"] == plant and e["role"] == role]
+        if not emps:
+            return {"preferred_length": "N/A", "count_1_2_days": 0, "total_cost": 0}
+        
+        prefs = defaultdict(int)
+        for e in emps:
+            prefs[e["training_days_willing"]] += 1
+        
+        preferred = max(prefs.items(), key=lambda x: x[1])[0]
+        count_1_2 = prefs.get("1-2 days", 0)
+        
+        # Training cost: $8/hour * hours based on preference
+        hours_map = {"<1 day": 4, "1-2 days": 12, ">2 days": 20}
+        cost_per_person = 8 * hours_map.get(preferred, 12)  # $8/hr training cost
+        total_cost = round(cost_per_person * len(emps))
+        
+        return {"preferred_length": preferred, "count_1_2_days": count_1_2, "total_cost": total_cost}
+    
+    truth["task12"] = {
+        "lowest_willingness_plant": lowest_plant,
+        "highest_willingness_plant": highest_plant,
+        "lowest_role_in_lowest_plant": lowest_role_in_lowest,
+        "highest_role_in_highest_plant": highest_role_in_highest,
+        "training_details": {
+            "lowest_plant_lowest_role": training_info(lowest_plant, lowest_role_in_lowest[0]),
+            "highest_plant_highest_role": training_info(highest_plant, highest_role_in_highest[0]),
+        }
+    }
+    
+    # =========================================================================
+    # TASK 13: Apply Frito-Lay downtime reduction
+    # =========================================================================
+    # 30% reduction in unplanned downtime per plant
+    
+    task13 = {}
+    for plant in PLANTS:
+        plant_equip = [eq for eq in equipment if eq["plant"] == plant]
+        total_scheduled = sum(eq["scheduled_hours"] for eq in plant_equip)
+        total_downtime = sum(eq["unplanned_downtime_hours"] for eq in plant_equip)
+        
+        current_ratio = total_downtime / total_scheduled if total_scheduled > 0 else 0
+        new_ratio = current_ratio * frito_lay_mult
+        task13[plant] = round(new_ratio * 100)  # nearest full percentage point
+    
+    truth["task13"] = task13
+    
+    # =========================================================================
+    # TASK 14: Training quality breakdown
+    # =========================================================================
+    
+    trained = [e for e in employees if e["training_received"] == "Yes"]
+    trained_count = len(trained)
+    
+    quality_counts = defaultdict(int)
+    for e in trained:
+        quality_counts[e["training_quality"]] += 1
+    
+    quality_pcts = {}
+    for q in TRAINING_QUALITY_OPTIONS:
+        quality_pcts[q] = round(quality_counts[q] / trained_count * 100)
+    
+    truth["task14"] = {
+        "trained_count": trained_count,
+        "quality_pcts": quality_pcts,
+    }
+    
+    return truth
+
+
+# =============================================================================
+# TASK PROMPT GENERATION
+# =============================================================================
+
+def generate_task_prompts(truth, cfg: WorldConfig):
+    """Generate task prompts adapted to the synthetic world."""
+    tasks = []
+    PLANTS = list(cfg.plants)
+    plants_il_wi_ia = ", ".join(PLANTS[:3])
+    
+    # TASK 1
+    tasks.append({
+        "task_id": "task_01",
+        "task_name": "High-Priority Digital Training Employees",
+        "prompt": """I'm trying to get a sense of which HarFeast employees are most ready for the digital training rollout. Can you pull the workforce survey data and identify all employees who are above their role type's median readiness score, willing to pilot new tools, willing to spend >2 days in training with dedicated training time, and above the overall median digital comfort score?
+
+Once you've identified that group, tell me:
+1. How many "high-priority" employees are there, and what % of total employees do they represent?
+2. How many total hours does this group spend weekly on manual entry, searching data, or fixing errors? What % of the company-wide total is that?
+3. Break down the high-priority count by role type.
+
+Report your answer here.""",
+        "ground_truth": truth["task1"],
+        "rubric": [
+            f"States that the number of high-priority employees is {truth['task1']['high_priority_count']}",
+            f"States that the percentage of all employees the high-priority employees represent is {truth['task1']['high_priority_pct']}%",
+            f"States that the total hours high-priority employees spend on manual entry, searching data or fixing errors is {truth['task1']['hp_inefficient_hours']:.0f}",
+            f"States that the percentage of all such hours from high-priority employees is {truth['task1']['hp_inefficient_pct']}%",
+            f"States that the number of high-priority employees in the Front-line role type is {truth['task1']['hp_frontline']}",
+            f"States that the number of high-priority employees in the Back-office/Support role type is {truth['task1']['hp_backoffice']}",
+            f"States that the number of high-priority employees in the Supervisor/Team Lead role type is {truth['task1']['hp_supervisor']}",
+            f"States that the number of high-priority employees in the Management role type is {truth['task1']['hp_management']}",
+        ]
+    })
+    
+    # TASK 2
+    rubric2 = [f"States that the adjusted cost of instability for {plant} is ${cost:,}" for plant, cost in truth["task2"].items()]
+    tasks.append({
+        "task_id": "task_02",
+        "task_name": "Adjusted Cost of Instability",
+        "prompt": """Calculate the Adjusted Cost of Instability for each site, defined as Abnormal scrap cost/(Actual Scrap % - Normal Scrap %) = adjusted cost of instability. The target scrap rate of HarFeast is the minimum in the range of acceptable scrap rate in the scrap rate report. Just use COGS per ton as your scrap cost for now.
+
+Report your final answers to me in a message. Round values to the nearest dollar.""",
+        "ground_truth": truth["task2"],
+        "rubric": rubric2,
+    })
+    
+    # TASK 3
+    rubric3 = []
+    for pf in PRODUCT_FAMILIES:
+        rubric3.append(f"States that the new overall scrap rate for {pf} is {truth['task3'][pf]['new_scrap_rate_pct']}%")
+        rubric3.append(f"States that the scrap units {pf} avoids per year is {truth['task3'][pf]['units_avoided']}")
+    tasks.append({
+        "task_id": "task_03",
+        "task_name": "Predictive Maintenance Scrap Impact",
+        "prompt": """Using HarFeast's equipment data, assess the impact of predictive maintenance on HarFeast's scrap rate. We will pilot predictive maintenance only on equipment a) whose scheduled hours per year are at or above that equipment type's median scheduled hours and b) whose labor hours are at or above its plant's median labor hours. For all equipment qualifying for the pilot, apply a 15% reduction to their scrap rate.
+
+Calculate:
+1. The new overall scrap rate for each product family (as a %)
+2. The total number of scrap units each product family avoids every year
+
+Report rounded to 1 decimal place for rates and nearest whole number for units.""",
+        "ground_truth": truth["task3"],
+        "rubric": rubric3,
+    })
+    
+    # TASK 4
+    rubric4 = [f"States that the digital lever is IoT Sensors for yield"]
+    for plant, data in truth["task4"].items():
+        if plant == "digital_lever":
+            continue
+        rubric4.append(f"States that the OEE level for {plant} in the first year exceeding world-class target is {data['oee_at_that_year']:.2%}")
+        rubric4.append(f"States that the first year {plant} exceeds world-class target is {data['first_year_exceeds']}")
+    tasks.append({
+        "task_id": "task_04",
+        "task_name": "Digital Lever Agreement and OEE Projections",
+        "prompt": """1. What is the digital lever that Sarah Jenkins, David Chen, and Mike Russo agree will deliver the fastest and biggest boost to HarFeast's Gross Margin?
+
+2. Assuming HarFeast adopts the chosen digital lever, determine the OEE level in the first full year in each plant location where the annual OEE value exceeds the world-class target. Use the OEE improvement assumptions file for growth rates and start dates.
+
+Report OEE values to 2 decimal places as percentages.""",
+        "ground_truth": truth["task4"],
+        "rubric": rubric4,
+    })
+    
+    # TASK 5
+    rubric5 = []
+    for plant, data in truth["task5"].items():
+        rubric5.append(f"States that the Total Annual Labor Cost for {plant} is ${data['total_labor_cost']:,}")
+        rubric5.append(f"States that the Efficiency Gains for {plant} is ${data['efficiency_gains']:,}")
+        rubric5.append(f"States that the Union Demand Increase for {plant} is ${data['union_demand_increase']:,}")
+    tasks.append({
+        "task_id": "task_05",
+        "task_name": "Labor Cost Analysis",
+        "prompt": f"""1. Give me the total labor cost for each plant location ({plants_il_wi_ia} only).
+
+2. Give me the efficiency gains for each plant location. West North Central division plant locations only have a 10% annual efficiency gain from labor cost. For other locations, the efficiency gain is 20%. However, the efficiency gain is 5% for non-unionized production supervisors no matter where they are located.
+
+3. Give me the forecasted labor cost increase from union demands, assuming a 5% increase for all union workers.
+
+Round to the nearest dollar.""",
+        "ground_truth": truth["task5"],
+        "rubric": rubric5,
+    })
+    
+    # TASK 6
+    rubric6 = [f"States the average inefficient time in {plant} is {val}" for plant, val in truth["task6"]["avg_by_plant"].items()]
+    for p in truth["task6"]["most_efficient"]:
+        rubric6.append(f"States that {p} is a plant with the lowest average inefficient time")
+    rubric6.append(f"States that {truth['task6']['least_efficient']} is the plant with the highest average inefficient time")
+    rubric6.append(f"States that the difference between highest and lowest average inefficient time is {truth['task6']['pct_difference']}%")
+    tasks.append({
+        "task_id": "task_06",
+        "task_name": "Operational Efficiency Analysis",
+        "prompt": """Analyze the operational efficiency at HarFeast and assess how many inefficient employee hours each plant is recording on average. Which plants have the most efficient operations and the least efficient operations? How much more efficient are the highest efficiency locations vs the lowest efficiency locations?
+
+Assume the following activities are considered inefficient: (a) manual data entry, (b) searching for data, (c) fixing errors. Use the workforce survey data. Report averages to 1 decimal place.""",
+        "ground_truth": truth["task6"],
+        "rubric": rubric6,
+    })
+    
+    # TASK 7
+    rubric7 = [f"States the average annual productivity loss cost of a {role} employee is ${loss:,}" for role, loss in truth["task7"]["avg_loss_by_role"].items()]
+    rubric7.append(f"States the total annual productivity loss cost is ${truth['task7']['total_annual_loss']:,}")
+    tasks.append({
+        "task_id": "task_07",
+        "task_name": "Productivity Loss Quantification",
+        "prompt": """I want to quantify the average annual productivity loss at a cost level for each employee in each primary role based on the sum of average hours spent doing manual entry, searching data, and fixing errors. Then, I want to calculate the total productivity loss cost HarFeast faces every year, company-wide.
+
+Note that the survey responses represent one week of work. Report your final answer as a message. Round to the nearest dollar.""",
+        "ground_truth": truth["task7"],
+        "rubric": rubric7,
+    })
+    
+    # TASK 8
+    tasks.append({
+        "task_id": "task_08",
+        "task_name": "High-Priority Equipment Quality Losses",
+        "prompt": """Using HarFeast's equipment data and quality losses dataset, consider all canned vegetables assets with a scrap rate > 5% and with unplanned downtime hours above the plant median for canned vegetables as "high-priority".
+
+1. For the "high-priority" group, calculate the total annual quality-related losses (scrap cost + unplanned failure cost).
+2. What percentage of all canned-vegetable quality losses comes from these high-priority assets?
+
+Report losses rounded to the nearest dollar and percentage to the nearest whole number.""",
+        "ground_truth": truth["task8"],
+        "rubric": [
+            f"States that the total annual quality-related losses for the high-priority group is ${truth['task8']['hp_quality_losses']:,}",
+            f"States that the percentage of all canned-vegetable quality losses from high-priority assets is {truth['task8']['hp_pct_of_cv_losses']}%",
+        ]
+    })
+    
+    # TASK 9
+    rubric9 = []
+    for plant, data in truth["task9"].items():
+        rubric9.append(f"States that the Labor Efficiency Variance (Hours) for {plant} is {data['variance_hours']} hours")
+        rubric9.append(f"States that the Labor Cost Variance for {plant} is ${data['variance_dollars']}")
+        rubric9.append(f"States that the Productivity Index for {plant} is {data['productivity_index']}")
+    tasks.append({
+        "task_id": "task_09",
+        "task_name": "Labor Variance Analysis",
+        "prompt": f"""Calculate the total labor variance in hours (favorable should be positive) and dollars for the Illinois and Wisconsin plants ({PLANTS[0]} and {PLANTS[1]}). A positive variance means Total Actual Hours are less than Total Standard Hours. Use the median wage for All Occupations in the food manufacturing industry from the BLS wage benchmark file to convert from hours to dollars.
+
+Also give me the straight productivity index (Actual Hours / Standard Hours) for each plant.
+
+Round hours to 2 decimal places, dollars to 2 decimal places, and the index to 2 decimal places.""",
+        "ground_truth": truth["task9"],
+        "rubric": rubric9,
+    })
+    
+    # TASK 10
+    tasks.append({
+        "task_id": "task_10",
+        "task_name": "Updated Productivity Loss with New Wages",
+        "prompt": """The client sent us employee wage data (attached), so we need to update our assumptions. Find the average hourly salary across all employee roles in the attached wage file and use that to calculate the updated annual productivity loss for the entire company.
+
+Note that survey responses represent one week of work. Report the annual productivity loss in thousands (000s) rounded to the nearest thousand. Also state the average hourly wage used.
+
+Report your answer here.""",
+        "ground_truth": truth["task10"],
+        "rubric": [
+            f"States the updated annual productivity loss is ${truth['task10']['annual_productivity_loss']:,}",
+            f"States the average fully-loaded hourly wage is ${truth['task10']['avg_hourly_wage']}",
+        ]
+    })
+    
+    # TASK 11
+    rubric11 = []
+    for plant, data in truth["task11"]["plant_results"].items():
+        rubric11.append(f"States that the unit sales for {plant} after deploying initiatives is {data['new_unit_sales']:,}")
+        rubric11.append(f"States that the Revised Projected Sales for {plant} is ${data['new_projected_sales']:,}")
+    tasks.append({
+        "task_id": "task_11",
+        "task_name": "Technology Investment Impact",
+        "prompt": """Identify the top five technology investments from the Aptean report with the largest positive difference in percentage revenue growth between users and non-users. Include only investments that the report explicitly identifies as either top technology investments to date or top investments planned for 2024.
+
+Next, assume that HarFeast will deploy all five of these top initiatives at every plant location. Apply the cumulative growth impact to each plant's current unit sales and calculate the revised projected sales revenue.
+
+Round unit sales to the nearest whole number and revenue to the nearest dollar.""",
+        "ground_truth": truth["task11"],
+        "rubric": rubric11,
+    })
+    
+    # TASK 12
+    t12 = truth["task12"]
+    tasks.append({
+        "task_id": "task_12",
+        "task_name": "Digital Adoption Willingness Analysis",
+        "prompt": """To implement the required roadmap, we need to identify what roles and plants are most and least willing to go through a digital transformation.
+
+Determine the plant with the highest and lowest average willingness to adopt digital tools. Within those plants, identify the roles with the highest and lowest willingness. For those specific role-plant combinations, determine the preferred training length, the count of employees preferring 1-2 days of training, and the total training cost (at $8/hour training rate).
+
+Report your findings here.""",
+        "ground_truth": truth["task12"],
+        "rubric": [
+            f"States that the plant with lowest willingness to adopt is {t12['lowest_willingness_plant']}",
+            f"States that the plant with highest willingness to adopt is {t12['highest_willingness_plant']}",
+            f"States the role with lowest willingness in {t12['lowest_willingness_plant']} is {t12['lowest_role_in_lowest_plant'][0]}",
+            f"States the role with highest willingness in {t12['highest_willingness_plant']} is {t12['highest_role_in_highest_plant'][0]}",
+        ]
+    })
+    
+    # TASK 13
+    rubric13 = [f"States that the new unplanned downtime ratio for {plant} is {pct}%" for plant, pct in truth["task13"].items()]
+    tasks.append({
+        "task_id": "task_13",
+        "task_name": "Frito-Lay Downtime Reduction Application",
+        "prompt": """Can you look at the Frito-Lay case study and apply their downtime reduction to HarFeast's numbers in the equipment data? I want to estimate what the improvement would look like for us (rounded to the nearest full percentage point).
+
+Calculate the current unplanned downtime ratio (unplanned downtime hours / scheduled hours) for each plant, apply the reduction from the case study, and report the new ratios.
+
+Output the information in a message here.""",
+        "ground_truth": truth["task13"],
+        "rubric": rubric13,
+    })
+    
+    # TASK 14
+    rubric14 = [f"States that the number of respondents who received training is {truth['task14']['trained_count']}"]
+    for quality, pct in truth["task14"]["quality_pcts"].items():
+        rubric14.append(f"States that percentage of respondents rated training as \"{quality}\" is {pct}%")
+    tasks.append({
+        "task_id": "task_14",
+        "task_name": "Training Quality Assessment",
+        "prompt": """Use the workforce survey responses to identify the number of respondents who received any kind of training on digital tools. Of those respondents, return the percentage of respondents for each training quality rating.
+
+Reply back here to me.""",
+        "ground_truth": truth["task14"],
+        "rubric": rubric14,
+    })
+    
+    return tasks
+
+
+# =============================================================================
+# FILE WRITERS
+# =============================================================================
+
+def write_csv(filepath, data, fieldnames=None):
+    """Write a list of dicts to CSV."""
+    if not data:
+        return
+    if fieldnames is None:
+        fieldnames = list(data[0].keys())
+    with open(filepath, "w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(data)
+
+
+def write_text(filepath, content):
+    """Write text content to a file."""
+    with open(filepath, "w") as f:
+        f.write(content)
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def generate_world(
+    seed: int = 42,
+    output_dir: str = "./harfeast_world",
+    config: Optional[WorldConfig] = None,
+) -> tuple:
+    """Generate the complete HarFeast synthetic world."""
+    rng = random.Random(seed)
+    cfg = config or sample_world_config(rng, seed)
+    cfg.seed = seed
+
+    os.makedirs(output_dir, exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "data"), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "documents"), exist_ok=True)
+
+    print(f"Generating world (seed={seed}, n_employees={cfg.n_employees}, plants={cfg.plants[0][:15]}...)...")
+
+    # Generate all datasets
+    employees = generate_employee_survey(rng, cfg)
+    equipment = generate_equipment_data(rng, cfg)
+    quality_losses = generate_quality_losses(rng, equipment)
+    plant_labor = generate_plant_labor(rng, cfg)
+    bls_wages = generate_bls_wages(cfg)
+    attached_wages = generate_attached_wages(cfg)
+    oee_assumptions = generate_oee_assumptions(cfg, rng)
+    plant_sales = generate_plant_sales(cfg, rng)
+    aptean_data = generate_aptean_report(cfg, rng)
+
+    # Write CSV files
+    write_csv(os.path.join(output_dir, "data", "employee_survey.csv"), employees)
+    write_csv(os.path.join(output_dir, "data", "equipment_data.csv"), equipment)
+    write_csv(os.path.join(output_dir, "data", "quality_losses.csv"), quality_losses)
+    write_csv(os.path.join(output_dir, "data", "plant_labor.csv"), plant_labor)
+    write_csv(os.path.join(output_dir, "data", "bls_wage_benchmark.csv"), bls_wages)
+    write_csv(os.path.join(output_dir, "data", "attached_wage_data.csv"), attached_wages)
+    write_csv(os.path.join(output_dir, "data", "oee_assumptions.csv"), oee_assumptions)
+    write_csv(os.path.join(output_dir, "data", "plant_unit_sales.csv"), plant_sales)
+    write_csv(os.path.join(output_dir, "data", "aptean_report_data.csv"), aptean_data)
+    
+    # Write text documents
+    write_text(os.path.join(output_dir, "documents", "scrap_rate_report.txt"), generate_scrap_report(cfg))
+
+    interviews = generate_interviews()
+    for name, text in interviews.items():
+        write_text(os.path.join(output_dir, "documents", f"interview_{name}.txt"), text)
+    
+    write_text(os.path.join(output_dir, "documents", "frito_lay_case_study.txt"), generate_frito_lay_case(cfg))
+    write_text(os.path.join(output_dir, "documents", "aptean_report.txt"), generate_aptean_report_text(aptean_data))
+    
+    # Compute ground truth
+    print("Computing ground truth...")
+    truth = compute_ground_truth(
+        employees, equipment, quality_losses, plant_labor,
+        bls_wages, attached_wages, oee_assumptions, plant_sales, aptean_data, cfg
+    )
+
+    # Generate task prompts and rubrics
+    print("Generating tasks...")
+    tasks = generate_task_prompts(truth, cfg)
+    
+    # Write tasks and ground truth
+    with open(os.path.join(output_dir, "tasks.json"), "w") as f:
+        json.dump(tasks, f, indent=2, default=str)
+    
+    with open(os.path.join(output_dir, "ground_truth.json"), "w") as f:
+        json.dump(truth, f, indent=2, default=str)
+    
+    # Print summary
+    print(f"\nWorld generated in {output_dir}/")
+    print(f"  Employees: {len(employees)}")
+    print(f"  Equipment: {len(equipment)}")
+    print(f"  Quality losses: {len(quality_losses)}")
+    print(f"  Plant labor: {len(plant_labor)}")
+    print(f"  Tasks: {len(tasks)}")
+    print(f"\nGround truth summary:")
+    for task in tasks:
+        n_criteria = len(task["rubric"])
+        print(f"  {task['task_id']} ({task['task_name']}): {n_criteria} criteria")
+    
+    # Print sample ground truth values for validation
+    print(f"\nSample answers for validation:")
+    print(f"  Task 1 - High-priority count: {truth['task1']['high_priority_count']}")
+    print(f"  Task 6 - Avg inefficient hours: {truth['task6']['avg_by_plant']}")
+    print(f"  Task 14 - Trained count: {truth['task14']['trained_count']}")
+    print(f"  Task 13 - Downtime ratios: {truth['task13']}")
+    
+    return employees, equipment, truth, tasks
+
+
+def generate_worlds_batch(
+    n_worlds: int,
+    output_base: str = "./harfeast_worlds",
+    base_seed: int = 0,
+) -> list[dict]:
+    """
+    Generate n_worlds distinct worlds for RL scalability.
+    Returns manifest of (world_id, path, task_count) for each world.
+    """
+    os.makedirs(output_base, exist_ok=True)
+    rng = random.Random(base_seed)
+    manifest = []
+
+    for i in range(n_worlds):
+        seed = base_seed + i * 10000 + rng.randint(0, 9999)
+        world_dir = os.path.join(output_base, f"world_{i:04d}")
+        try:
+            generate_world(seed=seed, output_dir=world_dir)
+            manifest.append({
+                "world_id": i,
+                "path": world_dir,
+                "seed": seed,
+                "task_count": 14,
+            })
+        except Exception as e:
+            print(f"Warning: world {i} failed: {e}")
+
+    manifest_path = os.path.join(output_base, "manifest.json")
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    # Build all_tasks.json: flat list for sampling (world_path, task_id, prompt)
+    all_tasks = []
+    for m in manifest:
+        tasks_path = os.path.join(m["path"], "tasks.json")
+        with open(tasks_path) as f:
+            tasks = json.load(f)
+        for t in tasks:
+            all_tasks.append({
+                "world_path": m["path"],
+                "world_id": m["world_id"],
+                "task_id": t["task_id"],
+                "task_name": t["task_name"],
+                "prompt": t["prompt"],
+            })
+    with open(os.path.join(output_base, "all_tasks.json"), "w") as f:
+        json.dump(all_tasks, f, indent=2)
+
+    print(f"\nBatch complete: {len(manifest)} worlds, {len(all_tasks)} task instances")
+    return manifest
+
+
+if __name__ == "__main__":
+    import sys
+    seed = 42
+    output_dir = "./harfeast_world"
+    batch_n = 0
+
+    args = sys.argv[1:]
+    i = 0
+    while i < len(args):
+        if args[i] == "--seed" and i + 1 < len(args):
+            seed = int(args[i + 1])
+            i += 2
+        elif args[i] == "--output-dir" and i + 1 < len(args):
+            output_dir = args[i + 1]
+            i += 2
+        elif args[i] == "--batch" and i + 1 < len(args):
+            batch_n = int(args[i + 1])
+            i += 2
+        else:
+            i += 1
+
+    if batch_n > 0:
+        generate_worlds_batch(n_worlds=batch_n, output_base=output_dir, base_seed=seed)
+    else:
+        generate_world(seed=seed, output_dir=output_dir)

harfeast_world/data/aptean_report_data.csv

@@ -0,0 +1,11 @@
+technology,users_growth,non_users_growth,category
+IoT Sensors,12.4,4.0,Top Investment to Date
+Predictive Maintenance,11.8,3.9,Top Planned 2024
+Cloud ERP,9.2,5.1,Top Investment to Date
+Robotic Automation,10.5,3.6,Top Planned 2024
+AI Quality Control,8.9,4.6,Top Investment to Date
+Digital Twin,7.3,4.0,Other
+Supply Chain AI,6.9,3.1,Other
+Automated Scheduling,8.1,5.7,Top Planned 2024
+Warehouse Robotics,7.8,5.2,Other
+Advanced Analytics,9.6,4.4,Top Investment to Date

harfeast_world/data/attached_wage_data.csv

@@ -0,0 +1,9 @@
+role,avg_hourly_salary
+Production/Manufacturing Operator,20.61
+Quality Control/Quality Assurance,24.73
+Maintenance Technician,28.19
+Production Supervisor/Team Lead,31.83
+Supply Chain/Logistics Coordinator,26.46
+Demand Planning/Forecasting,33.65
+Administrative/Support Staff,22.43
+Plant Management,46.5

harfeast_world/data/bls_wage_benchmark.csv

@@ -0,0 +1,7 @@
+occupation,industry,median_hourly_wage
+All Occupations,Food Manufacturing,18.94
+Production Workers,Food Manufacturing,17.11
+Supervisors,Food Manufacturing,27.32
+Maintenance,Food Manufacturing,23.3
+Quality Control,Food Manufacturing,20.28
+Logistics,Food Manufacturing,21.86

harfeast_world/data/equipment_data.csv

@@ -0,0 +1,250 @@
+equipment_id,plant,product_family,equipment_type,scheduled_hours,actual_hours,standard_hours,labor_hours,scrap_rate,oee,unplanned_downtime_hours,units_produced,cogs_per_ton,failure_cost
+EQ-ROC-000,"Rockford, Illinois",Canned Vegetables,Pasteurizer,1733,1586,1627,944,0.0418,0.8117,297,579796,1311.74,13428.4
+EQ-ROC-001,"Rockford, Illinois",Canned Vegetables,Filler,3678,3197,3621,2871,0.0368,0.7813,398,354781,1562.72,22948.38
+EQ-ROC-002,"Rockford, Illinois",Sauces,Pasteurizer,3912,2747,3329,763,0.0707,0.8684,478,297246,1842.58,42930.29
+EQ-ROC-003,"Rockford, Illinois",Canned Vegetables,Labeler,4152,3998,4059,1824,0.048,0.7672,148,552915,1412.38,40015.28
+EQ-ROC-004,"Rockford, Illinois",Canned Vegetables,Sealer,4696,3698,4498,1261,0.0733,0.8928,76,475144,1627.94,25348.82
+EQ-ROC-005,"Rockford, Illinois",Canned Vegetables,Conveyor,1992,1934,1964,2609,0.0337,0.8761,330,444346,1989.52,37354.69
+EQ-ROC-006,"Rockford, Illinois",Canned Vegetables,Labeler,4543,4367,3999,2068,0.0698,0.8549,125,299459,1599.28,5567.85
+EQ-ROC-007,"Rockford, Illinois",Condiments,Labeler,3601,3237,3157,2245,0.0682,0.8438,112,485890,1704.96,13410.6
+EQ-ROC-008,"Rockford, Illinois",Condiments,Conveyor,2061,1528,2020,2710,0.0362,0.8177,304,480395,1148.16,28810.95
+EQ-ROC-009,"Rockford, Illinois",Sauces,Filler,2086,1686,1986,754,0.083,0.8102,230,365046,932.98,41144.21
+EQ-ROC-010,"Rockford, Illinois",Condiments,Labeler,4403,3744,4229,2883,0.0305,0.7457,278,558580,1107.91,12617.83
+EQ-ROC-011,"Rockford, Illinois",Condiments,Filler,4229,3162,3621,1933,0.0359,0.8175,359,588148,1931.38,14392.21
+EQ-ROC-012,"Rockford, Illinois",Canned Vegetables,Sealer,4809,3382,4659,694,0.0665,0.7725,204,334544,1186.82,19387.8
+EQ-ROC-013,"Rockford, Illinois",Sauces,Sealer,3256,2429,2910,2823,0.0613,0.7478,155,360347,1405.05,24627.38
+EQ-ROC-014,"Rockford, Illinois",Sauces,Conveyor,1673,1174,1586,1068,0.0317,0.7232,182,121148,1207.69,27947.16
+EQ-ROC-015,"Rockford, Illinois",Condiments,Sealer,4013,2818,3711,909,0.0417,0.7836,339,332097,1090.85,37628.79
+EQ-ROC-016,"Rockford, Illinois",Sauces,Filler,3476,2548,3314,2769,0.0391,0.7519,121,533280,1031.93,6245.98
+EQ-ROC-017,"Rockford, Illinois",Canned Vegetables,Labeler,2842,2014,2793,1991,0.0555,0.7886,130,121735,1281.48,7889.72
+EQ-ROC-018,"Rockford, Illinois",Sauces,Conveyor,3733,3483,3652,1687,0.0354,0.7848,227,383518,1221.97,41539.85
+EQ-ROC-019,"Rockford, Illinois",Condiments,Boiler,3025,2550,2755,988,0.076,0.7787,124,511790,1751.8,42325.65
+EQ-ROC-020,"Rockford, Illinois",Condiments,Pasteurizer,3811,2695,3602,1858,0.0356,0.7725,285,402802,874.93,10593.37
+EQ-ROC-021,"Rockford, Illinois",Condiments,Labeler,4681,4192,4330,2238,0.0625,0.9395,237,137343,1501.37,20224.76
+EQ-ROC-022,"Rockford, Illinois",Condiments,Boiler,2897,2051,2673,1921,0.0853,0.7199,84,571595,1379.81,47643.34
+EQ-ROC-023,"Rockford, Illinois",Canned Vegetables,Filler,4595,4073,4288,1129,0.099,0.7846,481,260082,1342.54,44328.9
+EQ-ROC-024,"Rockford, Illinois",Condiments,Conveyor,3800,3003,3338,872,0.0732,0.7203,360,378981,1121.33,30381.28
+EQ-ROC-025,"Rockford, Illinois",Condiments,Labeler,2325,2089,2150,2946,0.097,0.8323,329,559489,1939.53,14673.21
+EQ-ROC-026,"Rockford, Illinois",Sauces,Sealer,3952,3753,3731,909,0.0931,0.877,159,363732,1281.06,24065.96
+EQ-ROC-027,"Rockford, Illinois",Sauces,Boiler,4300,3381,3903,1834,0.0487,0.7893,355,230265,1502.64,15463.34
+EQ-ROC-028,"Rockford, Illinois",Sauces,Labeler,2875,2558,2500,1099,0.0354,0.762,254,187043,1746.84,11998.44
+EQ-ROC-029,"Rockford, Illinois",Canned Vegetables,Sealer,4907,4625,4782,2642,0.0926,0.7067,473,430704,989.65,43344.48
+EQ-ROC-030,"Rockford, Illinois",Condiments,Conveyor,2181,1692,1873,1155,0.0914,0.8193,138,562547,1626.84,20451.59
+EQ-ROC-031,"Rockford, Illinois",Condiments,Filler,2904,2683,2698,1549,0.0921,0.8017,138,340842,838.59,17417.21
+EQ-ROC-032,"Rockford, Illinois",Condiments,Sealer,4297,3149,4238,2131,0.0515,0.7621,116,140630,926.3,20279.03
+EQ-ROC-033,"Rockford, Illinois",Sauces,Sealer,2526,2170,2328,1222,0.0836,0.8179,86,390567,1437.77,18467.72
+EQ-ROC-034,"Rockford, Illinois",Sauces,Labeler,2551,1955,2210,1418,0.0413,0.8961,234,494490,1389.34,32470.28
+EQ-ROC-035,"Rockford, Illinois",Condiments,Pasteurizer,2856,2142,2683,1753,0.061,0.8758,164,481912,1045.16,14648.35
+EQ-ROC-036,"Rockford, Illinois",Sauces,Boiler,3349,2809,3231,1925,0.0383,0.7689,259,524422,943.08,21586.28
+EQ-ROC-037,"Rockford, Illinois",Sauces,Mixer,4289,3267,3824,2709,0.0424,0.7725,359,223002,858.46,48103.73
+EQ-ROC-038,"Rockford, Illinois",Sauces,Filler,2410,2186,2409,564,0.0652,0.8075,185,598148,1086.33,26528.04
+EQ-ROC-039,"Rockford, Illinois",Sauces,Pasteurizer,4391,3546,3843,1014,0.0333,0.8158,418,137230,1905.1,33435.7
+EQ-ROC-040,"Rockford, Illinois",Canned Vegetables,Conveyor,2973,2700,2701,2313,0.0564,0.8243,159,333766,1895.76,32321.12
+EQ-ROC-041,"Rockford, Illinois",Canned Vegetables,Labeler,4504,3233,4445,1994,0.079,0.7054,67,277296,810.75,8488.7
+EQ-ROC-042,"Rockford, Illinois",Condiments,Conveyor,1792,1546,1551,2751,0.0523,0.887,87,123121,801.98,16444.37
+EQ-ROC-043,"Rockford, Illinois",Canned Vegetables,Filler,4686,3911,4375,2528,0.0679,0.9096,405,550914,1413.72,15207.6
+EQ-ROC-044,"Rockford, Illinois",Canned Vegetables,Mixer,4739,3397,4306,700,0.0823,0.7314,217,545889,1354.51,22776.33
+EQ-ROC-045,"Rockford, Illinois",Condiments,Boiler,3616,3176,3597,1763,0.0483,0.735,65,132324,1576.8,17866.29
+EQ-ROC-046,"Rockford, Illinois",Condiments,Labeler,2444,1887,2082,1689,0.089,0.8141,290,321846,881.28,49089.0
+EQ-ROC-047,"Rockford, Illinois",Sauces,Sealer,2094,1879,2045,2350,0.0796,0.8508,320,339577,1970.34,34686.41
+EQ-ROC-048,"Rockford, Illinois",Sauces,Conveyor,2247,2047,2075,2412,0.0653,0.7566,191,350536,1489.74,34703.48
+EQ-ROC-049,"Rockford, Illinois",Sauces,Pasteurizer,3371,3145,3063,1586,0.0628,0.7607,374,152274,848.43,31398.35
+EQ-ROC-050,"Rockford, Illinois",Sauces,Sealer,4054,3446,3638,2430,0.0872,0.7712,156,523880,1320.38,6143.75
+EQ-ROC-051,"Rockford, Illinois",Canned Vegetables,Boiler,2744,2345,2501,2082,0.0568,0.7888,373,548053,1540.88,14516.56
+EQ-ROC-052,"Rockford, Illinois",Condiments,Pasteurizer,3138,3003,2675,1715,0.0892,0.7761,90,252548,955.44,12433.76
+EQ-ROC-053,"Rockford, Illinois",Canned Vegetables,Conveyor,2588,2287,2555,1816,0.0914,0.7442,109,245449,1214.28,18202.75
+EQ-ROC-054,"Rockford, Illinois",Sauces,Sealer,4939,4296,4372,1513,0.0468,0.7952,160,505213,1343.79,37845.33
+EQ-MAD-055,"Madison, Wisconsin",Condiments,Mixer,4380,3952,3997,2205,0.0554,0.8175,398,340515,1875.26,26862.83
+EQ-MAD-056,"Madison, Wisconsin",Condiments,Boiler,4343,4012,3921,2801,0.0408,0.8097,199,528746,1693.36,42325.24
+EQ-MAD-057,"Madison, Wisconsin",Condiments,Conveyor,4276,4006,3668,2149,0.0864,0.794,398,546745,989.36,26613.26
+EQ-MAD-058,"Madison, Wisconsin",Sauces,Filler,3674,3151,3542,2980,0.0529,0.8324,229,233586,1614.37,31316.03
+EQ-MAD-059,"Madison, Wisconsin",Sauces,Boiler,1685,1208,1489,1793,0.0488,0.8669,247,130854,1472.32,39182.37
+EQ-MAD-060,"Madison, Wisconsin",Condiments,Boiler,4001,3855,3571,1537,0.0818,0.7254,427,384875,1208.85,36822.47
+EQ-MAD-061,"Madison, Wisconsin",Canned Vegetables,Pasteurizer,4796,4527,4346,1119,0.0413,0.7871,178,136869,1174.75,37535.73
+EQ-MAD-062,"Madison, Wisconsin",Sauces,Filler,1576,1129,1423,556,0.0853,0.8123,84,376409,1518.58,28650.97
+EQ-MAD-063,"Madison, Wisconsin",Canned Vegetables,Conveyor,2004,1504,1818,1373,0.0722,0.8969,424,445511,1062.21,27841.49
+EQ-MAD-064,"Madison, Wisconsin",Condiments,Mixer,3992,3480,3681,2511,0.0864,0.8201,493,486916,1764.05,15413.32
+EQ-MAD-065,"Madison, Wisconsin",Sauces,Labeler,2808,2187,2610,1253,0.0594,0.7906,412,325383,865.07,13133.05
+EQ-MAD-066,"Madison, Wisconsin",Canned Vegetables,Pasteurizer,3617,2734,3195,2776,0.0678,0.7664,80,404271,1088.35,23697.69
+EQ-MAD-067,"Madison, Wisconsin",Sauces,Pasteurizer,4761,3997,4374,1659,0.0468,0.6867,237,501208,1944.96,21986.38
+EQ-MAD-068,"Madison, Wisconsin",Condiments,Sealer,2546,2222,2186,1125,0.0974,0.8184,437,231134,1042.45,39718.31
+EQ-MAD-069,"Madison, Wisconsin",Sauces,Mixer,1878,1341,1704,1011,0.0521,0.8116,142,531271,859.18,32822.1
+EQ-MAD-070,"Madison, Wisconsin",Canned Vegetables,Filler,3919,2950,3887,706,0.0556,0.7764,488,372641,1177.88,38602.04
+EQ-MAD-071,"Madison, Wisconsin",Canned Vegetables,Conveyor,1580,1273,1347,847,0.0857,0.7543,56,330695,1137.73,9775.56
+EQ-MAD-072,"Madison, Wisconsin",Sauces,Mixer,4112,3220,3998,1694,0.041,0.8957,239,249762,1474.98,16010.75
+EQ-MAD-073,"Madison, Wisconsin",Condiments,Pasteurizer,1975,1768,1926,1947,0.0474,0.7237,128,247782,864.42,30505.35
+EQ-MAD-074,"Madison, Wisconsin",Condiments,Filler,2707,2400,2365,2351,0.0842,0.7234,254,502868,933.99,21840.78
+EQ-MAD-075,"Madison, Wisconsin",Canned Vegetables,Boiler,2426,2368,2266,2735,0.0714,0.841,451,476609,1507.36,48238.8
+EQ-MAD-076,"Madison, Wisconsin",Sauces,Sealer,4831,3901,4632,2062,0.0347,0.7559,191,528080,1272.3,49989.79
+EQ-MAD-077,"Madison, Wisconsin",Condiments,Conveyor,2380,1880,2108,1960,0.0321,0.7006,83,294196,1003.85,44286.01
+EQ-MAD-078,"Madison, Wisconsin",Sauces,Boiler,2815,2395,2532,1734,0.0307,0.8496,393,414109,1624.99,39402.44
+EQ-MAD-079,"Madison, Wisconsin",Canned Vegetables,Pasteurizer,2554,2111,2188,2833,0.0775,0.8107,153,356949,971.9,33875.59
+EQ-MAD-080,"Madison, Wisconsin",Condiments,Mixer,4100,3912,3914,643,0.0784,0.7435,455,117014,1794.39,27287.92
+EQ-MAD-081,"Madison, Wisconsin",Condiments,Pasteurizer,4477,3188,3972,1534,0.0455,0.7195,184,491395,1384.79,32813.73
+EQ-MAD-082,"Madison, Wisconsin",Sauces,Pasteurizer,1807,1713,1631,1309,0.0424,0.7283,373,473099,1905.91,44328.81
+EQ-MAD-083,"Madison, Wisconsin",Canned Vegetables,Labeler,3465,2813,3302,1755,0.0944,0.8487,482,456544,862.68,45827.13
+EQ-MAD-084,"Madison, Wisconsin",Condiments,Boiler,4774,3436,4315,1670,0.0785,0.736,237,550680,1305.64,30185.51
+EQ-MAD-085,"Madison, Wisconsin",Sauces,Sealer,4931,4233,4502,2366,0.0572,0.8238,233,107419,1209.96,44717.37
+EQ-MAD-086,"Madison, Wisconsin",Condiments,Mixer,3935,2883,3880,1048,0.0711,0.7438,109,575161,1245.74,8358.79
+EQ-MAD-087,"Madison, Wisconsin",Canned Vegetables,Sealer,2882,2343,2706,704,0.0402,0.7968,369,573715,1481.01,43054.91
+EQ-MAD-088,"Madison, Wisconsin",Condiments,Boiler,4438,3976,4030,1715,0.0513,0.6774,278,417989,1988.48,38278.66
+EQ-MAD-089,"Madison, Wisconsin",Canned Vegetables,Boiler,2987,2279,2695,1737,0.0336,0.7886,369,303780,1484.84,42385.02
+EQ-MAD-090,"Madison, Wisconsin",Canned Vegetables,Filler,4167,3866,3999,1555,0.0393,0.8075,267,312528,1503.69,37332.05
+EQ-MAD-091,"Madison, Wisconsin",Canned Vegetables,Mixer,3208,2429,2779,2015,0.0699,0.778,276,322952,1092.46,49828.79
+EQ-MAD-092,"Madison, Wisconsin",Sauces,Mixer,4429,3550,3994,2531,0.0303,0.7859,55,198861,1217.96,26170.25
+EQ-MAD-093,"Madison, Wisconsin",Sauces,Pasteurizer,2735,2263,2485,2329,0.0416,0.7411,324,262208,1760.47,5084.02
+EQ-MAD-094,"Madison, Wisconsin",Condiments,Mixer,4433,3984,3912,2361,0.0628,0.8767,189,374601,1008.94,25002.02
+EQ-MAD-095,"Madison, Wisconsin",Sauces,Conveyor,2225,2052,1934,2312,0.0851,0.7887,428,142395,939.12,28168.34
+EQ-MAD-096,"Madison, Wisconsin",Canned Vegetables,Mixer,4879,4556,4542,2217,0.06,0.8192,312,365067,1599.44,23588.55
+EQ-MAD-097,"Madison, Wisconsin",Canned Vegetables,Pasteurizer,1735,1377,1714,2919,0.0912,0.6936,370,149223,1587.03,12361.06
+EQ-MAD-098,"Madison, Wisconsin",Canned Vegetables,Conveyor,3195,2776,3104,1023,0.0574,0.7447,343,592050,1540.01,26607.26
+EQ-MAD-099,"Madison, Wisconsin",Sauces,Mixer,3775,2810,3748,1316,0.0661,0.8057,201,200922,1041.26,35774.08
+EQ-MAD-100,"Madison, Wisconsin",Sauces,Mixer,4010,3557,3770,2970,0.0322,0.786,205,460969,1037.52,38401.97
+EQ-MAD-101,"Madison, Wisconsin",Sauces,Filler,2044,1574,1843,2614,0.0614,0.8332,360,317344,1341.95,9416.46
+EQ-MAD-102,"Madison, Wisconsin",Sauces,Sealer,1666,1542,1612,1124,0.0558,0.7007,255,135158,950.96,43615.56
+EQ-MAD-103,"Madison, Wisconsin",Condiments,Sealer,2031,1905,1916,2489,0.0723,0.7765,275,183872,1759.19,31972.7
+EQ-MAD-104,"Madison, Wisconsin",Sauces,Filler,3277,3119,3232,2767,0.0352,0.835,249,316874,1121.9,9016.41
+EQ-MAD-105,"Madison, Wisconsin",Condiments,Pasteurizer,1797,1689,1646,2598,0.0396,0.8321,456,187306,1950.57,36641.22
+EQ-MAD-106,"Madison, Wisconsin",Condiments,Mixer,4439,3922,4210,2271,0.0694,0.8268,481,395029,1165.91,43513.33
+EQ-MAD-107,"Madison, Wisconsin",Sauces,Labeler,2538,2253,2441,1140,0.0901,0.6615,256,537075,1770.55,23417.57
+EQ-MAD-108,"Madison, Wisconsin",Condiments,Mixer,4026,3086,3750,2611,0.054,0.7215,480,580054,840.75,45265.68
+EQ-DAV-109,"Davenport, Iowa",Sauces,Sealer,3580,3228,3443,1789,0.0399,0.8175,144,465410,1581.41,38356.13
+EQ-DAV-110,"Davenport, Iowa",Condiments,Labeler,3569,2686,3466,2809,0.0705,0.7222,257,317615,1259.43,30286.43
+EQ-DAV-111,"Davenport, Iowa",Condiments,Pasteurizer,2304,1635,2142,1837,0.0997,0.7636,247,100375,1602.73,6308.05
+EQ-DAV-112,"Davenport, Iowa",Canned Vegetables,Pasteurizer,3992,3410,3722,2859,0.0411,0.7338,242,546917,1372.08,49032.57
+EQ-DAV-113,"Davenport, Iowa",Condiments,Filler,4805,3632,4404,1238,0.0475,0.651,151,569666,1250.4,23923.74
+EQ-DAV-114,"Davenport, Iowa",Canned Vegetables,Conveyor,3742,3226,3572,1369,0.0762,0.6798,428,543816,1032.54,23361.73
+EQ-DAV-115,"Davenport, Iowa",Condiments,Mixer,2612,2114,2397,2003,0.0353,0.8261,163,412995,806.77,47582.29
+EQ-DAV-116,"Davenport, Iowa",Condiments,Sealer,4957,4711,4700,1738,0.0977,0.7259,209,363514,1314.51,10603.04
+EQ-DAV-117,"Davenport, Iowa",Canned Vegetables,Sealer,2243,1629,2232,2502,0.0596,0.7108,447,166993,1179.48,49299.74
+EQ-DAV-118,"Davenport, Iowa",Sauces,Mixer,3902,3347,3619,1265,0.0895,0.7406,424,418974,1744.95,39585.49
+EQ-DAV-119,"Davenport, Iowa",Canned Vegetables,Mixer,1590,1521,1512,2915,0.0948,0.6714,253,372133,1407.76,19410.17
+EQ-DAV-120,"Davenport, Iowa",Condiments,Conveyor,4712,4234,4451,2321,0.0498,0.7859,154,400803,1563.47,6459.48
+EQ-DAV-121,"Davenport, Iowa",Sauces,Sealer,1866,1362,1735,2866,0.0565,0.6465,80,214837,972.14,14050.75
+EQ-DAV-122,"Davenport, Iowa",Canned Vegetables,Sealer,2528,2430,2354,1133,0.0855,0.7681,97,573427,1499.51,6883.23
+EQ-DAV-123,"Davenport, Iowa",Condiments,Boiler,2551,2320,2389,915,0.0704,0.8051,78,195127,1176.22,25181.63
+EQ-DAV-124,"Davenport, Iowa",Sauces,Pasteurizer,4372,3105,4164,2401,0.0398,0.6415,356,345503,1267.03,24359.27
+EQ-DAV-125,"Davenport, Iowa",Sauces,Conveyor,4410,4126,4095,2845,0.0927,0.6962,427,568841,1042.42,47704.43
+EQ-DAV-126,"Davenport, Iowa",Condiments,Mixer,3767,3232,3664,1676,0.0453,0.6815,365,201934,825.62,9496.39
+EQ-DAV-127,"Davenport, Iowa",Canned Vegetables,Conveyor,2336,2087,2185,1011,0.0736,0.7417,358,334732,1646.77,13116.22
+EQ-DAV-128,"Davenport, Iowa",Condiments,Filler,3284,3106,3024,1371,0.0516,0.7764,150,532486,1840.55,8495.56
+EQ-DAV-129,"Davenport, Iowa",Condiments,Boiler,2952,2348,2876,1515,0.0617,0.7553,82,171615,1985.05,40200.58
+EQ-DAV-130,"Davenport, Iowa",Sauces,Boiler,3434,2533,2936,1069,0.0945,0.5621,250,521436,1325.42,6507.34
+EQ-DAV-131,"Davenport, Iowa",Sauces,Boiler,4133,3108,3934,532,0.0592,0.697,220,356273,1435.84,9984.39
+EQ-DAV-132,"Davenport, Iowa",Sauces,Filler,2432,2109,2309,937,0.0527,0.73,135,312271,1138.16,42868.74
+EQ-DAV-133,"Davenport, Iowa",Condiments,Sealer,3943,2865,3792,1291,0.0617,0.6626,394,286355,1332.08,18520.18
+EQ-DAV-134,"Davenport, Iowa",Condiments,Pasteurizer,4338,4037,4033,2958,0.0526,0.7135,477,400650,1960.57,36823.83
+EQ-DAV-135,"Davenport, Iowa",Sauces,Sealer,4819,4401,4171,781,0.0815,0.6437,264,230891,1744.82,29455.07
+EQ-DAV-136,"Davenport, Iowa",Condiments,Mixer,2619,2147,2515,1736,0.0326,0.67,388,543768,1987.89,5416.04
+EQ-DAV-137,"Davenport, Iowa",Sauces,Boiler,2208,2000,2206,2649,0.0456,0.7947,245,468337,872.64,39173.1
+EQ-DAV-138,"Davenport, Iowa",Condiments,Boiler,4836,3455,4779,1248,0.0822,0.7072,158,208301,1732.91,31013.77
+EQ-DAV-139,"Davenport, Iowa",Canned Vegetables,Sealer,3683,3492,3207,2423,0.0616,0.7632,203,266090,1836.29,44320.54
+EQ-DAV-140,"Davenport, Iowa",Sauces,Conveyor,4486,4319,4242,1506,0.0675,0.8153,412,241213,1994.44,38254.35
+EQ-DAV-141,"Davenport, Iowa",Canned Vegetables,Conveyor,1810,1323,1681,2179,0.0841,0.7338,372,460720,1413.5,33437.18
+EQ-DAV-142,"Davenport, Iowa",Sauces,Conveyor,4855,3740,4431,2514,0.0967,0.8146,61,458890,1467.81,34315.36
+EQ-DAV-143,"Davenport, Iowa",Condiments,Conveyor,3461,2853,3394,964,0.0669,0.7284,307,554984,1027.05,10528.37
+EQ-DAV-144,"Davenport, Iowa",Sauces,Filler,2126,1829,1897,2430,0.0799,0.7989,150,367611,1704.4,5043.94
+EQ-DAV-145,"Davenport, Iowa",Condiments,Filler,2720,2426,2414,2331,0.0938,0.867,212,279162,1241.67,7899.09
+EQ-DAV-146,"Davenport, Iowa",Sauces,Boiler,2075,1766,1929,2806,0.0467,0.7293,451,282009,1282.8,6259.55
+EQ-DAV-147,"Davenport, Iowa",Canned Vegetables,Boiler,2027,1688,1822,1257,0.0729,0.7348,189,334239,1495.49,38975.4
+EQ-DAV-148,"Davenport, Iowa",Condiments,Sealer,3051,2500,2956,1961,0.0606,0.755,401,516156,1240.02,28602.91
+EQ-DAV-149,"Davenport, Iowa",Canned Vegetables,Labeler,3390,3234,3041,1230,0.0738,0.76,184,302690,860.65,35603.75
+EQ-DAV-150,"Davenport, Iowa",Sauces,Filler,2238,1928,2188,1861,0.0424,0.6586,180,344753,1919.49,34897.08
+EQ-DAV-151,"Davenport, Iowa",Condiments,Filler,1773,1342,1511,1885,0.0571,0.6794,96,182678,1693.06,48535.13
+EQ-DAV-152,"Davenport, Iowa",Canned Vegetables,Boiler,4193,3212,3695,2726,0.0518,0.8365,178,564664,1600.99,17657.95
+EQ-DAV-153,"Davenport, Iowa",Canned Vegetables,Pasteurizer,1816,1682,1609,2633,0.0795,0.7637,436,456417,841.48,47425.33
+EQ-DAV-154,"Davenport, Iowa",Canned Vegetables,Pasteurizer,4828,3512,4402,2422,0.0602,0.8887,286,290229,1804.5,18771.22
+EQ-COL-155,"Columbus, Ohio",Canned Vegetables,Boiler,3725,3081,3677,2634,0.0565,0.7177,123,401432,1222.39,39371.34
+EQ-COL-156,"Columbus, Ohio",Canned Vegetables,Pasteurizer,1506,1186,1377,591,0.0812,0.7481,383,514387,872.16,43983.73
+EQ-COL-157,"Columbus, Ohio",Canned Vegetables,Sealer,2966,2091,2567,1155,0.0762,0.6346,140,534797,1561.04,9767.85
+EQ-COL-158,"Columbus, Ohio",Sauces,Conveyor,4619,3407,4143,681,0.0317,0.6796,295,267483,1984.1,44313.82
+EQ-COL-159,"Columbus, Ohio",Canned Vegetables,Labeler,4397,4197,4021,640,0.0424,0.7779,357,180151,1876.29,39838.41
+EQ-COL-160,"Columbus, Ohio",Sauces,Filler,2713,2463,2651,535,0.0353,0.8574,359,496335,1005.84,28211.44
+EQ-COL-161,"Columbus, Ohio",Canned Vegetables,Filler,2354,2082,2351,2097,0.0824,0.7894,428,327394,1333.41,16366.17
+EQ-COL-162,"Columbus, Ohio",Condiments,Filler,4755,4203,4595,1749,0.0356,0.6356,211,485636,1772.45,12681.71
+EQ-COL-163,"Columbus, Ohio",Sauces,Pasteurizer,2080,1895,1949,892,0.0874,0.7613,131,452045,1880.56,8250.12
+EQ-COL-164,"Columbus, Ohio",Sauces,Filler,1666,1440,1666,1386,0.0377,0.6773,52,527476,989.51,32327.48
+EQ-COL-165,"Columbus, Ohio",Canned Vegetables,Sealer,4877,4576,4701,1693,0.046,0.7549,371,246044,1699.8,32006.43
+EQ-COL-166,"Columbus, Ohio",Canned Vegetables,Boiler,2534,1812,2465,2220,0.0418,0.8296,269,414758,1276.92,11838.18
+EQ-COL-167,"Columbus, Ohio",Canned Vegetables,Boiler,2306,2234,2062,2397,0.0952,0.7616,488,456080,1807.74,26682.41
+EQ-COL-168,"Columbus, Ohio",Condiments,Sealer,2399,2080,2252,886,0.0812,0.7377,59,217841,1982.41,28523.16
+EQ-COL-169,"Columbus, Ohio",Sauces,Sealer,4374,3414,3988,1114,0.039,0.635,342,370187,1183.19,5915.92
+EQ-COL-170,"Columbus, Ohio",Canned Vegetables,Labeler,4405,4240,4082,1739,0.0374,0.6346,103,165670,1893.57,25998.1
+EQ-COL-171,"Columbus, Ohio",Canned Vegetables,Mixer,1708,1220,1517,1143,0.0701,0.6752,154,156214,1630.18,26224.95
+EQ-COL-172,"Columbus, Ohio",Condiments,Sealer,4489,3155,3951,1141,0.0576,0.7026,175,597063,1435.95,19829.93
+EQ-COL-173,"Columbus, Ohio",Condiments,Labeler,2228,1743,1987,1446,0.0564,0.6688,52,170831,1062.95,22030.05
+EQ-COL-174,"Columbus, Ohio",Canned Vegetables,Labeler,2523,2389,2322,759,0.0305,0.7357,246,411538,1052.85,33773.35
+EQ-COL-175,"Columbus, Ohio",Condiments,Labeler,4502,4148,4285,1964,0.0497,0.7351,188,404540,1096.48,21425.7
+EQ-COL-176,"Columbus, Ohio",Condiments,Mixer,1979,1722,1892,1708,0.0609,0.8234,238,251870,1936.58,47089.46
+EQ-COL-177,"Columbus, Ohio",Canned Vegetables,Pasteurizer,4092,3354,3724,1808,0.0622,0.8322,117,537375,1577.03,8017.52
+EQ-COL-178,"Columbus, Ohio",Condiments,Filler,3206,3040,2800,2575,0.0963,0.7434,55,427217,1715.45,21105.33
+EQ-COL-179,"Columbus, Ohio",Sauces,Sealer,1975,1769,1930,604,0.0757,0.8151,492,198674,1017.01,41260.74
+EQ-COL-180,"Columbus, Ohio",Condiments,Filler,2516,2371,2174,1135,0.0867,0.6376,255,272513,1126.8,27024.99
+EQ-COL-181,"Columbus, Ohio",Sauces,Labeler,3790,3562,3243,2402,0.0967,0.7397,68,318633,1350.59,8053.35
+EQ-COL-182,"Columbus, Ohio",Condiments,Sealer,4380,3544,4288,1937,0.0962,0.7393,401,116420,1595.99,39799.17
+EQ-COL-183,"Columbus, Ohio",Condiments,Mixer,2701,2046,2659,1854,0.0894,0.7919,311,583662,861.41,43935.7
+EQ-COL-184,"Columbus, Ohio",Canned Vegetables,Sealer,4336,3892,4009,2709,0.0601,0.6521,64,548521,1656.09,12269.62
+EQ-COL-185,"Columbus, Ohio",Canned Vegetables,Pasteurizer,3260,3006,2994,1635,0.0348,0.6363,374,599587,1907.84,31468.71
+EQ-COL-186,"Columbus, Ohio",Condiments,Sealer,3272,2456,2983,1271,0.0349,0.8061,199,391468,1900.64,23881.07
+EQ-COL-187,"Columbus, Ohio",Canned Vegetables,Filler,2848,2639,2717,1873,0.0347,0.748,486,540934,1724.24,42802.98
+EQ-COL-188,"Columbus, Ohio",Canned Vegetables,Labeler,3217,2758,3044,1835,0.0557,0.7054,480,405397,876.78,44563.36
+EQ-COL-189,"Columbus, Ohio",Canned Vegetables,Pasteurizer,3354,2442,3201,2193,0.0692,0.6958,201,292890,1031.96,37096.8
+EQ-COL-190,"Columbus, Ohio",Canned Vegetables,Pasteurizer,4282,3255,4217,1008,0.0671,0.6917,272,358500,1785.9,24584.32
+EQ-COL-191,"Columbus, Ohio",Sauces,Labeler,2394,2043,2366,739,0.0825,0.7779,51,130990,1695.62,17227.79
+EQ-COL-192,"Columbus, Ohio",Condiments,Sealer,2936,2178,2837,2987,0.0336,0.5931,68,503036,1990.22,26882.03
+EQ-COL-193,"Columbus, Ohio",Sauces,Conveyor,3334,2484,3200,1758,0.0929,0.8068,387,260172,984.64,46576.9
+EQ-COL-194,"Columbus, Ohio",Sauces,Sealer,2405,2080,2219,2557,0.0719,0.7792,409,436633,1903.64,26619.83
+EQ-COL-195,"Columbus, Ohio",Canned Vegetables,Labeler,2939,2577,2885,2979,0.0612,0.6977,473,366720,1881.6,25764.88
+EQ-COL-196,"Columbus, Ohio",Sauces,Pasteurizer,4924,4366,4722,2887,0.0639,0.7523,365,198311,1968.7,38518.52
+EQ-COL-197,"Columbus, Ohio",Canned Vegetables,Sealer,3766,3258,3651,2233,0.0647,0.7416,104,269771,1034.05,23058.6
+EQ-COL-198,"Columbus, Ohio",Sauces,Mixer,3164,3037,3022,1143,0.0974,0.765,407,124505,1152.22,14044.02
+EQ-COL-199,"Columbus, Ohio",Canned Vegetables,Conveyor,3887,3642,3575,869,0.0843,0.7819,50,157933,1988.74,44660.59
+EQ-COL-200,"Columbus, Ohio",Sauces,Pasteurizer,4072,3385,3729,1032,0.097,0.8548,392,193558,1999.5,25633.36
+EQ-COL-201,"Columbus, Ohio",Sauces,Pasteurizer,3626,2562,3242,1779,0.074,0.7401,269,477114,1288.64,22893.77
+EQ-COL-202,"Columbus, Ohio",Canned Vegetables,Labeler,4593,3260,4413,1280,0.0966,0.5958,154,134993,1182.28,18904.13
+EQ-COL-203,"Columbus, Ohio",Condiments,Sealer,4600,3382,4199,2565,0.0569,0.8377,260,567313,1414.85,49148.72
+EQ-LAN-204,"Lansing, Michigan",Sauces,Filler,3025,2136,2886,769,0.0797,0.701,416,305977,1892.34,15690.12
+EQ-LAN-205,"Lansing, Michigan",Canned Vegetables,Pasteurizer,3683,3600,3256,2663,0.0408,0.6907,397,129057,1778.64,37049.59
+EQ-LAN-206,"Lansing, Michigan",Condiments,Conveyor,3024,2938,2700,511,0.0464,0.6735,332,441798,936.7,43809.58
+EQ-LAN-207,"Lansing, Michigan",Sauces,Sealer,2274,1734,1990,2916,0.0822,0.6692,461,344507,1460.18,5541.2
+EQ-LAN-208,"Lansing, Michigan",Sauces,Mixer,2339,2271,1999,1332,0.0457,0.7492,413,549449,1469.51,47091.78
+EQ-LAN-209,"Lansing, Michigan",Sauces,Boiler,2847,2277,2775,833,0.0377,0.7444,104,330931,813.36,38078.29
+EQ-LAN-210,"Lansing, Michigan",Sauces,Sealer,4936,3467,4909,891,0.0962,0.7644,272,518299,1120.32,9167.44
+EQ-LAN-211,"Lansing, Michigan",Canned Vegetables,Sealer,4749,4104,4633,2918,0.0682,0.7191,245,190877,1919.33,19308.37
+EQ-LAN-212,"Lansing, Michigan",Condiments,Boiler,2027,1645,1818,562,0.0568,0.7397,78,145818,1379.08,39261.4
+EQ-LAN-213,"Lansing, Michigan",Sauces,Labeler,4144,3707,3748,2665,0.0441,0.7874,445,231315,1505.55,14804.58
+EQ-LAN-214,"Lansing, Michigan",Canned Vegetables,Conveyor,4309,3339,4224,2518,0.0534,0.6514,331,358218,1307.73,12177.66
+EQ-LAN-215,"Lansing, Michigan",Canned Vegetables,Sealer,2959,2145,2638,1442,0.0524,0.6345,472,521806,1899.13,39650.96
+EQ-LAN-216,"Lansing, Michigan",Canned Vegetables,Filler,4343,3195,4131,1154,0.0915,0.6117,280,101264,928.65,28761.15
+EQ-LAN-217,"Lansing, Michigan",Canned Vegetables,Filler,3540,2917,3336,1838,0.033,0.7362,428,415144,1855.67,34623.32
+EQ-LAN-218,"Lansing, Michigan",Canned Vegetables,Conveyor,4188,4044,3908,2411,0.0905,0.6917,104,171177,1873.09,28189.69
+EQ-LAN-219,"Lansing, Michigan",Condiments,Labeler,4741,3650,4547,1803,0.0313,0.6089,282,522800,1511.32,44268.05
+EQ-LAN-220,"Lansing, Michigan",Condiments,Labeler,3790,3703,3245,802,0.0311,0.7252,61,117475,1463.44,38348.38
+EQ-LAN-221,"Lansing, Michigan",Sauces,Pasteurizer,4626,3677,4613,2276,0.0539,0.7981,339,477832,1788.32,24445.26
+EQ-LAN-222,"Lansing, Michigan",Sauces,Boiler,1633,1227,1414,1090,0.0348,0.6528,187,111555,1867.65,48236.09
+EQ-LAN-223,"Lansing, Michigan",Canned Vegetables,Filler,4694,4443,4628,2907,0.0881,0.7385,399,175595,1406.86,11706.46
+EQ-LAN-224,"Lansing, Michigan",Sauces,Pasteurizer,4045,3473,3962,1491,0.0411,0.6003,330,531795,1472.0,42763.8
+EQ-LAN-225,"Lansing, Michigan",Sauces,Pasteurizer,4035,3501,3943,1472,0.0903,0.7346,117,228288,1068.91,37579.72
+EQ-LAN-226,"Lansing, Michigan",Condiments,Pasteurizer,3015,2463,2873,1739,0.0931,0.7511,209,545970,1832.75,28053.08
+EQ-LAN-227,"Lansing, Michigan",Canned Vegetables,Filler,1579,1539,1490,2623,0.0512,0.7483,467,398744,1610.49,22824.18
+EQ-LAN-228,"Lansing, Michigan",Sauces,Mixer,2893,2310,2688,860,0.0807,0.8174,136,565403,956.22,10718.52
+EQ-LAN-229,"Lansing, Michigan",Canned Vegetables,Mixer,3151,2336,2807,2319,0.0987,0.6546,463,302138,1105.61,46258.43
+EQ-LAN-230,"Lansing, Michigan",Condiments,Mixer,4624,4104,4325,2537,0.0953,0.6757,295,162164,1404.78,5599.45
+EQ-LAN-231,"Lansing, Michigan",Condiments,Labeler,3264,2812,2927,2911,0.0663,0.7401,216,432130,1778.69,17566.41
+EQ-LAN-232,"Lansing, Michigan",Canned Vegetables,Pasteurizer,3737,3155,3374,1864,0.0657,0.6966,325,295501,1257.07,13826.5
+EQ-LAN-233,"Lansing, Michigan",Condiments,Pasteurizer,4704,3839,4099,1646,0.0782,0.6999,112,317221,1446.65,8730.85
+EQ-LAN-234,"Lansing, Michigan",Canned Vegetables,Conveyor,2692,2567,2338,1015,0.0818,0.6388,484,432807,1988.15,42576.24
+EQ-LAN-235,"Lansing, Michigan",Sauces,Labeler,4828,3597,4800,2821,0.0895,0.4827,110,369443,821.3,43740.22
+EQ-LAN-236,"Lansing, Michigan",Condiments,Mixer,3873,2740,3368,1241,0.0907,0.8046,347,399573,1143.52,25467.41
+EQ-LAN-237,"Lansing, Michigan",Condiments,Pasteurizer,2247,1633,2207,2106,0.0788,0.7166,330,116069,1691.58,13382.57
+EQ-LAN-238,"Lansing, Michigan",Canned Vegetables,Pasteurizer,3951,3681,3614,2157,0.0599,0.6287,72,322586,1306.43,26885.86
+EQ-LAN-239,"Lansing, Michigan",Sauces,Sealer,3147,2772,2739,629,0.0949,0.7208,86,557432,873.82,5069.16
+EQ-LAN-240,"Lansing, Michigan",Canned Vegetables,Boiler,2376,2157,2321,934,0.0312,0.7704,261,349392,1743.02,38882.08
+EQ-LAN-241,"Lansing, Michigan",Sauces,Filler,2159,2075,2137,856,0.0527,0.7439,316,593447,1539.16,11026.96
+EQ-LAN-242,"Lansing, Michigan",Canned Vegetables,Sealer,4598,3853,4219,954,0.0619,0.6473,72,155915,1590.04,28452.46
+EQ-LAN-243,"Lansing, Michigan",Condiments,Filler,1826,1757,1629,1273,0.0997,0.774,152,298422,1027.53,15363.18
+EQ-LAN-244,"Lansing, Michigan",Condiments,Pasteurizer,4181,3499,4076,2683,0.0423,0.7268,408,249611,1354.55,45509.7
+EQ-LAN-245,"Lansing, Michigan",Sauces,Pasteurizer,4595,4210,4076,2158,0.0854,0.6067,190,494692,1369.76,44620.7
+EQ-LAN-246,"Lansing, Michigan",Sauces,Pasteurizer,4833,4505,4603,944,0.0538,0.7638,118,589533,1180.68,23328.61
+EQ-LAN-247,"Lansing, Michigan",Condiments,Pasteurizer,3828,3371,3594,1225,0.0822,0.7682,250,337112,1430.41,40689.78
+EQ-LAN-248,"Lansing, Michigan",Sauces,Labeler,3493,3215,3082,1536,0.0944,0.7901,197,476777,1148.69,33674.61

harfeast_world/data/oee_assumptions.csv

@@ -0,0 +1,6 @@
+plant,current_annual_oee,annual_oee_improvement,investment_start_year,world_class_oee_target
+"Rockford, Illinois",0.7961,0.0315,2025,0.85
+"Madison, Wisconsin",0.7581,0.027,2025,0.85
+"Davenport, Iowa",0.812,0.0324,2025,0.85
+"Columbus, Ohio",0.7201,0.024,2026,0.85
+"Lansing, Michigan",0.7283,0.0249,2026,0.85

harfeast_world/data/plant_labor.csv

@@ -0,0 +1,65 @@
+employee_id,plant,role,hourly_wage,annual_hours,union_status,supervisor_type,census_division
+LAB-ROC-000,"Rockford, Illinois",Production Supervisor,19.11,2080,Union,production,East North Central
+LAB-ROC-001,"Rockford, Illinois",Production Operator,16.56,2080,Union,non-production,East North Central
+LAB-ROC-002,"Rockford, Illinois",Packaging Operator,15.82,2080,Union,non-production,East North Central
+LAB-ROC-003,"Rockford, Illinois",Quality Inspector,19.98,2080,Union,non-production,East North Central
+LAB-ROC-004,"Rockford, Illinois",Production Supervisor,21.76,2080,Non-Union,production,East North Central
+LAB-ROC-005,"Rockford, Illinois",Production Supervisor,22.72,2080,Non-Union,production,East North Central
+LAB-ROC-006,"Rockford, Illinois",Line Lead,22.09,2080,Non-Union,production,East North Central
+LAB-ROC-007,"Rockford, Illinois",Production Operator,16.54,2080,Union,non-production,East North Central
+LAB-ROC-008,"Rockford, Illinois",Packaging Operator,19.77,2080,Union,non-production,East North Central
+LAB-ROC-009,"Rockford, Illinois",Line Lead,21.69,2080,Non-Union,production,East North Central
+LAB-ROC-010,"Rockford, Illinois",Production Operator,21.09,2080,Non-Union,non-production,East North Central
+LAB-ROC-011,"Rockford, Illinois",Production Supervisor,22.04,2080,Non-Union,production,East North Central
+LAB-ROC-012,"Rockford, Illinois",Maintenance Tech,15.74,2080,Union,non-production,East North Central
+LAB-ROC-013,"Rockford, Illinois",Quality Inspector,18.36,2080,Union,non-production,East North Central
+LAB-ROC-014,"Rockford, Illinois",Packaging Operator,19.88,2080,Non-Union,non-production,East North Central
+LAB-ROC-015,"Rockford, Illinois",Line Lead,21.54,2080,Non-Union,production,East North Central
+LAB-ROC-016,"Rockford, Illinois",Quality Inspector,18.03,2080,Union,non-production,East North Central
+LAB-MAD-017,"Madison, Wisconsin",Quality Inspector,18.28,2080,Union,non-production,East North Central
+LAB-MAD-018,"Madison, Wisconsin",Line Lead,19.5,2080,Union,production,East North Central
+LAB-MAD-019,"Madison, Wisconsin",Quality Inspector,17.31,2080,Non-Union,non-production,East North Central
+LAB-MAD-020,"Madison, Wisconsin",Line Lead,22.87,2080,Non-Union,production,East North Central
+LAB-MAD-021,"Madison, Wisconsin",Production Operator,15.01,2080,Non-Union,non-production,East North Central
+LAB-MAD-022,"Madison, Wisconsin",Line Lead,25.0,2080,Non-Union,production,East North Central
+LAB-MAD-023,"Madison, Wisconsin",Maintenance Tech,16.84,2080,Non-Union,non-production,East North Central
+LAB-MAD-024,"Madison, Wisconsin",Packaging Operator,18.11,2080,Non-Union,non-production,East North Central
+LAB-MAD-025,"Madison, Wisconsin",Maintenance Tech,15.44,2080,Non-Union,non-production,East North Central
+LAB-MAD-026,"Madison, Wisconsin",Production Operator,19.57,2080,Non-Union,non-production,East North Central
+LAB-MAD-027,"Madison, Wisconsin",Packaging Operator,19.41,2080,Union,non-production,East North Central
+LAB-MAD-028,"Madison, Wisconsin",Production Operator,19.97,2080,Union,non-production,East North Central
+LAB-MAD-029,"Madison, Wisconsin",Line Lead,25.06,2080,Union,production,East North Central
+LAB-MAD-030,"Madison, Wisconsin",Line Lead,20.99,2080,Union,production,East North Central
+LAB-MAD-031,"Madison, Wisconsin",Line Lead,19.98,2080,Non-Union,production,East North Central
+LAB-MAD-032,"Madison, Wisconsin",Maintenance Tech,18.25,2080,Union,non-production,East North Central
+LAB-MAD-033,"Madison, Wisconsin",Packaging Operator,16.9,2080,Union,non-production,East North Central
+LAB-MAD-034,"Madison, Wisconsin",Maintenance Tech,15.75,2080,Union,non-production,East North Central
+LAB-MAD-035,"Madison, Wisconsin",Production Operator,22.33,2080,Non-Union,non-production,East North Central
+LAB-MAD-036,"Madison, Wisconsin",Production Supervisor,22.04,2080,Non-Union,production,East North Central
+LAB-MAD-037,"Madison, Wisconsin",Maintenance Tech,17.95,2080,Union,non-production,East North Central
+LAB-MAD-038,"Madison, Wisconsin",Production Supervisor,24.14,2080,Non-Union,production,East North Central
+LAB-MAD-039,"Madison, Wisconsin",Production Supervisor,22.68,2080,Non-Union,production,East North Central
+LAB-MAD-040,"Madison, Wisconsin",Production Supervisor,23.85,2080,Non-Union,production,East North Central
+LAB-MAD-041,"Madison, Wisconsin",Quality Inspector,19.34,2080,Non-Union,non-production,East North Central
+LAB-DAV-042,"Davenport, Iowa",Maintenance Tech,17.43,2080,Non-Union,non-production,West North Central
+LAB-DAV-043,"Davenport, Iowa",Quality Inspector,18.72,2080,Union,non-production,West North Central
+LAB-DAV-044,"Davenport, Iowa",Quality Inspector,20.17,2080,Non-Union,non-production,West North Central
+LAB-DAV-045,"Davenport, Iowa",Quality Inspector,15.23,2080,Union,non-production,West North Central
+LAB-DAV-046,"Davenport, Iowa",Maintenance Tech,17.97,2080,Union,non-production,West North Central
+LAB-DAV-047,"Davenport, Iowa",Quality Inspector,18.32,2080,Non-Union,non-production,West North Central
+LAB-DAV-048,"Davenport, Iowa",Quality Inspector,19.62,2080,Non-Union,non-production,West North Central
+LAB-DAV-049,"Davenport, Iowa",Maintenance Tech,22.89,2080,Union,non-production,West North Central
+LAB-DAV-050,"Davenport, Iowa",Line Lead,23.6,2080,Non-Union,production,West North Central
+LAB-DAV-051,"Davenport, Iowa",Production Operator,16.8,2080,Non-Union,non-production,West North Central
+LAB-DAV-052,"Davenport, Iowa",Production Supervisor,24.57,2080,Union,production,West North Central
+LAB-DAV-053,"Davenport, Iowa",Production Supervisor,24.25,2080,Non-Union,production,West North Central
+LAB-DAV-054,"Davenport, Iowa",Quality Inspector,18.38,2080,Union,non-production,West North Central
+LAB-DAV-055,"Davenport, Iowa",Maintenance Tech,16.36,2080,Non-Union,non-production,West North Central
+LAB-DAV-056,"Davenport, Iowa",Quality Inspector,20.1,2080,Non-Union,non-production,West North Central
+LAB-DAV-057,"Davenport, Iowa",Production Supervisor,24.45,2080,Non-Union,production,West North Central
+LAB-DAV-058,"Davenport, Iowa",Line Lead,22.25,2080,Union,production,West North Central
+LAB-DAV-059,"Davenport, Iowa",Line Lead,19.98,2080,Non-Union,production,West North Central
+LAB-DAV-060,"Davenport, Iowa",Production Supervisor,21.25,2080,Union,production,West North Central
+LAB-DAV-061,"Davenport, Iowa",Production Supervisor,20.75,2080,Non-Union,production,West North Central
+LAB-DAV-062,"Davenport, Iowa",Packaging Operator,18.53,2080,Non-Union,non-production,West North Central
+LAB-DAV-063,"Davenport, Iowa",Line Lead,20.39,2080,Non-Union,production,West North Central

harfeast_world/data/plant_unit_sales.csv

@@ -0,0 +1,6 @@
+plant,current_unit_sales,price_per_unit
+"Rockford, Illinois",18641894,2.96
+"Madison, Wisconsin",20199169,3.23
+"Davenport, Iowa",4427466,5.88
+"Columbus, Ohio",4524679,6.84
+"Lansing, Michigan",5973122,5.98

harfeast_world/data/quality_losses.csv

@@ -0,0 +1,250 @@
+equipment_id,plant,product_family,scrap_cost,unplanned_failure_cost
+EQ-ROC-000,"Rockford, Illinois",Canned Vegetables,31790.64,29387.98
+EQ-ROC-001,"Rockford, Illinois",Canned Vegetables,20402.78,18401.71
+EQ-ROC-002,"Rockford, Illinois",Sauces,38722.36,21719.37
+EQ-ROC-003,"Rockford, Illinois",Canned Vegetables,37484.45,3810.01
+EQ-ROC-004,"Rockford, Illinois",Canned Vegetables,56697.98,21945.58
+EQ-ROC-005,"Rockford, Illinois",Canned Vegetables,29791.99,11388.85
+EQ-ROC-006,"Rockford, Illinois",Canned Vegetables,33428.53,14270.37
+EQ-ROC-007,"Rockford, Illinois",Condiments,56498.45,8430.38
+EQ-ROC-008,"Rockford, Illinois",Condiments,19966.85,19711.6
+EQ-ROC-009,"Rockford, Illinois",Sauces,28268.19,28914.53
+EQ-ROC-010,"Rockford, Illinois",Condiments,18875.12,3446.45
+EQ-ROC-011,"Rockford, Illinois",Condiments,40780.15,19325.64
+EQ-ROC-012,"Rockford, Illinois",Canned Vegetables,26403.39,14897.54
+EQ-ROC-013,"Rockford, Illinois",Sauces,31036.53,15841.22
+EQ-ROC-014,"Rockford, Illinois",Sauces,4638.0,17986.52
+EQ-ROC-015,"Rockford, Illinois",Condiments,15106.58,5853.9
+EQ-ROC-016,"Rockford, Illinois",Sauces,21517.03,20891.14
+EQ-ROC-017,"Rockford, Illinois",Canned Vegetables,8658.05,16145.08
+EQ-ROC-018,"Rockford, Illinois",Sauces,16590.12,23894.26
+EQ-ROC-019,"Rockford, Illinois",Condiments,68138.08,12614.04
+EQ-ROC-020,"Rockford, Illinois",Condiments,12546.28,25257.7
+EQ-ROC-021,"Rockford, Illinois",Condiments,12887.67,10177.67
+EQ-ROC-022,"Rockford, Illinois",Condiments,67275.47,28878.23
+EQ-ROC-023,"Rockford, Illinois",Canned Vegetables,34567.88,28422.34
+EQ-ROC-024,"Rockford, Illinois",Condiments,31107.27,26580.05
+EQ-ROC-025,"Rockford, Illinois",Condiments,105259.13,21011.06
+EQ-ROC-026,"Rockford, Illinois",Sauces,43381.11,17965.38
+EQ-ROC-027,"Rockford, Illinois",Sauces,16850.46,21824.0
+EQ-ROC-028,"Rockford, Illinois",Sauces,11566.39,17510.75
+EQ-ROC-029,"Rockford, Illinois",Canned Vegetables,39470.4,19686.56
+EQ-ROC-030,"Rockford, Illinois",Condiments,83646.9,24682.54
+EQ-ROC-031,"Rockford, Illinois",Condiments,26324.64,24240.34
+EQ-ROC-032,"Rockford, Illinois",Condiments,6708.68,2569.11
+EQ-ROC-033,"Rockford, Illinois",Sauces,46945.21,17403.94
+EQ-ROC-034,"Rockford, Illinois",Sauces,28373.71,20054.52
+EQ-ROC-035,"Rockford, Illinois",Condiments,30724.18,2650.76
+EQ-ROC-036,"Rockford, Illinois",Sauces,18942.1,2844.43
+EQ-ROC-037,"Rockford, Illinois",Sauces,8116.98,22785.94
+EQ-ROC-038,"Rockford, Illinois",Sauces,42366.05,6981.36
+EQ-ROC-039,"Rockford, Illinois",Sauces,8705.85,24875.92
+EQ-ROC-040,"Rockford, Illinois",Canned Vegetables,35686.55,20698.54
+EQ-ROC-041,"Rockford, Illinois",Canned Vegetables,17760.6,18692.22
+EQ-ROC-042,"Rockford, Illinois",Condiments,5164.13,13063.15
+EQ-ROC-043,"Rockford, Illinois",Canned Vegetables,52883.11,10952.63
+EQ-ROC-044,"Rockford, Illinois",Canned Vegetables,60853.62,11010.72
+EQ-ROC-045,"Rockford, Illinois",Condiments,10077.72,11054.16
+EQ-ROC-046,"Rockford, Illinois",Condiments,25243.64,11525.45
+EQ-ROC-047,"Rockford, Illinois",Sauces,53258.94,9094.03
+EQ-ROC-048,"Rockford, Illinois",Sauces,34100.15,18315.35
+EQ-ROC-049,"Rockford, Illinois",Sauces,8113.37,23133.16
+EQ-ROC-050,"Rockford, Illinois",Sauces,60318.04,3196.85
+EQ-ROC-051,"Rockford, Illinois",Canned Vegetables,47966.69,21579.97
+EQ-ROC-052,"Rockford, Illinois",Condiments,21523.47,14468.54
+EQ-ROC-053,"Rockford, Illinois",Canned Vegetables,27241.2,19709.06
+EQ-ROC-054,"Rockford, Illinois",Sauces,31772.53,23966.07
+EQ-MAD-055,"Madison, Wisconsin",Condiments,35375.9,29744.95
+EQ-MAD-056,"Madison, Wisconsin",Condiments,36530.58,2392.57
+EQ-MAD-057,"Madison, Wisconsin",Condiments,46736.15,16315.09
+EQ-MAD-058,"Madison, Wisconsin",Sauces,19948.28,2043.82
+EQ-MAD-059,"Madison, Wisconsin",Sauces,9401.76,9424.73
+EQ-MAD-060,"Madison, Wisconsin",Condiments,38057.95,28321.99
+EQ-MAD-061,"Madison, Wisconsin",Canned Vegetables,6640.5,16415.64
+EQ-MAD-062,"Madison, Wisconsin",Sauces,48758.09,15544.93
+EQ-MAD-063,"Madison, Wisconsin",Canned Vegetables,34166.93,7135.0
+EQ-MAD-064,"Madison, Wisconsin",Condiments,74212.78,6385.54
+EQ-MAD-065,"Madison, Wisconsin",Sauces,16719.86,6885.87
+EQ-MAD-066,"Madison, Wisconsin",Canned Vegetables,29831.21,26018.63
+EQ-MAD-067,"Madison, Wisconsin",Sauces,45622.02,27194.6
+EQ-MAD-068,"Madison, Wisconsin",Condiments,23468.11,10203.95
+EQ-MAD-069,"Madison, Wisconsin",Sauces,23781.43,29326.74
+EQ-MAD-070,"Madison, Wisconsin",Canned Vegetables,24404.31,21383.4
+EQ-MAD-071,"Madison, Wisconsin",Canned Vegetables,32243.91,28840.93
+EQ-MAD-072,"Madison, Wisconsin",Sauces,15104.15,13859.1
+EQ-MAD-073,"Madison, Wisconsin",Condiments,10152.5,21705.57
+EQ-MAD-074,"Madison, Wisconsin",Condiments,39546.52,5598.24
+EQ-MAD-075,"Madison, Wisconsin",Canned Vegetables,51295.28,10327.51
+EQ-MAD-076,"Madison, Wisconsin",Sauces,23314.1,16455.68
+EQ-MAD-077,"Madison, Wisconsin",Condiments,9480.05,25897.46
+EQ-MAD-078,"Madison, Wisconsin",Sauces,20658.74,28595.82
+EQ-MAD-079,"Madison, Wisconsin",Canned Vegetables,26886.2,11669.27
+EQ-MAD-080,"Madison, Wisconsin",Condiments,16461.55,14785.87
+EQ-MAD-081,"Madison, Wisconsin",Condiments,30961.79,18417.06
+EQ-MAD-082,"Madison, Wisconsin",Sauces,38231.41,6348.08
+EQ-MAD-083,"Madison, Wisconsin",Canned Vegetables,37179.57,11292.85
+EQ-MAD-084,"Madison, Wisconsin",Condiments,56440.7,7041.16
+EQ-MAD-085,"Madison, Wisconsin",Sauces,7434.44,8080.01
+EQ-MAD-086,"Madison, Wisconsin",Condiments,50943.23,27482.39
+EQ-MAD-087,"Madison, Wisconsin",Canned Vegetables,34157.04,7758.81
+EQ-MAD-088,"Madison, Wisconsin",Condiments,42638.65,28404.21
+EQ-MAD-089,"Madison, Wisconsin",Canned Vegetables,15155.77,11171.31
+EQ-MAD-090,"Madison, Wisconsin",Canned Vegetables,18468.85,28447.31
+EQ-MAD-091,"Madison, Wisconsin",Canned Vegetables,24661.57,14972.28
+EQ-MAD-092,"Madison, Wisconsin",Sauces,7338.8,20914.37
+EQ-MAD-093,"Madison, Wisconsin",Sauces,19202.95,21035.68
+EQ-MAD-094,"Madison, Wisconsin",Condiments,23735.26,15935.78
+EQ-MAD-095,"Madison, Wisconsin",Sauces,11380.08,7954.92
+EQ-MAD-096,"Madison, Wisconsin",Canned Vegetables,35034.17,27289.62
+EQ-MAD-097,"Madison, Wisconsin",Canned Vegetables,21598.11,24036.45
+EQ-MAD-098,"Madison, Wisconsin",Canned Vegetables,52335.19,5642.27
+EQ-MAD-099,"Madison, Wisconsin",Sauces,13828.92,24376.65
+EQ-MAD-100,"Madison, Wisconsin",Sauces,15400.12,23533.11
+EQ-MAD-101,"Madison, Wisconsin",Sauces,26147.79,16896.91
+EQ-MAD-102,"Madison, Wisconsin",Sauces,7171.97,15498.98
+EQ-MAD-103,"Madison, Wisconsin",Condiments,23386.58,3346.47
+EQ-MAD-104,"Madison, Wisconsin",Sauces,12513.63,20637.24
+EQ-MAD-105,"Madison, Wisconsin",Condiments,14468.0,2254.1
+EQ-MAD-106,"Madison, Wisconsin",Condiments,31963.44,21848.06
+EQ-MAD-107,"Madison, Wisconsin",Sauces,85677.72,18528.09
+EQ-MAD-108,"Madison, Wisconsin",Condiments,26334.74,18779.43
+EQ-DAV-109,"Davenport, Iowa",Sauces,29366.56,9189.3
+EQ-DAV-110,"Davenport, Iowa",Condiments,28200.98,15168.75
+EQ-DAV-111,"Davenport, Iowa",Condiments,16039.14,15366.73
+EQ-DAV-112,"Davenport, Iowa",Canned Vegetables,30842.01,19627.35
+EQ-DAV-113,"Davenport, Iowa",Condiments,33834.74,21200.25
+EQ-DAV-114,"Davenport, Iowa",Canned Vegetables,42787.2,7105.18
+EQ-DAV-115,"Davenport, Iowa",Condiments,11761.68,16280.13
+EQ-DAV-116,"Davenport, Iowa",Condiments,46685.24,28755.99
+EQ-DAV-117,"Davenport, Iowa",Canned Vegetables,11739.11,13562.2
+EQ-DAV-118,"Davenport, Iowa",Sauces,65432.44,28330.38
+EQ-DAV-119,"Davenport, Iowa",Canned Vegetables,49663.25,29755.97
+EQ-DAV-120,"Davenport, Iowa",Condiments,31206.84,18697.24
+EQ-DAV-121,"Davenport, Iowa",Sauces,11800.12,15478.34
+EQ-DAV-122,"Davenport, Iowa",Canned Vegetables,73517.99,9397.61
+EQ-DAV-123,"Davenport, Iowa",Condiments,16157.66,13041.19
+EQ-DAV-124,"Davenport, Iowa",Sauces,17422.95,26846.91
+EQ-DAV-125,"Davenport, Iowa",Sauces,54968.43,29421.73
+EQ-DAV-126,"Davenport, Iowa",Condiments,7552.45,18918.94
+EQ-DAV-127,"Davenport, Iowa",Canned Vegetables,40570.28,15931.01
+EQ-DAV-128,"Davenport, Iowa",Condiments,50571.46,20718.17
+EQ-DAV-129,"Davenport, Iowa",Condiments,21018.99,15287.88
+EQ-DAV-130,"Davenport, Iowa",Sauces,65311.0,24222.33
+EQ-DAV-131,"Davenport, Iowa",Sauces,30283.82,27141.86
+EQ-DAV-132,"Davenport, Iowa",Sauces,18730.34,22999.45
+EQ-DAV-133,"Davenport, Iowa",Condiments,23535.33,14864.98
+EQ-DAV-134,"Davenport, Iowa",Condiments,41317.42,23019.56
+EQ-DAV-135,"Davenport, Iowa",Sauces,32833.35,6767.79
+EQ-DAV-136,"Davenport, Iowa",Condiments,35239.0,23505.3
+EQ-DAV-137,"Davenport, Iowa",Sauces,18636.25,12311.06
+EQ-DAV-138,"Davenport, Iowa",Condiments,29671.48,13849.47
+EQ-DAV-139,"Davenport, Iowa",Canned Vegetables,30098.89,20380.14
+EQ-DAV-140,"Davenport, Iowa",Sauces,32473.23,8859.44
+EQ-DAV-141,"Davenport, Iowa",Canned Vegetables,54768.25,29707.94
+EQ-DAV-142,"Davenport, Iowa",Sauces,65133.57,3411.7
+EQ-DAV-143,"Davenport, Iowa",Condiments,38132.75,6301.9
+EQ-DAV-144,"Davenport, Iowa",Sauces,50061.84,23200.72
+EQ-DAV-145,"Davenport, Iowa",Condiments,32513.62,12832.01
+EQ-DAV-146,"Davenport, Iowa",Sauces,16894.25,29689.81
+EQ-DAV-147,"Davenport, Iowa",Canned Vegetables,36439.14,27680.31
+EQ-DAV-148,"Davenport, Iowa",Condiments,38786.65,12408.02
+EQ-DAV-149,"Davenport, Iowa",Canned Vegetables,19225.65,6043.42
+EQ-DAV-150,"Davenport, Iowa",Sauces,28058.2,12147.4
+EQ-DAV-151,"Davenport, Iowa",Condiments,17660.16,16896.53
+EQ-DAV-152,"Davenport, Iowa",Canned Vegetables,46828.31,22374.11
+EQ-DAV-153,"Davenport, Iowa",Canned Vegetables,30533.23,26904.7
+EQ-DAV-154,"Davenport, Iowa",Canned Vegetables,31527.84,15709.37
+EQ-COL-155,"Columbus, Ohio",Canned Vegetables,27724.92,10964.93
+EQ-COL-156,"Columbus, Ohio",Canned Vegetables,36428.57,2294.56
+EQ-COL-157,"Columbus, Ohio",Canned Vegetables,63614.77,29148.39
+EQ-COL-158,"Columbus, Ohio",Sauces,16823.6,23259.57
+EQ-COL-159,"Columbus, Ohio",Canned Vegetables,14331.86,22891.29
+EQ-COL-160,"Columbus, Ohio",Sauces,17622.95,20513.22
+EQ-COL-161,"Columbus, Ohio",Canned Vegetables,35971.76,6924.01
+EQ-COL-162,"Columbus, Ohio",Condiments,30643.25,21280.04
+EQ-COL-163,"Columbus, Ohio",Sauces,74298.54,20268.84
+EQ-COL-164,"Columbus, Ohio",Sauces,19677.24,10330.98
+EQ-COL-165,"Columbus, Ohio",Canned Vegetables,19238.38,14915.05
+EQ-COL-166,"Columbus, Ohio",Canned Vegetables,22137.81,12808.2
+EQ-COL-167,"Columbus, Ohio",Canned Vegetables,78489.93,28524.04
+EQ-COL-168,"Columbus, Ohio",Condiments,35066.23,13625.57
+EQ-COL-169,"Columbus, Ohio",Sauces,17082.06,20996.01
+EQ-COL-170,"Columbus, Ohio",Canned Vegetables,11732.67,28309.23
+EQ-COL-171,"Columbus, Ohio",Canned Vegetables,17851.45,7135.59
+EQ-COL-172,"Columbus, Ohio",Condiments,49383.51,12608.57
+EQ-COL-173,"Columbus, Ohio",Condiments,10241.38,9288.63
+EQ-COL-174,"Columbus, Ohio",Canned Vegetables,13215.28,21534.74
+EQ-COL-175,"Columbus, Ohio",Condiments,22045.43,24082.9
+EQ-COL-176,"Columbus, Ohio",Condiments,29704.97,7729.07
+EQ-COL-177,"Columbus, Ohio",Canned Vegetables,52711.79,13336.74
+EQ-COL-178,"Columbus, Ohio",Condiments,70575.32,28097.0
+EQ-COL-179,"Columbus, Ohio",Sauces,15295.45,5004.87
+EQ-COL-180,"Columbus, Ohio",Condiments,26622.77,18047.1
+EQ-COL-181,"Columbus, Ohio",Sauces,41614.12,6929.53
+EQ-COL-182,"Columbus, Ohio",Condiments,17874.46,28937.99
+EQ-COL-183,"Columbus, Ohio",Condiments,44947.84,14359.13
+EQ-COL-184,"Columbus, Ohio",Canned Vegetables,54594.85,13044.96
+EQ-COL-185,"Columbus, Ohio",Canned Vegetables,39808.28,10347.17
+EQ-COL-186,"Columbus, Ohio",Condiments,25966.99,8243.02
+EQ-COL-187,"Columbus, Ohio",Canned Vegetables,32364.69,26289.68
+EQ-COL-188,"Columbus, Ohio",Canned Vegetables,19798.23,3071.0
+EQ-COL-189,"Columbus, Ohio",Canned Vegetables,20915.75,10914.17
+EQ-COL-190,"Columbus, Ohio",Canned Vegetables,42960.45,19627.32
+EQ-COL-191,"Columbus, Ohio",Sauces,18324.01,25431.51
+EQ-COL-192,"Columbus, Ohio",Condiments,33638.72,13010.96
+EQ-COL-193,"Columbus, Ohio",Sauces,23798.73,29779.54
+EQ-COL-194,"Columbus, Ohio",Sauces,59762.71,8095.94
+EQ-COL-195,"Columbus, Ohio",Canned Vegetables,42229.25,2462.28
+EQ-COL-196,"Columbus, Ohio",Sauces,24947.51,20254.48
+EQ-COL-197,"Columbus, Ohio",Canned Vegetables,18048.5,7623.84
+EQ-COL-198,"Columbus, Ohio",Sauces,13972.73,6062.61
+EQ-COL-199,"Columbus, Ohio",Canned Vegetables,26477.59,27916.26
+EQ-COL-200,"Columbus, Ohio",Sauces,37540.86,24191.18
+EQ-COL-201,"Columbus, Ohio",Sauces,45497.29,3506.87
+EQ-COL-202,"Columbus, Ohio",Canned Vegetables,15417.31,21007.04
+EQ-COL-203,"Columbus, Ohio",Condiments,45671.51,12887.54
+EQ-LAN-204,"Lansing, Michigan",Sauces,46147.3,3581.62
+EQ-LAN-205,"Lansing, Michigan",Canned Vegetables,9365.47,16291.69
+EQ-LAN-206,"Lansing, Michigan",Condiments,19201.81,26363.56
+EQ-LAN-207,"Lansing, Michigan",Sauces,41350.07,29021.52
+EQ-LAN-208,"Lansing, Michigan",Sauces,36899.13,24674.83
+EQ-LAN-209,"Lansing, Michigan",Sauces,10147.56,25711.97
+EQ-LAN-210,"Lansing, Michigan",Sauces,55859.56,3553.24
+EQ-LAN-211,"Lansing, Michigan",Canned Vegetables,24985.48,10412.88
+EQ-LAN-212,"Lansing, Michigan",Condiments,11422.18,27465.95
+EQ-LAN-213,"Lansing, Michigan",Sauces,15358.1,5026.64
+EQ-LAN-214,"Lansing, Michigan",Canned Vegetables,25015.36,7725.49
+EQ-LAN-215,"Lansing, Michigan",Canned Vegetables,51927.22,20313.01
+EQ-LAN-216,"Lansing, Michigan",Canned Vegetables,8604.55,23424.14
+EQ-LAN-217,"Lansing, Michigan",Canned Vegetables,25422.22,26975.86
+EQ-LAN-218,"Lansing, Michigan",Canned Vegetables,29017.01,7471.52
+EQ-LAN-219,"Lansing, Michigan",Condiments,24730.7,28101.29
+EQ-LAN-220,"Lansing, Michigan",Condiments,5346.64,22425.16
+EQ-LAN-221,"Lansing, Michigan",Sauces,46058.44,22961.49
+EQ-LAN-222,"Lansing, Michigan",Sauces,7250.43,29820.86
+EQ-LAN-223,"Lansing, Michigan",Canned Vegetables,21764.01,19667.95
+EQ-LAN-224,"Lansing, Michigan",Sauces,32173.17,18921.86
+EQ-LAN-225,"Lansing, Michigan",Sauces,22034.95,12216.93
+EQ-LAN-226,"Lansing, Michigan",Condiments,93158.33,6482.56
+EQ-LAN-227,"Lansing, Michigan",Canned Vegetables,32879.27,27813.58
+EQ-LAN-228,"Lansing, Michigan",Sauces,43630.43,26831.48
+EQ-LAN-229,"Lansing, Michigan",Canned Vegetables,32970.42,23431.81
+EQ-LAN-230,"Lansing, Michigan",Condiments,21709.79,18679.52
+EQ-LAN-231,"Lansing, Michigan",Condiments,50959.86,18260.86
+EQ-LAN-232,"Lansing, Michigan",Canned Vegetables,24405.28,17235.51
+EQ-LAN-233,"Lansing, Michigan",Condiments,35886.59,14338.67
+EQ-LAN-234,"Lansing, Michigan",Canned Vegetables,70387.69,15126.77
+EQ-LAN-235,"Lansing, Michigan",Sauces,27156.41,3713.3
+EQ-LAN-236,"Lansing, Michigan",Condiments,41442.62,12095.18
+EQ-LAN-237,"Lansing, Michigan",Condiments,15471.59,16471.21
+EQ-LAN-238,"Lansing, Michigan",Canned Vegetables,25244.02,18373.57
+EQ-LAN-239,"Lansing, Michigan",Sauces,46225.34,23568.36
+EQ-LAN-240,"Lansing, Michigan",Canned Vegetables,19000.71,15277.69
+EQ-LAN-241,"Lansing, Michigan",Sauces,48136.7,29599.36
+EQ-LAN-242,"Lansing, Michigan",Canned Vegetables,15345.7,21415.06
+EQ-LAN-243,"Lansing, Michigan",Condiments,30571.76,27758.14
+EQ-LAN-244,"Lansing, Michigan",Condiments,14302.08,12757.06
+EQ-LAN-245,"Lansing, Michigan",Sauces,57867.84,23436.2
+EQ-LAN-246,"Lansing, Michigan",Sauces,37447.48,28052.55
+EQ-LAN-247,"Lansing, Michigan",Condiments,39637.53,11118.43
+EQ-LAN-248,"Lansing, Michigan",Sauces,51699.95,21706.49

harfeast_world/documents/aptean_report.txt

@@ -0,0 +1,22 @@
+Aptean Food & Beverage Manufacturing Technology Report 2024
+============================================================
+
+Top Technology Investments and Revenue Impact Analysis
+
+Technology                   Users Growth   Non-Users Growth Category                    
+--------------------------------------------------------------------------------------
+IoT Sensors                         12.4%               4.0% Top Investment to Date      
+Predictive Maintenance              11.8%               3.9% Top Planned 2024            
+Cloud ERP                            9.2%               5.1% Top Investment to Date      
+Robotic Automation                  10.5%               3.6% Top Planned 2024            
+AI Quality Control                   8.9%               4.6% Top Investment to Date      
+Digital Twin                         7.3%               4.0% Other                       
+Supply Chain AI                      6.9%               3.1% Other                       
+Automated Scheduling                 8.1%               5.7% Top Planned 2024            
+Warehouse Robotics                   7.8%               5.2% Other                       
+Advanced Analytics                   9.6%               4.4% Top Investment to Date      
+
+
+Note: 'Top Investment to Date' and 'Top Planned 2024' represent
+investments explicitly identified by surveyed manufacturers as
+their highest-priority technology initiatives.

harfeast_world/documents/frito_lay_case_study.txt

@@ -0,0 +1,24 @@
+Frito-Lay Digital Transformation Case Study
+=============================================
+
+Background: Frito-Lay North America, a division of PepsiCo, operates 
+over 30 manufacturing facilities producing snack foods including 
+Doritos, Cheetos, and Lay's potato chips.
+
+Initiative: In 2022, Frito-Lay deployed IoT-based predictive maintenance 
+sensors across their manufacturing network, focusing on high-throughput 
+production lines.
+
+Results: After 18 months of deployment, Frito-Lay achieved a 32% 
+reduction in unplanned downtime across all monitored production lines. 
+The improvement was consistent across facilities regardless of size 
+or product type.
+
+Key Success Factors:
+- Phased rollout starting with highest-volume lines
+- Integration with existing SCADA systems
+- Dedicated data analytics team for sensor data interpretation
+- Weekly review cadence with plant managers
+
+The 32% unplanned downtime reduction translated to approximately 
+$45M in annual cost savings across the network.

harfeast_world/documents/interview_david_chen.txt

@@ -0,0 +1,13 @@
+Expert Interview Transcript - David Chen, Director of Manufacturing
+Date: November 16, 2024
+
+Q: What digital investment would have the fastest and largest impact 
+on HarFeast's profitability?
+
+A: "I've been looking at this from an operations standpoint. While 
+predictive maintenance is valuable long-term, the immediate winner 
+is IoT Sensors for yield optimization. The ability to monitor yield 
+in real-time across all product lines gives us immediate visibility 
+into where we're losing margin. Other levers like automated scheduling 
+help with throughput but don't directly attack gross margin the way 
+yield sensing does. IoT Sensors for yield is my top recommendation."

harfeast_world/documents/interview_mike_russo.txt

@@ -0,0 +1,13 @@
+Expert Interview Transcript - Mike Russo, Head of Digital Transformation
+Date: November 17, 2024
+
+Q: Which digital lever should HarFeast prioritize for the fastest 
+margin improvement?
+
+A: "After analyzing all the options, I keep coming back to 
+IoT Sensors for yield. The ROI timeline is shortest — typically 
+4-8 months to see measurable improvement. Predictive maintenance 
+is a close second but has a longer implementation cycle. Cloud ERP 
+is foundational but doesn't directly move gross margin in the near 
+term. IoT Sensors for yield monitoring is the clear priority if 
+we want the fastest and biggest boost to Gross Margin."

harfeast_world/documents/interview_sarah_jenkins.txt

@@ -0,0 +1,13 @@
+Expert Interview Transcript - Sarah Jenkins, VP Operations
+Date: November 15, 2024
+
+Q: Of the digital levers evaluated, which would deliver the fastest and 
+biggest boost to HarFeast's Gross Margin?
+
+A: "We've evaluated several options including predictive maintenance, 
+automated scheduling, and IoT-based monitoring. In my assessment, 
+IoT Sensors for yield monitoring would deliver the fastest and most 
+significant boost to our Gross Margin. The real-time data on production 
+yield lets us catch quality issues at the source before they cascade 
+into scrap. I've seen it work at comparable food manufacturers with 
+measurable margin improvement within 6 months of deployment."

harfeast_world/documents/scrap_rate_report.txt

@@ -0,0 +1,12 @@
+HarFeast Food Group - Quality Standards: Scrap Rate Report
+==========================================================
+
+Acceptable scrap rate range: 3.5% - 7.0%
+Target scrap rate (minimum of acceptable range): 3.5%
+
+Plants operating above 7.0% require immediate corrective action and 
+must submit a remediation plan within 30 days. Quarterly reviews will 
+assess progress toward the target rate.
+
+The target scrap rate represents the minimum of the acceptable range 
+and should be used as the baseline for all cost-of-quality calculations.

harfeast_world/ground_truth.json

@@ -0,0 +1,193 @@
+{
+  "task1": {
+    "high_priority_count": 52,
+    "high_priority_pct": 2.1,
+    "hp_inefficient_hours": 1068.0,
+    "hp_inefficient_pct": 2.2,
+    "hp_frontline": 19,
+    "hp_backoffice": 17,
+    "hp_supervisor": 8,
+    "hp_management": 8
+  },
+  "task2": {
+    "Rockford, Illinois": 28559265184,
+    "Madison, Wisconsin": 25208027893,
+    "Davenport, Iowa": 23644183501,
+    "Columbus, Ohio": 25448856089,
+    "Lansing, Michigan": 21243014839
+  },
+  "task3": {
+    "Canned Vegetables": {
+      "new_scrap_rate_pct": 6.1,
+      "units_avoided": 68948
+    },
+    "Condiments": {
+      "new_scrap_rate_pct": 6.1,
+      "units_avoided": 84913
+    },
+    "Sauces": {
+      "new_scrap_rate_pct": 6.0,
+      "units_avoided": 69887
+    }
+  },
+  "task4": {
+    "digital_lever": "IoT Sensors for yield",
+    "Rockford, Illinois": {
+      "first_year_exceeds": 2027,
+      "oee_at_that_year": 0.8591
+    },
+    "Madison, Wisconsin": {
+      "first_year_exceeds": 2029,
+      "oee_at_that_year": 0.8661
+    },
+    "Davenport, Iowa": {
+      "first_year_exceeds": 2027,
+      "oee_at_that_year": 0.8768
+    },
+    "Columbus, Ohio": {
+      "first_year_exceeds": 2032,
+      "oee_at_that_year": 0.8641
+    },
+    "Lansing, Michigan": {
+      "first_year_exceeds": 2031,
+      "oee_at_that_year": 0.8528
+    }
+  },
+  "task5": {
+    "Rockford, Illinois": {
+      "total_labor_cost": 692058,
+      "efficiency_gains": 97277,
+      "union_demand_increase": 16631
+    },
+    "Madison, Wisconsin": {
+      "total_labor_cost": 1032866,
+      "efficiency_gains": 156478,
+      "union_demand_increase": 19974
+    },
+    "Davenport, Iowa": {
+      "total_labor_cost": 919381,
+      "efficiency_gains": 78062,
+      "union_demand_increase": 16771
+    }
+  },
+  "task6": {
+    "avg_by_plant": {
+      "Rockford, Illinois": 8.7,
+      "Madison, Wisconsin": 8.7,
+      "Davenport, Iowa": 8.7,
+      "Columbus, Ohio": 37.2,
+      "Lansing, Michigan": 37.4
+    },
+    "most_efficient": [
+      "Rockford, Illinois",
+      "Madison, Wisconsin",
+      "Davenport, Iowa"
+    ],
+    "least_efficient": "Lansing, Michigan",
+    "pct_difference": 330
+  },
+  "task7": {
+    "avg_loss_by_role": {
+      "Production/Manufacturing Operator": 18964,
+      "Quality Control/Quality Assurance": 21948,
+      "Maintenance Technician": 25004,
+      "Production Supervisor/Team Lead": 28288,
+      "Supply Chain/Logistics Coordinator": 22701,
+      "Demand Planning/Forecasting": 28129,
+      "Administrative/Support Staff": 21637,
+      "Plant Management": 41416
+    },
+    "total_annual_loss": 62914681
+  },
+  "task8": {
+    "hp_quality_losses": 1526123,
+    "hp_pct_of_cv_losses": 38
+  },
+  "task9": {
+    "Rockford, Illinois": {
+      "variance_hours": 18506,
+      "variance_dollars": 350503.64,
+      "productivity_index": 0.89
+    },
+    "Madison, Wisconsin": {
+      "variance_hours": 13695,
+      "variance_dollars": 259383.3,
+      "productivity_index": 0.92
+    }
+  },
+  "task10": {
+    "avg_hourly_wage": 29.3,
+    "annual_productivity_loss": 73552000
+  },
+  "task11": {
+    "top5_technologies": [
+      "IoT Sensors",
+      "Predictive Maintenance",
+      "Robotic Automation",
+      "Advanced Analytics",
+      "AI Quality Control"
+    ],
+    "plant_results": {
+      "Rockford, Illinois": {
+        "new_unit_sales": 25575169,
+        "new_projected_sales": 75702500
+      },
+      "Madison, Wisconsin": {
+        "new_unit_sales": 27711624,
+        "new_projected_sales": 89508546
+      },
+      "Davenport, Iowa": {
+        "new_unit_sales": 6074125,
+        "new_projected_sales": 35715855
+      },
+      "Columbus, Ohio": {
+        "new_unit_sales": 6207493,
+        "new_projected_sales": 42459252
+      },
+      "Lansing, Michigan": {
+        "new_unit_sales": 8194640,
+        "new_projected_sales": 49003947
+      }
+    }
+  },
+  "task12": {
+    "lowest_willingness_plant": "Rockford, Illinois",
+    "highest_willingness_plant": "Madison, Wisconsin",
+    "lowest_role_in_lowest_plant": [
+      "Maintenance Technician",
+      2.47
+    ],
+    "highest_role_in_highest_plant": [
+      "Quality Control/Quality Assurance",
+      3.95
+    ],
+    "training_details": {
+      "lowest_plant_lowest_role": {
+        "preferred_length": ">2 days",
+        "count_1_2_days": 19,
+        "total_cost": 9920
+      },
+      "highest_plant_highest_role": {
+        "preferred_length": "<1 day",
+        "count_1_2_days": 21,
+        "total_cost": 2016
+      }
+    }
+  },
+  "task13": {
+    "Rockford, Illinois": 5,
+    "Madison, Wisconsin": 6,
+    "Davenport, Iowa": 5,
+    "Columbus, Ohio": 5,
+    "Lansing, Michigan": 5
+  },
+  "task14": {
+    "trained_count": 1099,
+    "quality_pcts": {
+      "Excellent- comprehensive and very helpful": 14,
+      "Good- adequate for most needs": 40,
+      "Fair- some gaps or inconsistencies": 36,
+      "Poor - insufficient or unhelpful": 9
+    }
+  }
+}

harfeast_world/tasks.json

@@ -0,0 +1,383 @@
+[
+  {
+    "task_id": "task_01",
+    "task_name": "High-Priority Digital Training Employees",
+    "prompt": "I'm trying to get a sense of which HarFeast employees are most ready for the digital training rollout. Can you pull the workforce survey data and identify all employees who are above their role type's median readiness score, willing to pilot new tools, willing to spend >2 days in training with dedicated training time, and above the overall median digital comfort score?\n\nOnce you've identified that group, tell me:\n1. How many \"high-priority\" employees are there, and what % of total employees do they represent?\n2. How many total hours does this group spend weekly on manual entry, searching data, or fixing errors? What % of the company-wide total is that?\n3. Break down the high-priority count by role type.\n\nReport your answer here.",
+    "ground_truth": {
+      "high_priority_count": 52,
+      "high_priority_pct": 2.1,
+      "hp_inefficient_hours": 1068.0,
+      "hp_inefficient_pct": 2.2,
+      "hp_frontline": 19,
+      "hp_backoffice": 17,
+      "hp_supervisor": 8,
+      "hp_management": 8
+    },
+    "rubric": [
+      "States that the number of high-priority employees is 52",
+      "States that the percentage of all employees the high-priority employees represent is 2.1%",
+      "States that the total hours high-priority employees spend on manual entry, searching data or fixing errors is 1068",
+      "States that the percentage of all such hours from high-priority employees is 2.2%",
+      "States that the number of high-priority employees in the Front-line role type is 19",
+      "States that the number of high-priority employees in the Back-office/Support role type is 17",
+      "States that the number of high-priority employees in the Supervisor/Team Lead role type is 8",
+      "States that the number of high-priority employees in the Management role type is 8"
+    ]
+  },
+  {
+    "task_id": "task_02",
+    "task_name": "Adjusted Cost of Instability",
+    "prompt": "Calculate the Adjusted Cost of Instability for each site, defined as Abnormal scrap cost/(Actual Scrap % - Normal Scrap %) = adjusted cost of instability. The target scrap rate of HarFeast is the minimum in the range of acceptable scrap rate in the scrap rate report. Just use COGS per ton as your scrap cost for now.\n\nReport your final answers to me in a message. Round values to the nearest dollar.",
+    "ground_truth": {
+      "Rockford, Illinois": 28559265184,
+      "Madison, Wisconsin": 25208027893,
+      "Davenport, Iowa": 23644183501,
+      "Columbus, Ohio": 25448856089,
+      "Lansing, Michigan": 21243014839
+    },
+    "rubric": [
+      "States that the adjusted cost of instability for Rockford, Illinois is $28,559,265,184",
+      "States that the adjusted cost of instability for Madison, Wisconsin is $25,208,027,893",
+      "States that the adjusted cost of instability for Davenport, Iowa is $23,644,183,501",
+      "States that the adjusted cost of instability for Columbus, Ohio is $25,448,856,089",
+      "States that the adjusted cost of instability for Lansing, Michigan is $21,243,014,839"
+    ]
+  },
+  {
+    "task_id": "task_03",
+    "task_name": "Predictive Maintenance Scrap Impact",
+    "prompt": "Using HarFeast's equipment data, assess the impact of predictive maintenance on HarFeast's scrap rate. We will pilot predictive maintenance only on equipment a) whose scheduled hours per year are at or above that equipment type's median scheduled hours and b) whose labor hours are at or above its plant's median labor hours. For all equipment qualifying for the pilot, apply a 15% reduction to their scrap rate.\n\nCalculate:\n1. The new overall scrap rate for each product family (as a %)\n2. The total number of scrap units each product family avoids every year\n\nReport rounded to 1 decimal place for rates and nearest whole number for units.",
+    "ground_truth": {
+      "Canned Vegetables": {
+        "new_scrap_rate_pct": 6.1,
+        "units_avoided": 68948
+      },
+      "Condiments": {
+        "new_scrap_rate_pct": 6.1,
+        "units_avoided": 84913
+      },
+      "Sauces": {
+        "new_scrap_rate_pct": 6.0,
+        "units_avoided": 69887
+      }
+    },
+    "rubric": [
+      "States that the new overall scrap rate for Canned Vegetables is 6.1%",
+      "States that the scrap units Canned Vegetables avoids per year is 68948",
+      "States that the new overall scrap rate for Condiments is 6.1%",
+      "States that the scrap units Condiments avoids per year is 84913",
+      "States that the new overall scrap rate for Sauces is 6.0%",
+      "States that the scrap units Sauces avoids per year is 69887"
+    ]
+  },
+  {
+    "task_id": "task_04",
+    "task_name": "Digital Lever Agreement and OEE Projections",
+    "prompt": "1. What is the digital lever that Sarah Jenkins, David Chen, and Mike Russo agree will deliver the fastest and biggest boost to HarFeast's Gross Margin?\n\n2. Assuming HarFeast adopts the chosen digital lever, determine the OEE level in the first full year in each plant location where the annual OEE value exceeds the world-class target. Use the OEE improvement assumptions file for growth rates and start dates.\n\nReport OEE values to 2 decimal places as percentages.",
+    "ground_truth": {
+      "digital_lever": "IoT Sensors for yield",
+      "Rockford, Illinois": {
+        "first_year_exceeds": 2027,
+        "oee_at_that_year": 0.8591
+      },
+      "Madison, Wisconsin": {
+        "first_year_exceeds": 2029,
+        "oee_at_that_year": 0.8661
+      },
+      "Davenport, Iowa": {
+        "first_year_exceeds": 2027,
+        "oee_at_that_year": 0.8768
+      },
+      "Columbus, Ohio": {
+        "first_year_exceeds": 2032,
+        "oee_at_that_year": 0.8641
+      },
+      "Lansing, Michigan": {
+        "first_year_exceeds": 2031,
+        "oee_at_that_year": 0.8528
+      }
+    },
+    "rubric": [
+      "States that the digital lever is IoT Sensors for yield",
+      "States that the OEE level for Rockford, Illinois in the first year exceeding world-class target is 85.91%",
+      "States that the first year Rockford, Illinois exceeds world-class target is 2027",
+      "States that the OEE level for Madison, Wisconsin in the first year exceeding world-class target is 86.61%",
+      "States that the first year Madison, Wisconsin exceeds world-class target is 2029",
+      "States that the OEE level for Davenport, Iowa in the first year exceeding world-class target is 87.68%",
+      "States that the first year Davenport, Iowa exceeds world-class target is 2027",
+      "States that the OEE level for Columbus, Ohio in the first year exceeding world-class target is 86.41%",
+      "States that the first year Columbus, Ohio exceeds world-class target is 2032",
+      "States that the OEE level for Lansing, Michigan in the first year exceeding world-class target is 85.28%",
+      "States that the first year Lansing, Michigan exceeds world-class target is 2031"
+    ]
+  },
+  {
+    "task_id": "task_05",
+    "task_name": "Labor Cost Analysis",
+    "prompt": "1. Give me the total labor cost for each plant location (Rockford, Illinois, Madison, Wisconsin, Davenport, Iowa only).\n\n2. Give me the efficiency gains for each plant location. West North Central division plant locations only have a 10% annual efficiency gain from labor cost. For other locations, the efficiency gain is 20%. However, the efficiency gain is 5% for non-unionized production supervisors no matter where they are located.\n\n3. Give me the forecasted labor cost increase from union demands, assuming a 5% increase for all union workers.\n\nRound to the nearest dollar.",
+    "ground_truth": {
+      "Rockford, Illinois": {
+        "total_labor_cost": 692058,
+        "efficiency_gains": 97277,
+        "union_demand_increase": 16631
+      },
+      "Madison, Wisconsin": {
+        "total_labor_cost": 1032866,
+        "efficiency_gains": 156478,
+        "union_demand_increase": 19974
+      },
+      "Davenport, Iowa": {
+        "total_labor_cost": 919381,
+        "efficiency_gains": 78062,
+        "union_demand_increase": 16771
+      }
+    },
+    "rubric": [
+      "States that the Total Annual Labor Cost for Rockford, Illinois is $692,058",
+      "States that the Efficiency Gains for Rockford, Illinois is $97,277",
+      "States that the Union Demand Increase for Rockford, Illinois is $16,631",
+      "States that the Total Annual Labor Cost for Madison, Wisconsin is $1,032,866",
+      "States that the Efficiency Gains for Madison, Wisconsin is $156,478",
+      "States that the Union Demand Increase for Madison, Wisconsin is $19,974",
+      "States that the Total Annual Labor Cost for Davenport, Iowa is $919,381",
+      "States that the Efficiency Gains for Davenport, Iowa is $78,062",
+      "States that the Union Demand Increase for Davenport, Iowa is $16,771"
+    ]
+  },
+  {
+    "task_id": "task_06",
+    "task_name": "Operational Efficiency Analysis",
+    "prompt": "Analyze the operational efficiency at HarFeast and assess how many inefficient employee hours each plant is recording on average. Which plants have the most efficient operations and the least efficient operations? How much more efficient are the highest efficiency locations vs the lowest efficiency locations?\n\nAssume the following activities are considered inefficient: (a) manual data entry, (b) searching for data, (c) fixing errors. Use the workforce survey data. Report averages to 1 decimal place.",
+    "ground_truth": {
+      "avg_by_plant": {
+        "Rockford, Illinois": 8.7,
+        "Madison, Wisconsin": 8.7,
+        "Davenport, Iowa": 8.7,
+        "Columbus, Ohio": 37.2,
+        "Lansing, Michigan": 37.4
+      },
+      "most_efficient": [
+        "Rockford, Illinois",
+        "Madison, Wisconsin",
+        "Davenport, Iowa"
+      ],
+      "least_efficient": "Lansing, Michigan",
+      "pct_difference": 330
+    },
+    "rubric": [
+      "States the average inefficient time in Rockford, Illinois is 8.7",
+      "States the average inefficient time in Madison, Wisconsin is 8.7",
+      "States the average inefficient time in Davenport, Iowa is 8.7",
+      "States the average inefficient time in Columbus, Ohio is 37.2",
+      "States the average inefficient time in Lansing, Michigan is 37.4",
+      "States that Rockford, Illinois is a plant with the lowest average inefficient time",
+      "States that Madison, Wisconsin is a plant with the lowest average inefficient time",
+      "States that Davenport, Iowa is a plant with the lowest average inefficient time",
+      "States that Lansing, Michigan is the plant with the highest average inefficient time",
+      "States that the difference between highest and lowest average inefficient time is 330%"
+    ]
+  },
+  {
+    "task_id": "task_07",
+    "task_name": "Productivity Loss Quantification",
+    "prompt": "I want to quantify the average annual productivity loss at a cost level for each employee in each primary role based on the sum of average hours spent doing manual entry, searching data, and fixing errors. Then, I want to calculate the total productivity loss cost HarFeast faces every year, company-wide.\n\nNote that the survey responses represent one week of work. Report your final answer as a message. Round to the nearest dollar.",
+    "ground_truth": {
+      "avg_loss_by_role": {
+        "Production/Manufacturing Operator": 18964,
+        "Quality Control/Quality Assurance": 21948,
+        "Maintenance Technician": 25004,
+        "Production Supervisor/Team Lead": 28288,
+        "Supply Chain/Logistics Coordinator": 22701,
+        "Demand Planning/Forecasting": 28129,
+        "Administrative/Support Staff": 21637,
+        "Plant Management": 41416
+      },
+      "total_annual_loss": 62914681
+    },
+    "rubric": [
+      "States the average annual productivity loss cost of a Production/Manufacturing Operator employee is $18,964",
+      "States the average annual productivity loss cost of a Quality Control/Quality Assurance employee is $21,948",
+      "States the average annual productivity loss cost of a Maintenance Technician employee is $25,004",
+      "States the average annual productivity loss cost of a Production Supervisor/Team Lead employee is $28,288",
+      "States the average annual productivity loss cost of a Supply Chain/Logistics Coordinator employee is $22,701",
+      "States the average annual productivity loss cost of a Demand Planning/Forecasting employee is $28,129",
+      "States the average annual productivity loss cost of a Administrative/Support Staff employee is $21,637",
+      "States the average annual productivity loss cost of a Plant Management employee is $41,416",
+      "States the total annual productivity loss cost is $62,914,681"
+    ]
+  },
+  {
+    "task_id": "task_08",
+    "task_name": "High-Priority Equipment Quality Losses",
+    "prompt": "Using HarFeast's equipment data and quality losses dataset, consider all canned vegetables assets with a scrap rate > 5% and with unplanned downtime hours above the plant median for canned vegetables as \"high-priority\".\n\n1. For the \"high-priority\" group, calculate the total annual quality-related losses (scrap cost + unplanned failure cost).\n2. What percentage of all canned-vegetable quality losses comes from these high-priority assets?\n\nReport losses rounded to the nearest dollar and percentage to the nearest whole number.",
+    "ground_truth": {
+      "hp_quality_losses": 1526123,
+      "hp_pct_of_cv_losses": 38
+    },
+    "rubric": [
+      "States that the total annual quality-related losses for the high-priority group is $1,526,123",
+      "States that the percentage of all canned-vegetable quality losses from high-priority assets is 38%"
+    ]
+  },
+  {
+    "task_id": "task_09",
+    "task_name": "Labor Variance Analysis",
+    "prompt": "Calculate the total labor variance in hours (favorable should be positive) and dollars for the Illinois and Wisconsin plants (Rockford, Illinois and Madison, Wisconsin). A positive variance means Total Actual Hours are less than Total Standard Hours. Use the median wage for All Occupations in the food manufacturing industry from the BLS wage benchmark file to convert from hours to dollars.\n\nAlso give me the straight productivity index (Actual Hours / Standard Hours) for each plant.\n\nRound hours to 2 decimal places, dollars to 2 decimal places, and the index to 2 decimal places.",
+    "ground_truth": {
+      "Rockford, Illinois": {
+        "variance_hours": 18506,
+        "variance_dollars": 350503.64,
+        "productivity_index": 0.89
+      },
+      "Madison, Wisconsin": {
+        "variance_hours": 13695,
+        "variance_dollars": 259383.3,
+        "productivity_index": 0.92
+      }
+    },
+    "rubric": [
+      "States that the Labor Efficiency Variance (Hours) for Rockford, Illinois is 18506 hours",
+      "States that the Labor Cost Variance for Rockford, Illinois is $350503.64",
+      "States that the Productivity Index for Rockford, Illinois is 0.89",
+      "States that the Labor Efficiency Variance (Hours) for Madison, Wisconsin is 13695 hours",
+      "States that the Labor Cost Variance for Madison, Wisconsin is $259383.3",
+      "States that the Productivity Index for Madison, Wisconsin is 0.92"
+    ]
+  },
+  {
+    "task_id": "task_10",
+    "task_name": "Updated Productivity Loss with New Wages",
+    "prompt": "The client sent us employee wage data (attached), so we need to update our assumptions. Find the average hourly salary across all employee roles in the attached wage file and use that to calculate the updated annual productivity loss for the entire company.\n\nNote that survey responses represent one week of work. Report the annual productivity loss in thousands (000s) rounded to the nearest thousand. Also state the average hourly wage used.\n\nReport your answer here.",
+    "ground_truth": {
+      "avg_hourly_wage": 29.3,
+      "annual_productivity_loss": 73552000
+    },
+    "rubric": [
+      "States the updated annual productivity loss is $73,552,000",
+      "States the average fully-loaded hourly wage is $29.3"
+    ]
+  },
+  {
+    "task_id": "task_11",
+    "task_name": "Technology Investment Impact",
+    "prompt": "Identify the top five technology investments from the Aptean report with the largest positive difference in percentage revenue growth between users and non-users. Include only investments that the report explicitly identifies as either top technology investments to date or top investments planned for 2024.\n\nNext, assume that HarFeast will deploy all five of these top initiatives at every plant location. Apply the cumulative growth impact to each plant's current unit sales and calculate the revised projected sales revenue.\n\nRound unit sales to the nearest whole number and revenue to the nearest dollar.",
+    "ground_truth": {
+      "top5_technologies": [
+        "IoT Sensors",
+        "Predictive Maintenance",
+        "Robotic Automation",
+        "Advanced Analytics",
+        "AI Quality Control"
+      ],
+      "plant_results": {
+        "Rockford, Illinois": {
+          "new_unit_sales": 25575169,
+          "new_projected_sales": 75702500
+        },
+        "Madison, Wisconsin": {
+          "new_unit_sales": 27711624,
+          "new_projected_sales": 89508546
+        },
+        "Davenport, Iowa": {
+          "new_unit_sales": 6074125,
+          "new_projected_sales": 35715855
+        },
+        "Columbus, Ohio": {
+          "new_unit_sales": 6207493,
+          "new_projected_sales": 42459252
+        },
+        "Lansing, Michigan": {
+          "new_unit_sales": 8194640,
+          "new_projected_sales": 49003947
+        }
+      }
+    },
+    "rubric": [
+      "States that the unit sales for Rockford, Illinois after deploying initiatives is 25,575,169",
+      "States that the Revised Projected Sales for Rockford, Illinois is $75,702,500",
+      "States that the unit sales for Madison, Wisconsin after deploying initiatives is 27,711,624",
+      "States that the Revised Projected Sales for Madison, Wisconsin is $89,508,546",
+      "States that the unit sales for Davenport, Iowa after deploying initiatives is 6,074,125",
+      "States that the Revised Projected Sales for Davenport, Iowa is $35,715,855",
+      "States that the unit sales for Columbus, Ohio after deploying initiatives is 6,207,493",
+      "States that the Revised Projected Sales for Columbus, Ohio is $42,459,252",
+      "States that the unit sales for Lansing, Michigan after deploying initiatives is 8,194,640",
+      "States that the Revised Projected Sales for Lansing, Michigan is $49,003,947"
+    ]
+  },
+  {
+    "task_id": "task_12",
+    "task_name": "Digital Adoption Willingness Analysis",
+    "prompt": "To implement the required roadmap, we need to identify what roles and plants are most and least willing to go through a digital transformation.\n\nDetermine the plant with the highest and lowest average willingness to adopt digital tools. Within those plants, identify the roles with the highest and lowest willingness. For those specific role-plant combinations, determine the preferred training length, the count of employees preferring 1-2 days of training, and the total training cost (at $8/hour training rate).\n\nReport your findings here.",
+    "ground_truth": {
+      "lowest_willingness_plant": "Rockford, Illinois",
+      "highest_willingness_plant": "Madison, Wisconsin",
+      "lowest_role_in_lowest_plant": [
+        "Maintenance Technician",
+        2.47
+      ],
+      "highest_role_in_highest_plant": [
+        "Quality Control/Quality Assurance",
+        3.95
+      ],
+      "training_details": {
+        "lowest_plant_lowest_role": {
+          "preferred_length": ">2 days",
+          "count_1_2_days": 19,
+          "total_cost": 9920
+        },
+        "highest_plant_highest_role": {
+          "preferred_length": "<1 day",
+          "count_1_2_days": 21,
+          "total_cost": 2016
+        }
+      }
+    },
+    "rubric": [
+      "States that the plant with lowest willingness to adopt is Rockford, Illinois",
+      "States that the plant with highest willingness to adopt is Madison, Wisconsin",
+      "States the role with lowest willingness in Rockford, Illinois is Maintenance Technician",
+      "States the role with highest willingness in Madison, Wisconsin is Quality Control/Quality Assurance"
+    ]
+  },
+  {
+    "task_id": "task_13",
+    "task_name": "Frito-Lay Downtime Reduction Application",
+    "prompt": "Can you look at the Frito-Lay case study and apply their downtime reduction to HarFeast's numbers in the equipment data? I want to estimate what the improvement would look like for us (rounded to the nearest full percentage point).\n\nCalculate the current unplanned downtime ratio (unplanned downtime hours / scheduled hours) for each plant, apply the reduction from the case study, and report the new ratios.\n\nOutput the information in a message here.",
+    "ground_truth": {
+      "Rockford, Illinois": 5,
+      "Madison, Wisconsin": 6,
+      "Davenport, Iowa": 5,
+      "Columbus, Ohio": 5,
+      "Lansing, Michigan": 5
+    },
+    "rubric": [
+      "States that the new unplanned downtime ratio for Rockford, Illinois is 5%",
+      "States that the new unplanned downtime ratio for Madison, Wisconsin is 6%",
+      "States that the new unplanned downtime ratio for Davenport, Iowa is 5%",
+      "States that the new unplanned downtime ratio for Columbus, Ohio is 5%",
+      "States that the new unplanned downtime ratio for Lansing, Michigan is 5%"
+    ]
+  },
+  {
+    "task_id": "task_14",
+    "task_name": "Training Quality Assessment",
+    "prompt": "Use the workforce survey responses to identify the number of respondents who received any kind of training on digital tools. Of those respondents, return the percentage of respondents for each training quality rating.\n\nReply back here to me.",
+    "ground_truth": {
+      "trained_count": 1099,
+      "quality_pcts": {
+        "Excellent- comprehensive and very helpful": 14,
+        "Good- adequate for most needs": 40,
+        "Fair- some gaps or inconsistencies": 36,
+        "Poor - insufficient or unhelpful": 9
+      }
+    },
+    "rubric": [
+      "States that the number of respondents who received training is 1099",
+      "States that percentage of respondents rated training as \"Excellent- comprehensive and very helpful\" is 14%",
+      "States that percentage of respondents rated training as \"Good- adequate for most needs\" is 40%",
+      "States that percentage of respondents rated training as \"Fair- some gaps or inconsistencies\" is 36%",
+      "States that percentage of respondents rated training as \"Poor - insufficient or unhelpful\" is 9%"
+    ]
+  }
+]