feat: publish private PacketCourt evidence audit MVP

Built with OpenAI Codex. Initial private hackathon deployment.

.gitignore

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

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,7 @@
+[
+  "tests/test_audit.py::test_absolute_natural_claim_is_refused",
+  "tests/test_audit.py::test_fssai_claim_is_not_treated_as_health_endorsement",
+  "tests/test_audit.py::test_multigrain_exposes_refined_flour_context",
+  "tests/test_audit.py::test_no_added_sugar_is_contradicted_by_glucose_syrup",
+  "tests/test_audit.py::test_relative_best_before_date_is_resolved"
+]

README.md

@@ -1,13 +1,66 @@
 ---
-title: Packetcourt
-emoji: 🌖
-colorFrom: pink
-colorTo: blue
+title: PacketCourt
+emoji: ⚖️
+colorFrom: yellow
+colorTo: red
 sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
+sdk_version: 6.0.1
 app_file: app.py
 pinned: false
+license: mit
+tags:
+  - track:backyard
+  - sponsor:openbmb
+  - sponsor:openai
+  - achievement:offbrand
+  - build-small-hackathon
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PacketCourt
+
+**The packet takes the stand.**
+
+PacketCourt audits front-of-pack marketing claims against evidence printed on
+the same Indian packaged-food label. It produces traceable, conservative
+verdicts instead of an unexplained health score.
+
+## Current MVP
+
+- Reads front and back label photos with local OCR.
+- Detects six common front claims.
+- Links claims to ingredients, nutrition, FSSAI license, and expiry evidence.
+- Resolves relative dates such as `best before 6 months from packaging`.
+- Produces a machine-readable evidence case.
+- Refuses unsupported legal, medical, and food-safety conclusions.
+
+## Run Locally
+
+```bash
+python -m pip install -r requirements.txt
+python app.py
+```
+
+## Test
+
+```bash
+pytest
+```
+
+## Model Plan
+
+Phase 2 integrates OpenBMB's 1.3B-parameter `MiniCPM-V-4.6` for evidence-region
+discovery and OCR correction, plus a fine-tuned `MiniCPM5-1B` for constrained
+claim-to-evidence mapping. Deterministic code remains responsible for numeric
+calculations and final verdict triggers.
+
+## Safety Boundary
+
+PacketCourt does not declare products healthy, safe, illegal, or fraudulent.
+It audits only the supplied label evidence and exposes uncertainty explicitly.
+
+## Codex Attribution
+
+The repository is being built with OpenAI Codex as the primary coding agent.
+Codex is responsible for the initial architecture, deterministic audit engine,
+tests, Gradio application, and deployment workflow.
+

