Initial ProofPrint hackathon prototype

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.streamlit/
+data/proofprint.sqlite
+exports/*
+!exports/.gitkeep

README.md

@@ -0,0 +1,78 @@
+# ProofPrint
+
+ProofPrint is a local-first evidence packet builder for informal workers and advocates. It turns scattered chats, payment notes, shift logs, voice transcripts, and receipts into a structured timeline, evidence index, missing-proof checklist, risk flags, and advocate-ready complaint draft.
+
+The project is designed for the Gemma 4 hackathon theme: high-impact local intelligence where privacy, low connectivity, and real-world utility matter.
+
+## Why this matters
+
+Informal workers often lose wage, safety, retaliation, or benefit claims because their proof is scattered across screenshots, receipts, notebooks, and voice notes. Legal aid teams and NGOs spend valuable time reconstructing the facts before they can even start helping.
+
+ProofPrint gives workers and advocates a private first step: organize the evidence, find gaps, and prepare a clean handoff packet.
+
+## Gemma 4 role
+
+ProofPrint is built around local Gemma-style inference through Ollama:
+
+- extract facts from messy evidence
+- classify case type
+- identify dates, amounts, people, promises, harms, and sensitivity
+- generate an advocate-ready packet
+- support future multimodal analysis of screenshots and document photos
+
+Packet generation requires Ollama plus a configured Gemma 4 model. The app does not silently generate packets through fallback extraction.
+
+## Local setup
+
+```powershell
+cd "H:\pro\kaggale comp\proofprint"
+python -m pip install -r requirements.txt
+streamlit run app.py
+```
+
+Then open the Streamlit URL shown in the terminal.
+
+## Optional Ollama setup
+
+Install Ollama and pull the competition-approved Gemma 4 model variant when available:
+
+```powershell
+ollama pull gemma4:e2b
+```
+
+Then run the app and set the model name in the sidebar to `gemma4:e2b`.
+
+## Demo flow
+
+1. Click `Load sample wage-theft case`.
+2. Click `Build ProofPrint packet`.
+3. Show the extracted case type, timeline, evidence table, missing evidence checklist, risk flags, and complaint draft.
+4. Download the advocate packet as Markdown.
+
+## Free-tier deployment
+
+Recommended free demo options:
+
+- Streamlit Community Cloud for a public interactive app
+- Hugging Face Spaces with Streamlit
+- GitHub repository for source code
+- YouTube for the 3-minute video
+
+For public deployment, use synthetic/anonymized sample evidence only.
+
+## Hackathon tracks
+
+Best fit:
+
+- Digital Equity & Inclusivity
+- Safety & Trust
+- Main Track
+
+Potential technology fit:
+
+- Ollama
+- llama.cpp, if packaged with a local quantized model runner
+
+## Safety boundary
+
+ProofPrint does not provide legal advice, verify evidence authenticity, or replace a lawyer or trained advocate. It organizes evidence and prepares a structured handoff packet for human review.

app.py

@@ -0,0 +1,696 @@
+from __future__ import annotations
+
+import html
+import json
+import sys
+import uuid
+from pathlib import Path
+
+import streamlit as st
+
+ROOT = Path(__file__).resolve().parent
+if str(ROOT.parent) not in sys.path:
+    sys.path.insert(0, str(ROOT.parent))
+
+from proofprint.core.analyzer import build_packet
+from proofprint.core.llm import LocalGemmaClient
+from proofprint.core.models import EvidenceItem
+from proofprint.core.storage import load_evidence, save_evidence
+
+
+SAMPLE_CASE = ROOT / "data" / "sample_unpaid_wages_case.json"
+RIGHTS_GUIDE = ROOT / "data" / "worker_rights_guide.md"
+
+
+st.set_page_config(
+    page_title="ProofPrint",
+    page_icon="PP",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+
+def apply_theme() -> None:
+    st.markdown(
+        """
+        <style>
+        :root {
+          --ink: #121722;
+          --muted: #515c6b;
+          --soft: #7b8492;
+          --line: #d7dde7;
+          --paper: #f6f4ee;
+          --panel: #ffffff;
+          --panel-soft: #fbfaf6;
+          --accent: #006b5f;
+          --accent-dark: #00483f;
+          --accent-soft: #e7f4f1;
+          --blue: #263f73;
+          --warn: #9a5a12;
+          --risk: #9b2f3b;
+          --ok: #17633e;
+        }
+        .stApp { background: var(--paper); color: var(--ink); }
+        .block-container { padding-top: 2.6rem; padding-bottom: 3rem; max-width: 1240px; }
+        header[data-testid="stHeader"] {
+          background: #0c1117;
+          border-bottom: 1px solid #1d2732;
+        }
+        h1, h2, h3, h4, h5, h6, p, label, span { letter-spacing: 0; }
+        h1, h2, h3 { color: var(--ink); }
+        h2, h3 { margin-top: 0.5rem; }
+        section[data-testid="stSidebar"] {
+          background: #ffffff;
+          border-right: 1px solid var(--line);
+        }
+        section[data-testid="stSidebar"] * { color: var(--ink); }
+        section[data-testid="stSidebar"] .stCaption, section[data-testid="stSidebar"] p { color: var(--muted) !important; }
+        div[data-testid="stTabs"] button { font-weight: 650; }
+        .pp-shell {
+          border: 1px solid var(--line);
+          background: var(--panel);
+          border-radius: 8px;
+          padding: 1.45rem 1.5rem;
+        }
+        .pp-topbar {
+          display: flex;
+          align-items: center;
+          justify-content: space-between;
+          gap: 1rem;
+          border: 1px solid var(--line);
+          background: #ffffff;
+          border-radius: 8px;
+          padding: 0.8rem 0.95rem;
+          margin: 0 0 1rem 0;
+        }
+        .pp-brand {
+          display: flex;
+          align-items: center;
+          gap: 0.65rem;
+          min-width: 0;
+        }
+        .pp-logo {
+          width: 2.1rem;
+          height: 2.1rem;
+          border-radius: 7px;
+          display: grid;
+          place-items: center;
+          background: var(--ink);
+          color: #ffffff;
+          font-weight: 800;
+          letter-spacing: 0;
+        }
+        .pp-brand-title { font-weight: 760; line-height: 1.05; }
+        .pp-brand-subtitle { color: var(--muted); font-size: 0.82rem; line-height: 1.15; }
+        .pp-top-actions { display: flex; gap: 0.35rem; flex-wrap: wrap; justify-content: flex-end; }
+        .pp-hero {
+          display: grid;
+          grid-template-columns: minmax(0, 1.35fr) minmax(300px, 0.78fr);
+          gap: 1rem;
+          align-items: stretch;
+          margin-bottom: 1.15rem;
+        }
+        .pp-kicker {
+          color: var(--accent);
+          font-size: 0.82rem;
+          font-weight: 700;
+          text-transform: uppercase;
+          letter-spacing: 0;
+        }
+        .pp-title {
+          font-size: 2.18rem;
+          line-height: 1.08;
+          font-weight: 760;
+          margin: 0.2rem 0 0.65rem 0;
+          max-width: 850px;
+        }
+        .pp-subtitle {
+          color: var(--muted);
+          max-width: 820px;
+          font-size: 0.98rem;
+          line-height: 1.5;
+          margin-bottom: 0.85rem;
+        }
+        .pp-card {
+          background: var(--panel);
+          border: 1px solid var(--line);
+          border-radius: 8px;
+          padding: 1rem;
+          min-height: 100%;
+        }
+        .pp-card-soft {
+          background: var(--panel-soft);
+          border: 1px solid var(--line);
+          border-radius: 8px;
+          padding: 1rem;
+        }
+        .pp-panel-dark {
+          background: linear-gradient(135deg, #102720 0%, #17202d 100%);
+          color: #f6fbf9;
+          border: 1px solid #203a35;
+          border-radius: 8px;
+          padding: 1.25rem;
+          min-height: 100%;
+        }
+        .pp-demo-title {
+          margin: 0.15rem 0 0.65rem 0;
+          color: #fff;
+          font-size: 1.45rem;
+          line-height: 1.18;
+        }
+        .pp-panel-dark strong { color: #ffffff; }
+        .pp-panel-dark .pp-muted { color: #b7c2bf; }
+        .pp-pill {
+          display: inline-block;
+          border: 1px solid var(--line);
+          border-radius: 999px;
+          padding: 0.2rem 0.58rem;
+          margin: 0.1rem 0.18rem 0.1rem 0;
+          color: var(--accent-dark);
+          font-size: 0.82rem;
+          background: var(--accent-soft);
+          border-color: #b9dad3;
+        }
+        .pp-pill-dark {
+          display: inline-block;
+          border: 1px solid #344554;
+          border-radius: 999px;
+          padding: 0.2rem 0.58rem;
+          margin: 0.12rem 0.18rem 0.12rem 0;
+          color: #d7e4df;
+          font-size: 0.82rem;
+          background: #17232c;
+        }
+        .pp-step {
+          display: flex;
+          gap: 0.75rem;
+          align-items: flex-start;
+          padding: 0.75rem 0;
+          border-bottom: 1px solid var(--line);
+        }
+        .pp-step:last-child { border-bottom: 0; }
+        .pp-num {
+          flex: 0 0 auto;
+          width: 1.75rem;
+          height: 1.75rem;
+          border-radius: 50%;
+          display: grid;
+          place-items: center;
+          color: #fff;
+          background: var(--accent);
+          font-weight: 760;
+          font-size: 0.86rem;
+        }
+        .pp-step-title { font-weight: 720; color: var(--ink); }
+        .pp-step-text { color: var(--muted); font-size: 0.93rem; line-height: 1.38; }
+        .pp-evidence-row {
+          border: 1px solid var(--line);
+          border-radius: 8px;
+          background: #fff;
+          padding: 0.85rem 0.95rem;
+          margin-bottom: 0.55rem;
+        }
+        .pp-evidence-head {
+          display: flex;
+          justify-content: space-between;
+          gap: 0.75rem;
+          align-items: baseline;
+        }
+        .pp-evidence-title { font-weight: 720; }
+        .pp-muted { color: var(--muted); }
+        .pp-small { color: var(--soft); font-size: 0.86rem; }
+        .pp-status {
+          border: 1px solid #c5d9d4;
+          color: var(--ok);
+          background: #f2faf6;
+          border-radius: 999px;
+          padding: 0.22rem 0.65rem;
+          font-size: 0.82rem;
+          display: inline-block;
+          font-weight: 650;
+        }
+        .pp-counter {
+          background: #ffffff;
+          border: 1px solid var(--line);
+          border-radius: 8px;
+          padding: 0.85rem 0.95rem;
+          min-height: 5.5rem;
+        }
+        .pp-counter-label {
+          color: var(--muted);
+          font-size: 0.82rem;
+          font-weight: 700;
+          text-transform: uppercase;
+          margin-bottom: 0.35rem;
+        }
+        .pp-counter-value {
+          color: var(--ink);
+          font-size: 1.35rem;
+          font-weight: 780;
+          line-height: 1.15;
+        }
+        .pp-upload-box {
+          background: #ffffff;
+          border: 1px solid var(--line);
+          border-radius: 8px;
+          padding: 1rem;
+          margin-top: 0.8rem;
+        }
+        .pp-risk {
+          border-left: 4px solid var(--risk);
+          padding: 0.5rem 0.75rem;
+          background: #fff6f5;
+          margin-bottom: 0.4rem;
+        }
+        .pp-missing {
+          border-left: 4px solid var(--warn);
+          padding: 0.5rem 0.75rem;
+          background: #fff8ef;
+          margin-bottom: 0.4rem;
+        }
+        div[data-testid="stDownloadButton"] button,
+        div[data-testid="stButton"] button {
+          border-radius: 7px;
+          font-weight: 650;
+          min-height: 2.55rem;
+          color: #ffffff !important;
+        }
+        div[data-testid="stDownloadButton"] button *,
+        div[data-testid="stButton"] button * {
+          color: #ffffff !important;
+        }
+        button,
+        button p,
+        button span,
+        [data-testid="stFormSubmitButton"] button,
+        [data-testid="stFormSubmitButton"] button p,
+        [data-testid="stFormSubmitButton"] button span,
+        [data-testid="stFileUploaderDropzone"] button,
+        [data-testid="stFileUploaderDropzone"] button p,
+        [data-testid="stFileUploaderDropzone"] button span {
+          color: #ffffff !important;
+        }
+        input, textarea, select {
+          background: #ffffff !important;
+          color: var(--ink) !important;
+          border-color: var(--line) !important;
+        }
+        textarea, input, select {
+          border-radius: 7px !important;
+        }
+        textarea::placeholder, input::placeholder {
+          color: #7b8492 !important;
+          opacity: 1 !important;
+        }
+        .stTextInput label, .stTextArea label, .stSelectbox label, .stFileUploader label {
+          color: var(--ink) !important;
+          font-weight: 650 !important;
+        }
+        @media (max-width: 900px) {
+          .pp-hero { grid-template-columns: 1fr; }
+          .pp-title { font-size: 1.85rem; }
+          .pp-topbar { align-items: flex-start; flex-direction: column; }
+          .pp-top-actions { justify-content: flex-start; }
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def read_text_file(uploaded_file) -> str:
+    data = uploaded_file.getvalue()
+    try:
+        return data.decode("utf-8")
+    except UnicodeDecodeError:
+        try:
+            return data.decode("latin-1")
+        except UnicodeDecodeError:
+            return ""
+
+
+def load_rights_guide() -> str:
+    return RIGHTS_GUIDE.read_text(encoding="utf-8") if RIGHTS_GUIDE.exists() else ""
+
+
+def load_sample_items() -> list[EvidenceItem]:
+    payload = json.loads(SAMPLE_CASE.read_text(encoding="utf-8"))
+    return [
+        EvidenceItem(
+            id=item["id"],
+            title=item["title"],
+            source_type=item["source_type"],
+            raw_text=item["raw_text"],
+            filename=item.get("filename", ""),
+            created_on=item.get("created_on", "2026-05-11"),
+        )
+        for item in payload["evidence"]
+    ]
+
+
+def init_state() -> None:
+    if "evidence" not in st.session_state:
+        st.session_state.evidence = load_evidence()
+    if "packet" not in st.session_state:
+        st.session_state.packet = None
+    if "worker_name" not in st.session_state:
+        st.session_state.worker_name = "Ravi Kumar"
+
+
+def add_evidence(title: str, source_type: str, raw_text: str, filename: str = "") -> None:
+    if not raw_text.strip():
+        return
+    st.session_state.evidence.append(
+        EvidenceItem(
+            id=f"E{len(st.session_state.evidence) + 1:03d}",
+            title=title.strip() or filename or "Untitled evidence",
+            source_type=source_type,
+            raw_text=raw_text.strip(),
+            filename=filename,
+        )
+    )
+    save_evidence(st.session_state.evidence)
+
+
+def packet_to_markdown(packet) -> str:
+    timeline = "\n".join(
+        f"- {event.date}: {event.event} Evidence: {', '.join(event.evidence_ids)} Amount: {event.amount or 'N/A'}"
+        for event in packet.timeline
+    )
+    evidence_rows = "\n".join(
+        f"| {row['id']} | {row['title']} | {row['type']} | {row['key_dates']} | {row['amounts']} | {row['sensitivity']} |"
+        for row in packet.evidence_table
+    )
+    return f"""# ProofPrint Case Packet
+
+Worker: {packet.worker_name}
+Case type: {packet.case_type}
+Model status: {packet.model_status}
+
+## Summary
+{packet.summary}
+
+## Timeline
+{timeline or "No timeline events extracted."}
+
+## Evidence Table
+| ID | Title | Type | Key dates | Amounts | Sensitivity |
+|---|---|---|---|---|---|
+{evidence_rows}
+
+## Missing Evidence
+{chr(10).join(f"- {item}" for item in packet.missing_evidence)}
+
+## Risk Flags
+{chr(10).join(f"- {item}" for item in packet.risk_flags)}
+
+## Privacy Notes
+{chr(10).join(f"- {item}" for item in packet.privacy_notes)}
+
+## Advocate Packet
+{packet.advocate_packet}
+
+## Complaint Draft
+{packet.complaint_draft}
+"""
+
+
+def render_header() -> None:
+    st.markdown(
+        """
+        <div class="pp-topbar">
+          <div class="pp-brand">
+            <div class="pp-logo">PP</div>
+            <div>
+              <div class="pp-brand-title">ProofPrint</div>
+              <div class="pp-brand-subtitle">Private evidence packets for worker advocates</div>
+            </div>
+          </div>
+          <div class="pp-top-actions">
+            <span class="pp-pill">Digital Equity</span>
+            <span class="pp-pill">Safety & Trust</span>
+            <span class="pp-pill">Ollama Track</span>
+          </div>
+        </div>
+        <div class="pp-hero">
+          <div class="pp-shell">
+            <div class="pp-kicker">Local-first justice access</div>
+            <div class="pp-title">ProofPrint turns scattered worker evidence into an advocate-ready packet.</div>
+            <div class="pp-subtitle">
+              A private Gemma 4 workflow for wage theft, unsafe work, retaliation, and denied benefits.
+              It converts chats, payment notes, shift logs, and voice transcripts into a timeline,
+              risk review, and human advocate handoff.
+            </div>
+            <span class="pp-pill">Gemma 4 local inference</span>
+            <span class="pp-pill">Ollama on device</span>
+            <span class="pp-pill">Evidence-grounded output</span>
+            <span class="pp-pill">No fallback generation</span>
+          </div>
+          <div class="pp-panel-dark">
+            <div class="pp-kicker" style="color:#84d7c4;">Demo case</div>
+            <div class="pp-demo-title">Ravi worked five shifts. Only Rs 1,500 arrived.</div>
+            <div class="pp-muted">
+              Proof is split across hiring messages, shift notes, a UPI transcript, follow-up messages,
+              and a voice note. ProofPrint turns it into one reviewable packet.
+            </div>
+            <div style="margin-top:0.8rem;">
+              <span class="pp-pill-dark">unpaid wages</span>
+              <span class="pp-pill-dark">retaliation risk</span>
+              <span class="pp-pill-dark">privacy redaction</span>
+            </div>
+          </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def render_sidebar() -> None:
+    with st.sidebar:
+        st.markdown("## ProofPrint")
+        st.caption("Local Gemma evidence kit")
+        st.divider()
+        st.subheader("Case setup")
+        st.session_state.worker_name = st.text_input("Worker name", st.session_state.worker_name)
+        model = st.text_input("Local Gemma model", "gemma4:e2b")
+        st.caption("Use a local Ollama Gemma model name. Packet generation is disabled unless Gemma is reachable.")
+
+        if st.button("Load sample case", use_container_width=True):
+            st.session_state.evidence = load_sample_items()
+            st.session_state.packet = None
+            save_evidence(st.session_state.evidence)
+            st.rerun()
+
+        if st.button("Clear evidence", use_container_width=True):
+            st.session_state.evidence = []
+            st.session_state.packet = None
+            save_evidence([])
+            st.rerun()
+
+        st.divider()
+        st.subheader("Engine")
+        st.markdown(
+            """
+            <span class="pp-pill">Gemma extraction</span>
+            <span class="pp-pill">timeline reasoning</span>
+            <span class="pp-pill">risk checks</span>
+            <span class="pp-pill">packet drafting</span>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.divider()
+        st.caption("For public demos, use synthetic or anonymized evidence only.")
+        return model
+
+
+def render_intake() -> None:
+    st.markdown("### Evidence Intake")
+    st.caption("Add the fragments a worker actually has: chats, payment notes, shift logs, letters, or transcripts.")
+    left, right = st.columns([1.08, 0.92], gap="large")
+
+    with left:
+        st.markdown('<div class="pp-card-soft"><strong>Paste evidence manually</strong><br/><span class="pp-muted">Use this for chats, OCR text, voice transcripts, or notes copied from an image.</span></div>', unsafe_allow_html=True)
+        with st.form("manual_evidence", clear_on_submit=True):
+            title = st.text_input("Evidence title", placeholder="UPI payment screenshot text, shift log, employer chat...")
+            source_type = st.selectbox("Source type", ["chat", "payment", "shift log", "receipt", "letter", "photo note", "other"])
+            raw_text = st.text_area("Paste text or transcript", height=210, placeholder="Paste OCR text, chat transcript, voice note transcript, or notes from an image.")
+            submitted = st.form_submit_button("Add evidence", use_container_width=True)
+            if submitted:
+                add_evidence(title, source_type, raw_text)
+                st.rerun()
+
+    with right:
+        st.markdown(
+            """
+            <div class="pp-card-soft">
+              <div class="pp-step">
+                <div class="pp-num">1</div>
+                <div><div class="pp-step-title">Collect proof</div><div class="pp-step-text">Bring in the messy material exactly as it exists.</div></div>
+              </div>
+              <div class="pp-step">
+                <div class="pp-num">2</div>
+                <div><div class="pp-step-title">Run Gemma locally</div><div class="pp-step-text">Extract facts without sending worker data to a hosted model.</div></div>
+              </div>
+              <div class="pp-step">
+                <div class="pp-num">3</div>
+                <div><div class="pp-step-title">Export packet</div><div class="pp-step-text">Give advocates a timeline, risk review, missing-proof list, and draft.</div></div>
+              </div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.markdown('<div class="pp-upload-box"><strong>Upload text evidence</strong><br/><span class="pp-muted">Import .txt, .md, or .csv evidence files.</span></div>', unsafe_allow_html=True)
+        uploaded_files = st.file_uploader(
+            "Choose evidence files",
+            accept_multiple_files=True,
+            type=["txt", "md", "csv"],
+        )
+        if uploaded_files:
+            st.caption(f"{len(uploaded_files)} file(s) ready to import.")
+            if st.button("Import uploaded files", use_container_width=True):
+                for uploaded_file in uploaded_files:
+                    add_evidence(uploaded_file.name, uploaded_file.type or "uploaded file", read_text_file(uploaded_file), uploaded_file.name)
+                st.rerun()
+
+
+def render_evidence_list() -> None:
+    st.markdown("### Evidence Board")
+    if not st.session_state.evidence:
+        st.markdown('<div class="pp-card-soft"><strong>No evidence yet.</strong><br/><span class="pp-muted">Load the sample case from the sidebar or add evidence manually.</span></div>', unsafe_allow_html=True)
+        return
+
+    for item in st.session_state.evidence:
+        preview = html.escape(item.raw_text[:180] + ("..." if len(item.raw_text) > 180 else ""))
+        title = html.escape(item.title)
+        source_type = html.escape(item.source_type)
+        st.markdown(
+            f"""
+            <div class="pp-evidence-row">
+              <div class="pp-evidence-head">
+                <div><span class="pp-small">{item.id} / {source_type}</span><br/><span class="pp-evidence-title">{title}</span></div>
+                <span class="pp-status">stored locally</span>
+              </div>
+              <div class="pp-muted" style="margin-top:0.45rem;">{preview}</div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+        with st.expander(f"{item.id} - {item.title}", expanded=False):
+            st.write(f"Type: `{item.source_type}`")
+            st.text_area("Raw evidence", item.raw_text, height=130, key=f"raw_{item.id}", disabled=True)
+
+
+def render_packet(packet) -> None:
+    st.markdown("### Generated Case Packet")
+    top = st.columns(4)
+    counters = [
+        ("Case type", packet.case_type),
+        ("Evidence items", str(len(packet.evidence_table))),
+        ("Timeline events", str(len(packet.timeline))),
+        ("Missing checks", str(len(packet.missing_evidence))),
+    ]
+    for column, (label, value) in zip(top, counters):
+        column.markdown(
+            f"""
+            <div class="pp-counter">
+              <div class="pp-counter-label">{html.escape(label)}</div>
+              <div class="pp-counter-value">{html.escape(value)}</div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+    st.markdown(f'<span class="pp-status">{packet.model_status}</span>', unsafe_allow_html=True)
+
+    st.markdown(f'<div class="pp-card-soft"><strong>Case summary</strong><br/><span class="pp-muted">{html.escape(packet.summary)}</span></div>', unsafe_allow_html=True)
+
+    timeline_tab, evidence_tab, risks_tab, packet_tab, draft_tab = st.tabs(
+        ["Timeline", "Evidence", "Risk checks", "Advocate packet", "Complaint draft"]
+    )
+
+    with timeline_tab:
+        for event in packet.timeline:
+            event_text = html.escape(event.event)
+            event_date = html.escape(str(event.date))
+            event_amount = html.escape(event.amount or "N/A")
+            evidence_ids = html.escape(", ".join(event.evidence_ids))
+            st.markdown(
+                f"""
+                <div class="pp-card">
+                  <span class="pp-small">{event_date}</span><br/>
+                  <strong>{event_text}</strong><br/>
+                  <span class="pp-pill">Evidence: {evidence_ids}</span>
+                  <span class="pp-pill">Amount: {event_amount}</span>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+    with evidence_tab:
+        st.dataframe(packet.evidence_table, use_container_width=True, hide_index=True)
+
+    with risks_tab:
+        st.markdown("##### Missing evidence")
+        for item in packet.missing_evidence:
+            st.markdown(f'<div class="pp-missing">{item}</div>', unsafe_allow_html=True)
+        st.markdown("##### Risk and privacy flags")
+        for item in packet.risk_flags:
+            st.markdown(f'<div class="pp-risk">{item}</div>', unsafe_allow_html=True)
+        st.markdown("##### Privacy notes")
+        for item in packet.privacy_notes:
+            st.write(f"- {item}")
+
+    with packet_tab:
+        st.markdown(packet.advocate_packet)
+
+    with draft_tab:
+        st.text_area("Draft", packet.complaint_draft, height=340)
+
+    markdown = packet_to_markdown(packet)
+    st.download_button(
+        "Download advocate packet",
+        data=markdown,
+        file_name=f"proofprint_packet_{uuid.uuid4().hex[:8]}.md",
+        mime="text/markdown",
+        use_container_width=True,
+    )
+
+
+def main() -> None:
+    apply_theme()
+    init_state()
+    model_name = render_sidebar()
+    render_header()
+
+    stats = st.columns(3)
+    stats[0].markdown('<div class="pp-card"><div class="pp-kicker">Problem</div><strong>Scattered proof blocks justice.</strong><br/><span class="pp-muted">Workers often have evidence, but not a usable case packet.</span></div>', unsafe_allow_html=True)
+    stats[1].markdown('<div class="pp-card"><div class="pp-kicker">Gemma 4</div><strong>Private local reasoning.</strong><br/><span class="pp-muted">Facts are extracted on device through Ollama and Gemma 4 E2B.</span></div>', unsafe_allow_html=True)
+    stats[2].markdown('<div class="pp-card"><div class="pp-kicker">Output</div><strong>Advocate-ready handoff.</strong><br/><span class="pp-muted">Timeline, evidence index, missing proof, risk flags, and draft.</span></div>', unsafe_allow_html=True)
+
+    st.divider()
+    render_intake()
+    render_evidence_list()
+
+    st.divider()
+    can_generate = bool(st.session_state.evidence)
+    st.markdown("### Packet Builder")
+    st.caption("This step calls the local Gemma model. On your laptop, the sample case can take a few minutes.")
+    if st.button("Build advocate packet with Gemma", type="primary", disabled=not can_generate, use_container_width=True):
+        llm = LocalGemmaClient(model=model_name)
+        try:
+            st.session_state.packet = build_packet(
+                worker_name=st.session_state.worker_name,
+                evidence_items=st.session_state.evidence,
+                llm=llm,
+                rights_guide=load_rights_guide(),
+            )
+            save_evidence(st.session_state.evidence)
+            st.rerun()
+        except RuntimeError as exc:
+            st.error(str(exc))
+
+    if st.session_state.packet:
+        render_packet(st.session_state.packet)
+
+
+if __name__ == "__main__":
+    main()

core/__init__.py

@@ -0,0 +1 @@
+"""ProofPrint core package."""

core/analyzer.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import re
+from collections import Counter
+from datetime import date
+from typing import Any
+
+from .llm import LocalGemmaClient, extract_json_block
+from .models import CasePacket, EvidenceItem, TimelineEvent
+
+
+DATE_PATTERN = re.compile(
+    r"\b(?:\d{1,2}[/-]\d{1,2}[/-]\d{2,4}|\d{4}[/-]\d{1,2}[/-]\d{1,2}|(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\.?\s+\d{1,2},?\s+\d{4})\b",
+    re.IGNORECASE,
+)
+AMOUNT_PATTERN = re.compile(r"(?:Rs\.?|INR|₹|\$)\s?[\d,]+(?:\.\d{1,2})?|\b\d{3,6}\s?(?:rupees|rs)\b", re.IGNORECASE)
+PHONE_PATTERN = re.compile(r"\b(?:\+?\d[\d -]{8,}\d)\b")
+EMAIL_PATTERN = re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.IGNORECASE)
+
+CASE_TYPES = {
+    "Unpaid wages": ["salary", "wage", "payment", "paid", "unpaid", "shift", "overtime", "invoice"],
+    "Unsafe work": ["injury", "unsafe", "accident", "protective", "helmet", "gloves", "hazard"],
+    "Harassment or retaliation": ["threat", "harass", "retaliation", "fired", "terminated", "abuse"],
+    "Denied benefit": ["claim", "benefit", "denied", "rejected", "eligibility", "scheme"],
+}
+
+
+def classify_case(text: str) -> str:
+    lowered = text.lower()
+    scores = {
+        case_type: sum(1 for keyword in keywords if keyword in lowered)
+        for case_type, keywords in CASE_TYPES.items()
+    }
+    best, score = max(scores.items(), key=lambda pair: pair[1])
+    return best if score else "Worker evidence packet"
+
+
+def extract_entities(text: str) -> dict[str, Any]:
+    dates = DATE_PATTERN.findall(text)
+    amounts = AMOUNT_PATTERN.findall(text)
+    phones = PHONE_PATTERN.findall(text)
+    emails = EMAIL_PATTERN.findall(text)
+    words = re.findall(r"\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,2}\b", text)
+    names = [word for word, count in Counter(words).most_common(8) if word.lower() not in {"I", "The", "This"}]
+    return {
+        "dates": sorted(set(dates)),
+        "amounts": sorted(set(amounts)),
+        "contacts": sorted(set(phones + emails)),
+        "possible_people_or_orgs": names,
+    }
+
+
+def analyze_evidence_item(item: EvidenceItem, llm: LocalGemmaClient) -> tuple[EvidenceItem, str]:
+    prompt = f"""
+You are ProofPrint, a local-first evidence organizer for worker advocates.
+Extract only facts supported by the evidence. Return valid compact JSON only, with keys:
+case_type, one_sentence_summary, dates, amounts, people_or_orgs, promises, harms, contradictions, sensitivity.
+Use arrays for dates, amounts, people_or_orgs, promises, harms, and contradictions.
+
+Evidence title: {item.title}
+Evidence text:
+{item.raw_text[:5000]}
+"""
+    response, status = llm.generate(prompt)
+    if not response:
+        raise RuntimeError(f"Gemma analysis failed for {item.id}: {status}")
+    parsed = extract_json_block(response)
+    if not parsed:
+        raise RuntimeError(f"Gemma did not return valid JSON for {item.id}. Raw response: {response[:400]}")
+
+    item.extracted = {
+        "case_type": str(parsed.get("case_type") or "Worker evidence packet"),
+        "one_sentence_summary": str(parsed.get("one_sentence_summary") or ""),
+        "dates": ensure_list(parsed.get("dates")),
+        "amounts": ensure_list(parsed.get("amounts")),
+        "people_or_orgs": ensure_list(parsed.get("people_or_orgs")),
+        "promises": ensure_list(parsed.get("promises")),
+        "harms": ensure_list(parsed.get("harms")),
+        "contradictions": ensure_list(parsed.get("contradictions")),
+        "sensitivity": str(parsed.get("sensitivity") or "unknown"),
+    }
+    return item, status
+
+
+def ensure_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def summarize_text(text: str) -> str:
+    clean = " ".join(text.split())
+    if len(clean) <= 220:
+        return clean
+    return clean[:217].rsplit(" ", 1)[0] + "..."
+
+
+def find_lines(text: str, keywords: list[str]) -> list[str]:
+    lines = [line.strip() for line in re.split(r"[\n\r.]+", text) if line.strip()]
+    matches = []
+    for line in lines:
+        lowered = line.lower()
+        if any(keyword in lowered for keyword in keywords):
+            matches.append(line[:240])
+    return matches[:5]
+
+
+def infer_sensitivity(text: str) -> str:
+    lowered = text.lower()
+    if EMAIL_PATTERN.search(text) or PHONE_PATTERN.search(text):
+        return "high: contains personal contact information"
+    if any(word in lowered for word in ["injury", "medical", "threat", "harass"]):
+        return "high: contains safety or health details"
+    if AMOUNT_PATTERN.search(text):
+        return "medium: contains payment details"
+    return "low"
+
+
+def build_packet(
+    worker_name: str,
+    evidence_items: list[EvidenceItem],
+    llm: LocalGemmaClient,
+    rights_guide: str,
+) -> CasePacket:
+    if not llm.available():
+        raise RuntimeError(
+            f"Local Gemma model '{llm.model}' is not reachable through Ollama. "
+            "Start Ollama and pull the configured Gemma model before building a packet."
+        )
+
+    analyzed = []
+    statuses = []
+    for item in evidence_items:
+        analyzed_item, status = analyze_evidence_item(item, llm)
+        analyzed.append(analyzed_item)
+        statuses.append(status)
+
+    full_text = "\n\n".join(item.raw_text for item in analyzed)
+    case_type = classify_case(full_text)
+    timeline = build_timeline(analyzed)
+    evidence_table = build_evidence_table(analyzed)
+    missing = missing_evidence_for(case_type, analyzed)
+    risks = risk_flags_for(analyzed)
+    privacy = privacy_notes_for(analyzed)
+    summary = build_case_summary(worker_name, case_type, analyzed)
+    advocate_packet = build_advocate_packet(worker_name, case_type, summary, timeline, evidence_table, missing, risks, rights_guide)
+    complaint_draft = build_complaint_draft(worker_name, case_type, summary, timeline, missing)
+
+    return CasePacket(
+        worker_name=worker_name or "Worker",
+        case_type=case_type,
+        summary=summary,
+        timeline=timeline,
+        evidence_table=evidence_table,
+        missing_evidence=missing,
+        risk_flags=risks,
+        advocate_packet=advocate_packet,
+        complaint_draft=complaint_draft,
+        privacy_notes=privacy,
+        model_status=most_relevant_status(statuses),
+    )
+
+
+def build_timeline(items: list[EvidenceItem]) -> list[TimelineEvent]:
+    events: list[TimelineEvent] = []
+    for item in items:
+        dates = item.extracted.get("dates") or [item.created_on]
+        amounts = item.extracted.get("amounts") or []
+        people = item.extracted.get("people_or_orgs") or []
+        summary = item.extracted.get("one_sentence_summary") or summarize_text(item.raw_text)
+        for event_date in dates[:3]:
+            events.append(
+                TimelineEvent(
+                    date=str(event_date),
+                    event=summary,
+                    evidence_ids=[item.id],
+                    amount=", ".join(map(str, amounts[:3])),
+                    people=[str(person) for person in people[:4]],
+                )
+            )
+    return sorted(events, key=lambda event: event.date)[:12]
+
+
+def build_evidence_table(items: list[EvidenceItem]) -> list[dict[str, str]]:
+    rows = []
+    for item in items:
+        extracted = item.extracted
+        rows.append(
+            {
+                "id": item.id,
+                "title": item.title,
+                "type": item.source_type,
+                "key_dates": ", ".join(map(str, extracted.get("dates", [])[:4])) or "Not found",
+                "amounts": ", ".join(map(str, extracted.get("amounts", [])[:4])) or "Not found",
+                "summary": str(extracted.get("one_sentence_summary", "")),
+                "sensitivity": str(extracted.get("sensitivity", infer_sensitivity(item.raw_text))),
+            }
+        )
+    return rows
+
+
+def missing_evidence_for(case_type: str, items: list[EvidenceItem]) -> list[str]:
+    text = "\n".join(item.raw_text.lower() for item in items)
+    checks = {
+        "Unpaid wages": [
+            ("employment terms or hiring chat", ["hired", "contract", "joining", "rate", "salary"]),
+            ("work dates or shift records", ["shift", "attendance", "worked", "hours"]),
+            ("payment proof or bank/UPI screenshot", ["upi", "bank", "paid", "payment", "transfer"]),
+            ("final demand or employer response", ["asked", "request", "reply", "will pay", "refused"]),
+        ],
+        "Unsafe work": [
+            ("photo or record of the hazard", ["photo", "unsafe", "hazard", "broken"]),
+            ("injury or incident date", ["injury", "accident", "hurt", "hospital"]),
+            ("manager notification proof", ["reported", "informed", "manager", "supervisor"]),
+        ],
+        "Harassment or retaliation": [
+            ("original message or witness note", ["message", "witness", "threat", "abuse"]),
+            ("timeline of retaliation", ["fired", "removed", "blocked", "terminated"]),
+        ],
+        "Denied benefit": [
+            ("denial letter or rejection message", ["denied", "rejected", "not eligible"]),
+            ("eligibility proof", ["eligible", "income", "identity", "document"]),
+        ],
+    }
+    selected = checks.get(case_type, checks["Unpaid wages"])
+    missing = [label for label, keywords in selected if not any(keyword in text for keyword in keywords)]
+    return missing or ["No obvious missing evidence detected. Advocate should still verify authenticity and deadlines."]
+
+
+def risk_flags_for(items: list[EvidenceItem]) -> list[str]:
+    text = "\n".join(item.raw_text.lower() for item in items)
+    flags = []
+    if "threat" in text or "abuse" in text:
+        flags.append("Possible retaliation or safety risk. Escalate to a trusted advocate before direct confrontation.")
+    if "injury" in text or "hospital" in text:
+        flags.append("Health or injury details detected. Preserve medical records and avoid public sharing.")
+    if not DATE_PATTERN.search(text):
+        flags.append("No clear dates found. Timeline needs stronger date evidence.")
+    if not AMOUNT_PATTERN.search(text):
+        flags.append("No clear money amounts found. Payment claim may need wage or invoice proof.")
+    if PHONE_PATTERN.search(text) or EMAIL_PATTERN.search(text):
+        flags.append("Personal contact details detected. Redact before public upload.")
+    return flags or ["No major risk flags detected from the provided evidence."]
+
+
+def privacy_notes_for(items: list[EvidenceItem]) -> list[str]:
+    notes = [
+        "Keep original evidence files unchanged.",
+        "Share the generated packet only with a trusted advocate, union, NGO, or official channel.",
+    ]
+    if any("high" in str(item.extracted.get("sensitivity", "")) for item in items):
+        notes.append("High-sensitivity evidence detected. Redact phone numbers, addresses, and health details for public demos.")
+    return notes
+
+
+def build_case_summary(worker_name: str, case_type: str, items: list[EvidenceItem]) -> str:
+    summaries = [str(item.extracted.get("one_sentence_summary", "")) for item in items if item.extracted]
+    name = worker_name or "The worker"
+    return f"{name} appears to have a {case_type.lower()} matter supported by {len(items)} evidence item(s). " + " ".join(summaries[:3])
+
+
+def build_advocate_packet(
+    worker_name: str,
+    case_type: str,
+    summary: str,
+    timeline: list[TimelineEvent],
+    evidence_table: list[dict[str, str]],
+    missing: list[str],
+    risks: list[str],
+    rights_guide: str,
+) -> str:
+    timeline_lines = "\n".join(
+        f"- {event.date}: {event.event} Evidence: {', '.join(event.evidence_ids)} Amount: {event.amount or 'N/A'}"
+        for event in timeline
+    )
+    evidence_lines = "\n".join(
+        f"- {row['id']} | {row['title']} | {row['type']} | Dates: {row['key_dates']} | Amounts: {row['amounts']}"
+        for row in evidence_table
+    )
+    missing_lines = "\n".join(f"- {item}" for item in missing)
+    risk_lines = "\n".join(f"- {item}" for item in risks)
+    guide_excerpt = rights_guide[:900].strip()
+    return f"""# ProofPrint Advocate Packet
+
+Generated: {date.today().isoformat()}
+Worker: {worker_name or "Worker"}
+Case type: {case_type}
+
+## Plain-language summary
+{summary}
+
+## Timeline
+{timeline_lines or "- No dated events found yet."}
+
+## Evidence index
+{evidence_lines}
+
+## Missing evidence checklist
+{missing_lines}
+
+## Risk and privacy flags
+{risk_lines}
+
+## Local rights guide context
+{guide_excerpt}
+
+## Important limitation
+ProofPrint organizes evidence and drafts support material. It does not provide legal advice, verify authenticity, or replace a qualified advocate.
+"""
+
+
+def build_complaint_draft(
+    worker_name: str,
+    case_type: str,
+    summary: str,
+    timeline: list[TimelineEvent],
+    missing: list[str],
+) -> str:
+    timeline_text = "\n".join(f"- {event.date}: {event.event}" for event in timeline[:8])
+    missing_text = "\n".join(f"- {item}" for item in missing)
+    return f"""Subject: Request for assistance with {case_type.lower()}
+
+I am requesting help reviewing a worker rights matter.
+
+Worker: {worker_name or "Worker"}
+Issue: {case_type}
+
+Summary:
+{summary}
+
+Timeline:
+{timeline_text or "- Dates are still being collected."}
+
+Evidence still needed:
+{missing_text}
+
+I understand this draft is only an evidence organization aid and should be reviewed by a qualified advocate before submission.
+"""
+
+
+def most_relevant_status(statuses: list[str]) -> str:
+    for status in statuses:
+        if status.startswith("local Gemma"):
+            return status
+    return statuses[-1] if statuses else "local Gemma status unavailable"

core/llm.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any
+
+
+DEFAULT_MODEL = os.getenv("PROOFPRINT_MODEL", "gemma4:e2b")
+OLLAMA_URL = os.getenv("OLLAMA_URL", "http://localhost:11434/api/generate")
+
+
+class LocalGemmaClient:
+    def __init__(self, model: str = DEFAULT_MODEL, url: str = OLLAMA_URL, timeout: int = 180) -> None:
+        self.model = model
+        self.url = url
+        self.timeout = timeout
+
+    def available(self) -> bool:
+        tags_url = self.url.replace("/api/generate", "/api/tags")
+        try:
+            with urllib.request.urlopen(tags_url, timeout=10) as response:
+                body = json.loads(response.read().decode("utf-8"))
+            return any(model.get("name") == self.model or model.get("model") == self.model for model in body.get("models", []))
+        except Exception:
+            return False
+
+    def generate(self, prompt: str, images: list[bytes] | None = None) -> tuple[str, str]:
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {"temperature": 0.2, "top_p": 0.9},
+        }
+        if images:
+            payload["images"] = [base64.b64encode(image).decode("ascii") for image in images]
+
+        try:
+            request = urllib.request.Request(
+                self.url,
+                data=json.dumps(payload).encode("utf-8"),
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                body = json.loads(response.read().decode("utf-8"))
+            return body.get("response", "").strip(), f"local Gemma via Ollama ({self.model})"
+        except urllib.error.HTTPError as exc:
+            return "", f"Ollama HTTP error: {exc.code}"
+        except Exception as exc:
+            return "", f"Gemma unavailable ({exc.__class__.__name__})"
+
+
+def extract_json_block(text: str) -> dict[str, Any] | None:
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        return None
+    try:
+        return json.loads(text[start : end + 1])
+    except json.JSONDecodeError:
+        return None

core/models.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Any
+
+
+@dataclass
+class EvidenceItem:
+    id: str
+    title: str
+    source_type: str
+    raw_text: str
+    filename: str = ""
+    created_on: str = field(default_factory=lambda: date.today().isoformat())
+    extracted: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class TimelineEvent:
+    date: str
+    event: str
+    evidence_ids: list[str]
+    amount: str = ""
+    people: list[str] = field(default_factory=list)
+    confidence: str = "medium"
+
+
+@dataclass
+class CasePacket:
+    worker_name: str
+    case_type: str
+    summary: str
+    timeline: list[TimelineEvent]
+    evidence_table: list[dict[str, str]]
+    missing_evidence: list[str]
+    risk_flags: list[str]
+    advocate_packet: str
+    complaint_draft: str
+    privacy_notes: list[str]
+    model_status: str

core/storage.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+
+from .models import EvidenceItem
+
+
+DB_PATH = Path(__file__).resolve().parents[1] / "data" / "proofprint.sqlite"
+
+
+def init_db(path: Path = DB_PATH) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with sqlite3.connect(path) as connection:
+        connection.execute(
+            """
+            CREATE TABLE IF NOT EXISTS evidence (
+                id TEXT PRIMARY KEY,
+                title TEXT NOT NULL,
+                source_type TEXT NOT NULL,
+                filename TEXT,
+                raw_text TEXT NOT NULL,
+                created_on TEXT NOT NULL,
+                extracted_json TEXT NOT NULL
+            )
+            """
+        )
+
+
+def save_evidence(items: list[EvidenceItem], path: Path = DB_PATH) -> None:
+    init_db(path)
+    with sqlite3.connect(path) as connection:
+        connection.executemany(
+            """
+            INSERT OR REPLACE INTO evidence
+            (id, title, source_type, filename, raw_text, created_on, extracted_json)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            [
+                (
+                    item.id,
+                    item.title,
+                    item.source_type,
+                    item.filename,
+                    item.raw_text,
+                    item.created_on,
+                    json.dumps(item.extracted),
+                )
+                for item in items
+            ],
+        )
+
+
+def load_evidence(path: Path = DB_PATH) -> list[EvidenceItem]:
+    init_db(path)
+    with sqlite3.connect(path) as connection:
+        rows = connection.execute(
+            "SELECT id, title, source_type, filename, raw_text, created_on, extracted_json FROM evidence ORDER BY created_on, id"
+        ).fetchall()
+    return [
+        EvidenceItem(
+            id=row[0],
+            title=row[1],
+            source_type=row[2],
+            filename=row[3] or "",
+            raw_text=row[4],
+            created_on=row[5],
+            extracted=json.loads(row[6] or "{}"),
+        )
+        for row in rows
+    ]

data/sample_unpaid_wages_case.json

@@ -0,0 +1,46 @@
+{
+  "worker_name": "Ravi Kumar",
+  "case_type": "Unpaid wages",
+  "evidence": [
+    {
+      "id": "E001",
+      "title": "Hiring chat with promised daily wage",
+      "source_type": "chat",
+      "filename": "hiring_chat.txt",
+      "created_on": "2026-05-11",
+      "raw_text": "March 2, 2026. Supervisor Amit: Come from tomorrow for delivery sorting work. Salary will be Rs 850 per day plus overtime after 9 hours. Ravi: I can join from March 3. Supervisor Amit: Yes, keep screenshots of your shifts if app does not show attendance."
+    },
+    {
+      "id": "E002",
+      "title": "Shift log copied from notebook",
+      "source_type": "shift log",
+      "filename": "shift_log.txt",
+      "created_on": "2026-05-11",
+      "raw_text": "Ravi Kumar shift notes: March 3, 2026 worked 10 hours. March 4, 2026 worked 11 hours. March 5, 2026 worked 10 hours. March 6, 2026 worked 9 hours. March 7, 2026 worked 12 hours. No weekly payment received. Expected base amount is Rs 4,250 plus overtime."
+    },
+    {
+      "id": "E003",
+      "title": "Payment screenshot transcript",
+      "source_type": "payment",
+      "filename": "upi_screenshot_text.txt",
+      "created_on": "2026-05-11",
+      "raw_text": "UPI transaction from QuickKart Logistics to Ravi Kumar on March 10, 2026: Rs 1,500 received. Note: partial settlement. Ravi phone number visible: +91 98765 43210."
+    },
+    {
+      "id": "E004",
+      "title": "Employer follow-up message",
+      "source_type": "chat",
+      "filename": "followup_chat.txt",
+      "created_on": "2026-05-11",
+      "raw_text": "March 12, 2026. Ravi: Sir, I worked five days and got only Rs 1,500. Balance salary and overtime are pending. Supervisor Amit: Accounts will pay tomorrow. Do not complain in the group. March 15, 2026. Ravi: Still no payment. Supervisor Amit: If you keep asking, do not come for next shifts."
+    },
+    {
+      "id": "E005",
+      "title": "Voice note transcript to worker group",
+      "source_type": "voice transcript",
+      "filename": "voice_note_transcript.txt",
+      "created_on": "2026-05-11",
+      "raw_text": "Ravi voice note on March 16, 2026: I need help. I worked at QuickKart Logistics from March 3 to March 7. They promised Rs 850 per day and overtime. I only received Rs 1,500. I am missing at least Rs 2,750 plus overtime. I have chat screenshots and the UPI screenshot."
+    }
+  ]
+}

data/worker_rights_guide.md

@@ -0,0 +1,9 @@
+# Worker Rights Guide Context
+
+This demo guide is intentionally general and should be replaced with jurisdiction-specific guidance before real deployment.
+
+Workers and advocates should preserve original evidence, including screenshots, messages, payment records, shift records, identity documents, and written employer responses. The strongest wage claim packets usually include proof of the agreed wage, proof that work was performed, proof of partial or missing payment, and a dated request for payment.
+
+For safety, workers should avoid public posting of private phone numbers, addresses, health information, and identity documents. If retaliation or threats are present, the matter should be reviewed by a trusted union, NGO, legal aid group, or official worker support channel before direct confrontation.
+
+ProofPrint does not provide legal advice. It helps organize evidence, identify missing proof, and prepare a structured handoff packet for qualified human review.

docs/kaggle_submission_checklist.md

@@ -0,0 +1,68 @@
+# ProofPrint Kaggle Submission Checklist
+
+## Done locally
+
+- Working app prototype: Streamlit app in `proofprint/app.py`
+- Local Gemma 4 inference: `gemma4:e2b` through Ollama
+- No fallback packet generation: app requires the configured Gemma model
+- Sample case: unpaid-wages worker evidence in `data/sample_unpaid_wages_case.json`
+- Evidence workflow: manual intake, text upload, local storage, packet builder
+- Generated outputs: timeline, evidence table, missing-evidence checks, risk flags, advocate packet, complaint draft
+- Project docs: `README.md`, `docs/writeup_draft.md`, `docs/submission_strategy.md`
+
+## Still needed before Kaggle submission
+
+- Public code repository
+- Public live demo URL
+- YouTube video under 3 minutes
+- Kaggle writeup under 1,500 words
+- Media Gallery cover image and screenshots
+- Final Kaggle Writeup submission before the deadline
+
+## Recommended track choices
+
+- Primary: Digital Equity & Inclusivity
+- Secondary: Safety & Trust
+- Special Technology Track: Ollama
+
+## Public repository checklist
+
+- Create a GitHub repository named `proofprint`
+- Push the `proofprint` folder contents
+- Include clear setup instructions from `README.md`
+- Do not commit real private evidence
+- Keep the sample case synthetic
+
+## Live demo checklist
+
+Use one of these free options:
+
+- Streamlit Community Cloud
+- Hugging Face Spaces with Streamlit
+
+For public demo reliability, deploy with the sample synthetic case. If the free host cannot run Ollama/Gemma locally, clearly label the hosted page as a UI demo and include the local Gemma video proof. The strongest submission should still show local Gemma running in the video.
+
+## Video checklist
+
+Keep it under 3 minutes:
+
+1. Show the problem: scattered proof from an informal worker.
+2. Open ProofPrint and load the sample case.
+3. Build the packet using `gemma4:e2b`.
+4. Show timeline, evidence index, missing proof, risk flags, and complaint draft.
+5. Explain local privacy: worker evidence stays on device.
+6. End with impact: advocates get a clean packet faster.
+
+## Kaggle writeup checklist
+
+Include:
+
+- Problem and target users
+- Why Gemma 4 is central
+- Architecture
+- Local-first/privacy explanation
+- Demo workflow
+- Limitations and safety boundary
+- Links to GitHub, video, and live demo
+
+Keep the writeup under 1,500 words.

docs/submission_strategy.md

@@ -0,0 +1,59 @@
+# ProofPrint Submission Strategy
+
+## One-line pitch
+
+ProofPrint turns scattered worker evidence into a private, structured, advocate-ready packet so informal workers can get help faster.
+
+## Problem
+
+Informal workers often do not have contracts, HR systems, or clean payroll records. When wages are withheld or unsafe work is ignored, their proof is spread across chats, payment screenshots, shift notes, voice messages, and receipts. Advocates must reconstruct the case manually before taking action.
+
+## Solution
+
+ProofPrint gives workers and advocates a local-first evidence organizer. It extracts dates, amounts, people, promises, harms, and risks; builds a timeline; identifies missing evidence; and drafts a complaint or NGO handoff packet.
+
+## Why Gemma 4
+
+Gemma 4 is valuable here because the evidence is sensitive and often messy. Local inference keeps private worker data on device. Multimodal reasoning can support screenshots, receipts, forms, and document photos. Function-style checks help turn model output into reliable structured workflow steps.
+
+## Architecture
+
+- Streamlit frontend for evidence intake and packet review
+- Local Python analysis pipeline
+- Ollama-compatible Gemma client
+- Gemma-required generation path for authentic local inference
+- SQLite local evidence store
+- Markdown packet export
+- Local rights guide used as grounded context
+
+## Demo story
+
+Ravi is a delivery sorting worker who was promised Rs 850 per day plus overtime. After five shifts, he received only Rs 1,500 and was warned not to complain. His evidence is scattered across chat screenshots, shift notes, UPI payment text, and a voice note. ProofPrint turns that material into a timeline, missing evidence checklist, privacy warning, and advocate packet.
+
+## Judging fit
+
+Impact & Vision:
+ProofPrint improves access to justice for workers who cannot easily prove what happened.
+
+Video Pitch & Storytelling:
+The demo has a clear human story: scattered proof becomes usable power.
+
+Technical Depth:
+The project uses local model inference, structured extraction, privacy flags, grounded drafting, and a functional packet export workflow.
+
+## Video outline under 3 minutes
+
+1. 0:00-0:25 - Show the problem: scattered screenshots, payment notes, and threats.
+2. 0:25-0:45 - Introduce ProofPrint as a local-first evidence kit.
+3. 0:45-1:40 - Run the sample case and build the packet.
+4. 1:40-2:20 - Show timeline, missing evidence, risk flags, and complaint draft.
+5. 2:20-2:50 - Explain Gemma 4 architecture and privacy value.
+6. 2:50-3:00 - Close with impact: clean evidence helps people reach real advocates.
+
+## What to submit
+
+- Kaggle writeup under 1,500 words
+- YouTube video under 3 minutes
+- Public GitHub repository
+- Live Streamlit or Hugging Face Spaces demo
+- Cover image and screenshots in Media Gallery

docs/writeup_draft.md

@@ -0,0 +1,25 @@
+# ProofPrint: Local Evidence Kits for Informal Workers
+
+## Subtitle
+
+A private Gemma 4 app that turns scattered worker evidence into advocate-ready case packets.
+
+## Writeup
+
+Informal workers often lose access to justice before anyone reviews the merits of their case. Their proof may exist, but it is scattered across WhatsApp messages, payment screenshots, handwritten shift notes, receipts, voice notes, and photos. A worker may know exactly what happened, yet still struggle to answer the questions an advocate needs first: What was promised? When did the work happen? What was paid? What is missing? Is there retaliation risk? Which evidence should be protected before it is shared?
+
+ProofPrint is a local-first Gemma 4 application for that gap. It helps informal workers, unions, worker centers, legal-aid clinics, and NGOs turn messy evidence into a structured first-review packet. The app extracts key facts from evidence fragments, builds a timeline, creates an evidence index, identifies missing proof, flags privacy and safety risks, and drafts a complaint or advocate handoff note.
+
+The demo follows Ravi, a delivery sorting worker who was promised Rs 850 per day plus overtime. After five shifts, he received only Rs 1,500 and was warned not to complain. His evidence is fragmented across a hiring chat, shift notes, a payment transcript, follow-up messages, and a voice note. ProofPrint turns those fragments into a packet an advocate can review quickly.
+
+Gemma 4 is central to the product because this workflow requires reasoning over sensitive, messy, real-world material. Worker evidence can contain phone numbers, payment records, health details, threats, and personal identifiers. Sending that material to a hosted model is often inappropriate. ProofPrint runs Gemma 4 locally through Ollama, keeping the evidence workflow on device while still enabling structured extraction, summarization, timeline reasoning, and grounded packet drafting.
+
+The current prototype uses `gemma4:e2b` with Ollama on a local laptop. The Streamlit interface handles evidence intake and packet review. The Python backend calls the local Gemma model for each evidence item and requires valid structured output before building the packet. A local analysis layer then assembles the timeline, evidence table, missing-evidence checklist, risk flags, privacy notes, advocate packet, and complaint draft. SQLite is used for local evidence storage, and the final packet can be exported as Markdown.
+
+ProofPrint intentionally avoids silent fallback generation. If the configured Gemma model is not reachable, the app refuses to generate a packet. This keeps the demo honest: the submitted workflow depends on local Gemma inference, not a hidden substitute.
+
+The safety boundary is also explicit. ProofPrint does not provide legal advice, verify evidence authenticity, or replace a lawyer or trained advocate. It organizes evidence and prepares a structured handoff for human review. This boundary matters because the goal is not to automate justice decisions. The goal is to help people reach real help with clearer facts, less delay, and less risk of exposing private information.
+
+The real-world impact is practical. Worker centers and legal-aid teams often spend precious intake time reconstructing timelines from screenshots and notes. ProofPrint can reduce that first-pass burden and help workers preserve the right evidence before deadlines, retaliation, or data loss make a case harder to pursue. The same pattern can extend beyond unpaid wages to unsafe work, retaliation, denied benefits, disaster-related compensation, and other situations where people have proof but no clean way to organize it.
+
+ProofPrint shows how local frontier intelligence can serve communities where privacy, trust, and access matter most. For informal workers, clean evidence is power. ProofPrint helps turn scattered proof into something a human advocate can act on.

exports/.gitkeep

@@ -0,0 +1 @@
+

requirements.txt

@@ -0,0 +1 @@
+streamlit>=1.33