Add OFF_DataQuality project with sanitized code and enriched README

OFF_DataQuality/.gitignore

@@ -0,0 +1,23 @@
+# Python cache/artifacts
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.pytest_cache/
+
+# Local environments
+.venv/
+venv/
+
+# Local data artifacts & databases (do not commit)
+*.db
+openfoodfacts-products.jsonl
+config/secret_key
+config/logs/
+results/tmp_engine_runs/
+
+# OS/editor
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/

OFF_DataQuality/README.md

@@ -0,0 +1,206 @@
+# OFF_DataQuality: Perl-to-Python Data Quality Migration & Benchmarking Framework
+
+## Overview
+
+**OFF_DataQuality** is an end-to-end framework designed to modernize legacy data quality validation logic for **Open Food Facts (OFF)**. 
+
+Historically, Open Food Facts relied on legacy **Perl (`.pl`)** scripts to enforce quality controls across millions of food products—ranging from energy unit conversions (kcal vs. kJ) and macro-nutrient balance checks (sugars, fats, carbohydrates) to jurisdiction-specific allergen and packaging compliance regulations. 
+
+This project provides an automated pipeline for:
+1. **Extracting** relational, threshold, and logic conditions from legacy Perl scripts.
+2. **Migrating** rules into modern **Python** validation logic using LLMs (Groq / GPT-oss-120b) with deterministic fallback templates and semantic guardrail verification.
+3. **Generating Declarative Targets** for **dbt-core** (DuckDB SQL tests) and **SodaCL** (Soda data quality contracts).
+4. **Benchmarking Parity** across legacy Perl outputs vs. Python, dbt, and Soda execution engines with conservative statistical confidence scoring (95% Wilson bounds & Beta posteriors).
+5. **Interactive Dashboarding** to inspect side-by-side rule performance, win distributions by complexity (simple, medium, intricate), and legal traceability metadata.
+
+---
+
+## Core Architecture & Workflow
+
+```mermaid
+flowchart TD
+    A[Legacy Perl Rules .pl] --> B[Perl Logic Extractor]
+    B --> C{Migration Engine}
+    C -->|LLM / Groq GPT-oss-120b| D[Python Rules]
+    C -->|Declarative Generator| E[dbt DuckDB SQL Tests]
+    C -->|Declarative Generator| F[SodaCL YAML Contracts]
+    D --> G[Semantic Guardrails Verification]
+    E --> H[DuckDB Parity Execution]
+    F --> H
+    G --> H
+    H --> I[Statistical Confidence & Parity Validator]
+    I --> J[Streamlit Comparison Dashboard]
+```
+
+---
+
+## Key Features
+
+### 1. Automated Perl Rule Extraction & Translation
+- **Perl Extractor (`extractor/perl_logic_extractor.py`)**: Parses legacy `.pl` condition files to isolate numeric bounds, relational field constraints, and tag generation logic.
+- **LLM Converter (`migration/llm_converter.py`)**: Translates extracted rules into executable Python functions via LLM API calls with 2-stage runtime and semantic contract validation.
+- **Deterministic Fallback**: If LLM API access is unavailable or semantic checks fail, the system falls back to deterministic rule templates.
+
+### 2. Multi-Engine Declarative Pilot (`dbt` & `SodaCL`)
+- **dbt Target**: Automatically generates dbt SQL test models and `count_violations` macros backed by DuckDB.
+- **SodaCL Target**: Automatically generates SodaCL contract YAML files for automated data quality scanning.
+
+### 3. Statistical Parity & Confidence Scoring
+Rule confidence is computed conservatively to prevent inflation on sparse evidence:
+$$	ext{overall\_confidence} = 	ext{llm\_confidence} 	imes 	ext{parity\_ci\_lower\_95} 	imes 	ext{evidence\_ci\_lower\_95}$$
+Where `parity_ci_lower_95` uses the **Wilson score interval** and `evidence_ci_lower_95` uses a **Beta posterior credible bound** on positive violation matches.
+
+### 4. Jurisdiction Profile Layers
+- **`global`**: Generic Open Food Facts nutrient consistency and boundary rules.
+- **`canada`**: Phase-1 Canadian regulatory proxy rules (e.g., Front-of-Package (FOP) symbols, bilingual label indicators, allergen statements) with legal citations, source URLs, and review metadata.
+- **`hybrid`**: Unified execution across both global and Canadian rule sets.
+
+### 5. Interactive Streamlit Dashboard
+An interactive UI (`dashboard/app.py`) presenting per-rule accuracy, side-by-side code/SQL comparisons, engine recommendations, and legal traceability metadata.
+
+---
+
+## Repository Structure
+
+```text
+OFF_DataQuality/
+├── README.md                 # Project documentation and execution guide
+├── requirements.txt           # Core dependencies (duckdb, streamlit, pandas, openai, dbt, soda)
+├── pytest.ini                 # Test configuration
+├── inspect_duckdb.py          # Utility script for inspecting DuckDB tables
+├── config/
+│   ├── hypercorn.toml         # Server configuration
+│   └── custom-covers/         # Custom asset configuration directories
+├── dashboard/
+│   └── app.py                 # Interactive Streamlit parity comparison dashboard
+├── data/
+│   ├── load_dataset.py        # Streamed product dataset loader (real OFF JSONL / sample)
+│   └── sample_products.jsonl  # 400 sample OFF product records for out-of-the-box execution
+├── declarative/
+│   └── check_runners.py       # Declarative dbt & Soda check generation & execution
+├── duckdb_utils/
+│   └── create_tables.py       # In-memory DuckDB table creation & schema setup
+├── extractor/
+│   └── perl_logic_extractor.py # Legacy Perl script logic parser
+├── llm-test/
+│   └── test_groq.py           # Verification script for Groq API integration
+├── migration/
+│   └── llm_converter.py       # LLM translation pipeline with semantic guardrails
+├── perl_checks/
+│   ├── legacy_checks.py       # Simulated & file-based legacy Perl rule runner
+│   └── rules/                 # 19 legacy Perl validation rules (.pl)
+├── python_checks/
+│   └── generated_checks.py    # Auto-generated Python quality check routines
+├── results/
+│   ├── engine_comparison.json # Pre-computed benchmark comparison report
+│   ├── migration_results.json # Migration execution output
+│   └── declarative_runtime/   # Generated dbt & Soda test models and contracts
+├── rulepacks/
+│   └── registry.py            # Global, Canada, and Hybrid rule-pack registry
+├── tests/                     # Comprehensive pytest suite
+└── validation/
+    ├── parity_validator.py    # End-to-end parity validation pipeline
+    ├── engine_comparison.py   # Multi-engine comparative benchmark suite
+    └── verification.py        # Semantic and runtime verification contracts
+```
+
+---
+
+## Security & Publishing Norms
+
+- **No Hardcoded Credentials**: API keys (such as `GROQ_API_KEY`) are read strictly from environment variables.
+- **Sanitized Configurations**: Local secret keys, temporary logs, and local SQLite/DuckDB binary database files are excluded.
+- **Reproducible Sample Dataset**: Includes 400 sample product records (`data/sample_products.jsonl`) so the entire pipeline can be benchmarked offline out-of-the-box.
+
+---
+
+## Quick Start
+
+### 1. Installation
+
+Clone the repository and install dependencies:
+
+```bash
+git clone https://huggingface.co/datasets/offCanada/Final_Deliverables
+cd Final_Deliverables/OFF_DataQuality
+pip install -r requirements.txt
+```
+
+### 2. Run Parity Validator Pipeline
+
+Run parity validation on sample products using the default Python target:
+
+```bash
+python -m validation.parity_validator --size 300 --seed 17
+```
+
+Run with declarative targets (`dbt` or `soda`):
+
+```bash
+python -m validation.parity_validator --size 300 --execution-engine dbt
+python -m validation.parity_validator --size 300 --execution-engine soda
+```
+
+Run using file-based Perl rule files:
+
+```bash
+python -m validation.parity_validator --size 300 --perl-rules-dir perl_checks/rules
+```
+
+### 3. Run Multi-Engine Comparison Benchmark
+
+Execute a comparison experiment across Python, dbt, and Soda engines:
+
+```bash
+python -m validation.engine_comparison --size 300 --mode off --llm-provider groq
+```
+
+Run with specific rule profiles:
+
+```bash
+python -m validation.engine_comparison --size 300 --profile global
+python -m validation.engine_comparison --size 300 --profile canada
+python -m validation.engine_comparison --size 300 --profile hybrid
+```
+
+### 4. Launch the Streamlit Dashboard
+
+Explore benchmark metrics, engine recommendations, and rule details interactively:
+
+```bash
+streamlit run dashboard/app.py
+```
+
+### 5. Running with Groq LLM Integration (Optional)
+
+To enable real LLM translation via Groq:
+
+```powershell
+# Windows PowerShell
+$env:GROQ_API_KEY="your_groq_api_key_here"
+```
+
+```bash
+# Bash / Linux / macOS
+export GROQ_API_KEY="your_groq_api_key_here"
+```
+
+Then run with Groq provider:
+
+```bash
+python -m validation.parity_validator --size 300 --llm-provider groq --llm-model openai/gpt-oss-120b
+```
+
+### 6. Automated Testing
+
+Run the test suite using `pytest`:
+
+```bash
+pytest -q
+```
+
+---
+
+## License & Attribution
+
+This project is part of the **Open Food Facts (Canada)** data quality modernization effort. All product sample data and rule definitions conform to Open Food Facts open-data specifications.

OFF_DataQuality/config/hypercorn.toml

@@ -0,0 +1,9 @@
+# http1 & http2 binding 
+bind = ["0.0.0.0:9810"]
+# http3 quick binding
+quick_bind = ["0.0.0.0:9810"]
+# http path prefix for codex
+root_path = ""
+# This can be a number or "auto" for Codex to guess a good value.
+# https://github.com/ajslater/codex#bulk-database-updates-fail
+max_import_batch_size = "auto"

OFF_DataQuality/dashboard/app.py