app.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import html
+import json
+import sys
+from pathlib import Path
+
+import gradio as gr
+
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT / "src"))
+
+from packetcourt import audit_packet
+from packetcourt.ocr import extract_text
+from packetcourt.samples import SAMPLES
+
+
+VERDICT_CLASS = {
+    "SUPPORTED BY PROVIDED LABEL": "supported",
+    "CONTRADICTED BY PROVIDED LABEL": "contradicted",
+    "TECHNICALLY TRUE, CONTEXT MISSING": "context",
+    "CANNOT VERIFY": "unknown",
+}
+
+
+def render_report(front_text: str, back_text: str) -> tuple[str, str]:
+    audit = audit_packet(front_text, back_text)
+    if not audit.claims:
+        cards = """
+        <div class="empty-state">
+          <div class="empty-mark">?</div>
+          <h3>No supported claim type detected</h3>
+          <p>Try a front label containing claims such as High Protein, No Added Sugar,
+          Multigrain, 100% Natural, FSSAI Approved, or No Preservatives.</p>
+        </div>
+        """
+    else:
+        cards = "".join(
+            f"""
+            <article class="claim-card {VERDICT_CLASS[claim.verdict.value]}">
+              <div class="claim-top">
+                <span class="claim-name">{html.escape(claim.claim)}</span>
+                <span class="verdict">{html.escape(claim.verdict.value)}</span>
+              </div>
+              <p class="summary">{html.escape(claim.summary)}</p>
+              <div class="evidence-list">
+                {''.join(f'<div class="evidence"><b>{html.escape(e.source)}</b><span>{html.escape(e.text)}</span></div>' for e in claim.evidence)}
+              </div>
+              {f'<p class="caveat">{html.escape(claim.caveat)}</p>' if claim.caveat else ''}
+            </article>
+            """
+            for claim in audit.claims
+        )
+
+    nutrition_rows = [
+        ("Basis", audit.nutrition.basis),
+        ("Protein", f"{audit.nutrition.protein_g:g}g" if audit.nutrition.protein_g is not None else "Not found"),
+        ("Total sugar", f"{audit.nutrition.total_sugar_g:g}g" if audit.nutrition.total_sugar_g is not None else "Not found"),
+        ("Added sugar", f"{audit.nutrition.added_sugar_g:g}g" if audit.nutrition.added_sugar_g is not None else "Not found"),
+        ("Sodium", f"{audit.nutrition.sodium_mg:g}mg" if audit.nutrition.sodium_mg is not None else "Not found"),
+    ]
+    facts = "".join(f"<div><span>{html.escape(k)}</span><b>{html.escape(v)}</b></div>" for k, v in nutrition_rows)
+    expiry = html.escape(audit.expiry.status)
+    report = f"""
+    <section class="report-shell">
+      <div class="report-heading">
+        <div><span class="eyebrow">EVIDENCE HEARING</span><h2>Packet claim audit</h2></div>
+        <span class="claim-count">{len(audit.claims)} claims examined</span>
+      </div>
+      <div class="claim-grid">{cards}</div>
+      <div class="secondary-grid">
+        <section class="facts-panel"><span class="eyebrow">NUTRITION EVIDENCE</span>{facts}</section>
+        <section class="expiry-panel"><span class="eyebrow">DATE EVIDENCE</span><h3>{expiry}</h3><p>Expiry interpretation is shown as evidence, not a food-safety guarantee.</p></section>
+      </div>
+    </section>
+    """
+    return report, json.dumps(audit.model_dump(mode="json"), indent=2)
+
+
+def read_images(front_image: str | None, back_image: str | None) -> tuple[str, str, str]:
+    front, front_status = extract_text(front_image)
+    back, back_status = extract_text(back_image)
+    return front, back, f"Front: {front_status}\nBack: {back_status}"
+
+
+def load_sample(name: str) -> tuple[str, str]:
+    sample = SAMPLES[name]
+    return sample["front"], sample["back"]
+
+
+CSS = """
+:root { --ink:#171611; --paper:#f7f2e7; --red:#d64c3f; --green:#2c7458; --amber:#b97918; }
+.gradio-container { max-width: 1180px !important; margin:auto; background:var(--paper); color:var(--ink); }
+.hero { border:1px solid #d7cdbd; border-radius:28px; padding:34px; margin:14px 0 20px;
+  background:radial-gradient(circle at 90% 10%,#ffd7a8,transparent 35%),linear-gradient(135deg,#fffaf0,#f1e8d8); }
+.hero h1 { font-size:clamp(42px,8vw,92px); line-height:.9; letter-spacing:-.07em; margin:8px 0 16px; }
+.hero p { max-width:700px; font-size:18px; color:#514c43; }
+.eyebrow { font:700 11px/1 monospace; letter-spacing:.16em; color:#6b6256; }
+.report-shell { margin-top:18px; }.report-heading,.claim-top { display:flex; justify-content:space-between; gap:12px; align-items:start; }
+.report-heading h2 { margin:6px 0 18px; font-size:34px; letter-spacing:-.04em; }
+.claim-count,.verdict { font:700 10px/1.3 monospace; text-transform:uppercase; padding:8px 10px; border:1px solid #c9beae; border-radius:99px; }
+.claim-grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(290px,1fr)); gap:14px; }
+.claim-card { background:#fffdf7; border:1px solid #d6ccbc; border-top:5px solid #777; border-radius:18px; padding:18px; box-shadow:0 8px 26px #5f493510; }
+.claim-card.supported { border-top-color:var(--green); }.claim-card.contradicted { border-top-color:var(--red); }
+.claim-card.context { border-top-color:var(--amber); }.claim-name { font-size:21px; font-weight:800; }
+.summary { min-height:48px; color:#49443c; }.evidence-list { display:grid; gap:7px; }
+.evidence { display:grid; gap:3px; background:#f4eee3; border-radius:10px; padding:10px; }
+.evidence b { font:700 10px/1 monospace; text-transform:uppercase; color:#756b5e; }
+.caveat { font-size:12px; color:#746b5f; border-top:1px dashed #cfc2af; padding-top:10px; }
+.secondary-grid { display:grid; grid-template-columns:1fr 1fr; gap:14px; margin-top:14px; }
+.facts-panel,.expiry-panel,.empty-state { border:1px solid #d6ccbc; border-radius:18px; padding:18px; background:#fffdf7; }
+.facts-panel div { display:flex; justify-content:space-between; border-bottom:1px solid #ebe2d5; padding:9px 0; }
+.empty-state { text-align:center; padding:35px; }.empty-mark { font-size:60px; color:var(--amber); }
+@media(max-width:700px){.secondary-grid{grid-template-columns:1fr}.hero{padding:24px}.claim-top{display:grid}.verdict{width:fit-content}}
+"""
+
+
+with gr.Blocks(title="PacketCourt") as demo:
+    gr.HTML(
+        """
+        <section class="hero">
+          <span class="eyebrow">PACKETCOURT / INDIA</span>
+          <h1>The packet<br>takes the stand.</h1>
+          <p>Photograph the front and back of an Indian food packet. PacketCourt audits
+          marketing claims against the evidence printed on the same package.</p>
+        </section>
+        """
+    )
+    with gr.Tabs():
+        with gr.Tab("Audit a packet"):
+            with gr.Row():
+                front_image = gr.Image(type="filepath", label="Front of packet", sources=["upload", "webcam"])
+                back_image = gr.Image(type="filepath", label="Back label", sources=["upload", "webcam"])
+            read_button = gr.Button("Read label photos", variant="secondary")
+            ocr_status = gr.Textbox(label="OCR status", interactive=False, lines=2)
+            with gr.Row():
+                front_text = gr.Textbox(label="Front claims", lines=7, placeholder="OCR output appears here. Correct it before auditing.")
+                back_text = gr.Textbox(label="Back-label evidence", lines=10, placeholder="Ingredients, nutrition panel, dates, and license evidence.")
+            audit_button = gr.Button("Put this packet on trial", variant="primary")
+        with gr.Tab("Try a prepared case"):
+            sample = gr.Dropdown(list(SAMPLES), value=list(SAMPLES)[0], label="Prepared evidence case")
+            sample_button = gr.Button("Load prepared case")
+            gr.Markdown("Prepared cases let judges test the complete audit flow without taking photos.")
+        with gr.Tab("Method"):
+            gr.Markdown(
+                """
+                ### Evidence before verdict
+                PacketCourt does not declare a product healthy, safe, illegal, or fraudulent.
+                It extracts visible claims, links them to supplied evidence, runs conservative
+                deterministic checks, and refuses conclusions it cannot support.
+
+                **Current Phase 1 claim types:** High Protein, No Added Sugar, Multigrain,
+                100% Natural, FSSAI Approved, and No Preservatives.
+                """
+            )
+    report = gr.HTML()
+    raw_json = gr.Code(label="Machine-readable evidence case", language="json")
+
+    read_button.click(read_images, [front_image, back_image], [front_text, back_text, ocr_status])
+    sample_button.click(load_sample, sample, [front_text, back_text]).then(render_report, [front_text, back_text], [report, raw_json])
+    audit_button.click(render_report, [front_text, back_text], [report, raw_json])
+
+if __name__ == "__main__":
+    demo.launch(css=CSS)

