Publish ORBench 100-problem catalog and recorded results

README.md

@@ -0,0 +1,54 @@
+---
+license: cc-by-4.0
+pretty_name: ORBench Decision Problems
+task_categories:
+  - other
+  - text-generation
+  - structured-data-extraction
+tags:
+  - operations-research
+  - model-benchmarking
+  - structured-generation
+  - synthetic
+  - evaluation
+language:
+  - en
+  - fa
+size_categories:
+  - n<1K
+---
+
+# ORBench problems and recorded results
+
+100 synthetic inventory, assignment, and scheduling instances for the ORBench demo.
+
+Organization dataset and collection are public. Live Gradio and the organization card are created by `scripts/publish.py`. Runnable Space source is stored in `demo/`. Collection: [Aria AI — OR + LLM Evaluation](https://huggingface.co/collections/AriaAICompany/aria-ai-or-llm-evaluation).
+
+Generated data, seed 25. All identifiers are synthetic. Gold objectives come from OR-Tools CP-SAT on the same schema that ships in each row. LLM rows in `results.jsonl` are explicitly `not_evaluated`.
+
+## Files
+
+- data/problems.jsonl
+- data/results.jsonl
+- data/leaderboard.csv
+- data/splits.json
+- data/sample_preview.json
+- data/protocol.md
+- demo/ — runnable Gradio Space source
+- showcase/ — organization static card
+
+## Splits
+
+- development: 60 instances, templates `D-A` / `D-B` / `D-C` with a `SCHEMA_BEGIN` block
+- test: 40 instances, templates `T-A` / `T-B` in prose
+- interactive: 20 ids listed in `splits.json`
+
+Development and test do not share `(family, template_id)` pairs. Near-duplicate prompt templates are therefore not reused across the split.
+
+## Metrics
+
+Independent validators recompute inventory balance, pack multiples, budget, capacity, assignment uniqueness/eligibility/capacity, and schedule overlap/precedence/release. Optimality gap is reported only when gold status is `optimal`. An unevaluated method is never written as 0.
+
+## License
+
+CC-BY-4.0. Keep the synthetic-data label.

data/leaderboard.csv

@@ -0,0 +1,11 @@
+method_id,evaluated,n,parse_rate,feasible_rate,infeasible_agreement,mean_gap,mean_fidelity,mean_seconds,mean_cost_usd,n_optimal
+heuristic,True,100,1.0,0.91,0.0,0.031919404673584915,1.0,7.628599880263209e-05,0.0,0
+json-extractor+solver,True,100,1.0,0.92,1.0,2.613101900343095e-18,1.0,0.004290478996699676,0.0,92
+naive-direct,True,100,1.0,0.22,0.0,0.0,1.0,4.173900291789323e-05,0.0,0
+structured-solver,True,100,1.0,0.92,1.0,2.613101900343095e-18,1.0,0.004329786997986957,0.0,92
+template-extractor+solver,True,100,0.6,0.6,0.0,2.033026425636911e-18,0.6,0.0030710569996153935,0.0,60
+Qwen/Qwen3-4B-Instruct-2507,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+Qwen/Qwen3.8-27B,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+deepseek-ai/DeepSeek-V4.1-Flash,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+moonshotai/Kimi-K3,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+zai-org/GLM-5.3,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated

data/protocol.md

@@ -0,0 +1,13 @@
+# ORBench reproduction protocol v1
+
+Seed: 25. Code version: 0.1.0. Solver: OR-Tools CP-SAT, 1 thread, 6–8 seconds.
+
+1. Generate the catalog with `python scripts/build_artifacts.py`.
+2. Each problem stores `schema_payload`, bilingual prompts, `gold_status`, `gold_objective`, and `gold_solution`.
+3. Evaluated methods: `structured-solver`, `heuristic`, `json-extractor+solver`, `template-extractor+solver`, `naive-direct`.
+4. Listed but not run: `Qwen/Qwen3-4B-Instruct-2507`, `Qwen/Qwen3.8-27B`, `moonshotai/Kimi-K3`, `zai-org/GLM-5.3`, `deepseek-ai/DeepSeek-V4.1-Flash`. Cells are `not_evaluated`.
+5. Gap = max(0, (method_obj − gold_obj) / max(1, |gold_obj|)) only if gold status is optimal and the method plan is feasible.
+6. Paid APIs stay off. Do not substitute a second paid provider when the first is missing.
+7. Synthetic results in this dataset are not customer data.
+
+Run `pytest tests/test_pipeline.py` after generation. A passing suite is the acceptance check for constraint validation, split hygiene, and honest unevaluated cells.

data/sample_preview.json

@@ -0,0 +1,17 @@
+{
+  "run_id": "orbench-eccc1a511a",
+  "status": "optimal",
+  "kpis": {
+    "n_problems": 100,
+    "structured_feasible": 0.92,
+    "heuristic_gap": 0.031919404673584915,
+    "template_fidelity": 0.6,
+    "n_methods_evaluated": 5,
+    "n_methods_listed": 10
+  },
+  "kpi_html": "<div class='kpi-grid'><article class='kpi-card'><p class='kpi-label'>Problems in view</p><p class='kpi-value'>100</p><p class='kpi-sub'>interactive subset or filtered catalog</p></article><article class='kpi-card'><p class='kpi-label'>Structured-solver feasible</p><p class='kpi-value'>92%</p><p class='kpi-sub'>share of valid plans after independent checks</p></article><article class='kpi-card'><p class='kpi-label'>Heuristic mean gap</p><p class='kpi-value'>3.2%</p><p class='kpi-sub'>only where gold status is proven optimal</p></article><article class='kpi-card'><p class='kpi-label'>Template fidelity</p><p class='kpi-value'>60%</p><p class='kpi-sub'>atomic constraint facts recovered from text</p></article><article class='kpi-card'><p class='kpi-label'>Methods evaluated</p><p class='kpi-value'>5/10</p><p class='kpi-sub'>evaluated / listed — unevaluated is not zero</p></article></div>",
+  "precomputed": true,
+  "n_problems": 100,
+  "n_eval_rows": 1000,
+  "interactive": "INV-001"
+}

data/splits.json

@@ -0,0 +1,128 @@
+{
+  "development": [
+    "INV-001",
+    "INV-002",
+    "INV-003",
+    "INV-004",
+    "INV-005",
+    "INV-006",
+    "INV-007",
+    "INV-008",
+    "INV-009",
+    "INV-010",
+    "INV-011",
+    "INV-012",
+    "INV-013",
+    "INV-014",
+    "INV-015",
+    "INV-016",
+    "INV-017",
+    "INV-018",
+    "INV-019",
+    "INV-020",
+    "ASN-001",
+    "ASN-002",
+    "ASN-003",
+    "ASN-004",
+    "ASN-005",
+    "ASN-006",
+    "ASN-007",
+    "ASN-008",
+    "ASN-009",
+    "ASN-010",
+    "ASN-011",
+    "ASN-012",
+    "ASN-013",
+    "ASN-014",
+    "ASN-015",
+    "ASN-016",
+    "ASN-017",
+    "ASN-018",
+    "ASN-019",
+    "ASN-020",
+    "SCH-001",
+    "SCH-002",
+    "SCH-003",
+    "SCH-004",
+    "SCH-005",
+    "SCH-006",
+    "SCH-007",
+    "SCH-008",
+    "SCH-009",
+    "SCH-010",
+    "SCH-011",
+    "SCH-012",
+    "SCH-013",
+    "SCH-014",
+    "SCH-015",
+    "SCH-016",
+    "SCH-017",
+    "SCH-018",
+    "SCH-019",
+    "SCH-020"
+  ],
+  "test": [
+    "INV-021",
+    "INV-022",
+    "INV-023",
+    "INV-024",
+    "INV-025",
+    "INV-026",
+    "INV-027",
+    "INV-028",
+    "INV-029",
+    "INV-030",
+    "INV-031",
+    "INV-032",
+    "INV-033",
+    "INV-034",
+    "ASN-021",
+    "ASN-022",
+    "ASN-023",
+    "ASN-024",
+    "ASN-025",
+    "ASN-026",
+    "ASN-027",
+    "ASN-028",
+    "ASN-029",
+    "ASN-030",
+    "ASN-031",
+    "ASN-032",
+    "ASN-033",
+    "SCH-021",
+    "SCH-022",
+    "SCH-023",
+    "SCH-024",
+    "SCH-025",
+    "SCH-026",
+    "SCH-027",
+    "SCH-028",
+    "SCH-029",
+    "SCH-030",
+    "SCH-031",
+    "SCH-032",
+    "SCH-033"
+  ],
+  "interactive": [
+    "INV-001",
+    "INV-008",
+    "INV-014",
+    "INV-021",
+    "INV-028",
+    "INV-031",
+    "INV-034",
+    "ASN-001",
+    "ASN-006",
+    "ASN-012",
+    "ASN-018",
+    "ASN-024",
+    "ASN-029",
+    "ASN-033",
+    "SCH-001",
+    "SCH-007",
+    "SCH-013",
+    "SCH-019",
+    "SCH-027",
+    "SCH-033"
+  ]
+}

demo/.gitattributes

@@ -0,0 +1,8 @@
+* text=auto eol=lf
+*.py text eol=lf
+*.md text eol=lf
+*.csv text eol=lf
+*.json text eol=lf
+*.jsonl text eol=lf
+*.html text eol=lf
+*.txt text eol=lf

demo/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+.pytest_cache/
+.venv/
+*.pyc
+.gradio/
+tmp/

demo/README.md

@@ -0,0 +1,55 @@
+---
+title: ORBench Solver and Agent Benchmark
+emoji: 🧪
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 6.15.1
+app_file: app.py
+fullWidth: true
+python_version: "3.12"
+short_description: Compare OR solvers and agents on 100 small problems
+pinned: true
+license: apache-2.0
+tags:
+  - model-benchmarking
+  - operations-research
+  - structured-generation
+  - evaluation
+  - data-visualization
+datasets:
+  - AriaAICompany/or-bench-problems
+---
+
+# ORBench — Solver and Agent Decision Benchmark
+
+**Aria AI** research prototype. Teams want to know whether a new model can recover constraints and produce a *valid* decision. A fluent paragraph is not a feasible plan. The numeric validator is the judge.
+
+The MVP is 100 small synthetic instances from inventory, assignment, and scheduling, with a 60/40 development–test split and 20 interactive samples. Three comparison paths are recorded: structured form + CP-SAT, text → schema → solver, and a fixed heuristic. A naive direct answer is included only as a labeled benchmark, not as an operational planner.
+
+## What you can do
+
+1. Load one of the 20 interactive problems (English or Persian).
+2. Compare CP-SAT, lot-for-lot / greedy / EDD, JSON extraction, template extraction, and a naive direct answer.
+3. Hide a hard constraint in the prompt and watch fidelity drop.
+4. Filter the recorded 100-problem table by family, split, language, or difficulty.
+5. Download the comparison CSV and the JSON report.
+
+CPU only. No paid API. Named Hub models (Qwen, Kimi, GLM, DeepSeek) stay **not_evaluated**. That cell is not a zero and not a rank.
+
+## Hosting
+
+- Live app: this Space (`alirezaaminzadeh/or-bench` if organization Gradio quota is 0).
+- Organization card: [AriaAICompany/or-bench](https://huggingface.co/spaces/AriaAICompany/or-bench).
+- Dataset: [AriaAICompany/or-bench-problems](https://huggingface.co/datasets/AriaAICompany/or-bench-problems).
+- Collection: [Aria AI — OR + LLM Evaluation](https://huggingface.co/collections/AriaAICompany/aria-ai-or-llm-evaluation).
+
+## Persian
+
+اوربنچ روش‌های ساخت تصمیم را روی مسئله‌های کوچک موجودی، تخصیص و زمان‌بندی مقایسه می‌کند. داور validator عددی است. خانه مدل اجرا‌نشده «ارزیابی نشده» است، نه صفر.
+
+## Links
+
+- [AriaAICompany](https://huggingface.co/AriaAICompany)
+- [aria-ai.ir](https://aria-ai.ir/)
+- Roadmap project 25 of 25

demo/app.py

@@ -0,0 +1,8 @@
+import gradio as gr
+
+from src.ui import CSS, build_demo
+
+demo = build_demo()
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="purple"), css=CSS)

demo/examples/leaderboard.csv

@@ -0,0 +1,11 @@
+method_id,evaluated,n,parse_rate,feasible_rate,infeasible_agreement,mean_gap,mean_fidelity,mean_seconds,mean_cost_usd,n_optimal
+heuristic,True,100,1.0,0.91,0.0,0.031919404673584915,1.0,7.628599880263209e-05,0.0,0
+json-extractor+solver,True,100,1.0,0.92,1.0,2.613101900343095e-18,1.0,0.004290478996699676,0.0,92
+naive-direct,True,100,1.0,0.22,0.0,0.0,1.0,4.173900291789323e-05,0.0,0
+structured-solver,True,100,1.0,0.92,1.0,2.613101900343095e-18,1.0,0.004329786997986957,0.0,92
+template-extractor+solver,True,100,0.6,0.6,0.0,2.033026425636911e-18,0.6,0.0030710569996153935,0.0,60
+Qwen/Qwen3-4B-Instruct-2507,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+Qwen/Qwen3.8-27B,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+deepseek-ai/DeepSeek-V4.1-Flash,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+moonshotai/Kimi-K3,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated
+zai-org/GLM-5.3,False,100,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated,not_evaluated

demo/examples/protocol.md

@@ -0,0 +1,13 @@
+# ORBench reproduction protocol v1
+
+Seed: 25. Code version: 0.1.0. Solver: OR-Tools CP-SAT, 1 thread, 6–8 seconds.
+
+1. Generate the catalog with `python scripts/build_artifacts.py`.
+2. Each problem stores `schema_payload`, bilingual prompts, `gold_status`, `gold_objective`, and `gold_solution`.
+3. Evaluated methods: `structured-solver`, `heuristic`, `json-extractor+solver`, `template-extractor+solver`, `naive-direct`.
+4. Listed but not run: `Qwen/Qwen3-4B-Instruct-2507`, `Qwen/Qwen3.8-27B`, `moonshotai/Kimi-K3`, `zai-org/GLM-5.3`, `deepseek-ai/DeepSeek-V4.1-Flash`. Cells are `not_evaluated`.
+5. Gap = max(0, (method_obj − gold_obj) / max(1, |gold_obj|)) only if gold status is optimal and the method plan is feasible.
+6. Paid APIs stay off. Do not substitute a second paid provider when the first is missing.
+7. Synthetic results in this dataset are not customer data.
+
+Run `pytest tests/test_pipeline.py` after generation. A passing suite is the acceptance check for constraint validation, split hygiene, and honest unevaluated cells.

demo/examples/sample_preview.json

@@ -0,0 +1,17 @@
+{
+  "run_id": "orbench-eccc1a511a",
+  "status": "optimal",
+  "kpis": {
+    "n_problems": 100,
+    "structured_feasible": 0.92,
+    "heuristic_gap": 0.031919404673584915,
+    "template_fidelity": 0.6,
+    "n_methods_evaluated": 5,
+    "n_methods_listed": 10
+  },
+  "kpi_html": "<div class='kpi-grid'><article class='kpi-card'><p class='kpi-label'>Problems in view</p><p class='kpi-value'>100</p><p class='kpi-sub'>interactive subset or filtered catalog</p></article><article class='kpi-card'><p class='kpi-label'>Structured-solver feasible</p><p class='kpi-value'>92%</p><p class='kpi-sub'>share of valid plans after independent checks</p></article><article class='kpi-card'><p class='kpi-label'>Heuristic mean gap</p><p class='kpi-value'>3.2%</p><p class='kpi-sub'>only where gold status is proven optimal</p></article><article class='kpi-card'><p class='kpi-label'>Template fidelity</p><p class='kpi-value'>60%</p><p class='kpi-sub'>atomic constraint facts recovered from text</p></article><article class='kpi-card'><p class='kpi-label'>Methods evaluated</p><p class='kpi-value'>5/10</p><p class='kpi-sub'>evaluated / listed — unevaluated is not zero</p></article></div>",
+  "precomputed": true,
+  "n_problems": 100,
+  "n_eval_rows": 1000,
+  "interactive": "INV-001"
+}

demo/examples/splits.json

@@ -0,0 +1,128 @@
+{
+  "development": [
+    "INV-001",
+    "INV-002",
+    "INV-003",
+    "INV-004",
+    "INV-005",
+    "INV-006",
+    "INV-007",
+    "INV-008",
+    "INV-009",
+    "INV-010",
+    "INV-011",
+    "INV-012",
+    "INV-013",
+    "INV-014",
+    "INV-015",
+    "INV-016",
+    "INV-017",
+    "INV-018",
+    "INV-019",
+    "INV-020",
+    "ASN-001",
+    "ASN-002",
+    "ASN-003",
+    "ASN-004",
+    "ASN-005",
+    "ASN-006",
+    "ASN-007",
+    "ASN-008",
+    "ASN-009",
+    "ASN-010",
+    "ASN-011",
+    "ASN-012",
+    "ASN-013",
+    "ASN-014",
+    "ASN-015",
+    "ASN-016",
+    "ASN-017",
+    "ASN-018",
+    "ASN-019",
+    "ASN-020",
+    "SCH-001",
+    "SCH-002",
+    "SCH-003",
+    "SCH-004",
+    "SCH-005",
+    "SCH-006",
+    "SCH-007",
+    "SCH-008",
+    "SCH-009",
+    "SCH-010",
+    "SCH-011",
+    "SCH-012",
+    "SCH-013",
+    "SCH-014",
+    "SCH-015",
+    "SCH-016",
+    "SCH-017",
+    "SCH-018",
+    "SCH-019",
+    "SCH-020"
+  ],
+  "test": [
+    "INV-021",
+    "INV-022",
+    "INV-023",
+    "INV-024",
+    "INV-025",
+    "INV-026",
+    "INV-027",
+    "INV-028",
+    "INV-029",
+    "INV-030",
+    "INV-031",
+    "INV-032",
+    "INV-033",
+    "INV-034",
+    "ASN-021",
+    "ASN-022",
+    "ASN-023",
+    "ASN-024",
+    "ASN-025",
+    "ASN-026",
+    "ASN-027",
+    "ASN-028",
+    "ASN-029",
+    "ASN-030",
+    "ASN-031",
+    "ASN-032",
+    "ASN-033",
+    "SCH-021",
+    "SCH-022",
+    "SCH-023",
+    "SCH-024",
+    "SCH-025",
+    "SCH-026",
+    "SCH-027",
+    "SCH-028",
+    "SCH-029",
+    "SCH-030",
+    "SCH-031",
+    "SCH-032",
+    "SCH-033"
+  ],
+  "interactive": [
+    "INV-001",
+    "INV-008",
+    "INV-014",
+    "INV-021",
+    "INV-028",
+    "INV-031",
+    "INV-034",
+    "ASN-001",
+    "ASN-006",
+    "ASN-012",
+    "ASN-018",
+    "ASN-024",
+    "ASN-029",
+    "ASN-033",
+    "SCH-001",
+    "SCH-007",
+    "SCH-013",
+    "SCH-019",
+    "SCH-027",
+    "SCH-033"
+  ]
+}

demo/requirements.txt

@@ -0,0 +1,5 @@
+pandas>=2.2.0,<3
+numpy>=1.26.0,<3
+pydantic>=2.6.0,<3
+ortools>=9.10,<10
+plotly>=5.24.0,<7

demo/src/__init__.py

@@ -0,0 +1 @@
+"""ORBench — reproducible comparison of solvers and structured agents."""

demo/src/baseline.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import math
+import time
+
+from src.domain import (
+    AssignmentInstance,
+    AssignmentRow,
+    Family,
+    InventoryInstance,
+    InventoryOrder,
+    ScheduleInstance,
+    ScheduleStart,
+    Solution,
+    SolveStatus,
+    parse_instance,
+)
+from src.optimizer import SolverOutcome
+
+
+def _round_pack(qty: int, pack: int) -> int:
+    if qty <= 0:
+        return 0
+    return int(math.ceil(qty / pack) * pack)
+
+
+def heuristic_inventory(instance: InventoryInstance) -> Solution:
+    remaining = int(instance.budget)
+    orders: list[InventoryOrder] = []
+    stock = {sku.sku_id: int(sku.initial_stock) for sku in instance.skus}
+    for t in range(1, instance.periods + 1):
+        for sku in sorted(instance.skus, key=lambda item: (-item.shortage_cost, item.sku_id)):
+            need = max(0, int(sku.demand[t - 1]) - stock[sku.sku_id])
+            qty = _round_pack(need, sku.pack_size)
+            cost = qty * sku.unit_cost
+            while qty and cost > remaining:
+                qty = max(0, qty - sku.pack_size)
+                cost = qty * sku.unit_cost
+            projected = sum(max(0, stock[other.sku_id] - (int(other.demand[t - 1]) if other.sku_id != sku.sku_id else 0)) for other in instance.skus)
+            projected += max(0, stock[sku.sku_id] + qty - int(sku.demand[t - 1]))
+            if projected > instance.warehouse_capacity:
+                qty = 0
+                cost = 0
+            remaining -= cost
+            orders.append(InventoryOrder(sku_id=sku.sku_id, period=t, qty=qty))
+            sold = min(stock[sku.sku_id] + qty, int(sku.demand[t - 1]))
+            stock[sku.sku_id] = stock[sku.sku_id] + qty - sold
+    return Solution(family=Family.INVENTORY, status=SolveStatus.HEURISTIC, orders=orders, message="lot-for-lot pack-rounded")
+
+
+def heuristic_assignment(instance: AssignmentInstance) -> Solution:
+    costs = instance.cost_map()
+    remaining = {agent.agent_id: agent.capacity for agent in instance.agents}
+    used: set[str] = set()
+    rows: list[AssignmentRow] = []
+    leftover: list[str] = []
+    ordered = sorted(instance.tasks, key=lambda task: (not task.required, -task.penalty, task.task_id))
+    for task in ordered:
+        candidates = []
+        for agent in instance.agents:
+            if not instance.eligible(task, agent):
+                continue
+            if remaining[agent.agent_id] < task.size:
+                continue
+            pair = (task.task_id, agent.agent_id)
+            if pair not in costs:
+                continue
+            candidates.append((costs[pair], agent.agent_id))
+        if not candidates:
+            leftover.append(task.task_id)
+            continue
+        candidates.sort()
+        agent_id = candidates[0][1]
+        rows.append(AssignmentRow(task_id=task.task_id, agent_id=agent_id))
+        remaining[agent_id] -= task.size
+        used.add(task.task_id)
+    leftover.extend(task.task_id for task in instance.tasks if task.task_id not in used and task.task_id not in leftover)
+    return Solution(
+        family=Family.ASSIGNMENT,
+        status=SolveStatus.HEURISTIC,
+        assignments=rows,
+        unassigned=leftover,
+        message="cheapest eligible agent with remaining capacity",
+    )
+
+
+def heuristic_scheduling(instance: ScheduleInstance) -> Solution:
+    ready = {machine: 0 for machine in instance.machines}
+    done_end: dict[str, int] = {}
+    remaining = {job.job_id: job for job in instance.jobs}
+    starts: list[ScheduleStart] = []
+    preds: dict[str, list[str]] = {job.job_id: [] for job in instance.jobs}
+    for edge in instance.precedences:
+        if edge.after in preds:
+            preds[edge.after].append(edge.before)
+
+    guard = 0
+    while remaining and guard < 200:
+        guard += 1
+        ready_jobs = [
+            job
+            for job in remaining.values()
+            if all(pred in done_end for pred in preds[job.job_id])
+        ]
+        if not ready_jobs:
+            break
+        ready_jobs.sort(key=lambda job: (job.due, -job.weight, job.job_id))
+        job = ready_jobs[0]
+        eligible = [machine for machine in instance.machines if machine in set(job.machine_eligible)] or list(instance.machines)
+        pred_end = max((done_end[pred] for pred in preds[job.job_id]), default=0)
+        machine = min(eligible, key=lambda item: (max(ready[item], job.release, pred_end), item))
+        start = max(ready[machine], job.release, pred_end)
+        end = start + job.duration
+        starts.append(ScheduleStart(job_id=job.job_id, machine_id=machine, start=start, end=end))
+        ready[machine] = end
+        done_end[job.job_id] = end
+        remaining.pop(job.job_id)
+    leftover = [job_id for job_id in remaining]
+    message = "earliest due date on the earliest eligible machine"
+    if leftover:
+        message += f"; leftover {leftover}"
+    return Solution(family=Family.SCHEDULING, status=SolveStatus.HEURISTIC, starts=starts, message=message)
+
+
+def naive_direct(family: Family | str, payload: dict) -> Solution:
+    family = Family(family)
+    instance = parse_instance(family, payload)
+    if family == Family.INVENTORY:
+        orders = []
+        for sku in instance.skus:
+            for t, demand in enumerate(sku.demand, start=1):
+                orders.append(InventoryOrder(sku_id=sku.sku_id, period=t, qty=int(demand)))
+        return Solution(
+            family=family,
+            status=SolveStatus.HEURISTIC,
+            orders=orders,
+            message="naive-direct: order raw demand, ignore pack/budget/capacity",
+        )
+    if family == Family.ASSIGNMENT:
+        if not instance.agents:
+            return Solution(family=family, status=SolveStatus.HEURISTIC, message="naive-direct: no agents")
+        first = instance.agents[0].agent_id
+        rows = [AssignmentRow(task_id=task.task_id, agent_id=first) for task in instance.tasks]
+        return Solution(
+            family=family,
+            status=SolveStatus.HEURISTIC,
+            assignments=rows,
+            message="naive-direct: assign every task to the first agent",
+        )
+    starts = []
+    cursor = 0
+    machine = instance.machines[0] if instance.machines else "M1"
+    for job in instance.jobs:
+        start = max(cursor, job.release)
+        starts.append(ScheduleStart(job_id=job.job_id, machine_id=machine, start=start, end=start + job.duration))
+        cursor = start + job.duration
+    return Solution(
+        family=family,
+        status=SolveStatus.HEURISTIC,
+        starts=starts,
+        message="naive-direct: single-machine FCFS ignoring eligibility and hard dues",
+    )
+
+
+def run_heuristic(family: Family | str, payload: dict) -> SolverOutcome:
+    started = time.perf_counter()
+    family = Family(family)
+    instance = parse_instance(family, payload)
+    if family == Family.INVENTORY:
+        solution = heuristic_inventory(instance)
+    elif family == Family.ASSIGNMENT:
+        solution = heuristic_assignment(instance)
+    else:
+        solution = heuristic_scheduling(instance)
+    return SolverOutcome(solution, time.perf_counter() - started, "heuristic-v1", solution.message)
+
+
+def run_naive(family: Family | str, payload: dict) -> SolverOutcome:
+    started = time.perf_counter()
+    solution = naive_direct(family, payload)
+    return SolverOutcome(solution, time.perf_counter() - started, "naive-direct-v1", solution.message)

demo/src/budget_guard.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import os
+
+# Paid provider calls stay off unless a future release adds an atomic shared budget.
+PAID_INFERENCE_ENABLED = False
+
+
+def paid_inference_allowed() -> bool:
+    if not PAID_INFERENCE_ENABLED:
+        return False
+    if os.environ.get("ORBENCH_ALLOW_PAID") != "1":
+        return False
+    return False
+
+
+def skip_reason() -> str:
+    return (
+        "Live LLM APIs are disabled. Comparison cells for unnamed or unpaid "
+        "model runs stay not_evaluated. The free path is the CPU solver, "
+        "heuristics, and deterministic extractors."
+    )

demo/src/domain.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+CODE_NAME = "or-bench"
+CODE_VERSION = "0.1.0"
+DEFAULT_SEED = 25
+DEFAULT_SOLVER_SECONDS = 8.0
+DEFAULT_THREADS = 1
+MAX_UPLOAD_MB = 10
+N_PROBLEMS = 100
+N_INVENTORY = 34
+N_ASSIGNMENT = 33
+N_SCHEDULING = 33
+N_INTERACTIVE = 20
+N_DEVELOPMENT = 60
+
+SOLVER_NAME = "ortools-cpsat"
+PROTOCOL_ID = "or-bench-v1"
+
+
+class Family(str, Enum):
+    INVENTORY = "inventory"
+    ASSIGNMENT = "assignment"
+    SCHEDULING = "scheduling"
+
+
+class Split(str, Enum):
+    DEVELOPMENT = "development"
+    TEST = "test"
+
+
+class Difficulty(str, Enum):
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"
+    INFEASIBLE = "infeasible"
+
+
+class SolveStatus(str, Enum):
+    OPTIMAL = "optimal"
+    FEASIBLE = "feasible"
+    HEURISTIC = "heuristic"
+    INFEASIBLE = "infeasible"
+    TIMEOUT = "timeout"
+    INVALID = "invalid"
+    ERROR = "error"
+    NOT_EVALUATED = "not_evaluated"
+
+
+class MethodKind(str, Enum):
+    STRUCTURED_SOLVER = "structured-solver"
+    HEURISTIC = "heuristic"
+    TEXT_TO_SCHEMA = "text-to-schema"
+    DIRECT_ANSWER = "direct-answer"
+    LLM_SCHEMA = "llm-schema"
+    LLM_DIRECT = "llm-direct"
+
+
+class PromptVariant(str, Enum):
+    TEMPLATE = "template"
+    JSON = "json"
+    MISSING_BUDGET = "missing_constraint"
+    CUSTOM = "custom"
+
+
+class InventorySku(BaseModel):
+    sku_id: str
+    name: str
+    demand: list[int]
+    initial_stock: int = Field(ge=0)
+    unit_cost: int = Field(ge=1)
+    holding_cost: int = Field(ge=0)
+    shortage_cost: int = Field(ge=0)
+    pack_size: int = Field(ge=1)
+    lead_time: int = Field(default=0, ge=0, le=0)
+
+
+class InventoryInstance(BaseModel):
+    periods: int = Field(ge=2, le=6)
+    budget: int = Field(ge=0)
+    warehouse_capacity: int = Field(ge=0)
+    cover_required: bool = False
+    lost_sales: bool = True
+    skus: list[InventorySku]
+
+    def sku_map(self) -> dict[str, InventorySku]:
+        return {item.sku_id: item for item in self.skus}
+
+
+class AssignmentTask(BaseModel):
+    task_id: str
+    name: str
+    size: int = Field(ge=1)
+    required: bool = True
+    skills: list[str]
+    penalty: int = Field(ge=0)
+
+
+class AssignmentAgent(BaseModel):
+    agent_id: str
+    name: str
+    capacity: int = Field(ge=0)
+    skills: list[str]
+
+
+class AssignmentCost(BaseModel):
+    task_id: str
+    agent_id: str
+    cost: int = Field(ge=0)
+
+
+class AssignmentInstance(BaseModel):
+    tasks: list[AssignmentTask]
+    agents: list[AssignmentAgent]
+    costs: list[AssignmentCost]
+
+    def cost_map(self) -> dict[tuple[str, str], int]:
+        return {(row.task_id, row.agent_id): row.cost for row in self.costs}
+
+    def eligible(self, task: AssignmentTask, agent: AssignmentAgent) -> bool:
+        return bool(set(task.skills) & set(agent.skills)) or not task.skills
+
+
+class ScheduleJob(BaseModel):
+    job_id: str
+    name: str
+    duration: int = Field(ge=1)
+    release: int = Field(ge=0)
+    due: int = Field(ge=0)
+    weight: int = Field(ge=1)
+    hard_due: bool = False
+    machine_eligible: list[str]
+
+
+class SchedulePrecedence(BaseModel):
+    before: str
+    after: str
+
+
+class ScheduleInstance(BaseModel):
+    machines: list[str]
+    jobs: list[ScheduleJob]
+    precedences: list[SchedulePrecedence]
+    horizon: int = Field(ge=1)
+
+
+class InventoryOrder(BaseModel):
+    sku_id: str
+    period: int
+    qty: int
+
+
+class AssignmentRow(BaseModel):
+    task_id: str
+    agent_id: str
+
+
+class ScheduleStart(BaseModel):
+    job_id: str
+    machine_id: str
+    start: int
+    end: int
+
+
+class Solution(BaseModel):
+    family: Family
+    status: SolveStatus = SolveStatus.FEASIBLE
+    objective: float | None = None
+    bound: float | None = None
+    orders: list[InventoryOrder] = Field(default_factory=list)
+    assignments: list[AssignmentRow] = Field(default_factory=list)
+    unassigned: list[str] = Field(default_factory=list)
+    starts: list[ScheduleStart] = Field(default_factory=list)
+    message: str = ""
+
+    def as_dict(self) -> dict[str, Any]:
+        return self.model_dump(mode="json")
+
+
+class ProblemRecord(BaseModel):
+    problem_id: str
+    family: Family
+    split: Split
+    interactive: bool
+    difficulty: Difficulty
+    language: Literal["en", "fa"]
+    template_id: str
+    seed: int
+    prompt_en: str
+    prompt_fa: str
+    prompt_json: str
+    schema_payload: dict[str, Any]
+    gold_status: str
+    gold_objective: float | None = None
+    gold_bound: float | None = None
+    gold_solution: dict[str, Any] = Field(default_factory=dict)
+    structural_key: str
+    notes: str = ""
+
+    def instance(self) -> InventoryInstance | AssignmentInstance | ScheduleInstance:
+        payload = self.schema_payload
+        if self.family == Family.INVENTORY:
+            return InventoryInstance.model_validate(payload)
+        if self.family == Family.ASSIGNMENT:
+            return AssignmentInstance.model_validate(payload)
+        return ScheduleInstance.model_validate(payload)
+
+
+class ConstraintConfig(BaseModel):
+    solver_seconds: float = Field(default=DEFAULT_SOLVER_SECONDS, gt=1, le=30)
+    threads: int = Field(default=DEFAULT_THREADS, ge=1, le=2)
+    include_infeasible: bool = True
+
+
+class ValidationIssue(BaseModel):
+    code: str
+    message: str
+    entity_id: str | None = None
+    passed: bool = False
+
+
+class ValidationReport(BaseModel):
+    ok: bool
+    issues: list[ValidationIssue]
+    checked: list[str]
+    recomputed_objective: float | None = None
+
+    def failed_codes(self) -> list[str]:
+        return [item.code for item in self.issues if not item.passed]
+
+
+class ConstraintFact(BaseModel):
+    key: str
+    value: Any
+    source: str = "schema"
+
+
+class MethodSpec(BaseModel):
+    method_id: str
+    display_name: str
+    kind: MethodKind
+    evaluated: bool
+    version: str
+    license: str = "apache-2.0"
+    cost_usd: float | None = None
+    notes: str = ""
+    reason_if_skipped: str = ""
+
+
+class EvalRow(BaseModel):
+    problem_id: str
+    method_id: str
+    method_kind: str
+    evaluated: bool
+    parse_success: bool | None = None
+    constraint_fidelity: float | None = None
+    status: str
+    feasible: bool | None = None
+    optimality_gap: float | None = None
+    objective: float | None = None
+    gold_objective: float | None = None
+    gold_status: str
+    seconds: float
+    cost_usd: float | None = None
+    violated: list[str] = Field(default_factory=list)
+    notes: str = ""
+    precomputed: bool = False
+    family: str
+    split: str
+    language: str
+    difficulty: str
+
+
+def not_evaluated_cell() -> str:
+    return "not_evaluated"
+
+
+def gap(objective: float | None, gold: float | None, gold_status: str) -> float | None:
+    if objective is None or gold is None:
+        return None
+    if gold_status != SolveStatus.OPTIMAL.value:
+        return None
+    denom = max(1.0, abs(float(gold)))
+    return max(0.0, (float(objective) - float(gold)) / denom)
+
+
+def parse_instance(family: Family | str, payload: dict[str, Any]) -> InventoryInstance | AssignmentInstance | ScheduleInstance:
+    family = Family(family)
+    if family == Family.INVENTORY:
+        return InventoryInstance.model_validate(payload)
+    if family == Family.ASSIGNMENT:
+        return AssignmentInstance.model_validate(payload)
+    return ScheduleInstance.model_validate(payload)

demo/src/explain.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from src.domain import EvalRow, SolveStatus
+from src.validation import ValidationReport
+
+
+def status_label(status: str, lang: str = "en") -> str:
+    mapping = {
+        "en": {
+            "optimal": "Proven optimal (within the model)",
+            "feasible": "Feasible incumbent within the time limit — not proven optimal",
+            "heuristic": "Heuristic feasible candidate — not a proven optimum",
+            "infeasible": "Proven infeasible under the stated constraints",
+            "timeout": "No plan found before the time limit — this is not a proof of infeasibility",
+            "invalid": "Invalid input or schema",
+            "error": "Solver error",
+            "not_evaluated": "Not evaluated — no run, so this is not a score of 0",
+        },
+        "fa": {
+            "optimal": "بهینه اثبات‌شده در مدل",
+            "feasible": "جواب شدنی در مهلت — بهینه بودن اثبات نشده",
+            "heuristic": "نامزد شدنی ابتکاری — بهینه اثبات‌شده نیست",
+            "infeasible": "ناممکن اثبات‌شده با قیود فعلی",
+            "timeout": "در مهلت جوابی پیدا نشد — این اثبات ناممکن بودن نیست",
+            "invalid": "ورودی یا schema نامعتبر",
+            "error": "خطای حل‌گر",
+            "not_evaluated": "ارزیابی نشده — اجرا نشده و این صفر یا رتبه نیست",
+        },
+    }
+    return mapping.get(lang, mapping["en"]).get(status, status)
+
+
+def numeric_reasons(problem, rows: list[EvalRow], report: ValidationReport | None, lang: str = "en") -> list[str]:
+    lines: list[str] = []
+    if lang == "fa":
+        lines.append(
+            f"{problem.problem_id} خانواده {problem.family.value}، دشواری {problem.difficulty.value}، "
+            f"وضعیت طلایی {problem.gold_status}، هدف طلایی {problem.gold_objective}."
+        )
+    else:
+        lines.append(
+            f"{problem.problem_id} is a {problem.difficulty.value} {problem.family.value} instance. "
+            f"Gold status {problem.gold_status}, gold objective {problem.gold_objective}."
+        )
+    by_id = {row.method_id: row for row in rows if row.evaluated}
+    structured = by_id.get("structured-solver")
+    heuristic = by_id.get("heuristic")
+    if structured and heuristic and structured.objective is not None and heuristic.objective is not None:
+        delta = float(heuristic.objective) - float(structured.objective)
+        if lang == "fa":
+            lines.append(f"هدف ابتکاری {heuristic.objective} در برابر حل‌گر {structured.objective} (اختلاف {delta:+.3f}).")
+        else:
+            lines.append(f"Heuristic objective {heuristic.objective} vs solver {structured.objective} (delta {delta:+.3f}).")
+    extractor = by_id.get("template-extractor+solver")
+    if extractor and extractor.constraint_fidelity is not None:
+        if lang == "fa":
+            lines.append(f"وفاداری استخراج قالب {extractor.constraint_fidelity:.3f}؛ parse={'موفق' if extractor.parse_success else 'ناموفق'}.")
+        else:
+            lines.append(f"Template-extractor fidelity {extractor.constraint_fidelity:.3f}; parse={'ok' if extractor.parse_success else 'failed'}.")
+    naive = by_id.get("naive-direct")
+    if naive and naive.violated:
+        if lang == "fa":
+            lines.append(f"پاسخ مستقیم ساده‌لوح قیود را نقض کرد: {', '.join(naive.violated[:6])}.")
+        else:
+            lines.append(f"Naive direct answer violated: {', '.join(naive.violated[:6])}.")
+    if report and not report.ok:
+        codes = ", ".join(report.failed_codes()[:6])
+        if lang == "fa":
+            lines.append(f"validator مستقل قیود نقض‌شده را گزارش کرد: {codes}.")
+        else:
+            lines.append(f"Independent validator flagged: {codes}.")
+    if problem.gold_status == SolveStatus.INFEASIBLE.value:
+        if lang == "fa":
+            lines.append("این نمونه ناممکن طراحی شده است. خانه‌های مدل اجرا‌نشده «ارزیابی نشده» می‌مانند.")
+        else:
+            lines.append("This instance is designed to be infeasible. Unevaluated model cells stay not_evaluated.")
+    if lang == "fa":
+        lines.append("امتیاز یک مدل زبانی داور نیست؛ validator عددی مرجع است. مسیر پاسخ مستقیم فقط برای بنچمارک است.")
+    else:
+        lines.append("An LLM score is not the judge. The numeric validator is the reference. Direct answers are benchmark-only.")
+    return lines[:8]

demo/src/extractor.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from src.domain import Family, InventoryInstance
+
+
+def extract_json(text: str) -> dict[str, Any] | None:
+    if not text or not str(text).strip():
+        return None
+    raw = str(text).strip()
+    candidates = [raw]
+    fenced = re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", raw, flags=re.S)
+    candidates.extend(fenced)
+    start = raw.find("{")
+    end = raw.rfind("}")
+    if start >= 0 and end > start:
+        candidates.append(raw[start : end + 1])
+    for item in candidates:
+        try:
+            payload = json.loads(item)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(payload, dict) and payload:
+            if "schema_payload" in payload and isinstance(payload["schema_payload"], dict):
+                return payload["schema_payload"]
+            return payload
+    return None
+
+
+def extract_template(text: str, family: Family | str) -> dict[str, Any] | None:
+    family = Family(family)
+    if not text:
+        return None
+    labeled = _extract_labeled_blocks(text)
+    if labeled:
+        return labeled
+    if family == Family.INVENTORY:
+        return _extract_inventory_prose(text)
+    return None
+
+
+def _extract_labeled_blocks(text: str) -> dict[str, Any] | None:
+    blocks = re.findall(r"SCHEMA_BEGIN\s*(\{.*?\})\s*SCHEMA_END", text, flags=re.S)
+    for block in blocks:
+        try:
+            payload = json.loads(block)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    return None
+
+
+def _extract_inventory_prose(text: str) -> dict[str, Any] | None:
+    budget = _first_int(text, r"(?:BUDGET|budget|بودجه)\s*[:=]?\s*(\d+)")
+    capacity = _first_int(text, r"(?:CAPACITY|capacity|ظرفیت انبار)\s*[:=]?\s*(\d+)")
+    periods = _first_int(text, r"(?:PERIODS|periods|دوره)\s*[:=]?\s*(\d+)")
+    cover = bool(re.search(r"COVER_REQUIRED:\s*1|cover is required|پوشش کامل الزامی", text, flags=re.I))
+    sku_lines = re.findall(
+        r"SKU\s+([A-Za-z0-9_-]+).*?demand=([0-9,]+).*?pack=(\d+).*?cost=(\d+).*?hold=(\d+).*?short=(\d+).*?stock=(\d+)",
+        text,
+        flags=re.I,
+    )
+    if budget is None or not sku_lines:
+        return None
+    skus = []
+    for sku_id, demand, pack, cost, hold, short, stock in sku_lines:
+        values = [int(item) for item in demand.split(",") if item.strip().isdigit()]
+        skus.append(
+            {
+                "sku_id": sku_id,
+                "name": sku_id,
+                "demand": values,
+                "initial_stock": int(stock),
+                "unit_cost": int(cost),
+                "holding_cost": int(hold),
+                "shortage_cost": int(short),
+                "pack_size": int(pack),
+                "lead_time": 0,
+            }
+        )
+    periods = periods or (len(skus[0]["demand"]) if skus else 0)
+    try:
+        InventoryInstance.model_validate(
+            {
+                "periods": periods,
+                "budget": budget,
+                "warehouse_capacity": capacity if capacity is not None else 10**6,
+                "cover_required": cover,
+                "lost_sales": True,
+                "skus": skus,
+            }
+        )
+    except Exception:
+        return None
+    return {
+        "periods": periods,
+        "budget": budget,
+        "warehouse_capacity": capacity if capacity is not None else 10**6,
+        "cover_required": cover,
+        "lost_sales": True,
+        "skus": skus,
+    }
+
+
+def _first_int(text: str, pattern: str) -> int | None:
+    match = re.search(pattern, text, flags=re.I)
+    if not match:
+        return None
+    return int(match.group(1))
+
+
+def flatten_facts(family: Family | str, payload: dict) -> dict[str, str]:
+    family = Family(family)
+    facts: dict[str, str] = {}
+    if family == Family.INVENTORY:
+        facts["periods"] = str(payload.get("periods"))
+        facts["budget"] = str(payload.get("budget"))
+        facts["warehouse_capacity"] = str(payload.get("warehouse_capacity"))
+        facts["cover_required"] = str(bool(payload.get("cover_required")))
+        for sku in payload.get("skus") or []:
+            key = sku.get("sku_id")
+            facts[f"{key}.demand"] = ",".join(str(int(v)) for v in sku.get("demand") or [])
+            facts[f"{key}.pack"] = str(sku.get("pack_size"))
+            facts[f"{key}.cost"] = str(sku.get("unit_cost"))
+            facts[f"{key}.stock"] = str(sku.get("initial_stock"))
+            facts[f"{key}.hold"] = str(sku.get("holding_cost"))
+            facts[f"{key}.short"] = str(sku.get("shortage_cost"))
+    elif family == Family.ASSIGNMENT:
+        facts["n_tasks"] = str(len(payload.get("tasks") or []))
+        facts["n_agents"] = str(len(payload.get("agents") or []))
+        for task in payload.get("tasks") or []:
+            facts[f"task.{task.get('task_id')}.size"] = str(task.get("size"))
+            facts[f"task.{task.get('task_id')}.required"] = str(bool(task.get("required")))
+            facts[f"task.{task.get('task_id')}.skills"] = ",".join(sorted(task.get("skills") or []))
+        for agent in payload.get("agents") or []:
+            facts[f"agent.{agent.get('agent_id')}.cap"] = str(agent.get("capacity"))
+            facts[f"agent.{agent.get('agent_id')}.skills"] = ",".join(sorted(agent.get("skills") or []))
+        for row in payload.get("costs") or []:
+            facts[f"cost.{row.get('task_id')}.{row.get('agent_id')}"] = str(row.get("cost"))
+    else:
+        facts["machines"] = ",".join(payload.get("machines") or [])
+        for job in payload.get("jobs") or []:
+            jid = job.get("job_id")
+            facts[f"job.{jid}.dur"] = str(job.get("duration"))
+            facts[f"job.{jid}.rel"] = str(job.get("release"))
+            facts[f"job.{jid}.due"] = str(job.get("due"))
+            facts[f"job.{jid}.w"] = str(job.get("weight"))
+            facts[f"job.{jid}.hard"] = str(bool(job.get("hard_due")))
+            facts[f"job.{jid}.m"] = ",".join(sorted(job.get("machine_eligible") or []))
+        for idx, edge in enumerate(payload.get("precedences") or []):
+            facts[f"pred.{idx}"] = f"{edge.get('before')}->{edge.get('after')}"
+    return facts
+
+
+def constraint_fidelity(family: Family | str, gold: dict, extracted: dict | None) -> float | None:
+    if extracted is None:
+        return 0.0
+    gold_facts = flatten_facts(family, gold)
+    got = flatten_facts(family, extracted)
+    if not gold_facts:
+        return 1.0
+    hits = sum(1 for key, value in gold_facts.items() if got.get(key) == value)
+    return hits / len(gold_facts)
+
+
+def drop_constraint(family: Family | str, payload: dict, prompt: str) -> tuple[dict, str]:
+    family = Family(family)
+    clone = json.loads(json.dumps(payload))
+    if family == Family.INVENTORY:
+        clone["budget"] = 10**9
+        stripped = re.sub(r"(BUDGET|budget|بودجه)\s*[:=]?\s*\d+", "BUDGET omitted", prompt)
+        return clone, stripped
+    if family == Family.ASSIGNMENT:
+        for agent in clone.get("agents") or []:
+            agent["capacity"] = 10**6
+        stripped = re.sub(r"(capacity|ظرفیت)\s*[:=]?\s*\d+", "capacity omitted", prompt, flags=re.I)
+        return clone, stripped
+    for job in clone.get("jobs") or []:
+        job["hard_due"] = False
+        job["due"] = job.get("due", 0) + 10**4
+    stripped = re.sub(r"(hard due|موعد سخت)", "due relaxed", prompt, flags=re.I)
+    return clone, stripped

demo/src/generator.py

@@ -0,0 +1,501 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+from pathlib import Path
+
+from src.domain import (
+    DEFAULT_SEED,
+    N_ASSIGNMENT,
+    N_INVENTORY,
+    N_PROBLEMS,
+    N_SCHEDULING,
+    AssignmentAgent,
+    AssignmentCost,
+    AssignmentInstance,
+    AssignmentTask,
+    Difficulty,
+    Family,
+    InventoryInstance,
+    InventorySku,
+    ProblemRecord,
+    ScheduleInstance,
+    ScheduleJob,
+    SchedulePrecedence,
+    Split,
+)
+from src.optimizer import solve_instance
+
+DEV_TEMPLATES = ("D-A", "D-B", "D-C")
+TEST_TEMPLATES = ("T-A", "T-B")
+SKU_NAMES = ("bearing", "seal", "gasket", "filter", "hose", "valve")
+SKU_FA = ("بلبرینگ", "آب‌بند", "واشر", "فیلتر", "شیلنگ", "شیر")
+TASK_SKILLS = ("weld", "inspect", "pack", "lift")
+INTERACTIVE_IDS = (
+    "INV-001",
+    "INV-008",
+    "INV-014",
+    "INV-021",
+    "INV-028",
+    "INV-031",
+    "INV-034",
+    "ASN-001",
+    "ASN-006",
+    "ASN-012",
+    "ASN-018",
+    "ASN-024",
+    "ASN-029",
+    "ASN-033",
+    "SCH-001",
+    "SCH-007",
+    "SCH-013",
+    "SCH-019",
+    "SCH-027",
+    "SCH-033",
+)
+
+
+def _split_for(index: int, n_items: int) -> Split:
+    # First 20 of each family → 60 development / 40 test overall.
+    _ = n_items
+    return Split.DEVELOPMENT if index <= 20 else Split.TEST
+
+
+def _difficulty(index: int, n_items: int, infeasible_tail: int) -> Difficulty:
+    if index > n_items - infeasible_tail:
+        return Difficulty.INFEASIBLE
+    if index % 7 == 0:
+        return Difficulty.HARD
+    if index % 3 == 0:
+        return Difficulty.MEDIUM
+    return Difficulty.EASY
+
+
+def _template(split: Split, index: int) -> str:
+    pool = DEV_TEMPLATES if split == Split.DEVELOPMENT else TEST_TEMPLATES
+    return pool[(index - 1) % len(pool)]
+
+
+def _key(*parts: object) -> str:
+    raw = "|".join(str(item) for item in parts)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
+
+
+def _wrap_schema(payload: dict, template_id: str) -> str:
+    if template_id.startswith("D-"):
+        return "SCHEMA_BEGIN\n" + json.dumps(payload, ensure_ascii=False) + "\nSCHEMA_END\n"
+    return ""
+
+
+def _json_prompt(payload: dict) -> str:
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+def make_inventory(index: int, rng: random.Random) -> tuple[InventoryInstance, str]:
+    difficulty = _difficulty(index, N_INVENTORY, 3)
+    n_sku = 2 if difficulty == Difficulty.EASY else 3 if difficulty != Difficulty.HARD else 4
+    periods = 3 if difficulty != Difficulty.HARD else 4
+    cover = difficulty in {Difficulty.HARD, Difficulty.INFEASIBLE} or index % 5 == 0
+    skus = []
+    for k in range(n_sku):
+        demand = [rng.randint(2, 8) for _ in range(periods)]
+        pack = rng.choice([1, 2, 3])
+        skus.append(
+            InventorySku(
+                sku_id=f"S{k + 1}",
+                name=SKU_NAMES[k],
+                demand=demand,
+                initial_stock=rng.randint(0, 3),
+                unit_cost=rng.randint(3, 9),
+                holding_cost=rng.randint(1, 3),
+                shortage_cost=rng.randint(6, 14),
+                pack_size=pack,
+                lead_time=0,
+            )
+        )
+    total_need = sum(max(0, sum(sku.demand) - sku.initial_stock) for sku in skus)
+    min_buy = 0
+    for sku in skus:
+        need = max(0, sum(sku.demand) - sku.initial_stock)
+        packs = (need + sku.pack_size - 1) // sku.pack_size
+        min_buy += packs * sku.pack_size * sku.unit_cost
+    cap = max(8, int(total_need * 0.7) + rng.randint(2, 8))
+    if difficulty == Difficulty.INFEASIBLE:
+        for sku in skus:
+            sku.initial_stock = 0
+            sku.demand = [max(3, value) for value in sku.demand]
+        total_need = sum(sum(sku.demand) for sku in skus)
+        min_buy = 0
+        for sku in skus:
+            packs = (sum(sku.demand) + sku.pack_size - 1) // sku.pack_size
+            min_buy += packs * sku.pack_size * sku.unit_cost
+        budget = max(1, min_buy // 5)
+        cover = True
+        cap = max(6, total_need)
+    elif difficulty == Difficulty.HARD:
+        budget = max(min_buy, int(min_buy * 1.05) + 2)
+    else:
+        budget = min_buy + rng.randint(8, 24)
+    instance = InventoryInstance(
+        periods=periods,
+        budget=int(budget),
+        warehouse_capacity=int(cap),
+        cover_required=cover,
+        lost_sales=True,
+        skus=skus,
+    )
+    return instance, difficulty.value
+
+
+def render_inventory(instance: InventoryInstance, template_id: str, language: str) -> tuple[str, str]:
+    labeled = []
+    for sku in instance.skus:
+        labeled.append(
+            f"SKU {sku.sku_id} demand={','.join(str(v) for v in sku.demand)} pack={sku.pack_size} "
+            f"cost={sku.unit_cost} hold={sku.holding_cost} short={sku.shortage_cost} stock={sku.initial_stock}"
+        )
+    labels = (
+        f"PERIODS: {instance.periods}\nBUDGET: {instance.budget}\nCAPACITY: {instance.warehouse_capacity}\n"
+        f"COVER_REQUIRED: {1 if instance.cover_required else 0}\n" + "\n".join(labeled)
+    )
+    schema_block = _wrap_schema(instance.model_dump(), template_id)
+    names = ", ".join(f"{sku.sku_id} ({sku.name})" for sku in instance.skus)
+    names_fa = ", ".join(f"{sku.sku_id} ({SKU_FA[int(sku.sku_id[1:]) - 1]})" for sku in instance.skus)
+    cover_en = "All demand must be covered; lost sales are forbidden." if instance.cover_required else "Lost sales are allowed and charged."
+    cover_fa = "پوشش کامل تقاضا الزامی است." if instance.cover_required else "کمبود مجاز است و جریمه دارد."
+    if template_id in {"D-A", "D-B", "D-C"}:
+        en = (
+            f"A B2B warehouse plans {instance.periods} weeks for {len(instance.skus)} SKUs: {names}. "
+            f"{cover_en} Orders are pack multiples. Lead time is 0. "
+            f"Budget is {instance.budget} currency units. Storage holds at most {instance.warehouse_capacity} units in total. "
+            "Minimize purchase + holding + shortage.\n"
+            f"{labels}\n{schema_block}"
+        )
+        fa = (
+            f"یک انبار B2B برای {instance.periods} هفته و {len(instance.skus)} کالا برنامه می‌خرد: {names_fa}. "
+            f"{cover_fa} سفارش مضرب بسته است. زمان تأمین صفر است. "
+            f"بودجه برابر {instance.budget} واحد پول و ظرفیت انبار {instance.warehouse_capacity} واحد است. "
+            "هدف کمینه‌کردن خرید + نگهداری + کمبود است.\n"
+            f"{labels}\n{schema_block}"
+        )
+    else:
+        demand_txt = "; ".join(f"{sku.sku_id} wants {sku.demand} at pack {sku.pack_size}" for sku in instance.skus)
+        en = (
+            f"Replenish {names} over a {instance.periods}-week horizon. {cover_en} "
+            f"The buyer cannot spend more than {instance.budget}. On-hand stock across SKUs cannot exceed {instance.warehouse_capacity}. "
+            f"{demand_txt}. Costs and opening stock are in the JSON companion."
+        )
+        fa = (
+            f"برای {names_fa} در افق {instance.periods} هفته خرید کنید. {cover_fa} "
+            f"سقف هزینه {instance.budget} و سقف موجودی کل {instance.warehouse_capacity} است. "
+            "جزئیات تقاضا و بسته در فایل JSON همراه است."
+        )
+    return en, fa
+
+
+def make_assignment(index: int, rng: random.Random) -> tuple[AssignmentInstance, str]:
+    difficulty = _difficulty(index, N_ASSIGNMENT, 2)
+    n_tasks = 4 if difficulty == Difficulty.EASY else 6 if difficulty != Difficulty.HARD else 8
+    n_agents = 3 if difficulty != Difficulty.HARD else 4
+    tasks = []
+    for k in range(n_tasks):
+        skills = [rng.choice(TASK_SKILLS)]
+        if difficulty != Difficulty.EASY and rng.random() < 0.35:
+            skills.append(rng.choice(TASK_SKILLS))
+            skills = sorted(set(skills))
+        tasks.append(
+            AssignmentTask(
+                task_id=f"T{k + 1}",
+                name=f"job-{k + 1}",
+                size=rng.randint(1, 3),
+                required=True if difficulty == Difficulty.INFEASIBLE else (k < n_tasks - 1 or difficulty != Difficulty.EASY),
+                skills=skills,
+                penalty=rng.randint(20, 40),
+            )
+        )
+    agents = []
+    for k in range(n_agents):
+        skills = [TASK_SKILLS[k % len(TASK_SKILLS)]]
+        if difficulty != Difficulty.EASY:
+            skills.append(TASK_SKILLS[(k + 1) % len(TASK_SKILLS)])
+        agents.append(
+            AssignmentAgent(
+                agent_id=f"A{k + 1}",
+                name=f"tech-{k + 1}",
+                capacity=rng.randint(3, 6) if difficulty != Difficulty.INFEASIBLE else 1,
+                skills=sorted(set(skills)),
+            )
+        )
+    if difficulty == Difficulty.INFEASIBLE:
+        for task in tasks:
+            task.required = True
+            task.size = 3
+        for agent in agents:
+            agent.capacity = 1
+    else:
+        for idx, task in enumerate(tasks):
+            agent = agents[idx % len(agents)]
+            if not (set(task.skills) & set(agent.skills)):
+                task.skills = sorted(set(task.skills + agent.skills[:1]))
+        required_load = sum(task.size for task in tasks if task.required)
+        agents[-1].skills = sorted(set(TASK_SKILLS))
+        total_cap = sum(agent.capacity for agent in agents)
+        if required_load > total_cap:
+            agents[-1].capacity += required_load - total_cap + 2
+        else:
+            agents[-1].capacity += 2
+    costs = []
+    for task in tasks:
+        for agent in agents:
+            if set(task.skills) & set(agent.skills) or not task.skills:
+                costs.append(AssignmentCost(task_id=task.task_id, agent_id=agent.agent_id, cost=rng.randint(4, 18)))
+    return AssignmentInstance(tasks=tasks, agents=agents, costs=costs), difficulty.value
+
+
+def render_assignment(instance: AssignmentInstance, template_id: str) -> tuple[str, str]:
+    payload = instance.model_dump()
+    schema_block = _wrap_schema(payload, template_id)
+    task_txt = ", ".join(f"{task.task_id} size {task.size} skills {'/'.join(task.skills)}" for task in instance.tasks)
+    agent_txt = ", ".join(f"{agent.agent_id} cap {agent.capacity} skills {'/'.join(agent.skills)}" for agent in instance.agents)
+    if template_id.startswith("D-"):
+        en = (
+            "Assign each required maintenance task to at most one eligible technician. "
+            "Do not exceed agent capacity. Optional leftover tasks pay a penalty.\n"
+            f"TASKS: {task_txt}\nAGENTS: {agent_txt}\n{schema_block}"
+        )
+        fa = (
+            "هر کار الزامی را حداکثر به یک تکنسین واجد مهارت بدهید و از ظرفیت نفر تجاوز نکنید. "
+            "کار اختیاریِ انجام‌نشده جریمه دارد.\n"
+            f"TASKS: {task_txt}\nAGENTS: {agent_txt}\n{schema_block}"
+        )
+    else:
+        en = (
+            f"A service desk has technicians {agent_txt}. Work orders: {task_txt}. "
+            "A task may use an agent only when they share a skill. Minimize assignment cost plus leftover penalties."
+        )
+        fa = (
+            f"میز خدمت تکنسین‌های {agent_txt} را دارد. سفارش‌ها: {task_txt}. "
+            "تخصیص فقط با مهارت مشترک مجاز است. هزینه تخصیص به‌علاوه جریمه کار باقی‌مانده کمینه شود."
+        )
+    return en, fa
+
+
+def make_schedule(index: int, rng: random.Random) -> tuple[ScheduleInstance, str]:
+    difficulty = _difficulty(index, N_SCHEDULING, 3)
+    n_jobs = 4 if difficulty == Difficulty.EASY else 6 if difficulty != Difficulty.HARD else 8
+    machines = ["M1"] if difficulty == Difficulty.EASY else ["M1", "M2"]
+    jobs = []
+    cursor = 0
+    for k in range(n_jobs):
+        duration = rng.randint(2, 5)
+        release = rng.choice([0, 0, 1, 2])
+        due = cursor + duration + rng.randint(1, 4)
+        hard = difficulty == Difficulty.INFEASIBLE and k < 2
+        if difficulty == Difficulty.INFEASIBLE and k < 2:
+            due = release + duration - 1
+        eligible = machines[:] if difficulty == Difficulty.EASY or rng.random() < 0.7 else [rng.choice(machines)]
+        jobs.append(
+            ScheduleJob(
+                job_id=f"J{k + 1}",
+                name=f"op-{k + 1}",
+                duration=duration,
+                release=release,
+                due=max(due, release + duration),
+                weight=rng.randint(1, 4),
+                hard_due=hard,
+                machine_eligible=eligible,
+            )
+        )
+        cursor += duration
+    if difficulty == Difficulty.INFEASIBLE and len(jobs) >= 2:
+        jobs[0].hard_due = True
+        jobs[0].due = jobs[0].release + jobs[0].duration - 1
+        jobs[1].hard_due = True
+        jobs[1].due = jobs[1].release + jobs[1].duration - 1
+        if jobs[0].due < jobs[0].release + jobs[0].duration:
+            pass
+    precedences = []
+    if difficulty != Difficulty.EASY and n_jobs >= 3:
+        precedences.append(SchedulePrecedence(before="J1", after="J3"))
+    if difficulty == Difficulty.HARD and n_jobs >= 5:
+        precedences.append(SchedulePrecedence(before="J2", after="J5"))
+    horizon = sum(job.duration for job in jobs) + 8
+    return ScheduleInstance(machines=machines, jobs=jobs, precedences=precedences, horizon=horizon), difficulty.value
+
+
+def render_schedule(instance: ScheduleInstance, template_id: str) -> tuple[str, str]:
+    payload = instance.model_dump()
+    schema_block = _wrap_schema(payload, template_id)
+    job_txt = ", ".join(
+        f"{job.job_id} dur {job.duration} rel {job.release} due {job.due}{' hard' if job.hard_due else ''}"
+        for job in instance.jobs
+    )
+    pred = ", ".join(f"{edge.before}->{edge.after}" for edge in instance.precedences) or "none"
+    if template_id.startswith("D-"):
+        en = (
+            f"Schedule jobs on machines {', '.join(instance.machines)} without overlap. "
+            f"Respect release times and precedences ({pred}). Hard due dates are deadlines.\n"
+            f"JOBS: {job_txt}\n{schema_block}"
+        )
+        fa = (
+            f"کارها را روی ماشین‌های {', '.join(instance.machines)} بدون هم‌پوشانی زمان‌بندی کنید. "
+            f"زمان آزادسازی و تقدم ({pred}) رعایت شود. موعد سخت ضرب‌الاجل است.\n"
+            f"JOBS: {job_txt}\n{schema_block}"
+        )
+    else:
+        en = (
+            f"A shop has machines {', '.join(instance.machines)}. Jobs: {job_txt}. "
+            f"Precedence: {pred}. Minimize weighted tardiness. Do not overlap a machine."
+        )
+        fa = (
+            f"کارگاه ماشین‌های {', '.join(instance.machines)} را دارد. کارها: {job_txt}. "
+            f"تقدم: {pred}. تأخیر وزنی کمینه شود و ماشین هم‌پوشانی نداشته باشد."
+        )
+    return en, fa
+
+
+def _finalize(
+    problem_id: str,
+    family: Family,
+    index: int,
+    n_items: int,
+    instance,
+    difficulty: str,
+    template_id: str,
+    language: str,
+    seed: int,
+    prompt_en: str,
+    prompt_fa: str,
+    notes: str,
+) -> ProblemRecord:
+    split = _split_for(index, n_items)
+    payload = instance.model_dump()
+    gold = solve_instance(family, payload, seconds=6.0, threads=1)
+    wanted = Difficulty(difficulty)
+    if wanted == Difficulty.INFEASIBLE and gold.solution.status.value != "infeasible":
+        notes = (notes + " requested infeasible; solver found a plan so the row is hard.").strip()
+        wanted = Difficulty.HARD
+    structural = _key(
+        family.value,
+        split.value,
+        template_id,
+        problem_id,
+        json.dumps(payload, sort_keys=True, ensure_ascii=False),
+        wanted.value,
+    )
+    return ProblemRecord(
+        problem_id=problem_id,
+        family=family,
+        split=split,
+        interactive=problem_id in INTERACTIVE_IDS,
+        difficulty=wanted,
+        language=language,
+        template_id=template_id,
+        seed=seed,
+        prompt_en=prompt_en,
+        prompt_fa=prompt_fa,
+        prompt_json=_json_prompt(payload),
+        schema_payload=payload,
+        gold_status=gold.solution.status.value,
+        gold_objective=gold.solution.objective,
+        gold_bound=gold.solution.bound,
+        gold_solution=gold.solution.as_dict(),
+        structural_key=structural,
+        notes=notes,
+    )
+
+
+def generate_catalog(seed: int = DEFAULT_SEED) -> list[ProblemRecord]:
+    problems: list[ProblemRecord] = []
+    for index in range(1, N_INVENTORY + 1):
+        rng = random.Random(seed * 1000 + index)
+        instance, difficulty = make_inventory(index, rng)
+        split = _split_for(index, N_INVENTORY)
+        template_id = _template(split, index)
+        language = "en" if index % 2 else "fa"
+        en, fa = render_inventory(instance, template_id, language)
+        problems.append(
+            _finalize(
+                f"INV-{index:03d}",
+                Family.INVENTORY,
+                index,
+                N_INVENTORY,
+                instance,
+                difficulty,
+                template_id,
+                language,
+                seed * 1000 + index,
+                en,
+                fa,
+                "lead time is 0; units are abstract currency and pieces",
+            )
+        )
+    for index in range(1, N_ASSIGNMENT + 1):
+        rng = random.Random(seed * 2000 + index)
+        instance, difficulty = make_assignment(index, rng)
+        split = _split_for(index, N_ASSIGNMENT)
+        template_id = _template(split, index)
+        language = "fa" if index % 2 else "en"
+        en, fa = render_assignment(instance, template_id)
+        problems.append(
+            _finalize(
+                f"ASN-{index:03d}",
+                Family.ASSIGNMENT,
+                index,
+                N_ASSIGNMENT,
+                instance,
+                difficulty,
+                template_id,
+                language,
+                seed * 2000 + index,
+                en,
+                fa,
+                "skill intersection is the eligibility rule",
+            )
+        )
+    for index in range(1, N_SCHEDULING + 1):
+        rng = random.Random(seed * 3000 + index)
+        instance, difficulty = make_schedule(index, rng)
+        split = _split_for(index, N_SCHEDULING)
+        template_id = _template(split, index)
+        language = "en" if index % 3 else "fa"
+        en, fa = render_schedule(instance, template_id)
+        problems.append(
+            _finalize(
+                f"SCH-{index:03d}",
+                Family.SCHEDULING,
+                index,
+                N_SCHEDULING,
+                instance,
+                difficulty,
+                template_id,
+                language,
+                seed * 3000 + index,
+                en,
+                fa,
+                "objective reported as weighted tardiness; makespan is a tie-break inside the solver only",
+            )
+        )
+    if len(problems) != N_PROBLEMS:
+        raise RuntimeError(f"expected {N_PROBLEMS} problems, got {len(problems)}")
+    return problems
+
+
+def write_catalog(path: Path, seed: int = DEFAULT_SEED) -> list[ProblemRecord]:
+    problems = generate_catalog(seed)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in problems:
+            handle.write(row.model_dump_json() + "\n")
+    return problems
+
+
+def load_catalog(path: Path | None = None) -> list[ProblemRecord]:
+    if path and path.exists():
+        rows = []
+        for line in path.read_text(encoding="utf-8").splitlines():
+            if line.strip():
+                rows.append(ProblemRecord.model_validate_json(line))
+        return rows
+    return generate_catalog()

demo/src/i18n.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+TEXTS = {
+    "en": {
+        "title": "ORBench — Solver and Agent Decision Benchmark",
+        "subtitle": "Compare structured solvers, heuristics, and text-to-schema agents on 100 small inventory, assignment, and scheduling tasks.",
+        "kind": "Research prototype · numeric validator is the judge · CPU · no paid API",
+        "run_sample": "Run sample",
+        "cancel": "Cancel run",
+        "reset": "Reset defaults",
+        "load_sample": "Load 20 interactive problems",
+        "language": "Language",
+        "problem": "Interactive problem",
+        "variant": "Prompt variant",
+        "template": "Labeled / narrative template",
+        "json": "JSON schema only",
+        "missing": "Hide a hard constraint in the text",
+        "time_limit": "Solver time limit (s)",
+        "advanced": "Advanced solver settings",
+        "sample_note": "Preview KPIs are a precomputed sample on the recorded 100-problem catalog. LLM rows stay not_evaluated. A fluent paragraph is not a feasible plan.",
+        "live_note": "Live CPU comparison: structured CP-SAT, fixed heuristic, JSON extractor, template extractor, and a naive direct answer. Named Hub models were not run.",
+        "kpi_n": "Problems in view",
+        "kpi_n_sub": "interactive subset or filtered catalog",
+        "kpi_feas": "Structured-solver feasible",
+        "kpi_feas_sub": "share of valid plans after independent checks",
+        "kpi_gap": "Heuristic mean gap",
+        "kpi_gap_sub": "only where gold status is proven optimal",
+        "kpi_fid": "Template fidelity",
+        "kpi_fid_sub": "atomic constraint facts recovered from text",
+        "kpi_eval": "Methods evaluated",
+        "kpi_eval_sub": "evaluated / listed — unevaluated is not zero",
+        "empty": "No live result yet. Load a sample problem and run a comparison.",
+        "status": "Reference status",
+        "upload_hint": "Edit the schema JSON only if you want a structured-solver what-if. Prompts stay synthetic. Direct-answer JSON is benchmark-only.",
+        "method_plot": "Parse and feasibility rates for evaluated methods",
+        "family_plot": "Feasibility by family for evaluated methods",
+        "sol_plot": "Reference CP-SAT plan",
+        "custom_text": "Optional custom prompt",
+        "custom_schema": "Editable schema JSON",
+        "direct_json": "Optional direct-answer JSON (benchmark only)",
+        "method_body": """
+ORBench is a research prototype for comparing decision-making *methods*, not a ranking of companies or a production optimizer.
+
+**What it decides.** For each tiny instance it records parse success, constraint fidelity, feasibility, and optimality gap versus a gold CP-SAT run. An LLM score is never the judge.
+
+**Three families.** Inventory (pack multiples, budget, warehouse capacity, optional hard cover), assignment (skill + capacity), and scheduling (release, precedence, optional hard due dates). Lead time is 0. Units are abstract.
+
+**Methods actually run.** `structured-solver`, `heuristic`, `json-extractor+solver`, `template-extractor+solver`, `naive-direct`. Development prompts include a `SCHEMA_BEGIN` block; test prompts are prose so the template extractor can fail honestly.
+
+**Methods listed but not run.** Qwen, Kimi, GLM, and DeepSeek cards stay `not_evaluated`. That cell is not a zero and not a rank.
+
+**Validator.** An independent checker recomputes inventory balance, pack, budget, capacity, assignment uniqueness/eligibility/capacity, and schedule overlap/precedence/release. Gap is reported only when gold status is optimal.
+
+**Limits.** 100 synthetic instances, CPU only, no paid API, no agent tool-use environment in this MVP, no claim that a fluent answer is operationally safe. Direct LLM-style answers are labeled benchmark-only.
+""",
+    },
+    "fa": {
+        "title": "اوربنچ — آزمایشگاه مقایسه حل‌گر و عامل تصمیم",
+        "subtitle": "حل‌گر ساختاریافته، ابتکاری ثابت و عامل متن‌به‌طرح را روی ۱۰۰ مسئله کوچک موجودی، تخصیص و زمان‌بندی مقایسه کنید.",
+        "kind": "نمونه پژوهشی · داور validator عددی است · CPU · بدون API پولی",
+        "run_sample": "اجرای نمونه",
+        "cancel": "لغو اجرا",
+        "reset": "بازگشت به پیش‌فرض",
+        "load_sample": "بارگذاری ۲۰ مسئله تعاملی",
+        "language": "زبان",
+        "problem": "مسئله تعاملی",
+        "variant": "نوع متن",
+        "template": "قالب برچسب‌دار / روایی",
+        "json": "فقط JSON",
+        "missing": "حذف یک قید سخت از متن",
+        "time_limit": "مهلت حل‌گر (ثانیه)",
+        "advanced": "تنظیمات پیشرفته حل‌گر",
+        "sample_note": "شاخص‌ها نمونه از پیش محاسبه‌شده روی کاتالوگ ۱۰۰ مسئله‌اند. ردیف مدل ��بانی «ارزیابی نشده» است. متن روان به‌معنای برنامه شدنی نیست.",
+        "live_note": "مقایسه زنده CPU: CP-SAT ساختاریافته، ابتکاری ثابت، استخراج JSON، استخراج قالب، و پاسخ مستقیم ساده‌لوح. مدل‌های Hub اجرا نشده‌اند.",
+        "kpi_n": "مسئله در نما",
+        "kpi_n_sub": "زیرمجموعه تعاملی یا کاتالوگ فیلترشده",
+        "kpi_feas": "شدنی بودن حل‌گر ساختاریافته",
+        "kpi_feas_sub": "سهم برنامه معتبر پس از کنترل مستقل",
+        "kpi_gap": "میانگین شکاف ابتکاری",
+        "kpi_gap_sub": "فقط وقتی وضعیت طلایی بهینه اثبات‌شده است",
+        "kpi_fid": "وفاداری استخراج قالب",
+        "kpi_fid_sub": "حقایق اتمی قید بازیابی‌شده از متن",
+        "kpi_eval": "روش‌های ارزیابی‌شده",
+        "kpi_eval_sub": "ارزیابی‌شده / فهرست‌شده — ارزیابی‌نشده صفر نیست",
+        "empty": "هنوز نتیجه زنده‌ای نیست. یک مسئله نمونه را اجرا کنید.",
+        "status": "وضعیت مرجع",
+        "upload_hint": "JSON طرح را فقط برای آزمون حل‌گر ساختاریافته ویرایش کنید. پاسخ مستقیم فقط برای بنچمارک است.",
+        "method_plot": "نرخ تجزیه و امکان‌پذیری روش‌های ارزیابی‌شده",
+        "family_plot": "امکان‌پذیری به تفکیک خانواده",
+        "sol_plot": "برنامه مرجع CP-SAT",
+        "custom_text": "متن سفارشی اختیاری",
+        "custom_schema": "JSON طرح قابل ویرایش",
+        "direct_json": "JSON پاسخ مستقیم اختیاری (فقط بنچمارک)",
+        "method_body": """
+اوربنچ نمونه پژوهشی مقایسه *روش* است، نه رتبه‌بندی شرکت و نه بهینه‌ساز عملیاتی.
+
+**تصمیم.** برای هر نمونه کوچک، موفقیت تجزیه، وفاداری قید، امکان‌پذیری و شکاف بهینگی نسبت به اجرای طلایی CP-SAT ثبت می‌شود. امتیاز مدل زبانی داور نیست.
+
+**سه خانواده.** موجودی، تخصیص و زمان‌بندی. زمان تأمین صفر است. واحدها انتزاعی‌اند.
+
+**روش‌های اجراشده.** حل‌گر ساختاریافته، ابتکاری، استخراج JSON، استخراج قالب، پاسخ مستقیم ساده‌لوح. متن توسعه بلوک SCHEMA دارد؛ متن آزمون نثر است تا استخراج قالب صادقانه شکست بخورد.
+
+**روش‌های اجرا‌نشده.** Qwen، Kimi، GLM و DeepSeek در خانه «ارزیابی نشده» می‌مانند؛ این صفر یا رتبه نیست.
+
+**محدودیت.** ۱۰۰ نمونه ساختگی، فقط CPU، بدون API پولی، بدون ادعای ایمنی عملیاتی برای متن روان.
+""",
+    },
+}
+
+
+def t(lang: str, key: str) -> str:
+    return TEXTS.get(lang, TEXTS["en"]).get(key, TEXTS["en"].get(key, key))

demo/src/metrics.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+import pandas as pd
+
+from src.domain import EvalRow, SolveStatus, gap, not_evaluated_cell
+from src.model_registry import UNEVALUATED_MODELS, evaluated_ids
+
+
+def row_from_run(
+    problem,
+    method_id: str,
+    method_kind: str,
+    parse_success: bool | None,
+    fidelity: float | None,
+    status: str,
+    feasible: bool | None,
+    objective: float | None,
+    seconds: float,
+    violated: list[str],
+    notes: str,
+    precomputed: bool = False,
+    cost_usd: float | None = 0.0,
+) -> EvalRow:
+    gold_status = problem.gold_status
+    gold_obj = problem.gold_objective
+    opt_gap = gap(objective, gold_obj, gold_status) if feasible else None
+    return EvalRow(
+        problem_id=problem.problem_id,
+        method_id=method_id,
+        method_kind=method_kind,
+        evaluated=True,
+        parse_success=parse_success,
+        constraint_fidelity=fidelity,
+        status=status,
+        feasible=feasible,
+        optimality_gap=opt_gap,
+        objective=objective,
+        gold_objective=gold_obj,
+        gold_status=gold_status,
+        seconds=seconds,
+        cost_usd=cost_usd,
+        violated=violated,
+        notes=notes,
+        precomputed=precomputed,
+        family=problem.family.value,
+        split=problem.split.value,
+        language=problem.language,
+        difficulty=problem.difficulty.value,
+    )
+
+
+def skipped_rows(problem) -> list[EvalRow]:
+    rows = []
+    for spec in UNEVALUATED_MODELS:
+        rows.append(
+            EvalRow(
+                problem_id=problem.problem_id,
+                method_id=spec.method_id,
+                method_kind=spec.kind.value,
+                evaluated=False,
+                parse_success=None,
+                constraint_fidelity=None,
+                status=not_evaluated_cell(),
+                feasible=None,
+                optimality_gap=None,
+                objective=None,
+                gold_objective=problem.gold_objective,
+                gold_status=problem.gold_status,
+                seconds=0.0,
+                cost_usd=None,
+                violated=[],
+                notes=spec.reason_if_skipped,
+                precomputed=True,
+                family=problem.family.value,
+                split=problem.split.value,
+                language=problem.language,
+                difficulty=problem.difficulty.value,
+            )
+        )
+    return rows
+
+
+def summarize(rows: list[EvalRow] | pd.DataFrame) -> pd.DataFrame:
+    frame = rows if isinstance(rows, pd.DataFrame) else pd.DataFrame([row.model_dump() for row in rows])
+    if frame.empty:
+        return pd.DataFrame()
+    out = []
+    for method_id, group in frame.groupby("method_id", dropna=False):
+        evaluated = bool(group["evaluated"].iloc[0])
+        if not evaluated:
+            out.append(
+                {
+                    "method_id": method_id,
+                    "evaluated": False,
+                    "n": int(len(group)),
+                    "parse_rate": not_evaluated_cell(),
+                    "feasible_rate": not_evaluated_cell(),
+                    "infeasible_agreement": not_evaluated_cell(),
+                    "mean_gap": not_evaluated_cell(),
+                    "mean_fidelity": not_evaluated_cell(),
+                    "mean_seconds": not_evaluated_cell(),
+                    "mean_cost_usd": not_evaluated_cell(),
+                    "n_optimal": not_evaluated_cell(),
+                }
+            )
+            continue
+        parsed = group["parse_success"].dropna()
+        feasible = group["feasible"].dropna()
+        inf_gold = group.loc[group["gold_status"] == SolveStatus.INFEASIBLE.value]
+        agree = None
+        if len(inf_gold):
+            agree = float((inf_gold["status"] == SolveStatus.INFEASIBLE.value).mean())
+        gaps = group["optimality_gap"].dropna()
+        fidelity = group["constraint_fidelity"].dropna()
+        out.append(
+            {
+                "method_id": method_id,
+                "evaluated": True,
+                "n": int(len(group)),
+                "parse_rate": None if parsed.empty else float(parsed.mean()),
+                "feasible_rate": None if feasible.empty else float(feasible.mean()),
+                "infeasible_agreement": agree,
+                "mean_gap": None if gaps.empty else float(gaps.mean()),
+                "mean_fidelity": None if fidelity.empty else float(fidelity.mean()),
+                "mean_seconds": float(group["seconds"].mean()),
+                "mean_cost_usd": float(group["cost_usd"].fillna(0).mean()),
+                "n_optimal": int((group["status"] == SolveStatus.OPTIMAL.value).sum()),
+            }
+        )
+    return pd.DataFrame(out).sort_values(["evaluated", "method_id"], ascending=[False, True]).reset_index(drop=True)
+
+
+def family_summary(rows: list[EvalRow] | pd.DataFrame) -> pd.DataFrame:
+    frame = rows if isinstance(rows, pd.DataFrame) else pd.DataFrame([row.model_dump() for row in rows])
+    if frame.empty:
+        return pd.DataFrame()
+    live = frame.loc[frame["evaluated"] == True]  # noqa: E712
+    if live.empty:
+        return pd.DataFrame()
+    records = []
+    for (family, method_id), group in live.groupby(["family", "method_id"]):
+        feasible = group["feasible"].dropna()
+        gaps = group["optimality_gap"].dropna()
+        records.append(
+            {
+                "family": family,
+                "method_id": method_id,
+                "n": int(len(group)),
+                "feasible_rate": None if feasible.empty else float(feasible.mean()),
+                "mean_gap": None if gaps.empty else float(gaps.mean()),
+            }
+        )
+    return pd.DataFrame(records).sort_values(["family", "method_id"]).reset_index(drop=True)
+
+
+def display_cell(value) -> str:
+    if value is None:
+        return not_evaluated_cell()
+    if isinstance(value, float):
+        return f"{value:.3f}"
+    return str(value)
+
+
+def kpi_snapshot(rows: list[EvalRow] | pd.DataFrame) -> dict[str, float | str | int]:
+    frame = rows if isinstance(rows, pd.DataFrame) else pd.DataFrame([row.model_dump() for row in rows])
+    live = frame.loc[frame["method_id"].isin(evaluated_ids())] if not frame.empty else frame
+    structured = live.loc[live["method_id"] == "structured-solver"] if not live.empty else live
+    heuristic = live.loc[live["method_id"] == "heuristic"] if not live.empty else live
+    extractor = live.loc[live["method_id"] == "template-extractor+solver"] if not live.empty else live
+    return {
+        "n_problems": int(structured["problem_id"].nunique()) if not structured.empty else 0,
+        "structured_feasible": float(structured["feasible"].dropna().mean()) if not structured.empty else 0.0,
+        "heuristic_gap": float(heuristic["optimality_gap"].dropna().mean()) if not heuristic.empty and heuristic["optimality_gap"].notna().any() else None,
+        "template_fidelity": float(extractor["constraint_fidelity"].dropna().mean()) if not extractor.empty and extractor["constraint_fidelity"].notna().any() else None,
+        "n_methods_evaluated": int(len(evaluated_ids())),
+        "n_methods_listed": int(frame["method_id"].nunique()) if not frame.empty else 0,
+    }
+
+
+def compare_two(rows: pd.DataFrame, left: str, right: str) -> pd.DataFrame:
+    if rows.empty:
+        return pd.DataFrame()
+    a = rows.loc[rows["method_id"] == left].set_index("problem_id")
+    b = rows.loc[rows["method_id"] == right].set_index("problem_id")
+    ids = sorted(set(a.index) & set(b.index))
+    out = []
+    for problem_id in ids:
+        out.append(
+            {
+                "problem_id": problem_id,
+                f"{left}_status": a.loc[problem_id, "status"],
+                f"{right}_status": b.loc[problem_id, "status"],
+                f"{left}_obj": a.loc[problem_id, "objective"],
+                f"{right}_obj": b.loc[problem_id, "objective"],
+                f"{left}_feasible": a.loc[problem_id, "feasible"],
+                f"{right}_feasible": b.loc[problem_id, "feasible"],
+            }
+        )
+    return pd.DataFrame(out)

demo/src/model_registry.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from src.domain import MethodKind, MethodSpec
+
+REGISTRY_VERSION = "2026-09-20"
+
+# Named Hub models are listed so the comparison table stays honest.
+# None of the LLM rows were executed in this release. Cells stay
+# "not_evaluated" rather than 0 or a fabricated rank.
+EVALUATED_METHODS = (
+    MethodSpec(
+        method_id="structured-solver",
+        display_name="Structured form + CP-SAT",
+        kind=MethodKind.STRUCTURED_SOLVER,
+        evaluated=True,
+        version="ortools-cpsat",
+        notes="Gold schema or user-edited schema enters the solver. Numeric reference.",
+    ),
+    MethodSpec(
+        method_id="heuristic",
+        display_name="Fixed heuristic (LFL / greedy / EDD)",
+        kind=MethodKind.HEURISTIC,
+        evaluated=True,
+        version="or-bench-heuristic-v1",
+        notes="Lot-for-lot inventory, cheapest-eligible assignment, earliest-due-date scheduling.",
+    ),
+    MethodSpec(
+        method_id="template-extractor+solver",
+        display_name="Template extractor → solver",
+        kind=MethodKind.TEXT_TO_SCHEMA,
+        evaluated=True,
+        version="or-bench-template-v1",
+        notes="Deterministic labeled-field parser, then CP-SAT. Not an LLM.",
+    ),
+    MethodSpec(
+        method_id="json-extractor+solver",
+        display_name="JSON extractor → solver",
+        kind=MethodKind.TEXT_TO_SCHEMA,
+        evaluated=True,
+        version="or-bench-json-v1",
+        notes="Parses a JSON object from the prompt, then CP-SAT.",
+    ),
+    MethodSpec(
+        method_id="naive-direct",
+        display_name="Naive direct answer (benchmark only)",
+        kind=MethodKind.DIRECT_ANSWER,
+        evaluated=True,
+        version="or-bench-naive-v1",
+        notes="Writes a sloppy numeric plan without a solver. Operational use is not allowed.",
+    ),
+)
+
+UNEVALUATED_MODELS = (
+    MethodSpec(
+        method_id="Qwen/Qwen3-4B-Instruct-2507",
+        display_name="Qwen3-4B-Instruct-2507",
+        kind=MethodKind.LLM_SCHEMA,
+        evaluated=False,
+        version="hub-card",
+        license="see model card",
+        reason_if_skipped="Paid/local LLM inference is off. No batch was run.",
+    ),
+    MethodSpec(
+        method_id="Qwen/Qwen3.8-27B",
+        display_name="Qwen3.8-27B",
+        kind=MethodKind.LLM_SCHEMA,
+        evaluated=False,
+        version="hub-card",
+        license="see model card",
+        reason_if_skipped="Not hosted on this CPU Space. No API batch.",
+    ),
+    MethodSpec(
+        method_id="moonshotai/Kimi-K3",
+        display_name="Kimi K3",
+        kind=MethodKind.LLM_SCHEMA,
+        evaluated=False,
+        version="hub-card",
+        license="see model card",
+        reason_if_skipped="API optional and disabled. Not evaluated.",
+    ),
+    MethodSpec(
+        method_id="zai-org/GLM-5.3",
+        display_name="GLM 5.3",
+        kind=MethodKind.LLM_SCHEMA,
+        evaluated=False,
+        version="hub-card",
+        license="see model card",
+        reason_if_skipped="API optional and disabled. Not evaluated.",
+    ),
+    MethodSpec(
+        method_id="deepseek-ai/DeepSeek-V4.1-Flash",
+        display_name="DeepSeek V4.1 Flash",
+        kind=MethodKind.LLM_SCHEMA,
+        evaluated=False,
+        version="hub-card",
+        license="see model card",
+        reason_if_skipped="API optional and disabled. Not evaluated.",
+    ),
+)
+
+
+def all_methods() -> list[MethodSpec]:
+    return list(EVALUATED_METHODS) + list(UNEVALUATED_MODELS)
+
+
+def evaluated_ids() -> list[str]:
+    return [item.method_id for item in EVALUATED_METHODS]
+
+
+def method_by_id(method_id: str) -> MethodSpec | None:
+    for item in all_methods():
+        if item.method_id == method_id:
+            return item
+    return None

demo/src/optimizer.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+from ortools.sat.python import cp_model
+
+from src.domain import (
+    AssignmentInstance,
+    AssignmentRow,
+    Family,
+    InventoryInstance,
+    InventoryOrder,
+    ScheduleInstance,
+    ScheduleStart,
+    Solution,
+    SolveStatus,
+    parse_instance,
+)
+
+
+@dataclass
+class SolverOutcome:
+    solution: Solution
+    seconds: float
+    solver_name: str
+    message: str
+
+
+def _status(model_status: int) -> SolveStatus:
+    if model_status == cp_model.OPTIMAL:
+        return SolveStatus.OPTIMAL
+    if model_status == cp_model.FEASIBLE:
+        return SolveStatus.FEASIBLE
+    if model_status == cp_model.INFEASIBLE:
+        return SolveStatus.INFEASIBLE
+    if model_status in {cp_model.UNKNOWN, cp_model.MODEL_INVALID}:
+        return SolveStatus.TIMEOUT
+    return SolveStatus.ERROR
+
+
+def _status_name(model_status: int) -> str:
+    names = {
+        cp_model.OPTIMAL: "OPTIMAL",
+        cp_model.FEASIBLE: "FEASIBLE",
+        cp_model.INFEASIBLE: "INFEASIBLE",
+        cp_model.UNKNOWN: "UNKNOWN",
+        cp_model.MODEL_INVALID: "MODEL_INVALID",
+    }
+    return names.get(model_status, str(model_status))
+
+
+def solve_inventory(instance: InventoryInstance, seconds: float, threads: int = 1) -> SolverOutcome:
+    started = time.perf_counter()
+    model = cp_model.CpModel()
+    periods = instance.periods
+    skus = instance.skus
+    order: dict[tuple[str, int], cp_model.IntVar] = {}
+    inv: dict[tuple[str, int], cp_model.IntVar] = {}
+    short: dict[tuple[str, int], cp_model.IntVar] = {}
+    sold: dict[tuple[str, int], cp_model.IntVar] = {}
+
+    max_demand = max((max(sku.demand) for sku in skus), default=1)
+    max_pack = max((sku.pack_size for sku in skus), default=1)
+    max_order = max(max_demand * periods + max_pack * 4, 1)
+
+    for sku in skus:
+        for t in range(1, periods + 1):
+            packs = model.NewIntVar(0, max_order // sku.pack_size + 1, f"packs_{sku.sku_id}_{t}")
+            qty = model.NewIntVar(0, max_order, f"ord_{sku.sku_id}_{t}")
+            model.Add(qty == packs * sku.pack_size)
+            order[(sku.sku_id, t)] = qty
+            inv[(sku.sku_id, t)] = model.NewIntVar(0, instance.warehouse_capacity, f"inv_{sku.sku_id}_{t}")
+            demand = int(sku.demand[t - 1])
+            short[(sku.sku_id, t)] = model.NewIntVar(0, demand, f"sh_{sku.sku_id}_{t}")
+            sold[(sku.sku_id, t)] = model.NewIntVar(0, demand, f"sd_{sku.sku_id}_{t}")
+            prev = sku.initial_stock if t == 1 else inv[(sku.sku_id, t - 1)]
+            model.Add(inv[(sku.sku_id, t)] + sold[(sku.sku_id, t)] == prev + qty)
+            model.Add(sold[(sku.sku_id, t)] + short[(sku.sku_id, t)] == demand)
+            if instance.cover_required:
+                model.Add(short[(sku.sku_id, t)] == 0)
+
+    for t in range(1, periods + 1):
+        model.Add(sum(inv[(sku.sku_id, t)] for sku in skus) <= instance.warehouse_capacity)
+
+    model.Add(
+        sum(sku.unit_cost * order[(sku.sku_id, t)] for sku in skus for t in range(1, periods + 1)) <= instance.budget
+    )
+
+    objective = []
+    for sku in skus:
+        for t in range(1, periods + 1):
+            objective.append(sku.unit_cost * order[(sku.sku_id, t)])
+            objective.append(sku.holding_cost * inv[(sku.sku_id, t)])
+            objective.append(sku.shortage_cost * short[(sku.sku_id, t)])
+    model.Minimize(sum(objective))
+
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = float(seconds)
+    solver.parameters.num_search_workers = int(threads)
+    raw = solver.Solve(model)
+    status = _status(raw)
+    elapsed = time.perf_counter() - started
+    message = _status_name(raw)
+    if status in {SolveStatus.OPTIMAL, SolveStatus.FEASIBLE}:
+        orders = [
+            InventoryOrder(sku_id=sku.sku_id, period=t, qty=int(solver.Value(order[(sku.sku_id, t)])))
+            for sku in skus
+            for t in range(1, periods + 1)
+        ]
+        obj = float(solver.ObjectiveValue())
+        bound = float(solver.BestObjectiveBound()) if status == SolveStatus.FEASIBLE else obj
+        return SolverOutcome(
+            Solution(
+                family=Family.INVENTORY,
+                status=status,
+                objective=obj,
+                bound=bound,
+                orders=orders,
+                message=message,
+            ),
+            elapsed,
+            "ortools-cpsat",
+            message,
+        )
+    return SolverOutcome(
+        Solution(family=Family.INVENTORY, status=status, message=message),
+        elapsed,
+        "ortools-cpsat",
+        message,
+    )
+
+
+def solve_assignment(instance: AssignmentInstance, seconds: float, threads: int = 1) -> SolverOutcome:
+    started = time.perf_counter()
+    model = cp_model.CpModel()
+    x: dict[tuple[str, str], cp_model.IntVar] = {}
+    costs = instance.cost_map()
+    for task in instance.tasks:
+        for agent in instance.agents:
+            if instance.eligible(task, agent) and (task.task_id, agent.agent_id) in costs:
+                x[(task.task_id, agent.agent_id)] = model.NewBoolVar(f"x_{task.task_id}_{agent.agent_id}")
+
+    unassigned: dict[str, cp_model.IntVar] = {}
+    for task in instance.tasks:
+        assigned = [x[(task.task_id, agent.agent_id)] for agent in instance.agents if (task.task_id, agent.agent_id) in x]
+        miss = model.NewBoolVar(f"u_{task.task_id}")
+        unassigned[task.task_id] = miss
+        model.Add(sum(assigned) + miss == 1)
+        if task.required:
+            model.Add(miss == 0)
+
+    for agent in instance.agents:
+        load = [
+            task.size * x[(task.task_id, agent.agent_id)]
+            for task in instance.tasks
+            if (task.task_id, agent.agent_id) in x
+        ]
+        if load:
+            model.Add(sum(load) <= agent.capacity)
+
+    obj_terms = []
+    for (task_id, agent_id), var in x.items():
+        obj_terms.append(costs[(task_id, agent_id)] * var)
+    for task in instance.tasks:
+        obj_terms.append(task.penalty * unassigned[task.task_id])
+    model.Minimize(sum(obj_terms) if obj_terms else 0)
+
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = float(seconds)
+    solver.parameters.num_search_workers = int(threads)
+    raw = solver.Solve(model)
+    status = _status(raw)
+    elapsed = time.perf_counter() - started
+    message = _status_name(raw)
+    if status in {SolveStatus.OPTIMAL, SolveStatus.FEASIBLE}:
+        rows = [
+            AssignmentRow(task_id=task_id, agent_id=agent_id)
+            for (task_id, agent_id), var in x.items()
+            if solver.Value(var)
+        ]
+        leftover = [task_id for task_id, var in unassigned.items() if solver.Value(var)]
+        obj = float(solver.ObjectiveValue())
+        bound = float(solver.BestObjectiveBound()) if status == SolveStatus.FEASIBLE else obj
+        return SolverOutcome(
+            Solution(
+                family=Family.ASSIGNMENT,
+                status=status,
+                objective=obj,
+                bound=bound,
+                assignments=rows,
+                unassigned=leftover,
+                message=message,
+            ),
+            elapsed,
+            "ortools-cpsat",
+            message,
+        )
+    return SolverOutcome(
+        Solution(family=Family.ASSIGNMENT, status=status, message=message),
+        elapsed,
+        "ortools-cpsat",
+        message,
+    )
+
+
+def solve_scheduling(instance: ScheduleInstance, seconds: float, threads: int = 1) -> SolverOutcome:
+    started = time.perf_counter()
+    model = cp_model.CpModel()
+    horizon = max(instance.horizon, sum(job.duration for job in instance.jobs) + max((job.release for job in instance.jobs), default=0) + 2)
+    intervals_by_machine: dict[str, list] = {machine: [] for machine in instance.machines}
+    start: dict[str, cp_model.IntVar] = {}
+    end: dict[str, cp_model.IntVar] = {}
+    tardy: dict[str, cp_model.IntVar] = {}
+    assign: dict[tuple[str, str], cp_model.IntVar] = {}
+
+    for job in instance.jobs:
+        start[job.job_id] = model.NewIntVar(job.release, horizon, f"s_{job.job_id}")
+        end[job.job_id] = model.NewIntVar(job.release + job.duration, horizon + job.duration, f"e_{job.job_id}")
+        model.Add(end[job.job_id] == start[job.job_id] + job.duration)
+        tardy[job.job_id] = model.NewIntVar(0, horizon + job.duration, f"tard_{job.job_id}")
+        model.Add(tardy[job.job_id] >= end[job.job_id] - job.due)
+        if job.hard_due:
+            model.Add(end[job.job_id] <= job.due)
+        eligible = [machine for machine in instance.machines if machine in set(job.machine_eligible)]
+        if not eligible:
+            eligible = list(instance.machines)
+        machine_bools = []
+        for machine in eligible:
+            flag = model.NewBoolVar(f"m_{job.job_id}_{machine}")
+            assign[(job.job_id, machine)] = flag
+            interval = model.NewOptionalIntervalVar(start[job.job_id], job.duration, end[job.job_id], flag, f"iv_{job.job_id}_{machine}")
+            intervals_by_machine[machine].append(interval)
+            machine_bools.append(flag)
+        model.AddExactlyOne(machine_bools)
+
+    for machine, intervals in intervals_by_machine.items():
+        if intervals:
+            model.AddNoOverlap(intervals)
+
+    job_ids = {job.job_id for job in instance.jobs}
+    for edge in instance.precedences:
+        if edge.before in job_ids and edge.after in job_ids:
+            model.Add(end[edge.before] <= start[edge.after])
+
+    makespan = model.NewIntVar(0, horizon + 8, "makespan")
+    for job in instance.jobs:
+        model.Add(makespan >= end[job.job_id])
+    model.Minimize(sum(job.weight * tardy[job.job_id] for job in instance.jobs) * 100 + makespan)
+
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = float(seconds)
+    solver.parameters.num_search_workers = int(threads)
+    raw = solver.Solve(model)
+    status = _status(raw)
+    elapsed = time.perf_counter() - started
+    message = _status_name(raw)
+    if status in {SolveStatus.OPTIMAL, SolveStatus.FEASIBLE}:
+        starts = []
+        for job in instance.jobs:
+            machine_id = next(machine for machine in instance.machines if (job.job_id, machine) in assign and solver.Value(assign[(job.job_id, machine)]))
+            starts.append(
+                ScheduleStart(
+                    job_id=job.job_id,
+                    machine_id=machine_id,
+                    start=int(solver.Value(start[job.job_id])),
+                    end=int(solver.Value(end[job.job_id])),
+                )
+            )
+        weighted = sum(job.weight * max(0, int(solver.Value(end[job.job_id])) - job.due) for job in instance.jobs)
+        obj = float(weighted)
+        return SolverOutcome(
+            Solution(
+                family=Family.SCHEDULING,
+                status=status,
+                objective=obj,
+                bound=obj if status == SolveStatus.OPTIMAL else None,
+                starts=starts,
+                message=message,
+            ),
+            elapsed,
+            "ortools-cpsat",
+            message,
+        )
+    return SolverOutcome(
+        Solution(family=Family.SCHEDULING, status=status, message=message),
+        elapsed,
+        "ortools-cpsat",
+        message,
+    )
+
+
+def solve_instance(family: Family | str, payload: dict, seconds: float, threads: int = 1) -> SolverOutcome:
+    family = Family(family)
+    instance = parse_instance(family, payload)
+    if family == Family.INVENTORY:
+        return solve_inventory(instance, seconds, threads)
+    if family == Family.ASSIGNMENT:
+        return solve_assignment(instance, seconds, threads)
+    return solve_scheduling(instance, seconds, threads)

demo/src/pipeline.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from src.baseline import run_heuristic, run_naive
+from src.budget_guard import skip_reason
+from src.domain import (
+    CODE_VERSION,
+    DEFAULT_SEED,
+    DEFAULT_SOLVER_SECONDS,
+    PROTOCOL_ID,
+    SOLVER_NAME,
+    ConstraintConfig,
+    EvalRow,
+    Family,
+    ProblemRecord,
+    PromptVariant,
+    Solution,
+    SolveStatus,
+)
+from src.explain import status_label
+from src.extractor import constraint_fidelity, drop_constraint, extract_json, extract_template
+from src.generator import INTERACTIVE_IDS, generate_catalog, load_catalog
+from src.metrics import row_from_run, skipped_rows, summarize
+from src.model_registry import REGISTRY_VERSION, method_by_id
+from src.optimizer import solve_instance
+from src.validation import format_input_error, validate_schema, validate_solution
+
+ROOT = Path(__file__).resolve().parents[1]
+CATALOG_PATH = ROOT / "examples" / "problems.jsonl"
+RESULTS_PATH = ROOT / "examples" / "results.jsonl"
+
+
+def _input_hash(payload: dict) -> str:
+    raw = json.dumps(payload, sort_keys=True, ensure_ascii=False)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
+
+
+def load_problems(path: Path | None = None) -> list[ProblemRecord]:
+    return load_catalog(path or CATALOG_PATH if (path or CATALOG_PATH).exists() else None)
+
+
+def load_results(path: Path | None = None) -> pd.DataFrame:
+    target = path or RESULTS_PATH
+    if not target.exists():
+        return pd.DataFrame()
+    rows = [json.loads(line) for line in target.read_text(encoding="utf-8").splitlines() if line.strip()]
+    return pd.DataFrame(rows)
+
+
+def interactive_problems(problems: list[ProblemRecord] | None = None) -> list[ProblemRecord]:
+    problems = problems or load_problems()
+    chosen = [item for item in problems if item.interactive]
+    if len(chosen) < 5:
+        chosen = problems[:20]
+    return chosen
+
+
+def problem_by_id(problem_id: str, problems: list[ProblemRecord] | None = None) -> ProblemRecord:
+    problems = problems or load_problems()
+    for item in problems:
+        if item.problem_id == problem_id:
+            return item
+    raise KeyError(problem_id)
+
+
+def _prompt_for(problem: ProblemRecord, lang: str, variant: PromptVariant) -> str:
+    if variant == PromptVariant.JSON:
+        return problem.prompt_json
+    text = problem.prompt_fa if lang == "fa" else problem.prompt_en
+    if variant == PromptVariant.MISSING_BUDGET:
+        _, text = drop_constraint(problem.family, problem.schema_payload, text)
+    return text
+
+
+def _evaluate_solver(problem: ProblemRecord, payload: dict, seconds: float, threads: int, method_id: str, method_kind: str, parse_success: bool | None, fidelity: float | None, notes: str) -> EvalRow:
+    schema = validate_schema(problem.family, payload)
+    if not schema.ok:
+        return row_from_run(
+            problem,
+            method_id,
+            method_kind,
+            False if parse_success is None else parse_success,
+            fidelity,
+            SolveStatus.INVALID.value,
+            False,
+            None,
+            0.0,
+            schema.failed_codes(),
+            format_input_error(schema),
+        )
+    outcome = solve_instance(problem.family, payload, seconds=seconds, threads=threads)
+    solution = outcome.solution
+    if solution.status == SolveStatus.INFEASIBLE:
+        feasible = False
+        violated: list[str] = ["infeasible"]
+        objective = None
+        report_notes = solution.message
+    elif solution.status in {SolveStatus.TIMEOUT, SolveStatus.ERROR}:
+        feasible = None
+        violated = [solution.status.value]
+        objective = None
+        report_notes = solution.message
+    else:
+        report = validate_solution(problem.family, payload, solution)
+        feasible = report.ok
+        violated = report.failed_codes()
+        objective = report.recomputed_objective if report.recomputed_objective is not None else solution.objective
+        report_notes = notes or solution.message
+        if not report.ok:
+            solution.status = SolveStatus.INVALID
+    return row_from_run(
+        problem,
+        method_id,
+        method_kind,
+        True if parse_success is None else parse_success,
+        fidelity,
+        solution.status.value,
+        feasible,
+        objective,
+        outcome.seconds,
+        violated,
+        report_notes,
+    )
+
+
+def _evaluate_direct(problem: ProblemRecord, payload: dict, solution: Solution, seconds: float, method_id: str, notes: str) -> EvalRow:
+    report = validate_solution(problem.family, payload, solution)
+    return row_from_run(
+        problem,
+        method_id,
+        "direct-answer",
+        True,
+        1.0,
+        SolveStatus.HEURISTIC.value if report.ok else SolveStatus.INVALID.value,
+        report.ok,
+        report.recomputed_objective,
+        seconds,
+        report.failed_codes(),
+        notes,
+    )
+
+
+def evaluate_problem(
+    problem: ProblemRecord,
+    lang: str = "en",
+    variant: PromptVariant | str = PromptVariant.TEMPLATE,
+    config: ConstraintConfig | None = None,
+    custom_text: str | None = None,
+    custom_schema: dict | None = None,
+    custom_solution: dict | None = None,
+) -> dict[str, Any]:
+    started = time.perf_counter()
+    config = config or ConstraintConfig()
+    variant = PromptVariant(variant)
+    prompt = custom_text if custom_text else _prompt_for(problem, lang, variant)
+    payload = custom_schema or problem.schema_payload
+    rows: list[EvalRow] = []
+
+    structured_payload = payload
+    rows.append(
+        _evaluate_solver(
+            problem,
+            structured_payload,
+            config.solver_seconds,
+            config.threads,
+            "structured-solver",
+            "structured-solver",
+            True,
+            1.0,
+            "schema entered the solver without an LLM",
+        )
+    )
+
+    heuristic = run_heuristic(problem.family, payload)
+    heur_report = validate_solution(problem.family, payload, heuristic.solution)
+    rows.append(
+        row_from_run(
+            problem,
+            "heuristic",
+            "heuristic",
+            True,
+            1.0,
+            SolveStatus.HEURISTIC.value if heur_report.ok else SolveStatus.INVALID.value,
+            heur_report.ok,
+            heur_report.recomputed_objective,
+            heuristic.seconds,
+            heur_report.failed_codes(),
+            heuristic.message,
+        )
+    )
+
+    json_payload = extract_json(prompt) or extract_json(problem.prompt_json)
+    json_ok = json_payload is not None
+    json_fid = constraint_fidelity(problem.family, problem.schema_payload, json_payload)
+    if json_ok:
+        rows.append(
+            _evaluate_solver(
+                problem,
+                json_payload,
+                config.solver_seconds,
+                config.threads,
+                "json-extractor+solver",
+                "text-to-schema",
+                True,
+                json_fid,
+                "JSON extracted from the prompt",
+            )
+        )
+    else:
+        rows.append(
+            row_from_run(
+                problem,
+                "json-extractor+solver",
+                "text-to-schema",
+                False,
+                0.0,
+                SolveStatus.INVALID.value,
+                False,
+                None,
+                0.0,
+                ["parse"],
+                "no JSON object found",
+            )
+        )
+
+    tmpl_payload = extract_template(prompt, problem.family)
+    tmpl_ok = tmpl_payload is not None
+    tmpl_fid = constraint_fidelity(problem.family, problem.schema_payload, tmpl_payload)
+    if tmpl_ok:
+        rows.append(
+            _evaluate_solver(
+                problem,
+                tmpl_payload,
+                config.solver_seconds,
+                config.threads,
+                "template-extractor+solver",
+                "text-to-schema",
+                True,
+                tmpl_fid,
+                "labeled fields or SCHEMA_BEGIN block",
+            )
+        )
+    else:
+        rows.append(
+            row_from_run(
+                problem,
+                "template-extractor+solver",
+                "text-to-schema",
+                False,
+                0.0,
+                SolveStatus.INVALID.value,
+                False,
+                None,
+                0.0,
+                ["parse"],
+                "template extractor found no labeled schema",
+            )
+        )
+
+    naive = run_naive(problem.family, payload)
+    rows.append(_evaluate_direct(problem, payload, naive.solution, naive.seconds, "naive-direct", naive.message))
+
+    if custom_solution:
+        try:
+            proposed = Solution.model_validate(custom_solution)
+            rows.append(_evaluate_direct(problem, payload, proposed, 0.0, "user-direct", "user-supplied direct answer"))
+        except Exception as exc:
+            rows.append(
+                row_from_run(
+                    problem,
+                    "user-direct",
+                    "direct-answer",
+                    True,
+                    1.0,
+                    SolveStatus.INVALID.value,
+                    False,
+                    None,
+                    0.0,
+                    ["schema"],
+                    f"direct answer rejected: {exc}",
+                )
+            )
+
+    rows.extend(skipped_rows(problem))
+    structured = next(row for row in rows if row.method_id == "structured-solver")
+    report = None
+    live_solution = None
+    if structured.status in {SolveStatus.OPTIMAL.value, SolveStatus.FEASIBLE.value, SolveStatus.HEURISTIC.value}:
+        live = solve_instance(problem.family, structured_payload, seconds=config.solver_seconds, threads=config.threads)
+        live_solution = live.solution
+        report = validate_solution(problem.family, structured_payload, live.solution)
+
+    elapsed = time.perf_counter() - started
+    run_id = f"orbench-{uuid.uuid4().hex[:10]}"
+    table = pd.DataFrame([row.model_dump() for row in rows])
+    return {
+        "run_id": run_id,
+        "error": None,
+        "problem": problem,
+        "prompt": prompt,
+        "variant": variant.value,
+        "schema": structured_payload,
+        "rows": rows,
+        "table": table,
+        "summary": summarize(rows),
+        "solution": live_solution.as_dict() if live_solution else {},
+        "validation": report,
+        "status": structured.status,
+        "status_label": status_label(structured.status, lang),
+        "seconds": elapsed,
+        "report": build_report(run_id, problem, rows, structured_payload, elapsed, lang, variant.value),
+    }
+
+
+def build_report(run_id: str, problem: ProblemRecord, rows: list[EvalRow], payload: dict, seconds: float, lang: str, variant: str) -> dict[str, Any]:
+    return {
+        "run_id": run_id,
+        "protocol_id": PROTOCOL_ID,
+        "code_version": CODE_VERSION,
+        "registry_version": REGISTRY_VERSION,
+        "solver_version": SOLVER_NAME,
+        "input_hash": _input_hash(payload),
+        "seed": problem.seed,
+        "problem_id": problem.problem_id,
+        "family": problem.family.value,
+        "split": problem.split.value,
+        "language": lang,
+        "prompt_variant": variant,
+        "gold_status": problem.gold_status,
+        "gold_objective": problem.gold_objective,
+        "seconds": seconds,
+        "budget_note": skip_reason(),
+        "rows": [row.model_dump() for row in rows],
+    }
+
+
+def evaluate_catalog(
+    problems: list[ProblemRecord] | None = None,
+    config: ConstraintConfig | None = None,
+    lang: str = "en",
+) -> list[EvalRow]:
+    problems = problems or generate_catalog(DEFAULT_SEED)
+    config = config or ConstraintConfig(solver_seconds=DEFAULT_SOLVER_SECONDS)
+    rows: list[EvalRow] = []
+    for problem in problems:
+        result = evaluate_problem(problem, lang=problem.language, config=config)
+        for row in result["rows"]:
+            row.precomputed = True
+            rows.append(row)
+    return rows
+
+
+def result_to_downloads(result: dict[str, Any], folder: Path) -> dict[str, str]:
+    folder.mkdir(parents=True, exist_ok=True)
+    run_id = result["run_id"]
+    files = {}
+    table: pd.DataFrame = result["table"]
+    csv_path = folder / f"{run_id}_comparison.csv"
+    table.to_csv(csv_path, index=False)
+    files["comparison"] = str(csv_path)
+    report_path = folder / f"{run_id}_report.json"
+    report_path.write_text(json.dumps(result["report"], indent=2, ensure_ascii=False), encoding="utf-8")
+    files["report"] = str(report_path)
+    if result.get("summary") is not None and len(result["summary"]):
+        summary_path = folder / f"{run_id}_summary.csv"
+        result["summary"].to_csv(summary_path, index=False)
+        files["summary"] = str(summary_path)
+    schema_path = folder / f"{run_id}_schema.json"
+    schema_path.write_text(json.dumps(result["schema"], indent=2, ensure_ascii=False), encoding="utf-8")
+    files["schema"] = str(schema_path)
+    return files
+
+
+def load_sample() -> dict[str, Any]:
+    problems = load_problems()
+    sample = next((item for item in problems if item.problem_id == INTERACTIVE_IDS[0]), problems[0])
+    return {"problem": sample, "problems": problems}

demo/src/plots.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import pandas as pd
+import plotly.graph_objects as go
+
+from src.domain import Family, not_evaluated_cell
+from src.i18n import t
+
+
+def empty_plot(title: str = "—") -> go.Figure:
+    fig = go.Figure()
+    fig.update_layout(template="plotly_white", height=380, title=title, margin=dict(l=40, r=20, t=50, b=40))
+    return fig
+
+
+def kpi_html(kpis: dict, lang: str = "en") -> str:
+    gap = kpis.get("heuristic_gap")
+    fidelity = kpis.get("template_fidelity")
+    cards = [
+        (t(lang, "kpi_n"), f"{kpis.get('n_problems', 0):.0f}", t(lang, "kpi_n_sub")),
+        (t(lang, "kpi_feas"), f"{100 * float(kpis.get('structured_feasible') or 0):.0f}%", t(lang, "kpi_feas_sub")),
+        (t(lang, "kpi_gap"), "—" if gap is None else f"{100 * float(gap):.1f}%", t(lang, "kpi_gap_sub")),
+        (t(lang, "kpi_fid"), "—" if fidelity is None else f"{100 * float(fidelity):.0f}%", t(lang, "kpi_fid_sub")),
+        (t(lang, "kpi_eval"), f"{kpis.get('n_methods_evaluated', 0):.0f}/{kpis.get('n_methods_listed', 0):.0f}", t(lang, "kpi_eval_sub")),
+    ]
+    blocks = []
+    for label, value, sub in cards:
+        blocks.append(
+            f"<article class='kpi-card'><p class='kpi-label'>{label}</p>"
+            f"<p class='kpi-value'>{value}</p><p class='kpi-sub'>{sub}</p></article>"
+        )
+    return f"<div class='kpi-grid'>{''.join(blocks)}</div>"
+
+
+def method_bars(summary: pd.DataFrame, title: str) -> go.Figure:
+    if summary is None or summary.empty:
+        return empty_plot(title)
+    live = summary.loc[summary["evaluated"] == True]  # noqa: E712
+    if live.empty:
+        return empty_plot(title)
+    fig = go.Figure()
+    fig.add_bar(name="feasible", x=live["method_id"], y=live["feasible_rate"].fillna(0))
+    fig.add_bar(name="parse", x=live["method_id"], y=live["parse_rate"].fillna(0))
+    fig.update_layout(
+        template="plotly_white",
+        barmode="group",
+        height=400,
+        title=title,
+        yaxis=dict(range=[0, 1], title="rate"),
+        legend=dict(orientation="h"),
+        margin=dict(l=40, r=20, t=50, b=80),
+    )
+    return fig
+
+
+def family_bars(family_tbl: pd.DataFrame, title: str) -> go.Figure:
+    if family_tbl is None or family_tbl.empty:
+        return empty_plot(title)
+    fig = go.Figure()
+    for method_id, group in family_tbl.groupby("method_id"):
+        fig.add_bar(name=str(method_id), x=group["family"], y=group["feasible_rate"].fillna(0))
+    fig.update_layout(
+        template="plotly_white",
+        barmode="group",
+        height=400,
+        title=title,
+        yaxis=dict(range=[0, 1], title="feasible rate"),
+        legend=dict(orientation="h"),
+        margin=dict(l=40, r=20, t=50, b=40),
+    )
+    return fig
+
+
+def schedule_gantt(solution: dict, title: str) -> go.Figure:
+    starts = (solution or {}).get("starts") or []
+    if not starts:
+        return empty_plot(title)
+    fig = go.Figure()
+    colors = ["#2563eb", "#0f766e", "#7c3aed", "#b45309", "#db2777", "#334155"]
+    for idx, row in enumerate(starts):
+        fig.add_bar(
+            x=[int(row["end"]) - int(row["start"])],
+            y=[row["machine_id"]],
+            base=[int(row["start"])],
+            orientation="h",
+            marker_color=colors[idx % len(colors)],
+            name=row["job_id"],
+            text=row["job_id"],
+            textposition="inside",
+            hovertemplate=f"{row['job_id']} {row['start']}-{row['end']}<extra></extra>",
+        )
+    fig.update_layout(template="plotly_white", height=360, title=title, barmode="stack", showlegend=False)
+    return fig
+
+
+def inventory_orders(solution: dict, title: str) -> go.Figure:
+    orders = (solution or {}).get("orders") or []
+    if not orders:
+        return empty_plot(title)
+    frame = pd.DataFrame(orders)
+    fig = go.Figure()
+    for sku_id, group in frame.groupby("sku_id"):
+        fig.add_bar(name=str(sku_id), x=group["period"].astype(str), y=group["qty"])
+    fig.update_layout(template="plotly_white", barmode="group", height=360, title=title)
+    return fig
+
+
+def assignment_table_plot(solution: dict, title: str) -> go.Figure:
+    rows = (solution or {}).get("assignments") or []
+    if not rows:
+        return empty_plot(title)
+    fig = go.Figure(
+        data=[
+            go.Table(
+                header=dict(values=["task_id", "agent_id"], fill_color="#e0e7ff"),
+                cells=dict(values=[[row["task_id"] for row in rows], [row["agent_id"] for row in rows]]),
+            )
+        ]
+    )
+    fig.update_layout(template="plotly_white", height=320, title=title)
+    return fig
+
+
+def solution_plot(family: str, solution: dict, title: str) -> go.Figure:
+    if family == Family.SCHEDULING.value:
+        return schedule_gantt(solution, title)
+    if family == Family.INVENTORY.value:
+        return inventory_orders(solution, title)
+    return assignment_table_plot(solution, title)
+
+
+def format_leaderboard(frame: pd.DataFrame) -> pd.DataFrame:
+    if frame is None or frame.empty:
+        return pd.DataFrame()
+    show = frame.copy()
+    for col in ("parse_success", "feasible", "constraint_fidelity", "optimality_gap", "objective", "cost_usd"):
+        if col in show.columns:
+            show[col] = show[col].apply(lambda value: not_evaluated_cell() if pd.isna(value) else value)
+    uneval = show["evaluated"] == False  # noqa: E712
+    if "status" in show.columns:
+        show.loc[uneval, "status"] = not_evaluated_cell()
+    return show

demo/src/ui.py

@@ -0,0 +1,470 @@
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+from zipfile import ZipFile
+
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+
+from src.domain import DEFAULT_SOLVER_SECONDS, ConstraintConfig, PromptVariant
+from src.explain import numeric_reasons, status_label
+from src.i18n import TEXTS, t
+from src.metrics import family_summary, kpi_snapshot, summarize
+from src.model_registry import all_methods
+from src.pipeline import (
+    evaluate_problem,
+    interactive_problems,
+    load_problems,
+    load_results,
+    load_sample,
+    problem_by_id,
+    result_to_downloads,
+)
+from src.plots import empty_plot, family_bars, format_leaderboard, kpi_html, method_bars, solution_plot
+from src.validation import ValidationReport
+
+ROOT = Path(__file__).resolve().parents[1]
+SAMPLE_PREVIEW = ROOT / "examples" / "sample_preview.json"
+CSS = """
+.gradio-container {max-width: 1280px !important; margin: 0 auto;}
+.dark .gradio-container {color: var(--body-text-color);}
+.aria-header h1 {margin-bottom: 0.2rem;}
+.aria-header p {opacity: 0.85;}
+.kpi-grid {display:grid; grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); gap: 12px;}
+.kpi-card {background: linear-gradient(180deg, #eef2ff, #ffffff); border: 1px solid #c7d2fe; border-radius: 16px; padding: 14px 16px;}
+.kpi-label {font-size: 0.8rem; color: #3730a3; margin: 0;}
+.kpi-value {font-size: 1.55rem; font-weight: 700; color: #312e81; margin: 4px 0;}
+.kpi-sub {margin: 0; font-size: 0.78rem; color: #334155;}
+.rtl-mode {direction: rtl; text-align: right;}
+"""
+
+
+def _preview_payload() -> dict:
+    if SAMPLE_PREVIEW.exists():
+        return json.loads(SAMPLE_PREVIEW.read_text(encoding="utf-8"))
+    return {}
+
+
+def _empty_plot() -> go.Figure:
+    return empty_plot("—")
+
+
+def _variant_choices(lang: str) -> list[str]:
+    return [t(lang, "template"), t(lang, "json"), t(lang, "missing")]
+
+
+def _parse_variant(value: str) -> PromptVariant:
+    if value in {PromptVariant.JSON.value, t("en", "json"), t("fa", "json")}:
+        return PromptVariant.JSON
+    if value in {PromptVariant.MISSING_BUDGET.value, t("en", "missing"), t("fa", "missing")}:
+        return PromptVariant.MISSING_BUDGET
+    return PromptVariant.TEMPLATE
+
+
+def _problem_choices() -> list[str]:
+    return [item.problem_id for item in interactive_problems()]
+
+
+def apply_language(lang: str):
+    rtl = lang == "fa"
+    preview = _preview_payload()
+    header = (
+        f"<div class='aria-header {'rtl-mode' if rtl else ''}'>"
+        f"<h1>{t(lang, 'title')}</h1><p>{t(lang, 'subtitle')}</p><p>{t(lang, 'kind')}</p></div>"
+    )
+    return (
+        gr.update(value=header),
+        gr.update(value=t(lang, "run_sample")),
+        gr.update(value=t(lang, "cancel")),
+        gr.update(value=t(lang, "reset")),
+        gr.update(value=t(lang, "load_sample")),
+        gr.update(label=t(lang, "problem")),
+        gr.update(label=t(lang, "variant"), choices=_variant_choices(lang), value=_variant_choices(lang)[0]),
+        gr.update(label=t(lang, "time_limit")),
+        gr.update(value=t(lang, "sample_note")),
+        gr.update(value=preview.get("kpi_html", "")),
+        gr.update(open=False, label=t(lang, "advanced")),
+        gr.update(value=t(lang, "method_body"), rtl=rtl),
+        gr.update(value=t(lang, "upload_hint")),
+        gr.update(label=t(lang, "custom_text")),
+        gr.update(label=t(lang, "custom_schema")),
+        gr.update(label=t(lang, "direct_json")),
+    )
+
+
+def _load_problem_fields(problem_id: str):
+    problem = problem_by_id(problem_id)
+    return (
+        problem.prompt_en,
+        problem.prompt_fa,
+        problem.prompt_json,
+        json.dumps(problem.schema_payload, indent=2, ensure_ascii=False),
+        problem.gold_status,
+        problem.gold_objective,
+        problem.family.value,
+        problem.split.value,
+        problem.difficulty.value,
+        problem.language,
+        problem.template_id,
+    )
+
+
+def load_sample_ui():
+    ids = _problem_choices()
+    fields = _load_problem_fields(ids[0])
+    return (ids[0], *fields)
+
+
+def run_live(lang, problem_id, variant, time_limit, custom_text, schema_text, direct_text):
+    problem = problem_by_id(problem_id)
+    schema = None
+    if schema_text and str(schema_text).strip():
+        try:
+            schema = json.loads(schema_text)
+        except json.JSONDecodeError as exc:
+            raise gr.Error(f"schema JSON: {exc}") from exc
+    direct = None
+    if direct_text and str(direct_text).strip():
+        try:
+            direct = json.loads(direct_text)
+        except json.JSONDecodeError as exc:
+            raise gr.Error(f"direct-answer JSON: {exc}") from exc
+    result = evaluate_problem(
+        problem,
+        lang=lang,
+        variant=_parse_variant(variant),
+        config=ConstraintConfig(solver_seconds=float(time_limit)),
+        custom_text=custom_text or None,
+        custom_schema=schema,
+        custom_solution=direct,
+    )
+    if result.get("error"):
+        raise gr.Error(result["error"])
+    validation: ValidationReport | None = result["validation"]
+    reasons = "\n".join(f"- {line}" for line in numeric_reasons(problem, result["rows"], validation, lang))
+    kpis = kpi_snapshot(result["table"])
+    status = (
+        f"**{t(lang, 'status')}:** {result['status_label']}\n\n"
+        f"{t(lang, 'live_note')}\n\n"
+        f"Gold `{problem.gold_status}` / {problem.gold_objective}. Validator "
+        f"{'ok' if validation is None or validation.ok else 'failed'}."
+    )
+    tmp = Path(tempfile.mkdtemp(prefix="orbench-"))
+    files = result_to_downloads(result, tmp)
+    zip_path = tmp / f"{result['run_id']}_tables.zip"
+    with ZipFile(zip_path, "w") as zipped:
+        for key, path in files.items():
+            zipped.write(path, arcname=Path(path).name)
+    live_table = format_leaderboard(result["table"])
+    summary = result["summary"]
+    fam = family_summary(result["table"])
+    plot = solution_plot(problem.family.value, result.get("solution") or {}, t(lang, "sol_plot"))
+    method_fig = method_bars(summary, t(lang, "method_plot"))
+    family_fig = family_bars(fam, t(lang, "family_plot"))
+    violated = pd.DataFrame(
+        [{"method_id": row.method_id, "status": row.status, "violated": ", ".join(row.violated), "notes": row.notes} for row in result["rows"]]
+    )
+    facts = pd.DataFrame(
+        [
+            {"field": "family", "value": problem.family.value},
+            {"field": "split", "value": problem.split.value},
+            {"field": "difficulty", "value": problem.difficulty.value},
+            {"field": "template_id", "value": problem.template_id},
+            {"field": "gold_status", "value": problem.gold_status},
+            {"field": "gold_objective", "value": problem.gold_objective},
+            {"field": "cover_or_hard", "value": str(problem.schema_payload.get("cover_required") or "")},
+        ]
+    )
+    return (
+        kpi_html(kpis, lang),
+        status,
+        reasons,
+        live_table,
+        summary,
+        violated,
+        facts,
+        plot,
+        method_fig,
+        family_fig,
+        str(zip_path),
+        files["report"],
+        result["prompt"],
+        json.dumps(result["schema"], indent=2, ensure_ascii=False),
+    )
+
+
+def filter_catalog(family, split, language, difficulty, evaluated_only):
+    frame = load_results()
+    if frame.empty:
+        return pd.DataFrame(), pd.DataFrame(), _empty_plot(), _empty_plot()
+    view = frame.copy()
+    if family and family != "all":
+        view = view.loc[view["family"] == family]
+    if split and split != "all":
+        view = view.loc[view["split"] == split]
+    if language and language != "all":
+        view = view.loc[view["language"] == language]
+    if difficulty and difficulty != "all":
+        view = view.loc[view["difficulty"] == difficulty]
+    if evaluated_only:
+        view = view.loc[view["evaluated"] == True]  # noqa: E712
+    summary = summarize(view)
+    fam = family_summary(view)
+    return format_leaderboard(view), summary, method_bars(summary, "Filtered methods"), family_bars(fam, "Filtered families")
+
+
+def compare_interactive(lang, time_limit):
+    rows = []
+    for problem in interactive_problems():
+        result = evaluate_problem(problem, lang=lang, config=ConstraintConfig(solver_seconds=min(6.0, float(time_limit))))
+        for row in result["rows"]:
+            if row.method_id in {"structured-solver", "heuristic", "template-extractor+solver"}:
+                rows.append(row.model_dump())
+    frame = pd.DataFrame(rows)
+    return format_leaderboard(frame), summarize(frame)
+
+
+def registry_table() -> pd.DataFrame:
+    return pd.DataFrame(
+        [
+            {
+                "method_id": item.method_id,
+                "kind": item.kind.value,
+                "evaluated": item.evaluated,
+                "version": item.version,
+                "notes": item.notes or item.reason_if_skipped,
+            }
+            for item in all_methods()
+        ]
+    )
+
+
+def solve_sample_api():
+    pack = load_sample()
+    result = evaluate_problem(pack["problem"], lang="en", config=ConstraintConfig(solver_seconds=6))
+    structured = result["table"].loc[result["table"]["method_id"] == "structured-solver"].iloc[0]
+    return result["status"], float(structured.get("feasible") or 0), float(structured.get("objective") or 0), float(result["seconds"])
+
+
+def build_demo() -> gr.Blocks:
+    pack = load_sample()
+    preview = _preview_payload()
+    ids = _problem_choices()
+    recorded = load_results()
+    preview_kpis = preview.get("kpis") or kpi_snapshot(recorded) if not recorded.empty else {
+        "n_problems": 100,
+        "structured_feasible": 0.0,
+        "heuristic_gap": None,
+        "template_fidelity": None,
+        "n_methods_evaluated": 5,
+        "n_methods_listed": 10,
+    }
+
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="purple"), css=CSS) as demo:
+        lang = gr.Radio(["en", "fa"], value="en", label=TEXTS["en"]["language"])
+        header = gr.HTML()
+        with gr.Row():
+            run_btn = gr.Button(t("en", "run_sample"), variant="primary")
+            cancel_btn = gr.Button(t("en", "cancel"), variant="stop")
+            reset_btn = gr.Button(t("en", "reset"))
+            load_btn = gr.Button(t("en", "load_sample"))
+        note = gr.Markdown(t("en", "sample_note"))
+        kpis = gr.HTML(preview.get("kpi_html") or kpi_html(preview_kpis, "en"))
+        status = gr.Markdown(t("en", "empty"))
+
+        with gr.Tabs():
+            with gr.Tab("Data"):
+                hint = gr.Markdown(t("en", "upload_hint"))
+                problem = gr.Dropdown(choices=ids, value=ids[0] if ids else None, label=t("en", "problem"))
+                with gr.Row():
+                    prompt_en = gr.Textbox(value=pack["problem"].prompt_en, label="prompt_en", lines=8)
+                    prompt_fa = gr.Textbox(value=pack["problem"].prompt_fa, label="prompt_fa", lines=8)
+                prompt_json = gr.Code(value=pack["problem"].prompt_json, language="json", label="prompt_json")
+                custom_text = gr.Textbox(label=t("en", "custom_text"), lines=4)
+                schema_text = gr.Code(
+                    value=json.dumps(pack["problem"].schema_payload, indent=2, ensure_ascii=False),
+                    language="json",
+                    label=t("en", "custom_schema"),
+                )
+                direct_text = gr.Textbox(label=t("en", "direct_json"), lines=4, placeholder='{"orders":[],"assignments":[],"starts":[]}')
+
+            with gr.Tab("Constraints"):
+                variant = gr.Radio(choices=_variant_choices("en"), value=_variant_choices("en")[0], label=t("en", "variant"))
+                with gr.Accordion(t("en", "advanced"), open=False) as advanced:
+                    time_limit = gr.Slider(3, 20, value=DEFAULT_SOLVER_SECONDS, step=1, label=t("en", "time_limit"))
+                facts = gr.Dataframe(
+                    value=pd.DataFrame(
+                        [
+                            {"field": "family", "value": pack["problem"].family.value},
+                            {"field": "gold_status", "value": pack["problem"].gold_status},
+                            {"field": "gold_objective", "value": pack["problem"].gold_objective},
+                        ]
+                    ),
+                    label="Instance facts",
+                )
+                meta = gr.Markdown(
+                    f"family `{pack['problem'].family.value}` · split `{pack['problem'].split.value}` · "
+                    f"difficulty `{pack['problem'].difficulty.value}` · template `{pack['problem'].template_id}`"
+                )
+
+            with gr.Tab("Results"):
+                reasons = gr.Markdown()
+                live_table = gr.Dataframe(label="Per-method cells (not_evaluated is not a score)")
+                violated = gr.Dataframe(label="Violated constraints / skip reasons")
+                sol_plot = gr.Plot(value=_empty_plot())
+                method_plot = gr.Plot(value=_empty_plot())
+                live_summary = gr.Dataframe(label="Evaluated-method summary")
+                with gr.Row():
+                    zip_out = gr.File(label="CSV / JSON bundle")
+                    json_out = gr.File(label="JSON report")
+
+            with gr.Tab("Scenario comparison"):
+                with gr.Row():
+                    family_f = gr.Dropdown(["all", "inventory", "assignment", "scheduling"], value="all", label="family")
+                    split_f = gr.Dropdown(["all", "development", "test"], value="all", label="split")
+                    lang_f = gr.Dropdown(["all", "en", "fa"], value="all", label="prompt language")
+                    diff_f = gr.Dropdown(["all", "easy", "medium", "hard", "infeasible"], value="all", label="difficulty")
+                    eval_only = gr.Checkbox(value=False, label="hide not_evaluated rows")
+                filter_btn = gr.Button("Filter recorded catalog")
+                compare_btn = gr.Button("Re-run 20 interactive problems")
+                board = gr.Dataframe(label="Recorded leaderboard", value=format_leaderboard(recorded) if not recorded.empty else None)
+                board_summary = gr.Dataframe(label="Catalog summary")
+                family_plot = gr.Plot(value=_empty_plot())
+                catalog_plot = gr.Plot(value=_empty_plot())
+                interactive_tbl = gr.Dataframe(label="Interactive re-run")
+                interactive_sum = gr.Dataframe(label="Interactive summary")
+
+            with gr.Tab("Method and limits"):
+                method = gr.Markdown(t("en", "method_body"))
+                registry = gr.Dataframe(value=registry_table(), label="Versioned method registry")
+                gr.Markdown(
+                    "Organization: [AriaAICompany](https://huggingface.co/AriaAICompany) · "
+                    "Dataset: [or-bench-problems](https://huggingface.co/datasets/AriaAICompany/or-bench-problems) · "
+                    "Site: [aria-ai.ir](https://aria-ai.ir/)"
+                )
+
+        hidden_gold_status = gr.Textbox(visible=False, value=pack["problem"].gold_status)
+        hidden_gold_obj = gr.Number(visible=False, value=pack["problem"].gold_objective or 0)
+        hidden_family = gr.Textbox(visible=False, value=pack["problem"].family.value)
+        hidden_split = gr.Textbox(visible=False, value=pack["problem"].split.value)
+        hidden_diff = gr.Textbox(visible=False, value=pack["problem"].difficulty.value)
+        hidden_plang = gr.Textbox(visible=False, value=pack["problem"].language)
+        hidden_tmpl = gr.Textbox(visible=False, value=pack["problem"].template_id)
+
+        outputs_lang = [
+            header,
+            run_btn,
+            cancel_btn,
+            reset_btn,
+            load_btn,
+            problem,
+            variant,
+            time_limit,
+            note,
+            kpis,
+            advanced,
+            method,
+            hint,
+            custom_text,
+            schema_text,
+            direct_text,
+        ]
+        lang.change(apply_language, inputs=[lang], outputs=outputs_lang)
+        demo.load(apply_language, inputs=[lang], outputs=outputs_lang)
+
+        problem.change(
+            _load_problem_fields,
+            inputs=[problem],
+            outputs=[
+                prompt_en,
+                prompt_fa,
+                prompt_json,
+                schema_text,
+                hidden_gold_status,
+                hidden_gold_obj,
+                hidden_family,
+                hidden_split,
+                hidden_diff,
+                hidden_plang,
+                hidden_tmpl,
+            ],
+        )
+        load_btn.click(
+            load_sample_ui,
+            outputs=[
+                problem,
+                prompt_en,
+                prompt_fa,
+                prompt_json,
+                schema_text,
+                hidden_gold_status,
+                hidden_gold_obj,
+                hidden_family,
+                hidden_split,
+                hidden_diff,
+                hidden_plang,
+                hidden_tmpl,
+            ],
+        )
+        reset_btn.click(
+            load_sample_ui,
+            outputs=[
+                problem,
+                prompt_en,
+                prompt_fa,
+                prompt_json,
+                schema_text,
+                hidden_gold_status,
+                hidden_gold_obj,
+                hidden_family,
+                hidden_split,
+                hidden_diff,
+                hidden_plang,
+                hidden_tmpl,
+            ],
+        )
+
+        run_event = run_live
+        event = run_btn.click(
+            run_live,
+            inputs=[lang, problem, variant, time_limit, custom_text, schema_text, direct_text],
+            outputs=[
+                kpis,
+                status,
+                reasons,
+                live_table,
+                live_summary,
+                violated,
+                facts,
+                sol_plot,
+                method_plot,
+                family_plot,
+                zip_out,
+                json_out,
+                custom_text,
+                schema_text,
+            ],
+        )
+        cancel_btn.click(lambda: None, cancels=[event])
+        filter_btn.click(
+            filter_catalog,
+            inputs=[family_f, split_f, lang_f, diff_f, eval_only],
+            outputs=[board, board_summary, catalog_plot, family_plot],
+        )
+        compare_btn.click(compare_interactive, inputs=[lang, time_limit], outputs=[interactive_tbl, interactive_sum])
+
+        api_status = gr.Textbox(visible=False)
+        api_feas = gr.Number(visible=False)
+        api_obj = gr.Number(visible=False)
+        api_sec = gr.Number(visible=False)
+        api_btn = gr.Button("solve_sample_api", visible=False)
+        api_btn.click(solve_sample_api, outputs=[api_status, api_feas, api_obj, api_sec], api_name="solve_sample")
+
+        _ = run_event
+        _ = meta
+
+    demo.queue(default_concurrency_limit=1)
+    return demo

demo/src/validation.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+from src.domain import (
+    AssignmentInstance,
+    Family,
+    InventoryInstance,
+    ScheduleInstance,
+    Solution,
+    ValidationIssue,
+    ValidationReport,
+    parse_instance,
+)
+
+
+def _issue(code: str, message: str, entity_id: str | None = None, passed: bool = False) -> ValidationIssue:
+    return ValidationIssue(code=code, message=message, entity_id=entity_id, passed=passed)
+
+
+def validate_schema(family: Family | str, payload: dict) -> ValidationReport:
+    issues: list[ValidationIssue] = []
+    checked = ["schema", "ids", "values"]
+    try:
+        instance = parse_instance(family, payload)
+    except Exception as exc:
+        return ValidationReport(ok=False, issues=[_issue("schema", f"schema rejected: {exc}")], checked=checked)
+
+    if isinstance(instance, InventoryInstance):
+        ids = [sku.sku_id for sku in instance.skus]
+        if len(ids) != len(set(ids)):
+            issues.append(_issue("ids", "duplicate SKU ids"))
+        if not instance.skus:
+            issues.append(_issue("schema", "inventory needs at least one SKU"))
+        for sku in instance.skus:
+            if len(sku.demand) != instance.periods:
+                issues.append(_issue("values", f"{sku.sku_id} demand length must equal periods", sku.sku_id))
+            if any(value < 0 for value in sku.demand):
+                issues.append(_issue("values", f"{sku.sku_id} demand must be non-negative", sku.sku_id))
+    elif isinstance(instance, AssignmentInstance):
+        if not instance.tasks or not instance.agents:
+            issues.append(_issue("schema", "assignment needs tasks and agents"))
+        task_ids = [task.task_id for task in instance.tasks]
+        agent_ids = [agent.agent_id for agent in instance.agents]
+        if len(task_ids) != len(set(task_ids)) or len(agent_ids) != len(set(agent_ids)):
+            issues.append(_issue("ids", "duplicate task or agent ids"))
+        known = {(task.task_id, agent.agent_id) for task in instance.tasks for agent in instance.agents}
+        for row in instance.costs:
+            if (row.task_id, row.agent_id) not in known:
+                issues.append(_issue("references", f"cost for unknown pair {row.task_id}/{row.agent_id}"))
+    else:
+        job_ids = [job.job_id for job in instance.jobs]
+        if len(job_ids) != len(set(job_ids)):
+            issues.append(_issue("ids", "duplicate job ids"))
+        if not instance.machines or not instance.jobs:
+            issues.append(_issue("schema", "scheduling needs jobs and machines"))
+        seen = set()
+        for edge in instance.precedences:
+            if edge.before not in job_ids or edge.after not in job_ids:
+                issues.append(_issue("references", f"precedence {edge.before}->{edge.after} is unknown"))
+            if edge.before == edge.after:
+                issues.append(_issue("values", f"self precedence on {edge.before}", edge.before))
+            pair = (edge.before, edge.after)
+            if pair in seen:
+                continue
+            seen.add(pair)
+        if _has_cycle(instance.precedences):
+            issues.append(_issue("values", "precedence graph has a cycle"))
+    return ValidationReport(ok=not issues, issues=issues, checked=checked)
+
+
+def _has_cycle(edges) -> bool:
+    graph: dict[str, list[str]] = defaultdict(list)
+    nodes: set[str] = set()
+    for edge in edges:
+        graph[edge.before].append(edge.after)
+        nodes.add(edge.before)
+        nodes.add(edge.after)
+    state: dict[str, int] = {}
+
+    def visit(node: str) -> bool:
+        state[node] = 1
+        for nxt in graph.get(node, []):
+            if state.get(nxt) == 1:
+                return True
+            if state.get(nxt, 0) == 0 and visit(nxt):
+                return True
+        state[node] = 2
+        return False
+
+    return any(state.get(node, 0) == 0 and visit(node) for node in nodes)
+
+
+def validate_solution(family: Family | str, payload: dict, solution: Solution | dict) -> ValidationReport:
+    family = Family(family)
+    schema_report = validate_schema(family, payload)
+    if not schema_report.ok:
+        return schema_report
+    instance = parse_instance(family, payload)
+    if not isinstance(solution, Solution):
+        solution = Solution.model_validate(solution)
+    if family == Family.INVENTORY:
+        return _validate_inventory(instance, solution)
+    if family == Family.ASSIGNMENT:
+        return _validate_assignment(instance, solution)
+    return _validate_schedule(instance, solution)
+
+
+def _validate_inventory(instance: InventoryInstance, solution: Solution) -> ValidationReport:
+    issues: list[ValidationIssue] = []
+    checked = ["pack", "budget", "balance", "capacity", "cover", "objective"]
+    qty = {(row.sku_id, int(row.period)): int(row.qty) for row in solution.orders}
+    spend = 0
+    hold_cost = 0
+    short_cost = 0
+    stock = {sku.sku_id: sku.initial_stock for sku in instance.skus}
+    for t in range(1, instance.periods + 1):
+        ending = 0
+        for sku in instance.skus:
+            order = int(qty.get((sku.sku_id, t), 0))
+            if order < 0:
+                issues.append(_issue("values", f"negative order {sku.sku_id}@{t}", sku.sku_id))
+            if sku.pack_size and order % sku.pack_size != 0:
+                issues.append(_issue("pack", f"{sku.sku_id}@{t} qty {order} is not a multiple of pack {sku.pack_size}", sku.sku_id))
+            spend += order * sku.unit_cost
+            demand = int(sku.demand[t - 1])
+            available = stock[sku.sku_id] + order
+            sold = min(available, demand)
+            short = demand - sold
+            stock[sku.sku_id] = available - sold
+            if stock[sku.sku_id] < 0:
+                issues.append(_issue("balance", f"negative inventory {sku.sku_id}@{t}", sku.sku_id))
+            if instance.cover_required and short:
+                issues.append(_issue("cover", f"{sku.sku_id}@{t} shortage {short} while cover is required", sku.sku_id))
+            ending += stock[sku.sku_id]
+            hold_cost += stock[sku.sku_id] * sku.holding_cost
+            short_cost += short * sku.shortage_cost
+        if ending > instance.warehouse_capacity:
+            issues.append(_issue("capacity", f"period {t} inventory {ending} exceeds capacity {instance.warehouse_capacity}"))
+    if spend > instance.budget:
+        issues.append(_issue("budget", f"purchase {spend} exceeds budget {instance.budget}"))
+    objective = float(spend + hold_cost + short_cost)
+    return ValidationReport(ok=not issues, issues=issues, checked=checked, recomputed_objective=objective)
+
+
+def _validate_assignment(instance: AssignmentInstance, solution: Solution) -> ValidationReport:
+    issues: list[ValidationIssue] = []
+    checked = ["unique", "eligible", "capacity", "required", "objective"]
+    seen_tasks: set[str] = set()
+    load: dict[str, int] = defaultdict(int)
+    cost_map = instance.cost_map()
+    agents = {agent.agent_id: agent for agent in instance.agents}
+    tasks = {task.task_id: task for task in instance.tasks}
+    spend = 0
+    for row in solution.assignments:
+        if row.task_id in seen_tasks:
+            issues.append(_issue("unique", f"task {row.task_id} assigned more than once", row.task_id))
+        seen_tasks.add(row.task_id)
+        task = tasks.get(row.task_id)
+        agent = agents.get(row.agent_id)
+        if task is None or agent is None:
+            issues.append(_issue("references", f"unknown pair {row.task_id}/{row.agent_id}", row.task_id))
+            continue
+        if not instance.eligible(task, agent):
+            issues.append(_issue("eligible", f"{row.task_id} is not eligible for {row.agent_id}", row.task_id))
+        if (row.task_id, row.agent_id) not in cost_map:
+            issues.append(_issue("references", f"no cost for {row.task_id}/{row.agent_id}", row.task_id))
+        else:
+            spend += cost_map[(row.task_id, row.agent_id)]
+        load[row.agent_id] += task.size
+    for agent in instance.agents:
+        if load[agent.agent_id] > agent.capacity:
+            issues.append(_issue("capacity", f"{agent.agent_id} load {load[agent.agent_id]} exceeds {agent.capacity}", agent.agent_id))
+    leftover = set(solution.unassigned)
+    for task in instance.tasks:
+        assigned = task.task_id in seen_tasks
+        if task.required and not assigned:
+            issues.append(_issue("required", f"required task {task.task_id} is unassigned", task.task_id))
+        if not assigned:
+            leftover.add(task.task_id)
+            spend += task.penalty
+        if assigned and task.task_id in leftover:
+            leftover.discard(task.task_id)
+    return ValidationReport(ok=not issues, issues=issues, checked=checked, recomputed_objective=float(spend))
+
+
+def _validate_schedule(instance: ScheduleInstance, solution: Solution) -> ValidationReport:
+    issues: list[ValidationIssue] = []
+    checked = ["unique", "eligible", "release", "overlap", "precedence", "hard_due", "duration", "objective"]
+    jobs = {job.job_id: job for job in instance.jobs}
+    seen: set[str] = set()
+    by_machine: dict[str, list[tuple[int, int, str]]] = defaultdict(list)
+    ends: dict[str, int] = {}
+    starts: dict[str, int] = {}
+    tardy = 0
+    for row in solution.starts:
+        if row.job_id in seen:
+            issues.append(_issue("unique", f"job {row.job_id} starts more than once", row.job_id))
+        seen.add(row.job_id)
+        job = jobs.get(row.job_id)
+        if job is None:
+            issues.append(_issue("references", f"unknown job {row.job_id}", row.job_id))
+            continue
+        if row.machine_id not in instance.machines:
+            issues.append(_issue("references", f"unknown machine {row.machine_id}", row.job_id))
+        if job.machine_eligible and row.machine_id not in set(job.machine_eligible):
+            issues.append(_issue("eligible", f"{row.job_id} cannot use {row.machine_id}", row.job_id))
+        if row.start < job.release:
+            issues.append(_issue("release", f"{row.job_id} starts at {row.start} before release {job.release}", row.job_id))
+        if row.end - row.start != job.duration:
+            issues.append(_issue("duration", f"{row.job_id} duration {row.end - row.start} != {job.duration}", row.job_id))
+        if job.hard_due and row.end > job.due:
+            issues.append(_issue("hard_due", f"{row.job_id} ends at {row.end} after hard due {job.due}", row.job_id))
+        by_machine[row.machine_id].append((row.start, row.end, row.job_id))
+        ends[row.job_id] = row.end
+        starts[row.job_id] = row.start
+        tardy += job.weight * max(0, row.end - job.due)
+    for job in instance.jobs:
+        if job.job_id not in seen:
+            issues.append(_issue("cover", f"job {job.job_id} has no start", job.job_id))
+    for machine, blocks in by_machine.items():
+        ordered = sorted(blocks)
+        for prev, cur in zip(ordered, ordered[1:]):
+            if prev[1] > cur[0]:
+                issues.append(_issue("overlap", f"{machine} overlap {prev[2]} and {cur[2]}", machine))
+    for edge in instance.precedences:
+        if edge.before in ends and edge.after in starts and ends[edge.before] > starts[edge.after]:
+            issues.append(_issue("precedence", f"{edge.before} must finish before {edge.after}", edge.after))
+    return ValidationReport(ok=not issues, issues=issues, checked=checked, recomputed_objective=float(tardy))
+
+
+def format_input_error(report: ValidationReport) -> str:
+    if report.ok:
+        return ""
+    return " | ".join(f"{item.code}: {item.message}" for item in report.issues[:8])

demo/tests/conftest.py

@@ -0,0 +1,6 @@
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))