@@ -0,0 +1,787 @@
+"""Streamlit dashboard for cross-engine migration comparison."""
+from __future__ import annotations
+
+import html
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Mapping
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from rulepacks.registry import DEFAULT_PROFILE, SUPPORTED_PROFILES
+from validation.engine_comparison import COMPARISON_PATH, run_engine_comparison
+
+DEFAULT_SOURCE_JSONL = PROJECT_ROOT / "openfoodfacts-products.jsonl"
+ENGINE_COLORS = {
+    "python": "#2563eb",
+    "dbt": "#f97316",
+    "soda": "#10b981",
+}
+
+
+def load_report() -> dict:
+    if not COMPARISON_PATH.exists():
+        return {}
+    with COMPARISON_PATH.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def _inject_theme() -> None:
+    st.markdown(
+        """
+        <style>
+        @import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap');
+        @import url('https://fonts.googleapis.com/css2?family=Material+Symbols+Rounded:opsz,wght,FILL,GRAD@20..48,400,0,0');
+        html, body, [class*="st-"], [class*="css"] {
+            font-family: "Space Grotesk", sans-serif;
+        }
+        [class^="material-symbols"], [class*=" material-symbols"] {
+            font-family: "Material Symbols Rounded" !important;
+            font-weight: normal;
+            font-style: normal;
+            font-size: 1rem;
+            line-height: 1;
+            letter-spacing: normal;
+            text-transform: none;
+            display: inline-block;
+            white-space: nowrap;
+            word-wrap: normal;
+            direction: ltr;
+            -webkit-font-smoothing: antialiased;
+        }
+        .block-container {
+            max-width: 1260px;
+            padding-top: 1.15rem;
+            padding-bottom: 2rem;
+        }
+        [data-testid="stMetric"] {
+            background: linear-gradient(120deg, #f8fafc 0%, #ecfeff 100%);
+            border: 1px solid #dbeafe;
+            border-radius: 14px;
+            padding: 0.6rem 0.8rem;
+            min-height: 118px;
+        }
+        [data-testid="stMetricLabel"] > div {
+            white-space: normal !important;
+            line-height: 1.15;
+        }
+        [data-testid="stMetricValue"] > div {
+            line-height: 1.15;
+        }
+        .stat-chip {
+            border-radius: 16px;
+            border: 1px solid #dbeafe;
+            background: linear-gradient(135deg, #f8fafc 0%, #ecfeff 100%);
+            padding: 0.8rem 0.95rem;
+            min-height: 112px;
+            display: flex;
+            flex-direction: column;
+            justify-content: space-between;
+            overflow: hidden;
+            box-shadow: 0 4px 12px rgba(15, 23, 42, 0.06);
+        }
+        .stat-chip .label {
+            color: #475569;
+            font-size: 0.76rem;
+            line-height: 1.1rem;
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.04em;
+            word-break: normal;
+            overflow-wrap: break-word;
+        }
+        .stat-chip .value {
+            color: #0f172a;
+            font-size: 1.28rem;
+            font-weight: 700;
+            line-height: 1.4rem;
+            margin-top: 0.5rem;
+            white-space: normal;
+            word-break: break-word;
+        }
+        .hero {
+            border-radius: 16px;
+            border: 1px solid #cbd5e1;
+            background: radial-gradient(circle at 10% 20%, #f0fdfa 0%, #eff6ff 45%, #fff7ed 100%);
+            padding: 1rem 1.2rem;
+            margin-bottom: 1.1rem;
+        }
+        .hero h1 {
+            margin: 0;
+            color: #0b1324;
+            font-size: 1.38rem;
+            letter-spacing: -0.01em;
+        }
+        .hero p {
+            margin: 0.3rem 0 0 0;
+            color: #334155;
+            font-size: 0.95rem;
+        }
+        .explain-chip {
+            border-radius: 14px;
+            border: 1px solid #bfdbfe;
+            background: linear-gradient(135deg, #eff6ff 0%, #f0f9ff 100%);
+            padding: 0.8rem 0.95rem;
+            margin: 0.6rem 0 0.9rem 0;
+            box-shadow: 0 4px 12px rgba(15, 23, 42, 0.05);
+        }
+        .explain-chip .title {
+            color: #1e3a8a;
+            font-size: 0.88rem;
+            line-height: 1.2rem;
+            font-weight: 700;
+            margin-bottom: 0.35rem;
+            text-transform: uppercase;
+            letter-spacing: 0.03em;
+        }
+        .explain-chip ul {
+            margin: 0.1rem 0 0 1rem;
+            padding: 0;
+        }
+        .explain-chip li {
+            color: #1e293b;
+            font-size: 0.92rem;
+            line-height: 1.35rem;
+            margin: 0.2rem 0;
+        }
+        [data-testid="stExpander"] > details > summary {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            line-height: 1.25;
+        }
+        [data-testid="stExpander"] > details > summary p {
+            margin: 0 !important;
+            line-height: 1.25 !important;
+        }
+        [data-testid="stExpander"] > details > summary svg {
+            flex-shrink: 0;
+            margin-top: 0 !important;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _to_pct(value: object) -> float:
+    try:
+        return round(float(value) * 100, 2)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _render_stat_chip(label: str, value: object) -> None:
+    st.markdown(
+        (
+            "<div class='stat-chip'>"
+            f"<div class='label'>{label}</div>"
+            f"<div class='value'>{value}</div>"
+            "</div>"
+        ),
+        unsafe_allow_html=True,
+    )
+
+
+def _render_explain_chip(title: str, lines: List[str]) -> None:
+    safe_items = "".join(f"<li>{html.escape(line)}</li>" for line in lines if line)
+    st.markdown(
+        (
+            "<div class='explain-chip'>"
+            f"<div class='title'>{html.escape(title)}</div>"
+            f"<ul>{safe_items}</ul>"
+            "</div>"
+        ),
+        unsafe_allow_html=True,
+    )
+
+
+def _engine_summary_frame(per_engine_summary: Mapping[str, Mapping[str, object]]) -> pd.DataFrame:
+    rows: List[Dict[str, object]] = []
+    for engine in ("python", "dbt", "soda"):
+        summary = per_engine_summary.get(engine, {})
+        rows.append(
+            {
+                "engine": engine.upper(),
+                "rules": int(summary.get("rules", 0)),
+                "passed": int(summary.get("passed", 0)),
+                "avg_overall_confidence_pct": _to_pct(summary.get("avg_overall_confidence", 0.0)),
+                "avg_effective_confidence_pct": _to_pct(summary.get("avg_effective_confidence", 0.0)),
+                "avg_parity_ci_low_pct": _to_pct(summary.get("avg_parity_ci_lower", 0.0)),
+                "avg_equivalence_rate_pct": _to_pct(summary.get("avg_equivalence_rate", 0.0)),
+                "avg_mutation_score_pct": _to_pct(summary.get("avg_mutation_score", 0.0)),
+                "fallback_rules": int(summary.get("fallback_rules", 0)),
+                "real_llm_rules": int(summary.get("real_llm_rules", 0)) if engine == "python" else None,
+                "real_llm_rate_pct": _to_pct(summary.get("real_llm_rate", 0.0)) if engine == "python" else None,
+                "repairs_applied": int(summary.get("repairs_applied", 0)) if engine == "python" else None,
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def _rule_frame(rule_comparison: List[Mapping[str, object]]) -> pd.DataFrame:
+    rows: List[Dict[str, object]] = []
+    for item in rule_comparison:
+        engines = item.get("engines", {})
+        py = engines.get("python", {})
+        dbt = engines.get("dbt", {})
+        soda = engines.get("soda", {})
+        best_engine = str(item.get("best_engine", "python"))
+
+        effective_confidences = {
+            "python": float(py.get("effective_confidence", py.get("overall_confidence", 0.0))),
+            "dbt": float(dbt.get("effective_confidence", dbt.get("overall_confidence", 0.0))),
+            "soda": float(soda.get("effective_confidence", soda.get("overall_confidence", 0.0))),
+        }
+        sorted_conf = sorted(effective_confidences.values(), reverse=True)
+        margin = sorted_conf[0] - sorted_conf[1] if len(sorted_conf) > 1 else sorted_conf[0]
+        decision_scores = {
+            "python": float(py.get("decision_score", effective_confidences["python"])),
+            "dbt": float(dbt.get("decision_score", effective_confidences["dbt"])),
+            "soda": float(soda.get("decision_score", effective_confidences["soda"])),
+        }
+        sorted_scores = sorted(decision_scores.values(), reverse=True)
+        score_margin = sorted_scores[0] - sorted_scores[1] if len(sorted_scores) > 1 else sorted_scores[0]
+
+        rows.append(
+            {
+                "rule_name": item.get("rule_name", ""),
+                "severity": item.get("severity", ""),
+                "condition": item.get("condition", ""),
+                "condition_type": item.get("condition_type", "unknown"),
+                "complexity": item.get("complexity", "unknown"),
+                "declarative_friendly": bool(item.get("declarative_friendly", False)),
+                "jurisdiction": str(item.get("jurisdiction", "global")),
+                "regulatory_type": str(item.get("regulatory_type", "")),
+                "legal_citation": str(item.get("legal_citation", "")),
+                "review_status": str(item.get("review_status", "")),
+                "products_tested": int(item.get("products_tested", 0)),
+                "best_engine": best_engine,
+                "best_effective_pct": _to_pct(effective_confidences.get(best_engine, 0.0)),
+                "effective_margin_pct": round(margin * 100, 2),
+                "best_decision_score": round(decision_scores.get(best_engine, 0.0), 4),
+                "decision_margin": round(score_margin, 4),
+                "python_status": py.get("status", "n/a"),
+                "dbt_status": dbt.get("status", "n/a"),
+                "soda_status": soda.get("status", "n/a"),
+                "python_effective_pct": _to_pct(py.get("effective_confidence", py.get("overall_confidence", 0.0))),
+                "dbt_effective_pct": _to_pct(dbt.get("effective_confidence", dbt.get("overall_confidence", 0.0))),
+                "soda_effective_pct": _to_pct(soda.get("effective_confidence", soda.get("overall_confidence", 0.0))),
+                "python_decision_score": round(decision_scores["python"], 4),
+                "dbt_decision_score": round(decision_scores["dbt"], 4),
+                "soda_decision_score": round(decision_scores["soda"], 4),
+                "python_overall_pct": _to_pct(py.get("overall_confidence", 0.0)),
+                "dbt_overall_pct": _to_pct(dbt.get("overall_confidence", 0.0)),
+                "soda_overall_pct": _to_pct(soda.get("overall_confidence", 0.0)),
+                "python_equivalence_pct": _to_pct(py.get("equivalence_match_rate", 1.0)),
+                "python_mutation_pct": _to_pct(py.get("mutation_score", 1.0)),
+                "python_verification_pct": _to_pct(py.get("verification_score", 1.0)),
+                "python_repair_applied": bool(py.get("counterexample_repair_applied", False)),
+                "python_mismatches": int(py.get("mismatches", 0)),
+                "dbt_mismatches": int(dbt.get("mismatches", 0)),
+                "soda_mismatches": int(soda.get("mismatches", 0)),
+                "python_real_llm": bool(py.get("real_llm_used", False)),
+                "python_provider": py.get("conversion_provider", ""),
+                "dbt_provider": dbt.get("conversion_provider", ""),
+                "soda_provider": soda.get("conversion_provider", ""),
+                "selection_reason": item.get("selection_reason", ""),
+                "declarative_tie_break_applied": bool(item.get("declarative_tie_break_applied", False)),
+                "recommendation": item.get("recommendation", ""),
+            }
+        )
+    frame = pd.DataFrame(rows)
+    if frame.empty:
+        return frame
+    return frame.sort_values(by=["best_effective_pct", "rule_name"], ascending=[False, True]).reset_index(drop=True)
+
+
+def _build_effective_chart(frame: pd.DataFrame) -> go.Figure:
+    chart = frame[["rule_name", "python_effective_pct", "dbt_effective_pct", "soda_effective_pct"]].copy()
+    chart = chart.melt(id_vars=["rule_name"], var_name="engine", value_name="effective_pct")
+    chart["engine"] = chart["engine"].str.replace("_effective_pct", "", regex=False).str.upper()
+    fig = px.bar(
+        chart,
+        x="rule_name",
+        y="effective_pct",
+        color="engine",
+        barmode="group",
+        color_discrete_map={"PYTHON": ENGINE_COLORS["python"], "DBT": ENGINE_COLORS["dbt"], "SODA": ENGINE_COLORS["soda"]},
+    )
+    fig.update_layout(
+        height=460,
+        margin=dict(l=20, r=20, t=30, b=80),
+        xaxis=dict(title=None, tickangle=-30),
+        yaxis=dict(title="Effective confidence (%)", range=[0, 100]),
+        legend=dict(orientation="h", y=1.08, x=0),
+        plot_bgcolor="#ffffff",
+        paper_bgcolor="#ffffff",
+    )
+    return fig
+
+
+def _build_best_engine_chart(frame: pd.DataFrame) -> go.Figure:
+    dist = frame["best_engine"].value_counts().rename_axis("engine").reset_index(name="rules")
+    fig = px.pie(
+        dist,
+        names="engine",
+        values="rules",
+        hole=0.58,
+        color="engine",
+        color_discrete_map=ENGINE_COLORS,
+    )
+    fig.update_layout(height=420, margin=dict(l=5, r=5, t=10, b=10), legend=dict(orientation="h", y=-0.1, x=0))
+    fig.update_traces(textinfo="label+value")
+    return fig
+
+
+def _complexity_summary_frame(per_complexity_summary: Mapping[str, Mapping[str, object]]) -> pd.DataFrame:
+    rows: List[Dict[str, object]] = []
+    for tier in ("simple", "medium", "intricate", "unknown"):
+        info = per_complexity_summary.get(tier)
+        if not info:
+            continue
+        rows.append(
+            {
+                "complexity": tier,
+                "rules": int(info.get("rules", 0)),
+                "python_wins": int(info.get("python_wins", 0)),
+                "dbt_wins": int(info.get("dbt_wins", 0)),
+                "soda_wins": int(info.get("soda_wins", 0)),
+                "avg_best_effective_pct": _to_pct(info.get("avg_best_effective_confidence", 0.0)),
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def _engine_detail_frame(selected_rule: Mapping[str, object]) -> pd.DataFrame:
+    rows: List[Dict[str, object]] = []
+    engines = selected_rule.get("engines", {})
+    for engine in ("python", "dbt", "soda"):
+        row = engines.get(engine, {})
+        rows.append(
+            {
+                "engine": engine.upper(),
+                "status": row.get("status", "n/a"),
+                "overall_confidence_pct": _to_pct(row.get("overall_confidence", 0.0)),
+                "effective_confidence_pct": _to_pct(row.get("effective_confidence", row.get("overall_confidence", 0.0))),
+                "decision_score": float(row.get("decision_score", row.get("effective_confidence", 0.0))),
+                "parity_ci_low_pct": _to_pct(row.get("parity_ci_lower", 0.0)),
+                "equivalence_pct": _to_pct(row.get("equivalence_match_rate", 1.0)),
+                "mutation_pct": _to_pct(row.get("mutation_score", 1.0)),
+                "verification_pct": _to_pct(row.get("verification_score", 1.0)),
+                "mismatches": int(row.get("mismatches", 0)),
+                "provider_factor_pct": _to_pct(row.get("provider_factor", 0.0)),
+                "provider": row.get("conversion_provider", ""),
+                "execution_mode": row.get("execution_mode", ""),
+                "cloud_connected": bool(row.get("cloud_connected", False)),
+                "cloud_scan_id": row.get("cloud_scan_id", ""),
+                "cloud_scan_url": row.get("cloud_scan_url", ""),
+                "real_llm_used": bool(row.get("real_llm_used")) if engine == "python" else None,
+                "repair_applied": bool(row.get("counterexample_repair_applied", False)) if engine == "python" else None,
+                "artifact_lines": int(row.get("conversion_lines", 0)),
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def _engine_artifact(selected_rule: Mapping[str, object], engine: str) -> str:
+    return str(selected_rule.get("engines", {}).get(engine, {}).get("conversion_artifact", "")).strip()
+
+
+def _engine_failed_cases(selected_rule: Mapping[str, object], engine: str) -> List[Mapping[str, object]]:
+    return list(selected_rule.get("engines", {}).get(engine, {}).get("failed_test_cases", []))
+
+
+def _engine_equivalence_counterexamples(selected_rule: Mapping[str, object], engine: str) -> List[Mapping[str, object]]:
+    return list(selected_rule.get("engines", {}).get(engine, {}).get("equivalence_counterexamples", []))
+
+
+def main() -> None:
+    st.set_page_config(page_title="OFF Migration Comparison Dashboard", layout="wide")
+    _inject_theme()
+    st.markdown(
+        """
+        <div class="hero">
+            <h1>Open Food Facts Migration Comparison Dashboard</h1>
+            <p>Compare Python (LLM), dbt, and Soda migrations for every rule, side-by-side.</p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    with st.sidebar:
+        st.subheader("Comparison Run")
+        size = st.slider("Dataset size", min_value=100, max_value=500, value=300, step=25)
+        default_mode = "OFF JSONL" if DEFAULT_SOURCE_JSONL.exists() else "Synthetic"
+        dataset_mode = st.radio("Dataset mode", options=["OFF JSONL", "Synthetic"], index=0 if default_mode == "OFF JSONL" else 1)
+        use_off_source = dataset_mode == "OFF JSONL"
+        seed = st.number_input("Seed (synthetic mode)", min_value=1, max_value=99999, value=17, disabled=use_off_source)
+        source_jsonl_text = st.text_input("Source JSONL path", value=str(DEFAULT_SOURCE_JSONL), disabled=not use_off_source)
+        perl_rules_dir_text = st.text_input("Perl rules directory (optional)", value="")
+        llm_provider = "groq"
+        st.caption("Python engine uses Groq for LLM conversion in this dashboard.")
+        llm_model = st.text_input("LLM model override", value="openai/gpt-oss-120b")
+        soda_mode = st.selectbox(
+            "Soda mode",
+            options=["local", "cloud"],
+            index=0,
+            help="Use `cloud` to attempt Soda Cloud scan publishing; falls back to local if unavailable.",
+        )
+        profile = st.selectbox("Rule profile", options=list(SUPPORTED_PROFILES), index=list(SUPPORTED_PROFILES).index(DEFAULT_PROFILE))
+        has_groq_key = bool(os.getenv("GROQ_API_KEY"))
+        if not has_groq_key:
+            st.warning("GROQ_API_KEY is not set. Python engine will fall back unless key is provided.")
+
+        if st.button("Run Full Comparison"):
+            try:
+                if not has_groq_key:
+                    raise RuntimeError("GROQ_API_KEY is required. Set it before running the comparison.")
+                with st.spinner("Running Python + dbt + Soda comparison..."):
+                    run_engine_comparison(
+                        dataset_size=int(size),
+                        seed=int(seed),
+                        source_jsonl=Path(source_jsonl_text) if use_off_source else None,
+                        use_default_off_source=use_off_source,
+                        llm_provider=llm_provider,
+                        llm_model=llm_model.strip() or None,
+                        perl_rules_dir=Path(perl_rules_dir_text) if perl_rules_dir_text.strip() else None,
+                        results_path=COMPARISON_PATH,
+                        require_real_llm=True,
+                        profile=profile,
+                        soda_mode=soda_mode,
+                    )
+                st.success("Comparison completed.")
+            except Exception as exc:  # noqa: BLE001
+                st.error(str(exc))
+
+    payload = load_report()
+    if not payload:
+        st.info("No comparison report found yet. Click 'Run Full Comparison' in the sidebar.")
+        return
+
+    dataset = payload.get("dataset", {})
+    rule_comparison = list(payload.get("rule_comparison", []))
+    engine_summary = payload.get("per_engine_summary", {})
+    complexity_summary = payload.get("per_complexity_summary", {})
+    run_config = payload.get("run_config", {})
+    comparison_method = payload.get("comparison_method", {})
+    comparison_fingerprint = payload.get("comparison_fingerprint", {})
+    frame = _rule_frame(rule_comparison)
+    if frame.empty:
+        st.warning("Comparison report has no rule rows.")
+        return
+
+    python_wins = int((frame["best_engine"] == "python").sum())
+    dbt_wins = int((frame["best_engine"] == "dbt").sum())
+    soda_wins = int((frame["best_engine"] == "soda").sum())
+    avg_best = frame["best_effective_pct"].mean()
+    canada_rules = int((frame["jurisdiction"] == "ca").sum()) if "jurisdiction" in frame.columns else 0
+
+    k1, k2, k3 = st.columns(3, gap="large")
+    with k1:
+        _render_stat_chip("Rules compared", len(frame))
+    with k2:
+        _render_stat_chip("Python wins", python_wins)
+    with k3:
+        _render_stat_chip("dbt wins", dbt_wins)
+    k4, k5, k6 = st.columns(3, gap="large")
+    with k4:
+        _render_stat_chip("Soda wins", soda_wins)
+    with k5:
+        _render_stat_chip("Avg best effective %", f"{avg_best:.2f}%")
+    with k6:
+        _render_stat_chip("Canada rules", canada_rules)
+
+    st.caption(f"Generated at: {payload.get('generated_at_utc', 'n/a')}")
+    st.caption(f"Dataset size: {dataset.get('products_tested', 'n/a')}")
+    st.caption(f"Dataset source: {dataset.get('source_jsonl', 'n/a')}")
+    st.caption(f"Profile: {dataset.get('profile', DEFAULT_PROFILE)}")
+    st.caption(
+        "Confidence context: we compare engines using effective confidence "
+        "(overall confidence x provider factor), with status and mismatches prioritized."
+    )
+    if run_config:
+        st.caption(
+            f"LLM provider={run_config.get('llm_provider', 'n/a')} | "
+            f"GROQ key set={run_config.get('groq_api_key_set')} | "
+            f"Require real LLM={run_config.get('require_real_llm')} | "
+            f"Run profile={run_config.get('profile', DEFAULT_PROFILE)} | "
+            f"Soda mode={run_config.get('soda_mode', 'local')} | "
+            f"Soda Cloud creds set={run_config.get('soda_cloud_credentials_set', False)}"
+        )
+    if comparison_fingerprint:
+        st.caption(
+            f"Comparison run ID: {comparison_fingerprint.get('comparison_run_id', 'n/a')} | "
+            f"Run SHA: {str(comparison_fingerprint.get('comparison_sha256', ''))[:12]}"
+        )
+        st.caption(
+            f"Dataset fingerprint: {str(comparison_fingerprint.get('dataset_fingerprint_sha256', ''))[:16]} | "
+            f"Rulepack fingerprint: {str(comparison_fingerprint.get('rulepack_fingerprint_sha256', ''))[:16]} | "
+            f"Commit: {str(comparison_fingerprint.get('code_commit', 'unknown'))[:12]}"
+        )
+        st.caption(
+            f"Cross-engine consistency -> "
+            f"dataset={comparison_fingerprint.get('dataset_fingerprint_consistent', False)} | "
+            f"rulepack={comparison_fingerprint.get('rulepack_fingerprint_consistent', False)}"
+        )
+    selection_lines: List[str] = [
+        str(
+            comparison_method.get(
+                "best_engine_ranking",
+                "Prefer MATCH status, then fewer mismatches, then higher effective confidence.",
+            )
+        )
+    ]
+    if comparison_method.get("hybrid_tie_break"):
+        selection_lines.append(str(comparison_method["hybrid_tie_break"]))
+    if comparison_method.get("declarative_tie_break"):
+        selection_lines.append(str(comparison_method["declarative_tie_break"]))
+    _render_explain_chip("How Best Migration Is Chosen", selection_lines)
+
+    st.subheader("Engine Summary")
+    summary_frame = _engine_summary_frame(engine_summary)
+    st.dataframe(
+        summary_frame,
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "engine": st.column_config.TextColumn("Engine"),
+            "rules": st.column_config.NumberColumn("Rules", format="%d"),
+            "passed": st.column_config.NumberColumn("Passed", format="%d"),
+            "avg_overall_confidence_pct": st.column_config.NumberColumn("Avg overall %", format="%.2f"),
+            "avg_effective_confidence_pct": st.column_config.NumberColumn("Avg effective %", format="%.2f"),
+            "avg_parity_ci_low_pct": st.column_config.NumberColumn("Avg parity CI low %", format="%.2f"),
+            "avg_equivalence_rate_pct": st.column_config.NumberColumn("Avg equivalence %", format="%.2f"),
+            "avg_mutation_score_pct": st.column_config.NumberColumn("Avg mutation %", format="%.2f"),
+            "fallback_rules": st.column_config.NumberColumn("Fallback rules", format="%d"),
+            "real_llm_rules": st.column_config.NumberColumn("Real LLM rules", format="%d"),
+            "real_llm_rate_pct": st.column_config.NumberColumn("Real LLM rate %", format="%.2f"),
+            "repairs_applied": st.column_config.NumberColumn("Repairs applied", format="%d"),
+        },
+    )
+
+    complexity_frame = _complexity_summary_frame(complexity_summary)
+    if not complexity_frame.empty:
+        st.subheader("Mixed-Complexity Benchmark Summary")
+        st.dataframe(
+            complexity_frame,
+            use_container_width=True,
+            hide_index=True,
+            column_config={
+                "complexity": st.column_config.TextColumn("Complexity tier"),
+                "rules": st.column_config.NumberColumn("Rules", format="%d"),
+                "python_wins": st.column_config.NumberColumn("Python wins", format="%d"),
+                "dbt_wins": st.column_config.NumberColumn("dbt wins", format="%d"),
+                "soda_wins": st.column_config.NumberColumn("Soda wins", format="%d"),
+                "avg_best_effective_pct": st.column_config.NumberColumn("Avg best effective %", format="%.2f"),
+            },
+        )
+
+    left, right = st.columns([0.72, 0.28], gap="large")
+    with left:
+        st.subheader("Effective Confidence by Rule and Engine")
+        st.plotly_chart(_build_effective_chart(frame), use_container_width=True)
+    with right:
+        st.subheader("Best Engine Distribution")
+        st.plotly_chart(_build_best_engine_chart(frame), use_container_width=True)
+
+    st.subheader("Rule Validation Table (Comparison View)")
+    show_advanced = st.checkbox("Show advanced metrics", value=False)
+    show_providers = st.checkbox("Show provider columns", value=False)
+    jurisdictions = sorted(frame["jurisdiction"].dropna().unique().tolist())
+    selected_jurisdictions = st.multiselect("Filter jurisdiction", options=jurisdictions, default=jurisdictions)
+    table_frame = frame[frame["jurisdiction"].isin(selected_jurisdictions)] if selected_jurisdictions else frame
+    columns = [
+        "rule_name",
+        "jurisdiction",
+        "regulatory_type",
+        "review_status",
+        "legal_citation",
+        "complexity",
+        "condition_type",
+        "severity",
+        "best_engine",
+        "best_effective_pct",
+        "decision_margin",
+        "recommendation",
+    ]
+    if show_advanced:
+        columns.extend(
+            [
+                "best_decision_score",
+                "effective_margin_pct",
+                "python_effective_pct",
+                "dbt_effective_pct",
+                "soda_effective_pct",
+                "python_equivalence_pct",
+                "python_mutation_pct",
+                "python_verification_pct",
+                "python_repair_applied",
+                "python_mismatches",
+                "dbt_mismatches",
+                "soda_mismatches",
+                "python_real_llm",
+                "declarative_tie_break_applied",
+                "selection_reason",
+            ]
+        )
+    if show_providers:
+        columns.extend(["python_provider", "dbt_provider", "soda_provider"])
+    st.dataframe(
+        table_frame[columns],
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "rule_name": st.column_config.TextColumn("Rule"),
+            "jurisdiction": st.column_config.TextColumn("Jurisdiction"),
+            "regulatory_type": st.column_config.TextColumn("Regulatory type"),
+            "review_status": st.column_config.TextColumn("Review status"),
+            "legal_citation": st.column_config.TextColumn("Legal citation"),
+            "complexity": st.column_config.TextColumn("Complexity"),
+            "condition_type": st.column_config.TextColumn("Condition type"),
+            "severity": st.column_config.TextColumn("Severity"),
+            "best_engine": st.column_config.TextColumn("Best migration"),
+            "best_effective_pct": st.column_config.NumberColumn("Best effective %", format="%.2f"),
+            "best_decision_score": st.column_config.NumberColumn("Best decision score", format="%.4f"),
+            "effective_margin_pct": st.column_config.NumberColumn("Win margin %", format="%.2f"),
+            "decision_margin": st.column_config.NumberColumn("Score margin", format="%.4f"),
+            "python_effective_pct": st.column_config.NumberColumn("Python effective %", format="%.2f"),
+            "dbt_effective_pct": st.column_config.NumberColumn("dbt effective %", format="%.2f"),
+            "soda_effective_pct": st.column_config.NumberColumn("Soda effective %", format="%.2f"),
+            "python_equivalence_pct": st.column_config.NumberColumn("Python equiv %", format="%.2f"),
+            "python_mutation_pct": st.column_config.NumberColumn("Python mutation %", format="%.2f"),
+            "python_verification_pct": st.column_config.NumberColumn("Python verify %", format="%.2f"),
+            "python_repair_applied": st.column_config.CheckboxColumn("Repair applied"),
+            "python_mismatches": st.column_config.NumberColumn("Python mismatches", format="%d"),
+            "dbt_mismatches": st.column_config.NumberColumn("dbt mismatches", format="%d"),
+            "soda_mismatches": st.column_config.NumberColumn("Soda mismatches", format="%d"),
+            "python_real_llm": st.column_config.CheckboxColumn("Python real LLM"),
+            "declarative_tie_break_applied": st.column_config.CheckboxColumn("dbt/soda tie-break"),
+            "selection_reason": st.column_config.TextColumn("Selection reason"),
+            "recommendation": st.column_config.TextColumn("Recommendation"),
+            "python_provider": st.column_config.TextColumn("Python provider"),
+            "dbt_provider": st.column_config.TextColumn("dbt provider"),
+            "soda_provider": st.column_config.TextColumn("Soda provider"),
+        },
+    )
+
+    st.subheader("Rule Detail")
+    rule_names = [row.get("rule_name", "") for row in rule_comparison]
+    selected_rule_name = st.selectbox("Select rule", rule_names)
+    selected_rule = next(row for row in rule_comparison if row.get("rule_name") == selected_rule_name)
+
+    d1, d2, d3 = st.columns(3, gap="large")
+    with d1:
+        _render_stat_chip("Best migration", str(selected_rule.get("best_engine", "n/a")).upper())
+    with d2:
+        _render_stat_chip("Severity", str(selected_rule.get("severity", "n/a")))
+    with d3:
+        _render_stat_chip("Products tested", int(selected_rule.get("products_tested", 0)))
+    best_engine = str(selected_rule.get("best_engine", "python"))
+    best_effective = selected_rule.get("engines", {}).get(best_engine, {}).get("effective_confidence", 0.0)
+    detail_row = frame.loc[frame["rule_name"] == selected_rule_name].iloc[0]
+    d4, d5 = st.columns(2, gap="large")
+    with d4:
+        _render_stat_chip("Best effective %", f"{_to_pct(best_effective):.2f}")
+    with d5:
+        _render_stat_chip("Decision margin", f"{float(detail_row['decision_margin']):.4f}")
+
+    st.caption(f"Condition: {selected_rule.get('condition', 'n/a')}")
+    st.caption(f"Rule IR hash: {selected_rule.get('rule_ir_hash', 'n/a')}")
+    st.caption(f"Condition type: {selected_rule.get('condition_type', 'n/a')}")
+    st.caption(f"Complexity tier: {selected_rule.get('complexity', 'n/a')}")
+    st.caption(f"Declarative friendly: {selected_rule.get('declarative_friendly', 'n/a')}")
+    st.caption(f"Jurisdiction: {selected_rule.get('jurisdiction', 'global')}")
+    st.caption(f"Regulatory type: {selected_rule.get('regulatory_type', 'n/a')}")
+    st.caption(f"Legal citation: {selected_rule.get('legal_citation', 'n/a')}")
+    source_url = str(selected_rule.get("source_url", "")).strip()
+    if source_url:
+        st.markdown(f"Source URL: [{source_url}]({source_url})")
+    else:
+        st.caption("Source URL: n/a")
+    st.caption(f"Effective date: {selected_rule.get('effective_date', 'n/a')}")
+    st.caption(f"Review status: {selected_rule.get('review_status', 'n/a')}")
+    st.caption(f"Reviewer: {selected_rule.get('reviewer', 'n/a')}")
+    st.caption(f"Exemption logic: {selected_rule.get('exemption_logic', 'n/a')}")
+    st.caption(f"Selection reason: {selected_rule.get('selection_reason', 'n/a')}")
+    st.caption(f"dbt/soda explicit tie-break applied: {selected_rule.get('declarative_tie_break_applied', False)}")
+    st.caption(f"Recommendation: {selected_rule.get('recommendation', 'n/a')}")
+    soda_meta = selected_rule.get("engines", {}).get("soda", {})
+    st.caption(
+        "Soda execution: "
+        f"mode={soda_meta.get('execution_mode', 'n/a')} | "
+        f"cloud_connected={soda_meta.get('cloud_connected', False)} | "
+        f"scan_id={soda_meta.get('cloud_scan_id', '') or 'n/a'}"
+    )
+    soda_scan_url = str(soda_meta.get("cloud_scan_url", "")).strip()
+    if soda_scan_url:
+        st.markdown(f"Soda Cloud scan URL: [{soda_scan_url}]({soda_scan_url})")
+
+    st.markdown("**Engine metrics for selected rule**")
+    st.dataframe(
+        _engine_detail_frame(selected_rule),
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "engine": st.column_config.TextColumn("Engine"),
+            "status": st.column_config.TextColumn("Status"),
+            "overall_confidence_pct": st.column_config.NumberColumn("Overall %", format="%.2f"),
+            "effective_confidence_pct": st.column_config.NumberColumn("Effective %", format="%.2f"),
+            "decision_score": st.column_config.NumberColumn("Decision score", format="%.4f"),
+            "parity_ci_low_pct": st.column_config.NumberColumn("Parity CI low %", format="%.2f"),
+            "equivalence_pct": st.column_config.NumberColumn("Equivalence %", format="%.2f"),
+            "mutation_pct": st.column_config.NumberColumn("Mutation %", format="%.2f"),
+            "verification_pct": st.column_config.NumberColumn("Verification %", format="%.2f"),
+            "mismatches": st.column_config.NumberColumn("Mismatches", format="%d"),
+            "provider_factor_pct": st.column_config.NumberColumn("Provider factor %", format="%.2f"),
+            "provider": st.column_config.TextColumn("Provider"),
+            "execution_mode": st.column_config.TextColumn("Execution mode"),
+            "cloud_connected": st.column_config.CheckboxColumn("Cloud connected"),
+            "cloud_scan_id": st.column_config.TextColumn("Cloud scan ID"),
+            "cloud_scan_url": st.column_config.TextColumn("Cloud scan URL"),
+            "real_llm_used": st.column_config.CheckboxColumn("Real LLM used"),
+            "repair_applied": st.column_config.CheckboxColumn("Repair applied"),
+            "artifact_lines": st.column_config.NumberColumn("Artifact lines", format="%d"),
+        },
+    )
+
+    st.markdown("**All three migration artifacts for this rule**")
+    c1, c2, c3 = st.columns(3, gap="large")
+    with c1:
+        st.markdown("`PYTHON`")
+        st.code(_engine_artifact(selected_rule, "python"), language="python")
+    with c2:
+        st.markdown("`DBT`")
+        st.code(_engine_artifact(selected_rule, "dbt"), language="sql")
+    with c3:
+        st.markdown("`SODA`")
+        st.code(_engine_artifact(selected_rule, "soda"), language="yaml")
+
+    st.markdown("**Python Equivalence Counterexamples**")
+    python_counterexamples = _engine_equivalence_counterexamples(selected_rule, "python")
+    if python_counterexamples:
+        st.dataframe(pd.DataFrame(python_counterexamples), use_container_width=True, hide_index=True)
+    else:
+        st.success("No Python equivalence counterexamples.")
+
+    st.markdown("**Parity mismatch samples by engine**")
+    for engine, title in [("python", "Python"), ("dbt", "dbt"), ("soda", "Soda")]:
+        st.markdown(f"`{title}`")
+        failed_cases = _engine_failed_cases(selected_rule, engine)
+        if failed_cases:
+            st.dataframe(pd.DataFrame(failed_cases), use_container_width=True, hide_index=True)
+        else:
+            st.success(f"No mismatches for {title}.")
+
+
+if __name__ == "__main__":
+    main()