docs/BUILD_PLAN.md

@@ -0,0 +1,23 @@
+# PacketCourt Build Plan
+
+## Phase 1: Evidence Engine
+
+- Parse common front-of-pack claims.
+- Extract ingredient, nutrition, licensing, and expiry evidence.
+- Produce conservative structured verdicts.
+- Refuse unsupported legal, medical, and safety conclusions.
+
+## Phase 2: Small-Model Pipeline
+
+- Integrate MiniCPM-V-4.6 for evidence-region discovery and OCR correction.
+- Build and publish an Indian packet-claim audit dataset.
+- Fine-tune MiniCPM5-1B for constrained claim-to-evidence mapping.
+- Evaluate against deterministic golden cases.
+
+## Phase 3: Product And Submission
+
+- Add evidence crops and front-versus-back persuasion-gap view.
+- Add anonymized trace export.
+- Validate with real Indian packaged foods and family users.
+- Publish Field Notes, demo video, public GitHub repository, and Space.
+

packages.txt

@@ -0,0 +1,2 @@
+tesseract-ocr
+

pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "packetcourt"
+version = "0.1.0"
+description = "Evidence-first claim auditing for Indian packaged-food labels"
+requires-python = ">=3.11"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+

requirements.txt

@@ -0,0 +1,5 @@
+gradio==6.0.1
+pillow>=11.0.0
+pydantic>=2.10.0
+pytesseract>=0.3.13
+