OFF_DataQuality/data/load_dataset.py

@@ -0,0 +1,494 @@
+"""Dataset utilities for the migration prototype.
+
+This module creates a reduced Open Food Facts-like JSONL dataset and loads
+it into DuckDB for downstream parity validation.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Mapping
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+DB_PATH = PROJECT_ROOT / "off_quality.db"
+SAMPLE_FILE = Path(__file__).resolve().parent / "sample_products.jsonl"
+DEFAULT_OFF_JSONL = PROJECT_ROOT / "openfoodfacts-products.jsonl"
+
+CORE_FIELDS = [
+    "product_id",
+    "energy_kj",
+    "energy_kj_computed",
+    "energy_kcal",
+    "fat",
+    "saturated_fat",
+    "carbohydrates",
+    "sugars",
+    "starch",
+    "sodium",
+    "ingredients_text",
+    "ingredients_text_present",
+    "contains_statement_present",
+    "allergen_evidence_present",
+    "fop_threshold_exceeded",
+    "fop_symbol_present",
+    "fop_exempt_proxy",
+    "product_is_prepackaged_proxy",
+]
+
+# Additional fields used for OFF language-related checks.
+OPTIONAL_FIELDS = ["lc", "lang", "language_code"]
+
+
+def _to_int_flag(value: bool) -> int:
+    return 1 if value else 0
+
+
+def _compute_fop_threshold_exceeded(sugars: object, saturated_fat: object, sodium: object) -> int:
+    """Proxy Front-of-Pack trigger for prototype experiments.
+
+    This is intentionally a simplified threshold model to exercise migration
+    architecture and should not be interpreted as full legal implementation.
+    """
+    sugars_val = _to_float(sugars) or 0.0
+    sat_fat_val = _to_float(saturated_fat) or 0.0
+    sodium_val = _to_float(sodium) or 0.0
+    return _to_int_flag((sugars_val >= 15.0) or (sat_fat_val >= 6.0) or (sodium_val >= 0.6))
+
+
+@dataclass(frozen=True)
+class DatasetConfig:
+    """Configuration for synthetic dataset generation."""
+
+    size: int = 300
+    seed: int = 17
+    output_path: Path = SAMPLE_FILE
+
+
+def _maybe(probability: float, rng: random.Random) -> bool:
+    return rng.random() < probability
+
+
+def _to_float(value: object) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        text = value.strip()
+        if not text:
+            return None
+        try:
+            return float(text)
+        except ValueError:
+            return None
+    return None
+
+
+def _first_number(*values: object) -> float | None:
+    for value in values:
+        parsed = _to_float(value)
+        if parsed is not None:
+            return parsed
+    return None
+
+
+def _apply_deterministic_synthetic_scenarios(index: int, product: Dict[str, object], rng: random.Random) -> None:
+    """Inject deterministic rule-violation scenarios for synthetic datasets.
+
+    This keeps synthetic runs visually informative in the dashboard by ensuring
+    each rule receives recurring, known-positive examples.
+    """
+    bucket = index % 21
+
+    if bucket == 1:
+        # energy_kcal > energy_kj
+        energy_kj = float(product["energy_kj"])
+        product["energy_kcal"] = round(energy_kj + rng.uniform(1.0, 50.0), 1)
+    elif bucket == 2:
+        # energy_kj < (3.7 * energy_kcal - 2)
+        energy_kcal = round(rng.uniform(80.0, 320.0), 1)
+        product["energy_kcal"] = energy_kcal
+        product["energy_kj"] = round((3.7 * energy_kcal) - rng.uniform(3.0, 30.0), 1)
+    elif bucket == 3:
+        # energy_kj > (4.7 * energy_kcal + 2)
+        energy_kcal = round(rng.uniform(80.0, 320.0), 1)
+        product["energy_kcal"] = energy_kcal
+        product["energy_kj"] = round((4.7 * energy_kcal) + rng.uniform(3.0, 30.0), 1)
+    elif bucket == 4:
+        # energy_kj > 3911
+        product["energy_kj"] = round(rng.uniform(3912.0, 5200.0), 1)
+    elif bucket == 5:
+        # saturated_fat > (fat + 0.001)
+        fat = round(rng.uniform(10.0, 80.0), 3)
+        product["fat"] = fat
+        product["saturated_fat"] = round(fat + rng.uniform(0.01, 9.0), 3)
+    elif bucket == 6:
+        # sugars + starch > carbohydrates + 0.001
+        carbs = round(rng.uniform(10.0, 90.0), 3)
+        sugars = round(rng.uniform(3.0, 60.0), 3)
+        starch = round(max((carbs - sugars) + rng.uniform(0.01, 6.0), 0.0), 3)
+        product["carbohydrates"] = carbs
+        product["sugars"] = sugars
+        product["starch"] = starch
+    elif bucket == 7:
+        # fat > 105
+        product["fat"] = round(rng.uniform(106.0, 135.0), 1)
+    elif bucket == 8:
+        # saturated_fat > 105
+        product["saturated_fat"] = round(rng.uniform(106.0, 135.0), 1)
+    elif bucket == 9:
+        # carbohydrates > 105
+        product["carbohydrates"] = round(rng.uniform(106.0, 140.0), 1)
+    elif bucket == 10:
+        # sugars > 105
+        product["sugars"] = round(rng.uniform(106.0, 140.0), 1)
+    elif bucket == 11:
+        # missing lc
+        product["lc"] = ""
+        product["language_code"] = ""
+    elif bucket == 12:
+        # missing lang
+        product["lang"] = ""
+        if product.get("lc"):
+            product["language_code"] = str(product["lc"])
+        else:
+            product["language_code"] = ""
+    elif bucket == 13:
+        # energy_kj_computed < (0.7 * energy_kj - 5)
+        energy_kj = float(product["energy_kj"])
+        product["energy_kj_computed"] = round((0.7 * energy_kj) - rng.uniform(6.0, 25.0), 1)
+    elif bucket == 14:
+        # energy_kj_computed > (1.3 * energy_kj + 5)
+        energy_kj = float(product["energy_kj"])
+        product["energy_kj_computed"] = round((1.3 * energy_kj) + rng.uniform(6.0, 25.0), 1)
+    elif bucket == 15:
+        # Allergen evidence present but ingredients text missing.
+        product["allergen_evidence_present"] = 1
+        product["contains_statement_present"] = 1
+        product["ingredients_text"] = ""
+        product["ingredients_text_present"] = 0
+    elif bucket == 16:
+        # Contains statement present without allergen evidence.
+        product["contains_statement_present"] = 1
+        product["allergen_evidence_present"] = 0
+        product["ingredients_text"] = "Contains: milk, soy."
+        product["ingredients_text_present"] = 1
+    elif bucket == 17:
+        # FOP required but symbol missing.
+        product["fop_threshold_exceeded"] = 1
+        product["fop_symbol_present"] = 0
+        product["fop_exempt_proxy"] = 0
+        product["product_is_prepackaged_proxy"] = 1
+    elif bucket == 18:
+        # FOP symbol present but threshold not exceeded (and not exempt).
+        product["fop_threshold_exceeded"] = 0
+        product["fop_symbol_present"] = 1
+        product["fop_exempt_proxy"] = 0
+        product["product_is_prepackaged_proxy"] = 1
+    elif bucket == 19:
+        # FOP symbol present on exempt product (proxy inconsistency).
+        product["fop_threshold_exceeded"] = 1
+        product["fop_symbol_present"] = 1
+        product["fop_exempt_proxy"] = 1
+        product["product_is_prepackaged_proxy"] = 1
+    elif bucket == 20:
+        # Not prepackaged proxy case (used to suppress FOP obligations).
+        product["product_is_prepackaged_proxy"] = 0
+        product["fop_symbol_present"] = 0
+
+
+def generate_product(index: int, rng: random.Random) -> Dict[str, object]:
+    """Generate a single product with occasional quality rule violations."""
+    energy_kj = rng.randint(50, 4800)
+    energy_kcal = int(round(energy_kj / 4.184))
+
+    fat = round(rng.uniform(0.0, 100.0), 1)
+    saturated_fat = round(rng.uniform(0.0, fat), 1)
+    carbohydrates = round(rng.uniform(0.0, 100.0), 1)
+    sugars = round(rng.uniform(0.0, carbohydrates), 1)
+    starch = round(rng.uniform(0.0, max(carbohydrates - sugars, 0.0)), 1)
+    sodium = round(rng.uniform(0.0, 1.5), 3)
+
+    if _maybe(0.10, rng):
+        energy_kcal = energy_kj + rng.randint(1, 100)
+    if _maybe(0.07, rng):
+        energy_kj = round((3.7 * energy_kcal) - rng.uniform(3.0, 30.0), 1)
+    if _maybe(0.07, rng):
+        energy_kj = round((4.7 * energy_kcal) + rng.uniform(3.0, 30.0), 1)
+    if _maybe(0.08, rng):
+        saturated_fat = round(fat + rng.uniform(0.1, 20.0), 1)
+    if _maybe(0.07, rng):
+        starch = round(max((carbohydrates - sugars) + rng.uniform(0.01, 6.0), 0.0), 1)
+
+    energy_kj_computed = round(float(energy_kj) * rng.uniform(0.92, 1.08), 1)
+    if _maybe(0.06, rng):
+        energy_kj_computed = round((0.65 * float(energy_kj)) - rng.uniform(1.0, 8.0), 1)
+    if _maybe(0.06, rng):
+        energy_kj_computed = round((1.35 * float(energy_kj)) + rng.uniform(1.0, 8.0), 1)
+
+    product: Dict[str, object] = {
+        "product_id": f"{index:013d}",
+        "energy_kj": energy_kj,
+        "energy_kj_computed": energy_kj_computed,
+        "energy_kcal": energy_kcal,
+        "fat": fat,
+        "saturated_fat": saturated_fat,
+        "carbohydrates": carbohydrates,
+        "sugars": sugars,
+        "starch": starch,
+        "sodium": sodium,
+    }
+
+    for nutrient in ("fat", "saturated_fat", "carbohydrates", "sugars"):
+        if _maybe(0.08, rng):
+            product[nutrient] = round(rng.uniform(106.0, 140.0), 1)
+
+    language_code = rng.choices(
+        ["en", "fr", "es", "de", "it", "", None],
+        weights=[0.55, 0.1, 0.08, 0.06, 0.06, 0.08, 0.07],
+        k=1,
+    )[0]
+    lang_value = rng.choices(
+        ["en", "fr", "es", "de", "it", "xx", "", None],
+        weights=[0.5, 0.1, 0.08, 0.06, 0.06, 0.03, 0.09, 0.08],
+        k=1,
+    )[0]
+    product["lc"] = language_code
+    product["lang"] = lang_value
+    product["language_code"] = language_code or lang_value
+    ingredients_text = rng.choices(
+        [
+            "Sugar, milk powder, cocoa butter.",
+            "Water, apple juice concentrate.",
+            "Ingredients: wheat flour, salt, yeast.",
+            "",
+            None,
+        ],
+        weights=[0.30, 0.22, 0.22, 0.16, 0.10],
+        k=1,
+    )[0]
+    product["ingredients_text"] = ingredients_text if ingredients_text is not None else ""
+    product["ingredients_text_present"] = _to_int_flag(str(product["ingredients_text"]).strip() != "")
+
+    # Prototype proxies for Canadian allergen/FOP checks.
+    contains_statement_present = _maybe(0.22, rng)
+    allergen_evidence_present = contains_statement_present or _maybe(0.15, rng)
+    fop_threshold_exceeded = _compute_fop_threshold_exceeded(product.get("sugars"), product.get("saturated_fat"), product.get("sodium"))
+    fop_exempt_proxy = _to_int_flag(_maybe(0.10, rng))
+    product_is_prepackaged_proxy = _to_int_flag(not _maybe(0.05, rng))
+    fop_symbol_present = _to_int_flag(
+        (fop_threshold_exceeded == 1 and _maybe(0.78, rng))
+        or (fop_threshold_exceeded == 0 and _maybe(0.10, rng))
+    )
+
+    product["contains_statement_present"] = _to_int_flag(contains_statement_present)
+    product["allergen_evidence_present"] = _to_int_flag(allergen_evidence_present)
+    product["fop_threshold_exceeded"] = int(fop_threshold_exceeded)
+    product["fop_symbol_present"] = int(fop_symbol_present)
+    product["fop_exempt_proxy"] = int(fop_exempt_proxy)
+    product["product_is_prepackaged_proxy"] = int(product_is_prepackaged_proxy)
+    _apply_deterministic_synthetic_scenarios(index=index, product=product, rng=rng)
+    return product
+
+
+def generate_products(config: DatasetConfig) -> List[Dict[str, object]]:
+    """Generate ``config.size`` synthetic products."""
+    rng = random.Random(config.seed)
+    return [generate_product(i, rng) for i in range(1, config.size + 1)]
+
+
+def extract_product_from_off_record(record: Mapping[str, object]) -> Dict[str, object] | None:
+    """Extract prototype fields from one Open Food Facts product object."""
+    product_id = str(record.get("code") or record.get("_id") or record.get("id") or "").strip()
+    if not product_id:
+        return None
+
+    nutriments = record.get("nutriments")
+    if not isinstance(nutriments, Mapping):
+        nutriments = {}
+
+    energy_kj = _first_number(
+        nutriments.get("energy-kj_100g"),
+        nutriments.get("energy-kj"),
+        nutriments.get("energy_100g"),
+        nutriments.get("energy"),
+    )
+    energy_kcal = _first_number(
+        nutriments.get("energy-kcal_100g"),
+        nutriments.get("energy-kcal"),
+        nutriments.get("energy-kcal_value"),
+        nutriments.get("energy-kcal_value_computed"),
+    )
+    energy_kj_computed = _first_number(
+        nutriments.get("energy-kj_value_computed"),
+        nutriments.get("energy-kj_value-computed"),
+        nutriments.get("energy-kj_computed"),
+    )
+    fat = _first_number(nutriments.get("fat_100g"), nutriments.get("fat"))
+    saturated_fat = _first_number(nutriments.get("saturated-fat_100g"), nutriments.get("saturated-fat"))
+    carbohydrates = _first_number(nutriments.get("carbohydrates_100g"), nutriments.get("carbohydrates"))
+    sugars = _first_number(nutriments.get("sugars_100g"), nutriments.get("sugars"))
+    starch = _first_number(nutriments.get("starch_100g"), nutriments.get("starch"))
+    sodium = _first_number(nutriments.get("sodium_100g"), nutriments.get("sodium"))
+    if sodium is None:
+        salt_value = _first_number(nutriments.get("salt_100g"), nutriments.get("salt"))
+        if salt_value is not None:
+            sodium = round(float(salt_value) * 0.393, 4)
+    lc = record.get("lc")
+    lang = record.get("lang")
+    language_code = lc or lang
+    ingredients_text = str(record.get("ingredients_text") or "").strip()
+
+    allergens_tags = record.get("allergens_tags")
+    allergens_list = allergens_tags if isinstance(allergens_tags, list) else []
+    contains_statement_present = bool(record.get("allergens")) or bool(record.get("traces")) or bool(allergens_list)
+    allergen_evidence_present = contains_statement_present or bool(record.get("allergens_from_ingredients"))
+
+    labels_tags = record.get("labels_tags")
+    labels_list = labels_tags if isinstance(labels_tags, list) else []
+    labels_text = " ".join(str(item).lower() for item in labels_list)
+    fop_symbol_present = (
+        ("high-in-sugars" in labels_text)
+        or ("high-in-sodium" in labels_text)
+        or ("high-in-saturated-fat" in labels_text)
+    )
+
+    categories_tags = record.get("categories_tags")
+    categories_list = categories_tags if isinstance(categories_tags, list) else []
+    categories_text = " ".join(str(item).lower() for item in categories_list)
+    fop_exempt_proxy = ("en:waters" in categories_text) or ("en:unflavoured-waters" in categories_text)
+    product_is_prepackaged_proxy = True
+    fop_threshold_exceeded = _compute_fop_threshold_exceeded(sugars, saturated_fat, sodium)
+
+    return {
+        "product_id": product_id,
+        "energy_kj": energy_kj,
+        "energy_kj_computed": energy_kj_computed,
+        "energy_kcal": energy_kcal,
+        "fat": fat,
+        "saturated_fat": saturated_fat,
+        "carbohydrates": carbohydrates,
+        "sugars": sugars,
+        "starch": starch,
+        "sodium": sodium,
+        "ingredients_text": ingredients_text,
+        "ingredients_text_present": _to_int_flag(ingredients_text != ""),
+        "contains_statement_present": _to_int_flag(contains_statement_present),
+        "allergen_evidence_present": _to_int_flag(allergen_evidence_present),
+        "fop_threshold_exceeded": int(fop_threshold_exceeded),
+        "fop_symbol_present": _to_int_flag(fop_symbol_present),
+        "fop_exempt_proxy": _to_int_flag(fop_exempt_proxy),
+        "product_is_prepackaged_proxy": _to_int_flag(product_is_prepackaged_proxy),
+        "lc": lc,
+        "lang": lang,
+        "language_code": language_code,
+    }
+
+
+def extract_products_from_off_jsonl(source_path: Path, max_products: int = 300) -> List[Dict[str, object]]:
+    """Stream OFF JSONL and extract up to ``max_products`` normalized records."""
+    products: List[Dict[str, object]] = []
+    with source_path.open("r", encoding="utf-8", errors="ignore") as handle:
+        for line in handle:
+            if len(products) >= max_products:
+                break
+            if not line.strip():
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(record, Mapping):
+                continue
+            extracted = extract_product_from_off_record(record)
+            if extracted is not None:
+                products.append(extracted)
+
+    if not products:
+        raise ValueError(f"No usable products extracted from {source_path}")
+    return products
+
+
+def write_products_jsonl(products: Iterable[Dict[str, object]], output_path: Path) -> None:
+    """Persist product records to JSONL."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with output_path.open("w", encoding="utf-8") as handle:
+        for record in products:
+            handle.write(json.dumps(record) + "\n")
+
+
+def read_products_jsonl(path: Path = SAMPLE_FILE) -> List[Dict[str, object]]:
+    """Read products from JSONL into a list."""
+    records: List[Dict[str, object]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                records.append(json.loads(line))
+    return records
+
+
+def create_and_load_dataset(
+    size: int = 300,
+    seed: int = 17,
+    output_path: Path = SAMPLE_FILE,
+    db_path: Path = DB_PATH,
+    source_jsonl: Path | None = None,
+) -> List[Dict[str, object]]:
+    """Build dataset records and load them into DuckDB.
+
+    Notes:
+    - ``seed`` is used only for synthetic generation.
+    - When ``source_jsonl`` is provided, records are streamed from that file and
+      ``seed`` has no effect.
+    """
+    if source_jsonl is not None:
+        products = extract_products_from_off_jsonl(Path(source_jsonl), max_products=size)
+    else:
+        config = DatasetConfig(size=size, seed=seed, output_path=output_path)
+        products = generate_products(config)
+    write_products_jsonl(products, output_path)
+
+    # Local import avoids module cycles between data and duckdb layers.
+    from duckdb_utils.create_tables import load_jsonl_to_duckdb, recreate_nutrition_table
+
+    recreate_nutrition_table(db_path=db_path)
+    load_jsonl_to_duckdb(jsonl_path=output_path, db_path=db_path)
+    return products
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Generate and load prototype dataset.")
+    parser.add_argument("--size", type=int, default=300, help="Number of products (100-500 recommended).")
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=17,
+        help="Random seed for synthetic data reproducibility (ignored when --source-jsonl is set).",
+    )
+    parser.add_argument(
+        "--source-jsonl",
+        type=Path,
+        default=None,
+        help="Path to OFF JSONL source file (if omitted, synthetic data is generated).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    products = create_and_load_dataset(size=args.size, seed=args.seed, source_jsonl=args.source_jsonl)
+    print(f"Generated {len(products)} records at {SAMPLE_FILE}")
+    if args.source_jsonl:
+        print(f"Source dataset: {Path(args.source_jsonl).resolve()}")
+    else:
+        print("Source dataset: synthetic generator")
+    print(f"Loaded dataset into {DB_PATH}")
+
+
+if __name__ == "__main__":
+    main()

OFF_DataQuality/declarative/__init__.py

@@ -0,0 +1,2 @@
+"""Declarative check execution helpers (dbt-core / soda-core prototypes)."""
+

OFF_DataQuality/declarative/check_runners.py

@@ -0,0 +1,742 @@
+"""Declarative check runners for dbt-core and soda-core pilots.
+
+These runners are intentionally lightweight:
+- They always compute violating product IDs from DuckDB SQL conditions
+  (deterministic parity baseline).
+- They optionally execute dbt/soda commands to prove declarative integration.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Mapping, Sequence
+
+import duckdb
+
+from duckdb_utils.create_tables import TABLE_NAME
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+RUNTIME_DIR = PROJECT_ROOT / "results" / "declarative_runtime"
+OUTPUT_TAIL_CHARS = 4000
+
+
+def _sql_for_rule(rule: Mapping[str, object]) -> str:
+    condition = str(rule["duckdb_condition"])
+    return f"SELECT product_id FROM {TABLE_NAME} WHERE {condition}"
+
+
+def _query_rule_product_ids(rule: Mapping[str, object], db_path: Path) -> List[str]:
+    query = _sql_for_rule(rule)
+    with duckdb.connect(db_path.as_posix()) as con:
+        rows = con.execute(query).fetchall()
+    return sorted(str(row[0]) for row in rows)
+
+
+def _build_per_product_tags(
+    rules: Sequence[Mapping[str, object]],
+    per_rule_ids: Dict[str, List[str]],
+    products: Sequence[Mapping[str, object]],
+) -> Dict[str, List[str]]:
+    per_product_tags: Dict[str, List[str]] = {str(product.get("product_id")): [] for product in products}
+    for rule in rules:
+        rule_name = str(rule["rule_name"])
+        tag = str(rule["tag"])
+        for product_id in per_rule_ids[rule_name]:
+            if product_id in per_product_tags:
+                per_product_tags[product_id].append(tag)
+    return per_product_tags
+
+
+def _run_command(command: List[str], cwd: Path, env: Mapping[str, str] | None = None) -> Dict[str, object]:
+    try:
+        full_env = os.environ.copy()
+        if env:
+            full_env.update(env)
+        completed = subprocess.run(
+            command,
+            cwd=cwd,
+            env=full_env,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+            timeout=180,
+        )
+        stdout = completed.stdout or ""
+        stderr = completed.stderr or ""
+        return {
+            "command": " ".join(command),
+            "executed": True,
+            "success": completed.returncode == 0,
+            "return_code": completed.returncode,
+            "stdout_tail": stdout[-OUTPUT_TAIL_CHARS:],
+            "stderr_tail": stderr[-OUTPUT_TAIL_CHARS:],
+        }
+    except FileNotFoundError:
+        return {
+            "command": " ".join(command),
+            "executed": False,
+            "success": False,
+            "return_code": None,
+            "stdout_tail": "",
+            "stderr_tail": f"Command not found: {command[0]}",
+        }
+    except subprocess.TimeoutExpired as exc:
+        return {
+            "command": " ".join(command),
+            "executed": True,
+            "success": False,
+            "return_code": None,
+            "stdout_tail": (exc.stdout or "")[-OUTPUT_TAIL_CHARS:] if exc.stdout else "",
+            "stderr_tail": (exc.stderr or "")[-OUTPUT_TAIL_CHARS:] if exc.stderr else "Command timed out.",
+        }
+
+
+def _soda_cloud_credentials() -> Dict[str, str] | None:
+    api_key_id = os.getenv("SODA_CLOUD_API_KEY_ID", "").strip()
+    api_key_secret = os.getenv("SODA_CLOUD_API_KEY_SECRET", "").strip()
+    host = os.getenv("SODA_CLOUD_HOST", "").strip()
+    if not (api_key_id and api_key_secret and host):
+        return None
+    return {
+        "api_key_id": api_key_id,
+        "api_key_secret": api_key_secret,
+        "host": host,
+    }
+
+
+def _extract_cloud_scan_metadata(stdout_tail: str, stderr_tail: str) -> Dict[str, str]:
+    text = f"{stdout_tail}\n{stderr_tail}"
+    scan_id = ""
+    scan_url = ""
+
+    scan_match = re.search(r"(?:scan[\s_-]?id)\s*[:=]\s*([a-zA-Z0-9\-]+)", text, flags=re.IGNORECASE)
+    if scan_match:
+        scan_id = scan_match.group(1).strip()
+
+    url_match = re.search(r"(https?://[^\s]+)", text)
+    if url_match:
+        scan_url = url_match.group(1).strip().rstrip(".,)")
+
+    return {
+        "scan_id": scan_id,
+        "scan_url": scan_url,
+    }
+
+
+def _write_soda_data_source_config(config_path: Path, data_source_name: str, runtime_db_path: Path) -> None:
+    config_path.write_text(
+        "\n".join(
+            [
+                "type: duckdb",
+                f"name: {data_source_name}",
+                "connection:",
+                f"  database: {runtime_db_path.as_posix()}",
+                "  schema: main",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _resolve_soda_cloud_config(target_path: Path) -> tuple[Path | None, str]:
+    explicit_path = os.getenv("SODA_CLOUD_CONFIG_PATH", "").strip()
+    candidate_paths = []
+    if explicit_path:
+        candidate_paths.append(Path(explicit_path).expanduser())
+    candidate_paths.append(PROJECT_ROOT / "sc_config.yml")
+
+    for candidate in candidate_paths:
+        if candidate.is_file():
+            shutil.copyfile(candidate, target_path)
+            return target_path, str(candidate)
+
+    credentials = _soda_cloud_credentials()
+    if credentials is None:
+        return None, ""
+
+    target_path.write_text(
+        "\n".join(
+            [
+                "soda_cloud:",
+                f"  host: {credentials['host']}",
+                f"  api_key_id: {credentials['api_key_id']}",
+                f"  api_key_secret: {credentials['api_key_secret']}",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return target_path, "env"
+
+
+def _prepare_dbt_project(rules: Sequence[Mapping[str, object]], db_path: Path, root_dir: Path) -> Dict[str, object]:
+    project_dir = root_dir / "dbt_project"
+    tests_dir = project_dir / "tests"
+    models_dir = project_dir / "models"
+    macros_dir = project_dir / "macros"
+    runtime_db_path = root_dir / "dbt_runtime.db"
+    tests_dir.mkdir(parents=True, exist_ok=True)
+    models_dir.mkdir(parents=True, exist_ok=True)
+    macros_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(db_path, runtime_db_path)
+
+    (project_dir / "dbt_project.yml").write_text(
+        "\n".join(
+            [
+                "name: off_quality_declarative",
+                "version: '1.0'",
+                "config-version: 2",
+                "profile: off_quality_duckdb",
+                "model-paths: ['models']",
+                "test-paths: ['tests']",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    (project_dir / "profiles.yml").write_text(
+        "\n".join(
+            [
+                "off_quality_duckdb:",
+                "  target: dev",
+                "  outputs:",
+                "    dev:",
+                "      type: duckdb",
+                f"      path: '{runtime_db_path.as_posix()}'",
+                "      schema: main",
+                "      threads: 1",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    (models_dir / "sources.yml").write_text(
+        "\n".join(
+            [
+                "version: 2",
+                "sources:",
+                "  - name: off_source",
+                "    schema: main",
+                "    tables:",
+                "      - name: nutrition_table",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    test_sql_by_rule: Dict[str, str] = {}
+    for rule in rules:
+        rule_name = str(rule["rule_name"])
+        condition = str(rule["duckdb_condition"])
+        sql = (
+            "SELECT product_id\n"
+            "FROM {{ source('off_source', 'nutrition_table') }}\n"
+            f"WHERE {condition}"
+        )
+        test_sql_by_rule[rule_name] = sql
+        (tests_dir / f"{rule_name}.sql").write_text(sql + "\n", encoding="utf-8")
+
+    # dbt test command uses multiprocessing in this environment and fails with WinError 5.
+    # Use run-operation to execute each rule query in real dbt runtime instead.
+    (macros_dir / "count_violations.sql").write_text(
+        "\n".join(
+            [
+                "{% macro count_violations(condition_sql) %}",
+                "  {% set q %}",
+                "    select count(*) as violation_count",
+                "    from {{ source('off_source', 'nutrition_table') }}",
+                "    where {{ condition_sql }}",
+                "  {% endset %}",
+                "  {% set t = run_query(q) %}",
+                "  {% if execute %}",
+                "    {% set c = t.columns[0].values()[0] %}",
+                "    {% do log('VIOLATION_COUNT=' ~ c, info=True) %}",
+                "  {% endif %}",
+                "{% endmacro %}",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    dbt_cmd = shutil.which("dbt")
+    if not dbt_cmd:
+        return {
+            "run": {
+                "command": "dbt test --project-dir ... --profiles-dir ...",
+                "executed": False,
+                "success": False,
+                "return_code": None,
+                "stdout_tail": "",
+                "stderr_tail": "dbt CLI not found. Install dbt-duckdb.",
+            },
+            "test_sql_by_rule": test_sql_by_rule,
+        }
+
+    debug_info = _run_command(
+        [dbt_cmd, "debug", "--project-dir", str(project_dir), "--profiles-dir", str(project_dir)],
+        cwd=project_dir,
+    )
+    per_rule_runs: Dict[str, Dict[str, object]] = {}
+    for rule in rules:
+        rule_name = str(rule["rule_name"])
+        condition = str(rule["duckdb_condition"])
+        args_yaml = f"{{condition_sql: {condition!r}}}"
+        per_rule_runs[rule_name] = _run_command(
+            [
+                dbt_cmd,
+                "run-operation",
+                "count_violations",
+                "--project-dir",
+                str(project_dir),
+                "--profiles-dir",
+                str(project_dir),
+                "--args",
+                args_yaml,
+            ],
+            cwd=project_dir,
+        )
+
+    all_executed = bool(debug_info.get("executed")) and all(bool(run.get("executed")) for run in per_rule_runs.values())
+    all_success_codes = (
+        debug_info.get("return_code") == 0 and all(run.get("return_code") == 0 for run in per_rule_runs.values())
+    )
+    failing_rules = [rule_name for rule_name, run in per_rule_runs.items() if run.get("return_code") != 0]
+    summary_stdout, summary_stderr = _summarize_soda_runs(per_rule_runs)
+
+    run_info = {
+        "command": (
+            f"dbt debug + dbt run-operation count_violations "
+            f"(per-rule x{len(per_rule_runs)}) --project-dir {project_dir} --profiles-dir {project_dir}"
+        ),
+        "executed": all_executed,
+        "success": all_success_codes,
+        "return_code": 0 if all_success_codes else 2,
+        "stdout_tail": summary_stdout,
+        "stderr_tail": summary_stderr,
+        "real_execution": all_success_codes,
+        "failed_rules": failing_rules,
+    }
+    return {"run": run_info, "test_sql_by_rule": test_sql_by_rule}
+
+
+def _prepare_soda_cloud_scan(
+    rules: Sequence[Mapping[str, object]],
+    db_path: Path,
+    root_dir: Path,
+) -> Dict[str, object]:
+    soda_dir = root_dir / "soda_cloud"
+    soda_dir.mkdir(parents=True, exist_ok=True)
+    runtime_db_path = root_dir / "soda_cloud_runtime.db"
+    shutil.copyfile(db_path, runtime_db_path)
+
+    data_source_name = "off_quality"
+    config_path = soda_dir / "data_source.yml"
+    soda_cloud_config_path = soda_dir / "soda_cloud.yml"
+    contracts_dir = soda_dir / "contracts"
+    contracts_dir.mkdir(parents=True, exist_ok=True)
+
+    check_yaml_by_rule: Dict[str, str] = {}
+    soda_cloud_config, cloud_config_source = _resolve_soda_cloud_config(soda_cloud_config_path)
+    if soda_cloud_config is None:
+        return {
+            "run": {
+                "command": "soda contract verify -c <contract.yml> -ds data_source.yml -sc soda_cloud.yml -p",
+                "executed": False,
+                "success": False,
+                "return_code": None,
+                "stdout_tail": "",
+                "stderr_tail": (
+                    "Soda Cloud config missing. Provide sc_config.yml, set SODA_CLOUD_CONFIG_PATH, "
+                    "or set SODA_CLOUD_API_KEY_ID, SODA_CLOUD_API_KEY_SECRET, SODA_CLOUD_HOST."
+                ),
+                "mode": "cloud",
+                "cloud_connected": False,
+                "cloud_scan_id": "",
+                "cloud_scan_url": "",
+                "real_execution": False,
+                "failed_rules": [str(rule["rule_name"]) for rule in rules],
+            },
+            "check_yaml_by_rule": check_yaml_by_rule,
+        }
+
+    _write_soda_data_source_config(config_path=config_path, data_source_name=data_source_name, runtime_db_path=runtime_db_path)
+
+    soda_cmd = shutil.which("soda")
+    if not soda_cmd:
+        return {
+            "run": {
+                "command": (
+                    f"soda contract verify -c <contract.yml> -ds {config_path} "
+                    f"-sc {soda_cloud_config_path} -p"
+                ),
+                "executed": False,
+                "success": False,
+                "return_code": None,
+                "stdout_tail": "",
+                "stderr_tail": "soda CLI not found. Install soda-duckdb.",
+                "mode": "cloud",
+                "cloud_connected": False,
+                "cloud_scan_id": "",
+                "cloud_scan_url": "",
+                "real_execution": False,
+                "failed_rules": [str(rule["rule_name"]) for rule in rules],
+            },
+            "check_yaml_by_rule": check_yaml_by_rule,
+        }
+
+    with duckdb.connect(db_path.as_posix()) as con:
+        columns = [str(row[1]) for row in con.execute(f"PRAGMA table_info('{TABLE_NAME}')").fetchall()]
+
+    soda_env = {
+        "OTEL_SDK_DISABLED": "true",
+        "PYTHONUTF8": "1",
+        "PYTHONIOENCODING": "utf-8",
+    }
+    per_rule_runs: Dict[str, Dict[str, object]] = {}
+    first_cloud_meta = {"scan_id": "", "scan_url": ""}
+    for rule in rules:
+        rule_name = str(rule["rule_name"])
+        condition = str(rule["duckdb_condition"])
+        check_block = (
+            f"  - failed_rows:\n"
+            f"      name: {rule_name}\n"
+            f"      expression: {condition}\n"
+        )
+        check_yaml_by_rule[rule_name] = check_block.rstrip("\n")
+
+        contract_lines: List[str] = [
+            f"dataset: {data_source_name}/main/{TABLE_NAME}",
+            "columns:",
+        ]
+        for column in columns:
+            contract_lines.append(f"  - name: {column}")
+        contract_lines.extend(["checks:", check_block.rstrip("\n")])
+
+        contract_path = contracts_dir / f"{rule_name}.yml"
+        contract_path.write_text("\n".join(contract_lines) + "\n", encoding="utf-8")
+
+        run = _run_command(
+            [
+                soda_cmd,
+                "contract",
+                "verify",
+                "-c",
+                str(contract_path),
+                "-ds",
+                str(config_path),
+                "-sc",
+                str(soda_cloud_config),
+                "-p",
+                "-v",
+            ],
+            cwd=soda_dir,
+            env=soda_env,
+        )
+        per_rule_runs[rule_name] = run
+        cloud_meta = _extract_cloud_scan_metadata(
+            stdout_tail=str(run.get("stdout_tail", "")),
+            stderr_tail=str(run.get("stderr_tail", "")),
+        )
+        if not first_cloud_meta["scan_id"] and cloud_meta["scan_id"]:
+            first_cloud_meta["scan_id"] = cloud_meta["scan_id"]
+        if not first_cloud_meta["scan_url"] and cloud_meta["scan_url"]:
+            first_cloud_meta["scan_url"] = cloud_meta["scan_url"]
+
+    all_executed = all(bool(run.get("executed")) for run in per_rule_runs.values())
+    all_success_codes = all(run.get("return_code") in {0, 1} for run in per_rule_runs.values())
+    all_real = all(_soda_run_is_real(run) for run in per_rule_runs.values())
+    all_published = all(_soda_cloud_publish_succeeded(run) for run in per_rule_runs.values())
+    failing_rules = [
+        rule_name
+        for rule_name, run in per_rule_runs.items()
+        if not (_soda_run_is_real(run) and _soda_cloud_publish_succeeded(run))
+    ]
+
+    summary_stdout, summary_stderr = _summarize_soda_runs(per_rule_runs)
+
+    run_info = {
+        "command": (
+            f"soda contract verify (per-rule x{len(per_rule_runs)}) -ds {config_path} "
+            f"-sc {soda_cloud_config} -p"
+        ),
+        "executed": all_executed,
+        "success": all_success_codes,
+        "return_code": 0 if all_success_codes else 3,
+        "stdout_tail": summary_stdout,
+        "stderr_tail": summary_stderr,
+        "mode": "cloud",
+        "real_execution": all_real,
+        "cloud_connected": all_published,
+        "cloud_scan_id": first_cloud_meta["scan_id"],
+        "cloud_scan_url": first_cloud_meta["scan_url"],
+        "cloud_config_source": cloud_config_source,
+        "failed_rules": failing_rules,
+    }
+    return {"run": run_info, "check_yaml_by_rule": check_yaml_by_rule}
+
+
+def _prepare_soda_contract(rules: Sequence[Mapping[str, object]], db_path: Path, root_dir: Path) -> Dict[str, object]:
+    soda_dir = root_dir / "soda"
+    soda_dir.mkdir(parents=True, exist_ok=True)
+    data_source_name = "off_quality"
+    runtime_db_path = root_dir / "soda_runtime.db"
+    config_path = soda_dir / "data_source.yml"
+    contracts_dir = soda_dir / "contracts"
+    contracts_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(db_path, runtime_db_path)
+
+    _write_soda_data_source_config(config_path=config_path, data_source_name=data_source_name, runtime_db_path=runtime_db_path)
+
+    with duckdb.connect(db_path.as_posix()) as con:
+        columns = [str(row[1]) for row in con.execute(f"PRAGMA table_info('{TABLE_NAME}')").fetchall()]
+
+    check_yaml_by_rule: Dict[str, str] = {}
+    soda_cmd = shutil.which("soda")
+    if not soda_cmd:
+        return {
+            "run": {
+                "command": f"soda contract verify -c <contract.yml> -ds {config_path}",
+                "executed": False,
+                "success": False,
+                "return_code": None,
+                "stdout_tail": "",
+                "stderr_tail": "soda CLI not found. Install soda-duckdb.",
+            },
+            "check_yaml_by_rule": check_yaml_by_rule,
+        }
+
+    soda_env = {
+        # Avoid blocked telemetry calls and Windows cp1252 console issues with emoji output.
+        "OTEL_SDK_DISABLED": "true",
+        "PYTHONUTF8": "1",
+        "PYTHONIOENCODING": "utf-8",
+    }
+    per_rule_runs: Dict[str, Dict[str, object]] = {}
+    for rule in rules:
+        rule_name = str(rule["rule_name"])
+        condition = str(rule["duckdb_condition"])
+        check_block = (
+            f"  - failed_rows:\n"
+            f"      name: {rule_name}\n"
+            f"      expression: {condition}\n"
+        )
+        check_yaml_by_rule[rule_name] = check_block.rstrip("\n")
+
+        contract_lines: List[str] = [
+            f"dataset: {data_source_name}/main/{TABLE_NAME}",
+            "columns:",
+        ]
+        for column in columns:
+            contract_lines.append(f"  - name: {column}")
+        contract_lines.extend(["checks:", check_block.rstrip("\n")])
+
+        contract_path = contracts_dir / f"{rule_name}.yml"
+        contract_path.write_text("\n".join(contract_lines) + "\n", encoding="utf-8")
+
+        per_rule_runs[rule_name] = _run_command(
+            [soda_cmd, "contract", "verify", "-c", str(contract_path), "-ds", str(config_path)],
+            cwd=soda_dir,
+            env=soda_env,
+        )
+
+    all_executed = all(bool(run.get("executed")) for run in per_rule_runs.values())
+    all_success_codes = all(run.get("return_code") in {0, 1} for run in per_rule_runs.values())
+    all_real = all(_soda_run_is_real(run) for run in per_rule_runs.values())
+    failing_rules = [rule_name for rule_name, run in per_rule_runs.items() if not _soda_run_is_real(run)]
+
+    summary_stdout = "\n".join(
+        f"{rule_name}: rc={run.get('return_code')}, success={run.get('success')}"
+        for rule_name, run in per_rule_runs.items()
+    )[-1200:]
+    summary_stderr = "\n".join(
+        f"{rule_name}: {str(run.get('stderr_tail', '')).strip()}"
+        for rule_name, run in per_rule_runs.items()
+        if str(run.get("stderr_tail", "")).strip()
+    )[-1200:]
+
+    run_info = {
+        "command": f"soda contract verify (per-rule x{len(per_rule_runs)}) -ds {config_path}",
+        "executed": all_executed,
+        "success": all_success_codes,
+        "return_code": 0 if all_success_codes else 3,
+        "stdout_tail": summary_stdout,
+        "stderr_tail": summary_stderr,
+        "mode": "local",
+        "real_execution": all_real,
+        "cloud_connected": False,
+        "cloud_scan_id": "",
+        "cloud_scan_url": "",
+        "failed_rules": failing_rules,
+    }
+    return {"run": run_info, "check_yaml_by_rule": check_yaml_by_rule}
+
+
+def _dbt_run_is_real(run_info: Mapping[str, object]) -> bool:
+    if "real_execution" in run_info:
+        return bool(run_info.get("real_execution"))
+    if not bool(run_info.get("executed")):
+        return False
+    return run_info.get("return_code") in {0, 1}
+
+
+def _soda_run_is_real(run_info: Mapping[str, object]) -> bool:
+    if not bool(run_info.get("executed")):
+        return False
+    output = f"{run_info.get('stdout_tail', '')}\n{run_info.get('stderr_tail', '')}".lower()
+    if "soda v3 commands are not supported" in output:
+        return False
+    if "contract results for" in output:
+        return True
+    if run_info.get("return_code") in {0, 1}:
+        return True
+    return bool(run_info.get("success"))
+
+
+def _soda_cloud_publish_succeeded(run_info: Mapping[str, object]) -> bool:
+    if not bool(run_info.get("executed")):
+        return False
+    output = f"{run_info.get('stdout_tail', '')}\n{run_info.get('stderr_tail', '')}".lower()
+    if "results sent to soda cloud" in output:
+        return True
+    if "to view the dataset on soda cloud" in output:
+        return True
+    if "cloud.soda.io/o/" in output:
+        return True
+    return False
+
+
+def _summarize_soda_runs(per_rule_runs: Mapping[str, Mapping[str, object]]) -> tuple[str, str]:
+    summary_stdout = "\n".join(
+        f"{rule_name}: rc={run.get('return_code')}, success={run.get('success')}"
+        for rule_name, run in per_rule_runs.items()
+    )
+    summary_stderr = "\n".join(
+        f"{rule_name}: {str(run.get('stderr_tail', '')).strip()}"
+        for rule_name, run in per_rule_runs.items()
+        if str(run.get("stderr_tail", "")).strip()
+    )
+
+    for rule_name, run in per_rule_runs.items():
+        if not _soda_run_is_real(run):
+            failing_stdout = str(run.get("stdout_tail", "")).strip()
+            failing_stderr = str(run.get("stderr_tail", "")).strip()
+            if failing_stdout:
+                summary_stdout = f"{summary_stdout}\n\nFirst failing rule: {rule_name}\n{failing_stdout}"
+            if failing_stderr:
+                summary_stderr = f"{summary_stderr}\n\nFirst failing rule: {rule_name}\n{failing_stderr}"
+            break
+
+    return summary_stdout[-1200:], summary_stderr[-1200:]
+
+
+def run_declarative_checks(
+    rules: Sequence[Mapping[str, object]],
+    products: Sequence[Mapping[str, object]],
+    db_path: Path,
+    engine: str,
+    soda_mode: str = "local",
+) -> Dict[str, object]:
+    """Run declarative checks and return parity-compatible output payload."""
+    if engine not in {"dbt", "soda"}:
+        raise ValueError(f"Unsupported declarative engine: {engine}")
+    if soda_mode not in {"local", "cloud"}:
+        raise ValueError("soda_mode must be one of: local, cloud")
+
+    runtime_root = RUNTIME_DIR / engine
+    runtime_root.mkdir(parents=True, exist_ok=True)
+
+    per_rule_ids: Dict[str, List[str]] = {}
+    for rule in rules:
+        per_rule_ids[str(rule["rule_name"])] = _query_rule_product_ids(rule, db_path=db_path)
+
+    per_product_tags = _build_per_product_tags(rules=rules, per_rule_ids=per_rule_ids, products=products)
+
+    if engine == "dbt":
+        artifact = _prepare_dbt_project(rules=rules, db_path=db_path, root_dir=runtime_root)
+        run_info = artifact["run"]
+        snippets = artifact["test_sql_by_rule"]
+        is_real = _dbt_run_is_real(run_info)
+        provider = "dbt_core" if is_real else "dbt_core_sql_fallback"
+        confidence = 0.99 if is_real else 0.92
+        note_prefix = (
+            "dbt tests executed through dbt-core."
+            if is_real
+            else "dbt execution unavailable/failed; used SQL-equivalent declarative parity."
+        )
+    else:
+        if soda_mode == "cloud":
+            cloud_artifact = _prepare_soda_cloud_scan(rules=rules, db_path=db_path, root_dir=runtime_root)
+            cloud_run = cloud_artifact["run"]
+            snippets = cloud_artifact["check_yaml_by_rule"]
+            cloud_ok = bool(cloud_run.get("cloud_connected")) and bool(cloud_run.get("real_execution"))
+            if cloud_ok:
+                run_info = cloud_run
+                is_real = True
+                provider = "soda_cloud"
+                confidence = 0.99
+                note_prefix = "Soda Cloud scan executed successfully."
+            else:
+                run_info = dict(cloud_run)
+                run_info.update(
+                    {
+                        "mode": "cloud_sql_fallback",
+                        "real_execution": False,
+                        "cloud_connected": bool(cloud_run.get("cloud_connected", False)),
+                        "cloud_scan_id": str(cloud_run.get("cloud_scan_id", "")),
+                        "cloud_scan_url": str(cloud_run.get("cloud_scan_url", "")),
+                        "failed_rules": [str(rule["rule_name"]) for rule in rules],
+                    }
+                )
+                is_real = False
+                provider = "soda_core_sql_fallback"
+                confidence = 0.92
+                note_prefix = "Soda Cloud unavailable/failed; used SQL-equivalent declarative parity (fast fallback)."
+        else:
+            artifact = _prepare_soda_contract(rules=rules, db_path=db_path, root_dir=runtime_root)
+            run_info = artifact["run"]
+            snippets = artifact["check_yaml_by_rule"]
+            is_real = bool(run_info.get("real_execution")) or _soda_run_is_real(run_info)
+            provider = "soda_core" if is_real else "soda_core_sql_fallback"
+            confidence = 0.99 if is_real else 0.92
+            note_prefix = (
+                "Soda contract verification executed through soda-core."
+                if is_real
+                else "Soda execution unavailable/failed; used SQL-equivalent declarative parity."
+            )
+
+    conversion_metadata: Dict[str, Dict[str, object]] = {}
+    for rule in rules:
+        rule_name = str(rule["rule_name"])
+        conversion_metadata[rule_name] = {
+            "function_name": f"{engine}_{rule_name}",
+            "python_code": snippets.get(rule_name, _sql_for_rule(rule)),
+            "llm_confidence": confidence,
+            "conversion_notes": (
+                f"{note_prefix} "
+                f"Command: {run_info['command']} | "
+                f"Success: {run_info['success']} | "
+                f"Return code: {run_info['return_code']}"
+            ),
+            "provider": provider,
+            "execution_mode": str(run_info.get("mode", "local")),
+            "cloud_connected": bool(run_info.get("cloud_connected", False)),
+            "cloud_scan_id": str(run_info.get("cloud_scan_id", "")),
+            "cloud_scan_url": str(run_info.get("cloud_scan_url", "")),
+        }
+
+    return {
+        "per_product": per_product_tags,
+        "per_rule": per_rule_ids,
+        "conversion_metadata": conversion_metadata,
+        "engine_run": run_info,
+    }

OFF_DataQuality/duckdb_utils/create_tables.py

@@ -0,0 +1,116 @@
+"""DuckDB helpers for the migration prototype."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List
+
+import duckdb
+
+DB_PATH = Path(__file__).resolve().parent.parent / "off_quality.db"
+TABLE_NAME = "nutrition_table"
+
+SCHEMA_SQL = f"""
+CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
+    product_id TEXT,
+    energy_kj DOUBLE,
+    energy_kj_computed DOUBLE,
+    energy_kcal DOUBLE,
+    fat DOUBLE,
+    saturated_fat DOUBLE,
+    carbohydrates DOUBLE,
+    sugars DOUBLE,
+    starch DOUBLE,
+    sodium DOUBLE,
+    ingredients_text TEXT,
+    ingredients_text_present INTEGER,
+    contains_statement_present INTEGER,
+    allergen_evidence_present INTEGER,
+    fop_threshold_exceeded INTEGER,
+    fop_symbol_present INTEGER,
+    fop_exempt_proxy INTEGER,
+    product_is_prepackaged_proxy INTEGER,
+    lc TEXT,
+    lang TEXT,
+    language_code TEXT
+)
+"""
+
+
+def connect(db_path: Path = DB_PATH) -> duckdb.DuckDBPyConnection:
+    return duckdb.connect(db_path.as_posix())
+
+
+def recreate_nutrition_table(db_path: Path = DB_PATH) -> None:
+    """Drop and recreate the main table for deterministic runs."""
+    with connect(db_path) as con:
+        con.execute(f"DROP TABLE IF EXISTS {TABLE_NAME}")
+        con.execute(SCHEMA_SQL)
+
+
+def load_jsonl_to_duckdb(jsonl_path: Path, db_path: Path = DB_PATH) -> None:
+    """Load JSONL records into DuckDB."""
+    with connect(db_path) as con:
+        con.execute(
+            f"""
+            INSERT INTO {TABLE_NAME}
+            SELECT
+                product_id,
+                energy_kj,
+                energy_kj_computed,
+                energy_kcal,
+                fat,
+                saturated_fat,
+                carbohydrates,
+                sugars,
+                starch,
+                sodium,
+                ingredients_text,
+                ingredients_text_present,
+                contains_statement_present,
+                allergen_evidence_present,
+                fop_threshold_exceeded,
+                fop_symbol_present,
+                fop_exempt_proxy,
+                product_is_prepackaged_proxy,
+                lc,
+                lang,
+                language_code
+            FROM read_json_auto(?)
+            """,
+            [jsonl_path.as_posix()],
+        )
+
+
+def fetch_products(db_path: Path = DB_PATH) -> List[Dict[str, object]]:
+    """Read all products from DuckDB as dictionaries."""
+    with connect(db_path) as con:
+        rows = con.execute(f"SELECT * FROM {TABLE_NAME}").fetchdf()
+    return rows.to_dict("records")
+
+
+def count_rows(db_path: Path = DB_PATH) -> int:
+    with connect(db_path) as con:
+        value = con.execute(f"SELECT COUNT(*) FROM {TABLE_NAME}").fetchone()
+    return int(value[0] if value else 0)
+
+
+def count_violations(condition_sql: str, db_path: Path = DB_PATH) -> int:
+    """Count records matching a rule condition."""
+    query = f"SELECT COUNT(*) FROM {TABLE_NAME} WHERE {condition_sql}"
+    with connect(db_path) as con:
+        value = con.execute(query).fetchone()
+    return int(value[0] if value else 0)
+
+
+def sample_violations(condition_sql: str, limit: int = 5, db_path: Path = DB_PATH) -> List[Dict[str, object]]:
+    """Return sample violating records for dashboard drilldown."""
+    query = f"""
+        SELECT *
+        FROM {TABLE_NAME}
+        WHERE {condition_sql}
+        ORDER BY product_id
+        LIMIT {int(limit)}
+    """
+    with connect(db_path) as con:
+        rows = con.execute(query).fetchdf()
+    return rows.to_dict("records")

OFF_DataQuality/extractor/perl_logic_extractor.py

@@ -0,0 +1,316 @@
+"""Perl logic extractor for converting legacy checks into structured rules."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Dict, Iterable, List, Mapping, Sequence
+
+RULE_NAME_RE = re.compile(r"#\s*RULE_NAME:\s*(?P<value>[a-zA-Z0-9_]+)")
+SEVERITY_RE = re.compile(r"#\s*SEVERITY:\s*(?P<value>[a-zA-Z0-9_]+)")
+COMPLEXITY_RE = re.compile(r"#\s*COMPLEXITY:\s*(?P<value>[a-zA-Z0-9_]+)")
+DECLARATIVE_RE = re.compile(r"#\s*DECLARATIVE_FRIENDLY:\s*(?P<value>[a-zA-Z0-9_]+)")
+TAG_RE = re.compile(r'"(?P<tag>[a-z0-9\-]+)"\s*;')
+
+VAR_COMPARE_RE = re.compile(
+    r"if\s*\(\s*\$(?P<left>[a-zA-Z_]\w*)\s*(?P<op>>=|<=|>|<|==|!=)\s*\$(?P<right>[a-zA-Z_]\w*)\s*\)",
+    re.DOTALL,
+)
+VALUE_COMPARE_RE = re.compile(
+    r"if\s*\(\s*\$(?P<left>[a-zA-Z_]\w*)\s*(?P<op>>=|<=|>|<|==|!=)\s*(?P<right>\d+(?:\.\d+)?)\s*\)",
+    re.DOTALL,
+)
+MISSING_FIELD_RE = re.compile(
+    r'if\s*\(\s*!defined\s+\$(?P<field>[a-zA-Z_]\w*)\s*\|\|\s*\$(?P=field)\s+eq\s+""\s*\)',
+    re.DOTALL,
+)
+SCALED_FIELD_COMPARE_RE = re.compile(
+    r"if\s*\(\s*\$(?P<left>[a-zA-Z_]\w*)\s*(?P<op>>=|<=|>|<|==|!=)\s*\(\s*\$(?P<right>[a-zA-Z_]\w*)\s*\*\s*(?P<factor>\d+(?:\.\d+)?)\s*\)\s*\)",
+    re.DOTALL,
+)
+AFFINE_FIELD_COMPARE_RE = re.compile(
+    r"if\s*\(\s*\$(?P<left>[a-zA-Z_]\w*)\s*(?P<op>>=|<=|>|<|==|!=)\s*\(\s*(?P<factor>\d+(?:\.\d+)?)\s*\*\s*\$(?P<right>[a-zA-Z_]\w*)\s*(?P<sign>[+-])\s*(?P<offset>\d+(?:\.\d+)?)\s*\)\s*\)",
+    re.DOTALL,
+)
+SUM_FIELDS_COMPARE_RE = re.compile(
+    r"if\s*\(\s*\(\s*\$(?P<left_a>[a-zA-Z_]\w*)\s*\+\s*\$(?P<left_b>[a-zA-Z_]\w*)\s*\)\s*(?P<op>>=|<=|>|<|==|!=)\s*\(\s*\$(?P<right>[a-zA-Z_]\w*)\s*(?P<sign>[+-])\s*(?P<offset>\d+(?:\.\d+)?)\s*\)\s*\)",
+    re.DOTALL,
+)
+IF_CONDITION_RE = re.compile(r"if\s*\(\s*(?P<condition>.*?)\s*\)\s*\{", re.DOTALL)
+THRESHOLD_CLAUSE_RE = re.compile(
+    r"^\s*\(?\s*\$(?P<left>[a-zA-Z_]\w*)\s*(?P<op>>=|<=|>|<|==|!=)\s*(?P<right>\d+(?:\.\d+)?)\s*\)?\s*$"
+)
+
+
+def _extract_named_value(pattern: re.Pattern[str], text: str, default: str) -> str:
+    match = pattern.search(text)
+    if not match:
+        return default
+    return match.group("value").strip()
+
+
+def _extract_tag(perl_logic: str) -> str:
+    match = TAG_RE.search(perl_logic)
+    if not match:
+        raise ValueError(f"Unable to extract tag from Perl logic:\n{perl_logic}")
+    return match.group("tag")
+
+
+def _default_rule_name(tag: str) -> str:
+    return tag.replace("-", "_")
+
+
+def _parse_declarative_flag(value: str) -> bool:
+    return value.strip().lower() in {"yes", "true", "1", "y"}
+
+
+def _default_complexity(condition_type: str) -> str:
+    if condition_type in {"field_comparison", "field_threshold", "missing_field"}:
+        return "simple"
+    if condition_type == "compound_threshold_and":
+        return "medium"
+    if condition_type == "sum_fields_comparison":
+        return "medium"
+    if condition_type == "affine_field_comparison":
+        return "intricate"
+    return "intricate"
+
+
+def _build_rule_ir(rule: Mapping[str, object]) -> Dict[str, object]:
+    condition_type = str(rule.get("condition_type", "unknown"))
+    ir: Dict[str, object] = {
+        "version": "1.0",
+        "rule_name": rule.get("rule_name"),
+        "condition_type": condition_type,
+        "severity": rule.get("severity"),
+        "tag": rule.get("tag"),
+    }
+    if condition_type in {"field_comparison", "field_threshold", "missing_field", "scaled_field_comparison", "affine_field_comparison"}:
+        ir["left_operand"] = rule.get("left_operand")
+    if condition_type in {"field_comparison", "field_threshold", "scaled_field_comparison", "affine_field_comparison", "sum_fields_comparison"}:
+        ir["operator"] = rule.get("operator")
+    if condition_type in {"field_comparison", "field_threshold", "scaled_field_comparison", "affine_field_comparison", "sum_fields_comparison"}:
+        ir["right_operand"] = rule.get("right_operand")
+    if condition_type == "sum_fields_comparison":
+        ir["left_operands"] = rule.get("left_operands")
+        ir["right_offset"] = rule.get("right_offset")
+    if condition_type == "scaled_field_comparison":
+        ir["scale_factor"] = rule.get("scale_factor")
+    if condition_type == "affine_field_comparison":
+        ir["scale_factor"] = rule.get("scale_factor")
+        ir["offset"] = rule.get("offset")
+    if condition_type == "compound_threshold_and":
+        ir["clauses"] = rule.get("clauses")
+    return ir
+
+
+def _attach_rule_ir(rule: Dict[str, object]) -> Dict[str, object]:
+    ir = _build_rule_ir(rule)
+    ir_json = json.dumps(ir, sort_keys=True, default=str)
+    rule["rule_ir"] = ir
+    rule["rule_ir_hash"] = hashlib.sha1(ir_json.encode("utf-8")).hexdigest()[:12]
+    return rule
+
+
+def extract_rule(perl_logic: str) -> Dict[str, object]:
+    """Extract one structured rule from a Perl snippet."""
+    perl_logic = perl_logic.lstrip("\ufeff").strip()
+    tag = _extract_tag(perl_logic)
+    rule_name = _extract_named_value(RULE_NAME_RE, perl_logic, _default_rule_name(tag))
+    severity = _extract_named_value(SEVERITY_RE, perl_logic, "error")
+    complexity_meta = _extract_named_value(COMPLEXITY_RE, perl_logic, "")
+    declarative_meta = _extract_named_value(DECLARATIVE_RE, perl_logic, "")
+    declarative_friendly = _parse_declarative_flag(declarative_meta) if declarative_meta else None
+
+    missing_match = MISSING_FIELD_RE.search(perl_logic)
+    if missing_match:
+        field = missing_match.group("field")
+        return {
+            "rule_name": rule_name,
+            "condition": f"missing({field})",
+            "duckdb_condition": f"{field} IS NULL OR TRIM({field}) = ''",
+            "condition_type": "missing_field",
+            "left_operand": field,
+            "operator": "missing",
+            "right_operand": None,
+            "complexity": complexity_meta or _default_complexity("missing_field"),
+            "declarative_friendly": True if declarative_friendly is None else declarative_friendly,
+            "tag": tag,
+            "severity": severity,
+            "perl_logic": perl_logic.strip(),
+        }
+
+    scaled_match = SCALED_FIELD_COMPARE_RE.search(perl_logic)
+    if scaled_match:
+        left = scaled_match.group("left")
+        operator = scaled_match.group("op")
+        right = scaled_match.group("right")
+        factor = float(scaled_match.group("factor"))
+        condition = f"{left} {operator} ({right} * {factor})"
+        return {
+            "rule_name": rule_name,
+            "condition": condition,
+            "duckdb_condition": f"{left} {operator} ({right} * {factor})",
+            "condition_type": "scaled_field_comparison",
+            "left_operand": left,
+            "operator": operator,
+            "right_operand": right,
+            "scale_factor": factor,
+            "complexity": complexity_meta or _default_complexity("scaled_field_comparison"),
+            "declarative_friendly": False if declarative_friendly is None else declarative_friendly,
+            "tag": tag,
+            "severity": severity,
+            "perl_logic": perl_logic.strip(),
+        }
+
+    affine_match = AFFINE_FIELD_COMPARE_RE.search(perl_logic)
+    if affine_match:
+        left = affine_match.group("left")
+        operator = affine_match.group("op")
+        right = affine_match.group("right")
+        factor = float(affine_match.group("factor"))
+        offset = float(affine_match.group("offset"))
+        if affine_match.group("sign") == "-":
+            offset *= -1.0
+        offset_sign = "+" if offset >= 0 else "-"
+        offset_abs = abs(offset)
+        condition = f"{left} {operator} ({factor} * {right} {offset_sign} {offset_abs})"
+        return {
+            "rule_name": rule_name,
+            "condition": condition,
+            "duckdb_condition": condition,
+            "condition_type": "affine_field_comparison",
+            "left_operand": left,
+            "operator": operator,
+            "right_operand": right,
+            "scale_factor": factor,
+            "offset": offset,
+            "complexity": complexity_meta or _default_complexity("affine_field_comparison"),
+            "declarative_friendly": False if declarative_friendly is None else declarative_friendly,
+            "tag": tag,
+            "severity": severity,
+            "perl_logic": perl_logic.strip(),
+        }
+
+    sum_match = SUM_FIELDS_COMPARE_RE.search(perl_logic)
+    if sum_match:
+        left_a = sum_match.group("left_a")
+        left_b = sum_match.group("left_b")
+        operator = sum_match.group("op")
+        right = sum_match.group("right")
+        offset = float(sum_match.group("offset"))
+        if sum_match.group("sign") == "-":
+            offset *= -1.0
+        offset_sign = "+" if offset >= 0 else "-"
+        offset_abs = abs(offset)
+        condition = f"({left_a} + {left_b}) {operator} ({right} {offset_sign} {offset_abs})"
+        return {
+            "rule_name": rule_name,
+            "condition": condition,
+            "duckdb_condition": condition,
+            "condition_type": "sum_fields_comparison",
+            "left_operands": [left_a, left_b],
+            "operator": operator,
+            "right_operand": right,
+            "right_offset": offset,
+            "left_operand": None,
+            "complexity": complexity_meta or _default_complexity("sum_fields_comparison"),
+            "declarative_friendly": True if declarative_friendly is None else declarative_friendly,
+            "tag": tag,
+            "severity": severity,
+            "perl_logic": perl_logic.strip(),
+        }
+
+    if "&&" in perl_logic:
+        condition_match = IF_CONDITION_RE.search(perl_logic)
+        if condition_match:
+            condition_body = condition_match.group("condition").strip()
+            clauses: List[Dict[str, object]] = []
+            for part in [token.strip() for token in condition_body.split("&&")]:
+                clause_match = THRESHOLD_CLAUSE_RE.match(part)
+                if not clause_match:
+                    clauses = []
+                    break
+                clauses.append(
+                    {
+                        "left_operand": clause_match.group("left"),
+                        "operator": clause_match.group("op"),
+                        "right_operand": float(clause_match.group("right")),
+                    }
+                )
+            if clauses:
+                duckdb_condition = " AND ".join(
+                    f"{clause['left_operand']} {clause['operator']} {clause['right_operand']}" for clause in clauses
+                )
+                condition = " && ".join(
+                    f"{clause['left_operand']} {clause['operator']} {clause['right_operand']}" for clause in clauses
+                )
+                return {
+                    "rule_name": rule_name,
+                    "condition": condition,
+                    "duckdb_condition": duckdb_condition,
+                    "condition_type": "compound_threshold_and",
+                    "clauses": clauses,
+                    "left_operand": None,
+                    "operator": "&&",
+                    "right_operand": None,
+                    "complexity": complexity_meta or _default_complexity("compound_threshold_and"),
+                    "declarative_friendly": True if declarative_friendly is None else declarative_friendly,
+                    "tag": tag,
+                    "severity": severity,
+                    "perl_logic": perl_logic.strip(),
+                }
+
+    var_match = VAR_COMPARE_RE.search(perl_logic)
+    if var_match:
+        left = var_match.group("left")
+        operator = var_match.group("op")
+        right = var_match.group("right")
+        condition = f"{left} {operator} {right}"
+        return {
+            "rule_name": rule_name,
+            "condition": condition,
+            "duckdb_condition": condition,
+            "condition_type": "field_comparison",
+            "left_operand": left,
+            "operator": operator,
+            "right_operand": right,
+            "complexity": complexity_meta or _default_complexity("field_comparison"),
+            "declarative_friendly": True if declarative_friendly is None else declarative_friendly,
+            "tag": tag,
+            "severity": severity,
+            "perl_logic": perl_logic.strip(),
+        }
+
+    value_match = VALUE_COMPARE_RE.search(perl_logic)
+    if value_match:
+        left = value_match.group("left")
+        operator = value_match.group("op")
+        right = value_match.group("right")
+        condition = f"{left} {operator} {right}"
+        return {
+            "rule_name": rule_name,
+            "condition": condition,
+            "duckdb_condition": condition,
+            "condition_type": "field_threshold",
+            "left_operand": left,
+            "operator": operator,
+            "right_operand": float(right),
+            "complexity": complexity_meta or _default_complexity("field_threshold"),
+            "declarative_friendly": True if declarative_friendly is None else declarative_friendly,
+            "tag": tag,
+            "severity": severity,
+            "perl_logic": perl_logic.strip(),
+        }
+
+    raise ValueError(f"Unsupported Perl condition format:\n{perl_logic}")
+
+
+def extract_rules(perl_snippets: Sequence[str] | str) -> List[Dict[str, object]]:
+    """Extract structured rules from Perl snippets."""
+    snippets: Iterable[str]
+    if isinstance(perl_snippets, str):
+        snippets = [chunk.strip() for chunk in perl_snippets.split("\n\n") if chunk.strip()]
+    else:
+        snippets = perl_snippets
+    return [_attach_rule_ir(extract_rule(snippet)) for snippet in snippets]

OFF_DataQuality/inspect_duckdb.py

@@ -0,0 +1,6 @@
+import duckdb
+
+print('module', duckdb)
+print('attrs', dir(duckdb))
+print('has_connect', 'connect' in dir(duckdb))
+print('location', getattr(duckdb, '__file__', None))

OFF_DataQuality/llm-test/test_groq.py

@@ -0,0 +1,26 @@
+import os
+
+from openai import OpenAI
+
+
+def main() -> None:
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        raise RuntimeError("GROQ_API_KEY is not set. Set it in your shell before running.")
+
+    client = OpenAI(
+        api_key=api_key,
+        base_url="https://api.groq.com/openai/v1",
+    )
+
+    response = client.chat.completions.create(
+        model="openai/gpt-oss-120b",
+        messages=[{"role": "user", "content": "Explain quantum tunnelling in one paragraph"}],
+        temperature=0.7,
+        max_tokens=500,
+    )
+    print(response.choices[0].message.content)
+
+
+if __name__ == "__main__":
+    main()

OFF_DataQuality/migration/llm_converter.py

@@ -0,0 +1,714 @@
+"""LLM-style conversion from structured rules to Python check code."""
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import asdict, dataclass
+from typing import Dict, List, Sequence
+
+
+@dataclass(frozen=True)
+class ConversionResult:
+    rule_name: str
+    function_name: str
+    python_code: str
+    llm_confidence: float
+    conversion_notes: str
+    provider: str
+
+
+def _safe_identifier(name: str) -> str:
+    sanitized = re.sub(r"[^a-zA-Z0-9_]", "_", name).strip("_")
+    if not sanitized:
+        sanitized = "generated_rule"
+    if sanitized[0].isdigit():
+        sanitized = f"rule_{sanitized}"
+    return sanitized
+
+
+def _python_literal(value: object) -> str:
+    if isinstance(value, str):
+        return repr(value)
+    if isinstance(value, (int, float)):
+        return str(value)
+    if value is None:
+        return "None"
+    return repr(str(value))
+
+
+def _confidence_for_rule(rule: Dict[str, object]) -> float:
+    condition_type = str(rule.get("condition_type", ""))
+    if condition_type == "field_comparison":
+        return 0.98
+    if condition_type == "field_threshold":
+        return 0.96
+    if condition_type == "missing_field":
+        return 0.93
+    if condition_type == "sum_fields_comparison":
+        return 0.91
+    if condition_type == "compound_threshold_and":
+        return 0.90
+    if condition_type == "affine_field_comparison":
+        return 0.89
+    if condition_type == "scaled_field_comparison":
+        return 0.88
+    return 0.80
+
+
+def _build_python_code(rule: Dict[str, object], function_name: str) -> str:
+    tag_literal = _python_literal(rule["tag"])
+    condition_type = str(rule.get("condition_type"))
+
+    if condition_type == "field_comparison":
+        left = str(rule["left_operand"])
+        right = str(rule["right_operand"])
+        operator = str(rule["operator"])
+        return f"""def {function_name}(product):
+    left_raw = product.get({left!r})
+    right_raw = product.get({right!r})
+    try:
+        left_value = float(left_raw)
+        right_value = float(right_raw)
+    except (TypeError, ValueError):
+        return None
+    if left_value {operator} right_value:
+        return {tag_literal}
+    return None
+"""
+
+    if condition_type == "field_threshold":
+        left = str(rule["left_operand"])
+        operator = str(rule["operator"])
+        right_literal = _python_literal(rule["right_operand"])
+        return f"""def {function_name}(product):
+    left_raw = product.get({left!r})
+    try:
+        left_value = float(left_raw)
+    except (TypeError, ValueError):
+        return None
+    if left_value {operator} {right_literal}:
+        return {tag_literal}
+    return None
+"""
+
+    if condition_type == "missing_field":
+        field = str(rule["left_operand"])
+        return f"""def {function_name}(product):
+    value = product.get({field!r})
+    if value is None or str(value).strip() == "":
+        return {tag_literal}
+    return None
+"""
+
+    if condition_type == "scaled_field_comparison":
+        left = str(rule["left_operand"])
+        right = str(rule["right_operand"])
+        operator = str(rule["operator"])
+        factor = float(rule["scale_factor"])
+        return f"""def {function_name}(product):
+    left_raw = product.get({left!r})
+    right_raw = product.get({right!r})
+    try:
+        left_value = float(left_raw)
+        right_value = float(right_raw)
+    except (TypeError, ValueError):
+        return None
+    scaled_value = right_value * {factor}
+    if left_value {operator} scaled_value:
+        return {tag_literal}
+    return None
+"""
+
+    if condition_type == "compound_threshold_and":
+        clauses = list(rule.get("clauses", []))
+        lines = [
+            f"def {function_name}(product):",
+            "    try:",
+        ]
+        for idx, clause in enumerate(clauses):
+            field = str(clause["left_operand"])
+            lines.append(f"        value_{idx} = float(product.get({field!r}))")
+        lines.append("    except (TypeError, ValueError):")
+        lines.append("        return None")
+        checks: List[str] = []
+        for idx, clause in enumerate(clauses):
+            operator = str(clause["operator"])
+            threshold = float(clause["right_operand"])
+            checks.append(f"(value_{idx} {operator} {threshold})")
+        joined = " and ".join(checks) if checks else "False"
+        lines.append(f"    if {joined}:")
+        lines.append(f"        return {tag_literal}")
+        lines.append("    return None")
+        return "\n".join(lines) + "\n"
+
+    if condition_type == "affine_field_comparison":
+        left = str(rule["left_operand"])
+        right = str(rule["right_operand"])
+        operator = str(rule["operator"])
+        factor = float(rule["scale_factor"])
+        offset = float(rule["offset"])
+        return f"""def {function_name}(product):
+    left_raw = product.get({left!r})
+    right_raw = product.get({right!r})
+    try:
+        left_value = float(left_raw)
+        right_value = float(right_raw)
+    except (TypeError, ValueError):
+        return None
+    target = ({factor} * right_value) + ({offset})
+    if left_value {operator} target:
+        return {tag_literal}
+    return None
+"""
+
+    if condition_type == "sum_fields_comparison":
+        left_operands = list(rule.get("left_operands", []))
+        if len(left_operands) != 2:
+            raise ValueError("sum_fields_comparison requires exactly two left_operands.")
+        left_a = str(left_operands[0])
+        left_b = str(left_operands[1])
+        right = str(rule["right_operand"])
+        operator = str(rule["operator"])
+        right_offset = float(rule["right_offset"])
+        return f"""def {function_name}(product):
+    left_a_raw = product.get({left_a!r})
+    left_b_raw = product.get({left_b!r})
+    right_raw = product.get({right!r})
+    try:
+        left_a_value = float(left_a_raw)
+        left_b_value = float(left_b_raw)
+        right_value = float(right_raw)
+    except (TypeError, ValueError):
+        return None
+    left_sum = left_a_value + left_b_value
+    right_target = right_value + ({right_offset})
+    if left_sum {operator} right_target:
+        return {tag_literal}
+    return None
+"""
+
+    raise ValueError(f"Unsupported condition type: {condition_type}")
+
+
+def _extract_code_block(text: str) -> str:
+    match = re.search(r"```(?:python)?\s*(?P<code>.*?)```", text, re.DOTALL | re.IGNORECASE)
+    if match:
+        return match.group("code").strip()
+    return text.strip()
+
+
+def _validate_generated_code(code: str, function_name: str) -> None:
+    namespace: Dict[str, object] = {}
+    exec(code, {}, namespace)
+    fn = namespace.get(function_name)
+    if not callable(fn):
+        raise ValueError(f"Generated code does not define callable `{function_name}`.")
+    # Basic runtime contract checks to avoid unsafe generated code.
+    probe_products = [
+        {},
+        {
+            "energy_kj": None,
+            "energy_kj_computed": None,
+            "energy_kcal": 100.0,
+            "fat": None,
+            "saturated_fat": None,
+            "carbohydrates": None,
+            "sugars": None,
+            "language_code": None,
+            "ingredients_text_present": None,
+            "contains_statement_present": None,
+            "allergen_evidence_present": None,
+            "fop_threshold_exceeded": None,
+            "fop_symbol_present": None,
+            "fop_exempt_proxy": None,
+            "product_is_prepackaged_proxy": None,
+        },
+        {
+            "energy_kj": 100.0,
+            "energy_kj_computed": 100.0,
+            "energy_kcal": 10.0,
+            "fat": 10.0,
+            "saturated_fat": 2.0,
+            "carbohydrates": 15.0,
+            "sugars": 5.0,
+            "language_code": "en",
+            "ingredients_text_present": 1,
+            "contains_statement_present": 0,
+            "allergen_evidence_present": 0,
+            "fop_threshold_exceeded": 0,
+            "fop_symbol_present": 0,
+            "fop_exempt_proxy": 0,
+            "product_is_prepackaged_proxy": 1,
+        },
+    ]
+    for product in probe_products:
+        try:
+            result = fn(product)
+        except Exception as exc:  # noqa: BLE001 - intentional hard guard for generated code
+            raise ValueError(f"Generated function raised {exc.__class__.__name__}: {exc}") from exc
+        if result is not None and not isinstance(result, str):
+            raise ValueError("Generated function must return str or None.")
+
+
+def _comparison_truth_pairs(operator_token: str) -> tuple[tuple[float, float], tuple[float, float]]:
+    pairs = {
+        ">": ((2.0, 1.0), (1.0, 2.0)),
+        "<": ((1.0, 2.0), (2.0, 1.0)),
+        ">=": ((2.0, 2.0), (1.0, 2.0)),
+        "<=": ((2.0, 2.0), (3.0, 2.0)),
+        "==": ((2.0, 2.0), (2.0, 3.0)),
+        "!=": ((2.0, 3.0), (2.0, 2.0)),
+    }
+    if operator_token not in pairs:
+        raise ValueError(f"Unsupported comparison operator: {operator_token}")
+    return pairs[operator_token]
+
+
+def _threshold_truth_values(operator_token: str, threshold: float) -> tuple[float, float]:
+    if operator_token == ">":
+        return threshold + 1.0, threshold
+    if operator_token == "<":
+        return threshold - 1.0, threshold
+    if operator_token == ">=":
+        return threshold, threshold - 1.0
+    if operator_token == "<=":
+        return threshold, threshold + 1.0
+    if operator_token == "==":
+        return threshold, threshold + 1.0
+    if operator_token == "!=":
+        return threshold + 1.0, threshold
+    raise ValueError(f"Unsupported threshold operator: {operator_token}")
+
+
+def _semantic_test_cases(rule: Dict[str, object]) -> List[tuple[Dict[str, object], str | None, str]]:
+    condition_type = str(rule.get("condition_type"))
+    tag = str(rule["tag"])
+
+    if condition_type == "field_comparison":
+        left = str(rule["left_operand"])
+        right = str(rule["right_operand"])
+        operator_token = str(rule["operator"])
+        true_pair, false_pair = _comparison_truth_pairs(operator_token)
+        return [
+            ({left: true_pair[0], right: true_pair[1]}, tag, "comparison_true"),
+            ({left: false_pair[0], right: false_pair[1]}, None, "comparison_false"),
+            ({left: None, right: true_pair[1]}, None, "comparison_missing_left"),
+            ({left: true_pair[0], right: None}, None, "comparison_missing_right"),
+            ({left: "nan_text", right: true_pair[1]}, None, "comparison_non_numeric_left"),
+        ]
+
+    if condition_type == "field_threshold":
+        left = str(rule["left_operand"])
+        operator_token = str(rule["operator"])
+        threshold = float(rule["right_operand"])
+        true_value, false_value = _threshold_truth_values(operator_token, threshold)
+        return [
+            ({left: true_value}, tag, "threshold_true"),
+            ({left: false_value}, None, "threshold_false"),
+            ({left: None}, None, "threshold_missing"),
+            ({left: "nan_text"}, None, "threshold_non_numeric"),
+        ]
+
+    if condition_type == "missing_field":
+        field = str(rule["left_operand"])
+        return [
+            ({field: None}, tag, "missing_none"),
+            ({field: ""}, tag, "missing_empty_string"),
+            ({field: "   "}, tag, "missing_whitespace"),
+            ({field: "en"}, None, "missing_present"),
+        ]
+
+    if condition_type == "scaled_field_comparison":
+        left = str(rule["left_operand"])
+        right = str(rule["right_operand"])
+        operator_token = str(rule["operator"])
+        factor = float(rule["scale_factor"])
+        true_right = 10.0
+        scaled = true_right * factor
+        if operator_token == ">":
+            true_left, false_left = scaled + 1.0, scaled - 1.0
+        elif operator_token == ">=":
+            true_left, false_left = scaled, scaled - 1.0
+        elif operator_token == "<":
+            true_left, false_left = scaled - 1.0, scaled + 1.0
+        elif operator_token == "<=":
+            true_left, false_left = scaled, scaled + 1.0
+        elif operator_token == "==":
+            true_left, false_left = scaled, scaled + 1.0
+        elif operator_token == "!=":
+            true_left, false_left = scaled + 1.0, scaled
+        else:
+            raise ValueError(f"Unsupported scaled comparison operator: {operator_token}")
+        return [
+            ({left: true_left, right: true_right}, tag, "scaled_true"),
+            ({left: false_left, right: true_right}, None, "scaled_false"),
+            ({left: None, right: true_right}, None, "scaled_missing_left"),
+            ({left: true_left, right: None}, None, "scaled_missing_right"),
+            ({left: "nan_text", right: true_right}, None, "scaled_non_numeric"),
+        ]
+
+    if condition_type == "affine_field_comparison":
+        left = str(rule["left_operand"])
+        right = str(rule["right_operand"])
+        operator_token = str(rule["operator"])
+        factor = float(rule["scale_factor"])
+        offset = float(rule["offset"])
+        true_right = 10.0
+        target = (factor * true_right) + offset
+        if operator_token == ">":
+            true_left, false_left = target + 1.0, target - 1.0
+        elif operator_token == ">=":
+            true_left, false_left = target, target - 1.0
+        elif operator_token == "<":
+            true_left, false_left = target - 1.0, target + 1.0
+        elif operator_token == "<=":
+            true_left, false_left = target, target + 1.0
+        elif operator_token == "==":
+            true_left, false_left = target, target + 1.0
+        elif operator_token == "!=":
+            true_left, false_left = target + 1.0, target
+        else:
+            raise ValueError(f"Unsupported affine comparison operator: {operator_token}")
+        return [
+            ({left: true_left, right: true_right}, tag, "affine_true"),
+            ({left: false_left, right: true_right}, None, "affine_false"),
+            ({left: None, right: true_right}, None, "affine_missing_left"),
+            ({left: true_left, right: None}, None, "affine_missing_right"),
+            ({left: "nan_text", right: true_right}, None, "affine_non_numeric"),
+        ]
+
+    if condition_type == "sum_fields_comparison":
+        left_operands = list(rule.get("left_operands", []))
+        if len(left_operands) != 2:
+            raise ValueError("sum_fields_comparison rule must define two left operands.")
+        left_a = str(left_operands[0])
+        left_b = str(left_operands[1])
+        right = str(rule["right_operand"])
+        operator_token = str(rule["operator"])
+        right_offset = float(rule["right_offset"])
+        right_value = 20.0
+        target = right_value + right_offset
+        if operator_token == ">":
+            true_sum, false_sum = target + 1.0, target - 1.0
+        elif operator_token == ">=":
+            true_sum, false_sum = target, target - 1.0
+        elif operator_token == "<":
+            true_sum, false_sum = target - 1.0, target + 1.0
+        elif operator_token == "<=":
+            true_sum, false_sum = target, target + 1.0
+        elif operator_token == "==":
+            true_sum, false_sum = target, target + 1.0
+        elif operator_token == "!=":
+            true_sum, false_sum = target + 1.0, target
+        else:
+            raise ValueError(f"Unsupported sum comparison operator: {operator_token}")
+
+        true_a = true_sum / 2.0
+        true_b = true_sum - true_a
+        false_a = false_sum / 2.0
+        false_b = false_sum - false_a
+        return [
+            ({left_a: true_a, left_b: true_b, right: right_value}, tag, "sum_true"),
+            ({left_a: false_a, left_b: false_b, right: right_value}, None, "sum_false"),
+            ({left_a: None, left_b: true_b, right: right_value}, None, "sum_missing_left_a"),
+            ({left_a: true_a, left_b: None, right: right_value}, None, "sum_missing_left_b"),
+            ({left_a: true_a, left_b: true_b, right: None}, None, "sum_missing_right"),
+        ]
+
+    if condition_type == "compound_threshold_and":
+        clauses = list(rule.get("clauses", []))
+        if not clauses:
+            raise ValueError("compound_threshold_and rule must define clauses.")
+        true_product: Dict[str, object] = {}
+        false_product: Dict[str, object] = {}
+        missing_product: Dict[str, object] = {}
+        for idx, clause in enumerate(clauses):
+            field = str(clause["left_operand"])
+            operator_token = str(clause["operator"])
+            threshold = float(clause["right_operand"])
+            true_value, false_value = _threshold_truth_values(operator_token, threshold)
+            true_product[field] = true_value
+            false_product[field] = true_value
+            missing_product[field] = true_value
+            if idx == 0:
+                false_product[field] = false_value
+                missing_product[field] = None
+        return [
+            (true_product, tag, "compound_true"),
+            (false_product, None, "compound_false"),
+            (missing_product, None, "compound_missing"),
+        ]
+
+    raise ValueError(f"Unsupported condition type for semantic checks: {condition_type}")
+
+
+def _validate_generated_semantics(code: str, function_name: str, rule: Dict[str, object]) -> None:
+    namespace: Dict[str, object] = {}
+    exec(code, {}, namespace)
+    fn = namespace.get(function_name)
+    if not callable(fn):
+        raise ValueError(f"Generated code does not define callable `{function_name}`.")
+
+    for product, expected, case_name in _semantic_test_cases(rule):
+        try:
+            result = fn(product)
+        except Exception as exc:  # noqa: BLE001
+            raise ValueError(f"Semantic test `{case_name}` raised {exc.__class__.__name__}: {exc}") from exc
+        if result != expected:
+            raise ValueError(
+                f"Semantic test `{case_name}` failed: expected {expected!r}, got {result!r}."
+            )
+
+
+def _normalize_function_name(code: str, function_name: str) -> str:
+    """Rename the first generated function to the expected runtime name."""
+    match = re.search(r"def\s+(?P<name>[a-zA-Z_]\w*)\s*\(", code)
+    if not match:
+        return code
+    found_name = match.group("name")
+    if found_name == function_name:
+        return code
+    start, end = match.span("name")
+    return code[:start] + function_name + code[end:]
+
+
+def _build_llm_prompt(rule: Dict[str, object], function_name: str) -> str:
+    rule_payload = {
+        "rule_name": rule["rule_name"],
+        "tag": rule["tag"],
+        "condition_type": rule["condition_type"],
+        "condition": rule.get("condition"),
+        "duckdb_condition": rule.get("duckdb_condition"),
+        "left_operand": rule.get("left_operand"),
+        "left_operands": rule.get("left_operands"),
+        "operator": rule.get("operator"),
+        "right_operand": rule.get("right_operand"),
+        "scale_factor": rule.get("scale_factor"),
+        "offset": rule.get("offset"),
+        "right_offset": rule.get("right_offset"),
+        "clauses": rule.get("clauses"),
+        "complexity": rule.get("complexity"),
+    }
+    examples: List[Dict[str, object]] = []
+    for product, expected, case_name in _semantic_test_cases(rule):
+        examples.append({"case": case_name, "input": product, "expected": expected})
+    return (
+        "Generate one Python function for a data-quality rule.\n"
+        f"Function name must be exactly: {function_name}\n"
+        "Input: product (dict)\n"
+        "Output: return the rule tag string if the VIOLATION condition is TRUE; else return None.\n"
+        "Important: do NOT invert the condition.\n"
+        "Important: return only Python code, no markdown, no explanation.\n"
+        "Behavior requirements:\n"
+        "- field_comparison and field_threshold rules: if value is missing/non-numeric, return None.\n"
+        '- missing_field rule: None, empty string "", or whitespace-only string => return tag.\n'
+        "- Otherwise return None.\n"
+        f"Rule JSON: {json.dumps(rule_payload)}\n"
+        f"Validation examples (must pass): {json.dumps(examples)}"
+    )
+
+
+def _build_llm_repair_prompt(
+    rule: Dict[str, object],
+    function_name: str,
+    previous_code: str,
+    error_message: str,
+) -> str:
+    return (
+        "Your previous function failed validator checks.\n"
+        f"Validation error: {error_message}\n"
+        "Fix the function so all examples pass.\n"
+        "Return only corrected Python code.\n"
+        f"Previous code:\n{previous_code}\n\n"
+        f"{_build_llm_prompt(rule, function_name)}"
+    )
+
+
+def _call_groq(
+    rule: Dict[str, object],
+    function_name: str,
+    model: str,
+    prompt: str | None = None,
+) -> str:
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        raise RuntimeError("GROQ_API_KEY is not set.")
+
+    try:
+        from openai import OpenAI
+    except Exception as exc:  # noqa: BLE001
+        raise RuntimeError("openai package is required for Groq provider.") from exc
+
+    endpoint = os.getenv("GROQ_ENDPOINT", "https://api.groq.com/openai/v1")
+    client = OpenAI(api_key=api_key, base_url=endpoint)
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": "You are a strict Python code generator for data quality rules."},
+            {"role": "user", "content": prompt or _build_llm_prompt(rule, function_name)},
+        ],
+        temperature=0.0,
+    )
+    content = response.choices[0].message.content
+    if not isinstance(content, str):
+        content = str(content)
+    return _extract_code_block(content)
+
+
+def convert_rule_to_python(
+    rule: Dict[str, object],
+    provider: str = "groq",
+    model: str | None = None,
+) -> ConversionResult:
+    """Convert one structured rule to Python code and confidence metadata."""
+    function_name = f"check_{_safe_identifier(str(rule['rule_name']))}"
+    confidence = _confidence_for_rule(rule)
+    provider_used = provider
+
+    if provider == "groq":
+        strict_llm = os.getenv("LLM_STRICT", "0").strip().lower() in {"1", "true", "yes", "on"}
+        chosen_model = model or os.getenv("GROQ_MODEL", "openai/gpt-oss-120b")
+        first_attempt_code = ""
+        try:
+            python_code = _call_groq(rule, function_name=function_name, model=chosen_model)
+            first_attempt_code = python_code
+            python_code = _normalize_function_name(python_code, function_name=function_name)
+            _validate_generated_code(python_code, function_name=function_name)
+            _validate_generated_semantics(python_code, function_name=function_name, rule=rule)
+            notes = f"Converted via Groq ({chosen_model})."
+            confidence = min(0.99, confidence + 0.01)
+        except (
+            RuntimeError,
+            ValueError,
+            TypeError,
+            json.JSONDecodeError,
+            TimeoutError,
+        ) as exc:
+            repair_exc: Exception | None = None
+            try:
+                repair_prompt = _build_llm_repair_prompt(
+                    rule=rule,
+                    function_name=function_name,
+                    previous_code=first_attempt_code or "# no usable code returned in first attempt",
+                    error_message=f"{exc.__class__.__name__}: {exc}",
+                )
+                python_code = _call_groq(
+                    rule,
+                    function_name=function_name,
+                    model=chosen_model,
+                    prompt=repair_prompt,
+                )
+                python_code = _normalize_function_name(python_code, function_name=function_name)
+                _validate_generated_code(python_code, function_name=function_name)
+                _validate_generated_semantics(python_code, function_name=function_name, rule=rule)
+                notes = f"Converted via Groq ({chosen_model}) after repair pass."
+                confidence = min(0.99, confidence + 0.005)
+            except (
+                RuntimeError,
+                ValueError,
+                TypeError,
+                json.JSONDecodeError,
+                TimeoutError,
+            ) as second_exc:
+                repair_exc = second_exc
+
+            if repair_exc is not None:
+                if strict_llm:
+                    raise RuntimeError(
+                        f"Groq conversion failed and LLM_STRICT=1 is enabled. "
+                        f"First error: {exc.__class__.__name__}: {exc} | "
+                        f"Repair error: {repair_exc.__class__.__name__}: {repair_exc}"
+                    ) from repair_exc
+                python_code = _build_python_code(rule, function_name=function_name)
+                _validate_generated_code(python_code, function_name=function_name)
+                _validate_generated_semantics(python_code, function_name=function_name, rule=rule)
+                notes = (
+                    f"Groq conversion failed after retry "
+                    f"(first: {exc.__class__.__name__}: {exc}; "
+                    f"retry: {repair_exc.__class__.__name__}: {repair_exc}). "
+                    "Fell back to deterministic converter."
+                )
+                provider_used = "simulated_fallback"
+                confidence = max(0.70, confidence - 0.05)
+    else:
+        if provider not in {"simulated", "simulated_fallback"}:
+            provider_used = "simulated_fallback"
+        python_code = _build_python_code(rule, function_name=function_name)
+        _validate_generated_code(python_code, function_name=function_name)
+        _validate_generated_semantics(python_code, function_name=function_name, rule=rule)
+        notes = f"Converted {rule['condition_type']} rule using deterministic template."
+
+    return ConversionResult(
+        rule_name=str(rule["rule_name"]),
+        function_name=function_name,
+        python_code=python_code,
+        llm_confidence=confidence,
+        conversion_notes=notes,
+        provider=provider_used,
+    )
+
+
+def _build_counterexample_repair_prompt(
+    rule: Dict[str, object],
+    function_name: str,
+    previous_code: str,
+    counterexamples: Sequence[Dict[str, object]],
+) -> str:
+    limited = list(counterexamples)[:5]
+    return (
+        "Your previous code fails equivalence against legacy Perl behavior.\n"
+        "Fix the function using these concrete failing examples.\n"
+        "Return only Python code.\n"
+        f"Function name must remain: {function_name}\n"
+        f"Counterexamples: {json.dumps(limited)}\n"
+        f"Previous code:\n{previous_code}\n\n"
+        f"{_build_llm_prompt(rule, function_name)}"
+    )
+
+
+def repair_conversion_with_counterexamples(
+    rule: Dict[str, object],
+    converted_rule: Dict[str, object],
+    counterexamples: Sequence[Dict[str, object]],
+    provider: str = "groq",
+    model: str | None = None,
+) -> Dict[str, object]:
+    """Attempt counterexample-driven repair for an already converted rule."""
+    if provider != "groq":
+        return dict(converted_rule)
+    if not counterexamples:
+        return dict(converted_rule)
+
+    function_name = str(converted_rule["function_name"])
+    previous_code = str(converted_rule["python_code"])
+    chosen_model = model or os.getenv("GROQ_MODEL", "openai/gpt-oss-120b")
+    repair_prompt = _build_counterexample_repair_prompt(
+        rule=rule,
+        function_name=function_name,
+        previous_code=previous_code,
+        counterexamples=counterexamples,
+    )
+    repaired_code = _call_groq(rule, function_name=function_name, model=chosen_model, prompt=repair_prompt)
+    repaired_code = _normalize_function_name(repaired_code, function_name=function_name)
+    _validate_generated_code(repaired_code, function_name=function_name)
+    _validate_generated_semantics(repaired_code, function_name=function_name, rule=rule)
+
+    repaired = dict(converted_rule)
+    repaired["python_code"] = repaired_code
+    repaired["provider"] = "groq"
+    repaired["llm_confidence"] = min(0.99, float(converted_rule.get("llm_confidence", 0.9)) + 0.01)
+    repaired["conversion_notes"] = (
+        f"{converted_rule.get('conversion_notes', '')} "
+        "Counterexample-driven Groq repair applied."
+    ).strip()
+    return repaired
+
+
+def convert_rules(
+    rules: Sequence[Dict[str, object]],
+    provider: str = "groq",
+    model: str | None = None,
+) -> List[Dict[str, object]]:
+    """Batch convert structured rules to generated Python snippets."""
+    return [asdict(convert_rule_to_python(rule, provider=provider, model=model)) for rule in rules]

OFF_DataQuality/perl_checks/legacy_checks.py

@@ -0,0 +1,590 @@
+"""Simulated legacy Perl checks for migration parity testing."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Dict, List, Mapping, Sequence, Set
+
+Product = Mapping[str, object]
+
+
+@dataclass(frozen=True)
+class LegacyRule:
+    rule_name: str
+    tag: str
+    severity: str
+    condition: str
+    duckdb_condition: str
+    complexity: str
+    declarative_friendly: bool
+    perl_logic: str
+    evaluator: Callable[[Product], bool]
+
+
+def _to_float(value: object) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _greater_than(left_value: object, right_value: object) -> bool:
+    left = _to_float(left_value)
+    right = _to_float(right_value)
+    return left is not None and right is not None and left > right
+
+
+def _greater_than_plus_offset(left_value: object, right_value: object, offset: float) -> bool:
+    left = _to_float(left_value)
+    right = _to_float(right_value)
+    return left is not None and right is not None and left > (right + offset)
+
+
+def _affine_compare(
+    left_value: object,
+    right_value: object,
+    operator: str,
+    factor: float,
+    offset: float,
+) -> bool:
+    left = _to_float(left_value)
+    right = _to_float(right_value)
+    if left is None or right is None:
+        return False
+    target = (factor * right) + offset
+    if operator == ">":
+        return left > target
+    if operator == "<":
+        return left < target
+    if operator == ">=":
+        return left >= target
+    if operator == "<=":
+        return left <= target
+    if operator == "==":
+        return left == target
+    if operator == "!=":
+        return left != target
+    return False
+
+
+def _sum_compare(
+    left_a: object,
+    left_b: object,
+    operator: str,
+    right: object,
+    right_offset: float,
+) -> bool:
+    left_a_num = _to_float(left_a)
+    left_b_num = _to_float(left_b)
+    right_num = _to_float(right)
+    if left_a_num is None or left_b_num is None or right_num is None:
+        return False
+    left_sum = left_a_num + left_b_num
+    right_value = right_num + right_offset
+    if operator == ">":
+        return left_sum > right_value
+    if operator == "<":
+        return left_sum < right_value
+    if operator == ">=":
+        return left_sum >= right_value
+    if operator == "<=":
+        return left_sum <= right_value
+    if operator == "==":
+        return left_sum == right_value
+    if operator == "!=":
+        return left_sum != right_value
+    return False
+
+
+def _is_missing(value: object) -> bool:
+    return value is None or str(value).strip() == ""
+
+
+def _compare_values(left_value: object, operator: str, right_value: object) -> bool:
+    left = _to_float(left_value)
+    right = _to_float(right_value)
+    if left is None or right is None:
+        return False
+    if operator == ">":
+        return left > right
+    if operator == "<":
+        return left < right
+    if operator == ">=":
+        return left >= right
+    if operator == "<=":
+        return left <= right
+    if operator == "==":
+        return left == right
+    if operator == "!=":
+        return left != right
+    return False
+
+
+LEGACY_RULES: List[LegacyRule] = [
+    LegacyRule(
+        rule_name="energy_kcal_vs_kj",
+        tag="energy-value-in-kcal-greater-than-in-kj",
+        severity="error",
+        condition="energy_kcal > energy_kj",
+        duckdb_condition="energy_kcal > energy_kj",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: energy_kcal_vs_kj
+# SEVERITY: error
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($energy_kcal > $energy_kj) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kcal-greater-than-in-kj";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than(product.get("energy_kcal"), product.get("energy_kj")),
+    ),
+    LegacyRule(
+        rule_name="energy_kj_mismatch_low",
+        tag="energy-value-in-kcal-does-not-match-value-in-kj-low",
+        severity="error",
+        condition="energy_kj < (3.7 * energy_kcal - 2)",
+        duckdb_condition="energy_kj < (3.7 * energy_kcal - 2)",
+        complexity="intricate",
+        declarative_friendly=False,
+        perl_logic="""
+# RULE_NAME: energy_kj_mismatch_low
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj < (3.7 * $energy_kcal - 2)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kcal-does-not-match-value-in-kj-low";
+}
+""".strip(),
+        evaluator=lambda product: _affine_compare(
+            product.get("energy_kj"),
+            product.get("energy_kcal"),
+            operator="<",
+            factor=3.7,
+            offset=-2.0,
+        ),
+    ),
+    LegacyRule(
+        rule_name="energy_kj_mismatch_high",
+        tag="energy-value-in-kcal-does-not-match-value-in-kj-high",
+        severity="error",
+        condition="energy_kj > (4.7 * energy_kcal + 2)",
+        duckdb_condition="energy_kj > (4.7 * energy_kcal + 2)",
+        complexity="intricate",
+        declarative_friendly=False,
+        perl_logic="""
+# RULE_NAME: energy_kj_mismatch_high
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj > (4.7 * $energy_kcal + 2)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kcal-does-not-match-value-in-kj-high";
+}
+""".strip(),
+        evaluator=lambda product: _affine_compare(
+            product.get("energy_kj"),
+            product.get("energy_kcal"),
+            operator=">",
+            factor=4.7,
+            offset=2.0,
+        ),
+    ),
+    LegacyRule(
+        rule_name="energy_kj_over_3911",
+        tag="value-over-3911-energy",
+        severity="error",
+        condition="energy_kj > 3911",
+        duckdb_condition="energy_kj > 3911",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: energy_kj_over_3911
+# SEVERITY: error
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($energy_kj > 3911) {
+    push @{$product_ref->{$data_quality_tags}}, "value-over-3911-energy";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than(product.get("energy_kj"), 3911),
+    ),
+    LegacyRule(
+        rule_name="energy_kj_computed_mismatch_low",
+        tag="energy-value-in-kj-does-not-match-value-computed-from-other-nutrients-low",
+        severity="error",
+        condition="energy_kj_computed < (0.7 * energy_kj - 5)",
+        duckdb_condition="energy_kj_computed < (0.7 * energy_kj - 5)",
+        complexity="intricate",
+        declarative_friendly=False,
+        perl_logic="""
+# RULE_NAME: energy_kj_computed_mismatch_low
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj_computed < (0.7 * $energy_kj - 5)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kj-does-not-match-value-computed-from-other-nutrients-low";
+}
+""".strip(),
+        evaluator=lambda product: _affine_compare(
+            product.get("energy_kj_computed"),
+            product.get("energy_kj"),
+            operator="<",
+            factor=0.7,
+            offset=-5.0,
+        ),
+    ),
+    LegacyRule(
+        rule_name="energy_kj_computed_mismatch_high",
+        tag="energy-value-in-kj-does-not-match-value-computed-from-other-nutrients-high",
+        severity="error",
+        condition="energy_kj_computed > (1.3 * energy_kj + 5)",
+        duckdb_condition="energy_kj_computed > (1.3 * energy_kj + 5)",
+        complexity="intricate",
+        declarative_friendly=False,
+        perl_logic="""
+# RULE_NAME: energy_kj_computed_mismatch_high
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj_computed > (1.3 * $energy_kj + 5)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kj-does-not-match-value-computed-from-other-nutrients-high";
+}
+""".strip(),
+        evaluator=lambda product: _affine_compare(
+            product.get("energy_kj_computed"),
+            product.get("energy_kj"),
+            operator=">",
+            factor=1.3,
+            offset=5.0,
+        ),
+    ),
+    LegacyRule(
+        rule_name="saturated_fat_vs_fat",
+        tag="saturated-fat-greater-than-fat",
+        severity="error",
+        condition="saturated_fat > (1 * fat + 0.001)",
+        duckdb_condition="saturated_fat > (1 * fat + 0.001)",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: saturated_fat_vs_fat
+# SEVERITY: error
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($saturated_fat > (1 * $fat + 0.001)) {
+    push @{$product_ref->{$data_quality_tags}}, "saturated-fat-greater-than-fat";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than_plus_offset(product.get("saturated_fat"), product.get("fat"), 0.001),
+    ),
+    LegacyRule(
+        rule_name="sugars_plus_starch_vs_carbohydrates",
+        tag="sugars-plus-starch-greater-than-carbohydrates",
+        severity="error",
+        condition="(sugars + starch) > (carbohydrates + 0.001)",
+        duckdb_condition="(sugars + starch) > (carbohydrates + 0.001)",
+        complexity="medium",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: sugars_plus_starch_vs_carbohydrates
+# SEVERITY: error
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($sugars + $starch) > ($carbohydrates + 0.001)) {
+    push @{$product_ref->{$data_quality_tags}}, "sugars-plus-starch-greater-than-carbohydrates";
+}
+""".strip(),
+        evaluator=lambda product: _sum_compare(
+            product.get("sugars"),
+            product.get("starch"),
+            operator=">",
+            right=product.get("carbohydrates"),
+            right_offset=0.001,
+        ),
+    ),
+    LegacyRule(
+        rule_name="fat_over_105g",
+        tag="fat-value-over-105g",
+        severity="warning",
+        condition="fat > 105",
+        duckdb_condition="fat > 105",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: fat_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($fat > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "fat-value-over-105g";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than(product.get("fat"), 105),
+    ),
+    LegacyRule(
+        rule_name="saturated_fat_over_105g",
+        tag="saturated-fat-value-over-105g",
+        severity="warning",
+        condition="saturated_fat > 105",
+        duckdb_condition="saturated_fat > 105",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: saturated_fat_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($saturated_fat > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "saturated-fat-value-over-105g";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than(product.get("saturated_fat"), 105),
+    ),
+    LegacyRule(
+        rule_name="carbohydrates_over_105g",
+        tag="carbohydrates-value-over-105g",
+        severity="warning",
+        condition="carbohydrates > 105",
+        duckdb_condition="carbohydrates > 105",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: carbohydrates_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($carbohydrates > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "carbohydrates-value-over-105g";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than(product.get("carbohydrates"), 105),
+    ),
+    LegacyRule(
+        rule_name="sugars_over_105g",
+        tag="sugars-value-over-105g",
+        severity="warning",
+        condition="sugars > 105",
+        duckdb_condition="sugars > 105",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: sugars_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($sugars > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "sugars-value-over-105g";
+}
+""".strip(),
+        evaluator=lambda product: _greater_than(product.get("sugars"), 105),
+    ),
+    LegacyRule(
+        rule_name="main_language_code_missing",
+        tag="main-language-code-missing",
+        severity="bug",
+        condition="missing(lc)",
+        duckdb_condition="lc IS NULL OR TRIM(lc) = ''",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: main_language_code_missing
+# SEVERITY: bug
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if (!defined $lc || $lc eq "") {
+    push @{$product_ref->{$data_quality_tags}}, "main-language-code-missing";
+}
+""".strip(),
+        evaluator=lambda product: _is_missing(product.get("lc")),
+    ),
+    LegacyRule(
+        rule_name="main_language_missing",
+        tag="main-language-missing",
+        severity="bug",
+        condition="missing(lang)",
+        duckdb_condition="lang IS NULL OR TRIM(lang) = ''",
+        complexity="simple",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: main_language_missing
+# SEVERITY: bug
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if (!defined $lang || $lang eq "") {
+    push @{$product_ref->{$data_quality_tags}}, "main-language-missing";
+}
+        """.strip(),
+        evaluator=lambda product: _is_missing(product.get("lang")),
+    ),
+    LegacyRule(
+        rule_name="ca_allergen_evidence_missing_ingredients_text",
+        tag="ca-allergen-evidence-but-missing-ingredients-text",
+        severity="warning",
+        condition="allergen_evidence_present > 0 && ingredients_text_present == 0",
+        duckdb_condition="allergen_evidence_present > 0 AND ingredients_text_present == 0",
+        complexity="medium",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: ca_allergen_evidence_missing_ingredients_text
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($allergen_evidence_present > 0) && ($ingredients_text_present == 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-allergen-evidence-but-missing-ingredients-text";
+}
+""".strip(),
+        evaluator=lambda product: (
+            _compare_values(product.get("allergen_evidence_present"), ">", 0)
+            and _compare_values(product.get("ingredients_text_present"), "==", 0)
+        ),
+    ),
+    LegacyRule(
+        rule_name="ca_contains_statement_without_allergen_evidence",
+        tag="ca-contains-statement-without-allergen-evidence",
+        severity="warning",
+        condition="contains_statement_present > 0 && allergen_evidence_present == 0",
+        duckdb_condition="contains_statement_present > 0 AND allergen_evidence_present == 0",
+        complexity="medium",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: ca_contains_statement_without_allergen_evidence
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($contains_statement_present > 0) && ($allergen_evidence_present == 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-contains-statement-without-allergen-evidence";
+}
+""".strip(),
+        evaluator=lambda product: (
+            _compare_values(product.get("contains_statement_present"), ">", 0)
+            and _compare_values(product.get("allergen_evidence_present"), "==", 0)
+        ),
+    ),
+    LegacyRule(
+        rule_name="ca_fop_required_but_symbol_missing",
+        tag="ca-fop-required-but-symbol-missing",
+        severity="error",
+        condition="fop_threshold_exceeded > 0 && fop_symbol_present == 0 && fop_exempt_proxy == 0 && product_is_prepackaged_proxy > 0",
+        duckdb_condition=(
+            "fop_threshold_exceeded > 0 AND fop_symbol_present == 0 "
+            "AND fop_exempt_proxy == 0 AND product_is_prepackaged_proxy > 0"
+        ),
+        complexity="medium",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: ca_fop_required_but_symbol_missing
+# SEVERITY: error
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($fop_threshold_exceeded > 0) && ($fop_symbol_present == 0) && ($fop_exempt_proxy == 0) && ($product_is_prepackaged_proxy > 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-fop-required-but-symbol-missing";
+}
+""".strip(),
+        evaluator=lambda product: (
+            _compare_values(product.get("fop_threshold_exceeded"), ">", 0)
+            and _compare_values(product.get("fop_symbol_present"), "==", 0)
+            and _compare_values(product.get("fop_exempt_proxy"), "==", 0)
+            and _compare_values(product.get("product_is_prepackaged_proxy"), ">", 0)
+        ),
+    ),
+    LegacyRule(
+        rule_name="ca_fop_symbol_present_but_not_required",
+        tag="ca-fop-symbol-present-but-not-required",
+        severity="warning",
+        condition="fop_symbol_present > 0 && fop_threshold_exceeded == 0 && fop_exempt_proxy == 0 && product_is_prepackaged_proxy > 0",
+        duckdb_condition=(
+            "fop_symbol_present > 0 AND fop_threshold_exceeded == 0 "
+            "AND fop_exempt_proxy == 0 AND product_is_prepackaged_proxy > 0"
+        ),
+        complexity="medium",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: ca_fop_symbol_present_but_not_required
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($fop_symbol_present > 0) && ($fop_threshold_exceeded == 0) && ($fop_exempt_proxy == 0) && ($product_is_prepackaged_proxy > 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-fop-symbol-present-but-not-required";
+}
+""".strip(),
+        evaluator=lambda product: (
+            _compare_values(product.get("fop_symbol_present"), ">", 0)
+            and _compare_values(product.get("fop_threshold_exceeded"), "==", 0)
+            and _compare_values(product.get("fop_exempt_proxy"), "==", 0)
+            and _compare_values(product.get("product_is_prepackaged_proxy"), ">", 0)
+        ),
+    ),
+    LegacyRule(
+        rule_name="ca_fop_symbol_present_on_exempt_product",
+        tag="ca-fop-symbol-present-on-exempt-product",
+        severity="warning",
+        condition="fop_symbol_present > 0 && fop_exempt_proxy > 0 && product_is_prepackaged_proxy > 0",
+        duckdb_condition="fop_symbol_present > 0 AND fop_exempt_proxy > 0 AND product_is_prepackaged_proxy > 0",
+        complexity="medium",
+        declarative_friendly=True,
+        perl_logic="""
+# RULE_NAME: ca_fop_symbol_present_on_exempt_product
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($fop_symbol_present > 0) && ($fop_exempt_proxy > 0) && ($product_is_prepackaged_proxy > 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-fop-symbol-present-on-exempt-product";
+}
+""".strip(),
+        evaluator=lambda product: (
+            _compare_values(product.get("fop_symbol_present"), ">", 0)
+            and _compare_values(product.get("fop_exempt_proxy"), ">", 0)
+            and _compare_values(product.get("product_is_prepackaged_proxy"), ">", 0)
+        ),
+    ),
+]
+
+
+RULE_FILES_DIR = Path(__file__).resolve().parent / "rules"
+
+
+def load_rule_snippets_from_directory(rules_dir: Path = RULE_FILES_DIR) -> List[str]:
+    snippets: List[str] = []
+    for file_path in sorted(rules_dir.glob("*.pl")):
+        content = file_path.read_text(encoding="utf-8").lstrip("\ufeff").strip()
+        if content:
+            snippets.append(content)
+    if not snippets:
+        raise ValueError(f"No Perl rule files found in {rules_dir}")
+    return snippets
+
+
+def get_perl_rule_snippets(
+    rules: Sequence[LegacyRule] = LEGACY_RULES,
+    rules_dir: Path | None = None,
+) -> List[str]:
+    if rules_dir is not None:
+        return load_rule_snippets_from_directory(Path(rules_dir))
+    return [rule.perl_logic for rule in rules]
+
+
+def get_legacy_rule_map(rules: Sequence[LegacyRule] = LEGACY_RULES) -> Dict[str, LegacyRule]:
+    return {rule.rule_name: rule for rule in rules}
+
+
+def run_perl_checks(products: Sequence[Product], rules: Sequence[LegacyRule] = LEGACY_RULES) -> Dict[str, Dict[str, object]]:
+    """Run simulated Perl checks and return per-product and per-rule outputs."""
+    per_product_tags: Dict[str, List[str]] = {}
+    per_rule_products: Dict[str, Set[str]] = {rule.rule_name: set() for rule in rules}
+
+    for product in products:
+        product_id = str(product.get("product_id"))
+        emitted_tags: List[str] = []
+        for rule in rules:
+            if rule.evaluator(product):
+                emitted_tags.append(rule.tag)
+                per_rule_products[rule.rule_name].add(product_id)
+        per_product_tags[product_id] = emitted_tags
+
+    return {
+        "per_product": per_product_tags,
+        "per_rule": {name: sorted(ids) for name, ids in per_rule_products.items()},
+    }

OFF_DataQuality/perl_checks/rules/01_energy_kcal_vs_kj.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: energy_kcal_vs_kj
+# SEVERITY: error
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($energy_kcal > $energy_kj) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kcal-greater-than-in-kj";
+}

OFF_DataQuality/perl_checks/rules/02_energy_kj_mismatch_low.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: energy_kj_mismatch_low
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj < (3.7 * $energy_kcal - 2)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kcal-does-not-match-value-in-kj-low";
+}

OFF_DataQuality/perl_checks/rules/03_energy_kj_mismatch_high.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: energy_kj_mismatch_high
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj > (4.7 * $energy_kcal + 2)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kcal-does-not-match-value-in-kj-high";
+}

OFF_DataQuality/perl_checks/rules/04_energy_kj_over_3911.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: energy_kj_over_3911
+# SEVERITY: error
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($energy_kj > 3911) {
+    push @{$product_ref->{$data_quality_tags}}, "value-over-3911-energy";
+}

OFF_DataQuality/perl_checks/rules/05_saturated_fat_vs_fat.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: saturated_fat_vs_fat
+# SEVERITY: error
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($saturated_fat > (1 * $fat + 0.001)) {
+    push @{$product_ref->{$data_quality_tags}}, "saturated-fat-greater-than-fat";
+}

OFF_DataQuality/perl_checks/rules/06_sugars_plus_starch_vs_carbohydrates.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: sugars_plus_starch_vs_carbohydrates
+# SEVERITY: error
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($sugars + $starch) > ($carbohydrates + 0.001)) {
+    push @{$product_ref->{$data_quality_tags}}, "sugars-plus-starch-greater-than-carbohydrates";
+}

OFF_DataQuality/perl_checks/rules/07_fat_over_105g.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: fat_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($fat > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "fat-value-over-105g";
+}