src/packetcourt/__init__.py

@@ -0,0 +1,6 @@
+"""PacketCourt claim-audit engine."""
+
+from .audit import audit_packet
+
+__all__ = ["audit_packet"]
+

src/packetcourt/audit.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import re
+
+from .models import ClaimAudit, Evidence, PacketAudit, Verdict
+from .parser import extract_claims, extract_ingredients, parse_expiry, parse_nutrition
+
+
+ADDED_SUGAR_TERMS = {
+    "sugar",
+    "glucose",
+    "glucose syrup",
+    "corn syrup",
+    "high fructose corn syrup",
+    "invert syrup",
+    "cane sugar",
+    "brown sugar",
+    "jaggery",
+    "honey",
+    "dextrose",
+    "fructose",
+    "sucrose",
+}
+
+
+def _ingredient_evidence(ingredients: list[str], matches: list[str]) -> list[Evidence]:
+    return [Evidence(source="ingredient list", text=item) for item in matches]
+
+
+def _audit_claim(claim: str, back_text: str, ingredients: list[str], nutrition) -> ClaimAudit:
+    lowered_ingredients = [item.lower() for item in ingredients]
+
+    if claim == "No Added Sugar":
+        matches = [
+            original
+            for original, lowered in zip(ingredients, lowered_ingredients)
+            if any(re.search(rf"\b{re.escape(term)}\b", lowered) for term in ADDED_SUGAR_TERMS)
+        ]
+        if matches:
+            return ClaimAudit(
+                claim=claim,
+                verdict=Verdict.CONTRADICTED,
+                summary="The provided ingredient list names one or more added-sugar ingredients.",
+                evidence=_ingredient_evidence(ingredients, matches),
+                caveat="This verdict only checks the supplied label text; it is not a laboratory analysis.",
+            )
+        if ingredients:
+            return ClaimAudit(
+                claim=claim,
+                verdict=Verdict.SUPPORTED,
+                summary="No common added-sugar term was found in the provided ingredient list.",
+                evidence=[Evidence(source="ingredient list", text=", ".join(ingredients))],
+                caveat="Unrecognized sweeteners or incomplete OCR may change this result.",
+            )
+
+    if claim == "Multigrain":
+        grain_terms = ("wheat", "rice", "oat", "barley", "ragi", "millet", "jowar", "bajra", "maize", "corn")
+        matches = [item for item in ingredients if any(term in item.lower() for term in grain_terms)]
+        if len(matches) >= 2:
+            first = ingredients[0] if ingredients else ""
+            return ClaimAudit(
+                claim=claim,
+                verdict=Verdict.CONTEXT_MISSING if "refined" in first.lower() else Verdict.SUPPORTED,
+                summary=(
+                    "Multiple grains are listed, but refined grain appears first."
+                    if "refined" in first.lower()
+                    else "Multiple grain ingredients are present in the supplied ingredient list."
+                ),
+                evidence=_ingredient_evidence(ingredients, matches),
+                caveat="Ingredient order indicates relative quantity, but exact grain percentages may be unavailable.",
+            )
+
+    if claim == "High Protein":
+        if nutrition.protein_g is not None:
+            if nutrition.basis == "unknown":
+                return ClaimAudit(
+                    claim=claim,
+                    verdict=Verdict.CANNOT_VERIFY,
+                    summary="Protein is listed, but its measurement basis could not be determined.",
+                    evidence=[Evidence(source="nutrition panel", text=f"Protein {nutrition.protein_g:g}g")],
+                )
+            return ClaimAudit(
+                claim=claim,
+                verdict=Verdict.CONTEXT_MISSING,
+                summary="The protein quantity is visible, but claim compliance depends on product category and applicable rules.",
+                evidence=[
+                    Evidence(
+                        source="nutrition panel",
+                        text=f"Protein {nutrition.protein_g:g}g ({nutrition.basis})",
+                    )
+                ],
+                caveat="PacketCourt does not make a regulatory-compliance determination in this prototype.",
+            )
+
+    if claim == "No Preservatives":
+        preservative_pattern = r"\b(?:preservative|sodium benzoate|potassium sorbate|ins\s*2\d{2})\b"
+        matches = [item for item in ingredients if re.search(preservative_pattern, item, re.IGNORECASE)]
+        if matches:
+            return ClaimAudit(
+                claim=claim,
+                verdict=Verdict.CONTRADICTED,
+                summary="The ingredient list contains a recognizable preservative term or code.",
+                evidence=_ingredient_evidence(ingredients, matches),
+            )
+        if ingredients:
+            return ClaimAudit(
+                claim=claim,
+                verdict=Verdict.SUPPORTED,
+                summary="No recognizable preservative term was found in the supplied ingredient list.",
+                evidence=[Evidence(source="ingredient list", text=", ".join(ingredients))],
+                caveat="Incomplete OCR or unfamiliar additive codes may change this result.",
+            )
+
+    if claim == "100% Natural":
+        return ClaimAudit(
+            claim=claim,
+            verdict=Verdict.CANNOT_VERIFY,
+            summary="An absolute naturalness claim cannot be established from package text alone.",
+            evidence=[Evidence(source="front claim", text=claim)],
+            caveat="PacketCourt refuses to infer product composition beyond the supplied label.",
+        )
+
+    if claim == "FSSAI Approved":
+        license_match = re.search(r"\bfssai\b.{0,30}(\d{14})", back_text, re.IGNORECASE)
+        evidence = [Evidence(source="back label", text=f"FSSAI license number {license_match.group(1)}")] if license_match else []
+        return ClaimAudit(
+            claim=claim,
+            verdict=Verdict.CONTEXT_MISSING,
+            summary="An FSSAI license indicates regulatory registration; it is not a health endorsement.",
+            evidence=evidence or [Evidence(source="front claim", text=claim)],
+        )
+
+    return ClaimAudit(
+        claim=claim,
+        verdict=Verdict.CANNOT_VERIFY,
+        summary="The supplied back-label evidence is insufficient for this claim.",
+        evidence=[Evidence(source="front claim", text=claim)],
+    )
+
+
+def audit_packet(front_text: str, back_text: str) -> PacketAudit:
+    claims = extract_claims(front_text)
+    ingredients = extract_ingredients(back_text)
+    nutrition = parse_nutrition(back_text)
+    expiry = parse_expiry(back_text)
+
+    limitations = [
+        "PacketCourt audits only the text and images supplied by the user.",
+        "Verdicts are evidence summaries, not legal, medical, or food-safety determinations.",
+        "Users should verify low-confidence OCR against the physical packet.",
+    ]
+
+    return PacketAudit(
+        claims=[_audit_claim(claim, back_text, ingredients, nutrition) for claim in claims],
+        nutrition=nutrition,
+        ingredients=ingredients,
+        expiry=expiry,
+        front_text=front_text,
+        back_text=back_text,
+        limitations=limitations,
+    )
+