OFF_DataQuality/perl_checks/rules/08_saturated_fat_over_105g.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: saturated_fat_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($saturated_fat > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "saturated-fat-value-over-105g";
+}

OFF_DataQuality/perl_checks/rules/09_carbohydrates_over_105g.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: carbohydrates_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($carbohydrates > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "carbohydrates-value-over-105g";
+}

OFF_DataQuality/perl_checks/rules/10_sugars_over_105g.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: sugars_over_105g
+# SEVERITY: warning
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if ($sugars > 105) {
+    push @{$product_ref->{$data_quality_tags}}, "sugars-value-over-105g";
+}

OFF_DataQuality/perl_checks/rules/11_main_language_code_missing.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: main_language_code_missing
+# SEVERITY: bug
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if (!defined $lc || $lc eq "") {
+    push @{$product_ref->{$data_quality_tags}}, "main-language-code-missing";
+}

OFF_DataQuality/perl_checks/rules/12_main_language_missing.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: main_language_missing
+# SEVERITY: bug
+# COMPLEXITY: simple
+# DECLARATIVE_FRIENDLY: yes
+if (!defined $lang || $lang eq "") {
+    push @{$product_ref->{$data_quality_tags}}, "main-language-missing";
+}

OFF_DataQuality/perl_checks/rules/13_energy_kj_computed_mismatch_low.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: energy_kj_computed_mismatch_low
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj_computed < (0.7 * $energy_kj - 5)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kj-does-not-match-value-computed-from-other-nutrients-low";
+}