src/packetcourt/models.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class Verdict(StrEnum):
+    SUPPORTED = "SUPPORTED BY PROVIDED LABEL"
+    CONTRADICTED = "CONTRADICTED BY PROVIDED LABEL"
+    CONTEXT_MISSING = "TECHNICALLY TRUE, CONTEXT MISSING"
+    CANNOT_VERIFY = "CANNOT VERIFY"
+
+
+class Evidence(BaseModel):
+    source: str
+    text: str
+
+
+class ClaimAudit(BaseModel):
+    claim: str
+    verdict: Verdict
+    summary: str
+    evidence: list[Evidence] = Field(default_factory=list)
+    caveat: str = ""
+
+
+class NutritionFacts(BaseModel):
+    basis: str = "unknown"
+    serving_size_g: float | None = None
+    package_size_g: float | None = None
+    protein_g: float | None = None
+    total_sugar_g: float | None = None
+    added_sugar_g: float | None = None
+    sodium_mg: float | None = None
+    saturated_fat_g: float | None = None
+
+
+class ExpiryInfo(BaseModel):
+    packed_on: str | None = None
+    best_before: str | None = None
+    instruction: str | None = None
+    status: str = "Not enough label evidence"
+
+
+class PacketAudit(BaseModel):
+    claims: list[ClaimAudit]
+    nutrition: NutritionFacts
+    ingredients: list[str]
+    expiry: ExpiryInfo
+    front_text: str
+    back_text: str
+    limitations: list[str]
+

src/packetcourt/ocr.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from PIL import Image
+
+
+def extract_text(image_path: str | None) -> tuple[str, str]:
+    if not image_path:
+        return "", "No image supplied."
+    try:
+        import pytesseract
+
+        image = Image.open(Path(image_path)).convert("RGB")
+        text = pytesseract.image_to_string(image, config="--psm 6").strip()
+        if text:
+            return text, "OCR completed with Tesseract. Verify against the packet."
+        return "", "OCR found no readable text. Use a closer photo or paste the label text."
+    except Exception as exc:
+        return "", f"OCR unavailable: {exc}. Paste the label text to continue."
+

src/packetcourt/parser.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import calendar
+import re
+from datetime import date
+
+from .models import ExpiryInfo, NutritionFacts
+
+
+CLAIM_PATTERNS: list[tuple[str, str]] = [
+    ("High Protein", r"\bhigh[\s-]*protein\b"),
+    ("No Added Sugar", r"\bno[\s-]*added[\s-]*sugar\b"),
+    ("Multigrain", r"\bmulti[\s-]*grain\b"),
+    ("100% Natural", r"\b100\s*%\s*natural\b"),
+    ("FSSAI Approved", r"\bfssai[\s-]*approved\b"),
+    ("No Preservatives", r"\bno[\s-]*preservatives?\b"),
+]
+
+
+def normalize_space(text: str) -> str:
+    return re.sub(r"\s+", " ", text or "").strip()
+
+
+def extract_claims(front_text: str) -> list[str]:
+    text = normalize_space(front_text).lower()
+    return [name for name, pattern in CLAIM_PATTERNS if re.search(pattern, text)]
+
+
+def _number_after(label: str, text: str, unit: str) -> float | None:
+    pattern = rf"\b{label}\b[^0-9]{{0,24}}(\d+(?:\.\d+)?)\s*{unit}\b"
+    match = re.search(pattern, text, re.IGNORECASE)
+    return float(match.group(1)) if match else None
+
+
+def parse_nutrition(back_text: str) -> NutritionFacts:
+    text = normalize_space(back_text)
+    basis = "unknown"
+    if re.search(r"\bper\s*100\s*g\b", text, re.IGNORECASE):
+        basis = "per 100g"
+    elif re.search(r"\bper\s*serving\b", text, re.IGNORECASE):
+        basis = "per serving"
+
+    return NutritionFacts(
+        basis=basis,
+        serving_size_g=_number_after(r"serving\s*size", text, "g"),
+        package_size_g=_number_after(r"net\s*(?:weight|wt)", text, "g"),
+        protein_g=_number_after("protein", text, "g"),
+        total_sugar_g=_number_after(r"total\s*sugars?", text, "g"),
+        added_sugar_g=_number_after(r"added\s*sugars?", text, "g"),
+        sodium_mg=_number_after("sodium", text, "mg"),
+        saturated_fat_g=_number_after(r"saturated\s*fat", text, "g"),
+    )
+
+
+def extract_ingredients(back_text: str) -> list[str]:
+    match = re.search(
+        r"\bingredients?\s*:\s*(.+?)(?=\b(?:nutrition|allergen|contains|best before|mfd|pkd|manufactured|packed)\b|$)",
+        normalize_space(back_text),
+        re.IGNORECASE,
+    )
+    if not match:
+        return []
+    return [item.strip(" .") for item in re.split(r"[,;]", match.group(1)) if item.strip()]
+
+
+def _parse_date(value: str) -> date | None:
+    clean = value.strip().upper().replace(".", " ").replace("-", " ").replace("/", " ")
+    formats = [
+        r"(?P<day>\d{1,2})\s+(?P<month>\d{1,2})\s+(?P<year>\d{2,4})",
+        r"(?P<day>\d{1,2})\s+(?P<month>[A-Z]{3,9})\s+(?P<year>\d{2,4})",
+    ]
+    for pattern in formats:
+        match = re.search(pattern, clean)
+        if not match:
+            continue
+        year = int(match.group("year"))
+        year += 2000 if year < 100 else 0
+        month_raw = match.group("month")
+        if month_raw.isdigit():
+            month = int(month_raw)
+        else:
+            month = next(
+                (i for i, name in enumerate(calendar.month_abbr) if name and month_raw.startswith(name.upper())),
+                0,
+            )
+        try:
+            return date(year, month, int(match.group("day")))
+        except ValueError:
+            return None
+    return None
+
+
+def _add_months(value: date, months: int) -> date:
+    month_index = value.month - 1 + months
+    year = value.year + month_index // 12
+    month = month_index % 12 + 1
+    day = min(value.day, calendar.monthrange(year, month)[1])
+    return date(year, month, day)
+
+
+def parse_expiry(back_text: str) -> ExpiryInfo:
+    text = normalize_space(back_text)
+    packed_match = re.search(
+        r"\b(?:pkd|packed(?:\s+on)?|mfd|manufactured(?:\s+on)?)\s*[:\-]?\s*"
+        r"(\d{1,2}[\s/\-.]+(?:\d{1,2}|[A-Za-z]{3,9})[\s/\-.]+\d{2,4})",
+        text,
+        re.IGNORECASE,
+    )
+    packed = _parse_date(packed_match.group(1)) if packed_match else None
+
+    direct_match = re.search(
+        r"\b(?:exp|expiry|use\s+by|best\s+before)\s*[:\-]?\s*"
+        r"(\d{1,2}[\s/\-.]+(?:\d{1,2}|[A-Za-z]{3,9})[\s/\-.]+\d{2,4})",
+        text,
+        re.IGNORECASE,
+    )
+    best_before = _parse_date(direct_match.group(1)) if direct_match else None
+
+    relative_match = re.search(
+        r"\bbest\s+before\s+(\d+)\s+months?\s+from\s+(?:packaging|packing|manufacture|manufacturing)\b",
+        text,
+        re.IGNORECASE,
+    )
+    instruction = relative_match.group(0) if relative_match else None
+    if packed and relative_match:
+        best_before = _add_months(packed, int(relative_match.group(1)))
+
+    if best_before:
+        status = f"Best-before evidence resolves to {best_before.isoformat()}"
+    elif instruction and not packed:
+        status = "Relative shelf-life found, but the starting date is missing"
+    else:
+        status = "No resolvable best-before date found"
+
+    return ExpiryInfo(
+        packed_on=packed.isoformat() if packed else None,
+        best_before=best_before.isoformat() if best_before else None,
+        instruction=instruction,
+        status=status,
+    )
+