OFF_DataQuality/perl_checks/rules/14_energy_kj_computed_mismatch_high.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: energy_kj_computed_mismatch_high
+# SEVERITY: error
+# COMPLEXITY: intricate
+# DECLARATIVE_FRIENDLY: no
+if ($energy_kj_computed > (1.3 * $energy_kj + 5)) {
+    push @{$product_ref->{$data_quality_tags}}, "energy-value-in-kj-does-not-match-value-computed-from-other-nutrients-high";
+}

OFF_DataQuality/perl_checks/rules/15_ca_allergen_evidence_missing_ingredients_text.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: ca_allergen_evidence_missing_ingredients_text
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($allergen_evidence_present > 0) && ($ingredients_text_present == 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-allergen-evidence-but-missing-ingredients-text";
+}

OFF_DataQuality/perl_checks/rules/16_ca_contains_statement_without_allergen_evidence.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: ca_contains_statement_without_allergen_evidence
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($contains_statement_present > 0) && ($allergen_evidence_present == 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-contains-statement-without-allergen-evidence";
+}

OFF_DataQuality/perl_checks/rules/17_ca_fop_required_but_symbol_missing.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: ca_fop_required_but_symbol_missing
+# SEVERITY: error
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($fop_threshold_exceeded > 0) && ($fop_symbol_present == 0) && ($fop_exempt_proxy == 0) && ($product_is_prepackaged_proxy > 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-fop-required-but-symbol-missing";
+}