src/packetcourt/samples.py

@@ -0,0 +1,24 @@
+SAMPLES = {
+    "Protein cereal with context gap": {
+        "front": "POWER START HIGH PROTEIN MULTIGRAIN 100% NATURAL",
+        "back": (
+            "Ingredients: Refined wheat flour, rolled oats, ragi flour, sugar, cocoa powder, salt. "
+            "Nutrition information per 100g: Protein 12.4g, Total Sugars 22g, Added Sugars 18g, "
+            "Sodium 410mg, Saturated Fat 3.2g. Net weight 300g. "
+            "PKD: 13 JUN 26. Best before 6 months from packaging."
+        ),
+    },
+    "No-added-sugar contradiction": {
+        "front": "NO ADDED SUGAR | FSSAI APPROVED",
+        "back": (
+            "Ingredients: Rolled oats, glucose syrup, peanuts, cocoa. "
+            "Nutrition information per 100g: Protein 8g, Total Sugars 19g, Added Sugars 12g. "
+            "FSSAI Lic. No. 12345678901234. Use by: 08 JUL 2026."
+        ),
+    },
+    "Conservative refusal": {
+        "front": "100% NATURAL HIGH PROTEIN",
+        "back": "Ingredients: Chickpea flour, spices, salt. Protein 9g. Best before 09/2026.",
+    },
+}
+

tests/test_audit.py

@@ -0,0 +1,46 @@
+from packetcourt import audit_packet
+from packetcourt.models import Verdict
+
+
+def by_claim(result, name):
+    return next(claim for claim in result.claims if claim.claim == name)
+
+
+def test_no_added_sugar_is_contradicted_by_glucose_syrup():
+    result = audit_packet(
+        "NO ADDED SUGAR",
+        "Ingredients: rolled oats, glucose syrup, peanuts. Nutrition per 100g: Total Sugar 18g.",
+    )
+    assert by_claim(result, "No Added Sugar").verdict == Verdict.CONTRADICTED
+
+
+def test_multigrain_exposes_refined_flour_context():
+    result = audit_packet(
+        "MULTIGRAIN",
+        "Ingredients: refined wheat flour, oats, ragi flour, salt.",
+    )
+    assert by_claim(result, "Multigrain").verdict == Verdict.CONTEXT_MISSING
+
+
+def test_absolute_natural_claim_is_refused():
+    result = audit_packet("100% NATURAL", "Ingredients: chickpea flour, salt.")
+    assert by_claim(result, "100% Natural").verdict == Verdict.CANNOT_VERIFY
+
+
+def test_relative_best_before_date_is_resolved():
+    result = audit_packet(
+        "HIGH PROTEIN",
+        "PKD: 13 JUN 26. Best before 6 months from packaging. Nutrition per 100g: Protein 12g.",
+    )
+    assert result.expiry.best_before == "2026-12-13"
+
+
+def test_fssai_claim_is_not_treated_as_health_endorsement():
+    result = audit_packet(
+        "FSSAI APPROVED",
+        "FSSAI Lic. No. 12345678901234. Ingredients: oats.",
+    )
+    audit = by_claim(result, "FSSAI Approved")
+    assert audit.verdict == Verdict.CONTEXT_MISSING
+    assert "not a health endorsement" in audit.summary
+