OFF_DataQuality/perl_checks/rules/18_ca_fop_symbol_present_but_not_required.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: ca_fop_symbol_present_but_not_required
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($fop_symbol_present > 0) && ($fop_threshold_exceeded == 0) && ($fop_exempt_proxy == 0) && ($product_is_prepackaged_proxy > 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-fop-symbol-present-but-not-required";
+}

OFF_DataQuality/perl_checks/rules/19_ca_fop_symbol_present_on_exempt_product.pl

@@ -0,0 +1,7 @@
+# RULE_NAME: ca_fop_symbol_present_on_exempt_product
+# SEVERITY: warning
+# COMPLEXITY: medium
+# DECLARATIVE_FRIENDLY: yes
+if (($fop_symbol_present > 0) && ($fop_exempt_proxy > 0) && ($product_is_prepackaged_proxy > 0)) {
+    push @{$product_ref->{$data_quality_tags}}, "ca-fop-symbol-present-on-exempt-product";
+}

OFF_DataQuality/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+testpaths = tests

OFF_DataQuality/python_checks/generated_checks.py

@@ -0,0 +1,36 @@
+"""Runtime compiler for generated Python checks."""
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Tuple
+
+
+def compile_generated_checks(
+    converted_rules: List[Dict[str, object]],
+) -> Tuple[Dict[str, Callable[[Dict[str, object]], object]], Dict[str, Dict[str, object]]]:
+    """Compile generated Python snippets into callable checks."""
+    checks: Dict[str, Callable[[Dict[str, object]], object]] = {}
+    metadata: Dict[str, Dict[str, object]] = {}
+
+    for converted in converted_rules:
+        function_name = str(converted["function_name"])
+        rule_name = str(converted["rule_name"])
+        code = str(converted["python_code"])
+
+        namespace: Dict[str, object] = {}
+        exec(code, {}, namespace)
+        check_fn = namespace[function_name]
+        checks[rule_name] = check_fn
+        metadata[rule_name] = {
+            "function_name": function_name,
+            "python_code": code,
+            "llm_confidence": float(converted["llm_confidence"]),
+            "conversion_notes": converted["conversion_notes"],
+            "provider": converted.get("provider", "unknown"),
+        }
+    return checks, metadata
+
+
+def render_generated_module(metadata: Dict[str, Dict[str, object]]) -> str:
+    """Return a readable module-like rendering of generated checks."""
+    code_blocks = [str(info["python_code"]).rstrip() for info in metadata.values()]
+    return "\n\n".join(code_blocks) + "\n"

OFF_DataQuality/requirements.txt

@@ -0,0 +1,8 @@
+duckdb
+streamlit
+pandas
+openai
+pytest
+plotly
+dbt-duckdb
+soda-duckdb

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/dbt_project.yml

@@ -0,0 +1,6 @@
+name: off_quality_declarative
+version: '1.0'
+config-version: 2
+profile: off_quality_duckdb
+model-paths: ['models']
+test-paths: ['tests']

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/macros/count_violations.sql

@@ -0,0 +1,12 @@
+{% macro count_violations(condition_sql) %}
+  {% set q %}
+    select count(*) as violation_count
+    from {{ source('off_source', 'nutrition_table') }}
+    where {{ condition_sql }}
+  {% endset %}
+  {% set t = run_query(q) %}
+  {% if execute %}
+    {% set c = t.columns[0].values()[0] %}
+    {% do log('VIOLATION_COUNT=' ~ c, info=True) %}
+  {% endif %}
+{% endmacro %}

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/models/sources.yml

@@ -0,0 +1,6 @@
+version: 2
+sources:
+  - name: off_source
+    schema: main
+    tables:
+      - name: nutrition_table

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/profiles.yml

@@ -0,0 +1,8 @@
+off_quality_duckdb:
+  target: dev
+  outputs:
+    dev:
+      type: duckdb
+      path: 'results/declarative_runtime/dbt/dbt_runtime.db'
+      schema: main
+      threads: 1

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/tests/ca_allergen_evidence_missing_ingredients_text.sql

@@ -0,0 +1,3 @@
+SELECT product_id
+FROM {{ source('off_source', 'nutrition_table') }}
+WHERE allergen_evidence_present > 0.0 AND ingredients_text_present == 0.0

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/tests/ca_contains_statement_without_allergen_evidence.sql

@@ -0,0 +1,3 @@
+SELECT product_id
+FROM {{ source('off_source', 'nutrition_table') }}
+WHERE contains_statement_present > 0.0 AND allergen_evidence_present == 0.0

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/tests/ca_fop_required_but_symbol_missing.sql

@@ -0,0 +1,3 @@
+SELECT product_id
+FROM {{ source('off_source', 'nutrition_table') }}
+WHERE fop_threshold_exceeded > 0.0 AND fop_symbol_present == 0.0 AND fop_exempt_proxy == 0.0 AND product_is_prepackaged_proxy > 0.0

OFF_DataQuality/results/declarative_runtime/dbt/dbt_project/tests/ca_fop_symbol_present_but_not_required.sql

@@ -0,0 +1,3 @@
+SELECT product_id
+FROM {{ source('off_source', 'nutrition_table') }}
+WHERE fop_symbol_present > 0.0 AND fop_threshold_exceeded == 0.0 AND fop_exempt_proxy == 0.0 AND product_is_prepackaged_proxy > 0.0