Upload frozen release files

DATASET.md

@@ -0,0 +1,25 @@
+# Dataset candidate
+
+## Provenance
+
+The candidate indexes factual fields mechanically extracted from the California Attorney General’s [data breach notice registry](https://oag.ca.gov/privacy/databreach/list) and its CSV export. The registry describes sample notices submitted for incidents affecting more than 500 California residents. The filer may not be the organization that experienced the incident.
+
+Each build writes a local source manifest with source URL, access time, content type, byte count, and SHA-256. `data/coverage.json` is the committed receipt for the build included here. Source PDFs are inputs only: they are not committed, redistributed, or converted into published notice prose.
+
+## Fields
+
+Every row has: `id`, `organization`, `breach_dates`, `reported_date`, `data_exposed`, `remedy_type`, `remedy_provider`, `remedy_duration_months`, `remedy_duration_text`, `enrollment_deadline`, `enrollment_deadline_timezone`, `deadline_status`, `source_report_url`, `source_notice_url`, `source_notice_sha256`, `source_accessed_at`, and `extraction_confidence`.
+
+`deadline_status` is `open`, `expired`, or `unknown`. It is calculated only from an explicit printed deadline and the recorded build timestamp. An ambiguous or absent deadline stays null and `unknown`; the builder does not infer a deadline from a letter date or the protection duration.
+
+## Coverage and limitations
+
+This candidate is partial. See `data/coverage.json` for its source-record denominator, report pages attempted, notice PDFs fetched, and resolved-row numerator. It does not claim complete registry coverage. Deterministic text extraction can miss a scanned notice or an unfamiliar deadline format. The index does not determine enrolment eligibility and must not be used as a substitute for a recipient’s notice.
+
+The included receipt was updated 2026-07-30. To report a correction, write to hello@cybernative.ai.
+
+## Dataset license and scope
+
+The software in this repository is MIT-licensed under [LICENSE](LICENSE). CyberNative AI LLC dedicates its copyright and database rights, if any, in the selection and arrangement of the factual dataset in [`data/`](data/) to the public domain under [CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/legalcode).
+
+This CC0 dedication applies only to `data/` and only to the extent CyberNative AI LLC holds those rights. It does not apply to linked or underlying notice PDFs, notice prose, third-party trademarks, or any other third-party material. The CC0 1.0 Universal legal code and disclaimer are available at https://creativecommons.org/publicdomain/zero/1.0/legalcode.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CyberNative AI LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,23 @@
+# Breach Clock
+
+Breach Clock builds a small, static index of protection offers and printed enrolment deadlines from California Attorney General data-breach notice filings. It is a search aid, not an eligibility decision: a person’s own letter and its activation code determine whether they can enrol.
+
+## Run
+
+Requires Python 3.11+ and `pdftotext` from Poppler. The scripts use only the Python standard library and make no metered API calls.
+
+```sh
+python scripts/fetch_registry.py
+python scripts/fetch_notices.py --only-id sb24-626307 --max-reports 1
+python scripts/extract_offers.py
+python scripts/build_index.py
+python -m unittest discover -s tests -v
+```
+
+The downloaded source inputs and `build/source-manifest.json` are local build inputs; they are intentionally not committed. Notice PDFs and notice prose are never published by this repository.
+
+## Output
+
+`data/offers.jsonl` is the line-oriented index. `data/offers.json` is the browser-ready equivalent. `data/coverage.json` describes the exact build scope and counts. Each row links to the original report and notice, and records the notice hash and access time.
+
+The software is MIT-licensed. CyberNative AI LLC dedicates only its rights, if any, in the selection and arrangement of `data/` under CC0 1.0 Universal; linked or underlying notices, notice prose, third-party trademarks, and other third-party material are excluded. [DATASET.md](DATASET.md) governs the exact scope.

data/coverage.json

@@ -0,0 +1,14 @@
+{
+  "built_at": "2026-07-30T00:00:00Z",
+  "coverage_complete": false,
+  "extraction_failures": 0,
+  "pdfs_fetched": 138,
+  "report_pages_attempted": 138,
+  "resolved_record_count": 137,
+  "rows_expired": 0,
+  "rows_open": 20,
+  "rows_unknown": 117,
+  "rows_with_any_remedy": 128,
+  "rows_with_explicit_deadline": 20,
+  "source_record_count": 5232
+}

pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "breach-clock"
+version = "0.1.0"
+description = "Static index builder for California breach-notice protection offers."
+requires-python = ">=3.11"
+
+[tool.unittest]
+start-directory = "tests"

schema/offers.schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Breach Clock offer row",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["id", "organization", "breach_dates", "reported_date", "data_exposed", "remedy_type", "remedy_provider", "remedy_duration_months", "remedy_duration_text", "enrollment_deadline", "enrollment_deadline_timezone", "deadline_status", "source_report_url", "source_notice_url", "source_notice_sha256", "source_accessed_at", "extraction_confidence"],
+  "properties": {
+    "id": {"type": "string"},
+    "organization": {"type": ["string", "null"]},
+    "breach_dates": {"type": "array", "items": {"type": "string", "format": "date"}},
+    "reported_date": {"type": ["string", "null"], "format": "date"},
+    "data_exposed": {"type": "array", "items": {"type": "string"}},
+    "remedy_type": {"type": ["string", "null"]},
+    "remedy_provider": {"type": ["string", "null"]},
+    "remedy_duration_months": {"type": ["integer", "null"], "minimum": 0},
+    "remedy_duration_text": {"type": ["string", "null"]},
+    "enrollment_deadline": {"type": ["string", "null"], "format": "date"},
+    "enrollment_deadline_timezone": {"type": ["string", "null"]},
+    "deadline_status": {"enum": ["open", "expired", "unknown"]},
+    "source_report_url": {"type": "string", "format": "uri"},
+    "source_notice_url": {"type": "string", "format": "uri"},
+    "source_notice_sha256": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+    "source_accessed_at": {"type": "string", "format": "date-time"},
+    "extraction_confidence": {"type": "number", "minimum": 0, "maximum": 1}
+  }
+}

scripts/build_index.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Build publication JSON and a coverage receipt from extracted factual rows."""
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--rows", default="build/extracted.jsonl")
+    parser.add_argument("--reports", default="build/reports.jsonl")
+    parser.add_argument("--notices", default="build/notices/manifest.jsonl")
+    parser.add_argument("--out-dir", default="data")
+    parser.add_argument("--built-at", default=datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"))
+    parser.add_argument("--report-pages-attempted", type=int)
+    parser.add_argument("--pdfs-fetched", type=int)
+    args = parser.parse_args()
+    rows = [json.loads(line) for line in Path(args.rows).read_text(encoding="utf-8").splitlines() if line]
+    reports = [line for line in Path(args.reports).read_text(encoding="utf-8").splitlines() if line]
+    notices = [json.loads(line) for line in Path(args.notices).read_text(encoding="utf-8").splitlines() if line]
+    rows.sort(key=lambda row: (row["organization"] or "").casefold())
+    counts = Counter(row["deadline_status"] for row in rows)
+    out = Path(args.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    (out / "offers.jsonl").write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+    (out / "offers.json").write_text(json.dumps(rows, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    coverage = {
+        "built_at": args.built_at, "source_record_count": len(reports), "report_pages_attempted": args.report_pages_attempted if args.report_pages_attempted is not None else len(notices),
+        "pdfs_fetched": args.pdfs_fetched if args.pdfs_fetched is not None else sum("pdf_path" in row for row in notices), "extraction_failures": sum("error" in row for row in notices) + sum("pdf_path" not in row for row in notices),
+        "resolved_record_count": len(rows), "rows_with_any_remedy": sum(bool(row["remedy_type"]) for row in rows),
+        "rows_with_explicit_deadline": sum(bool(row["enrollment_deadline"]) for row in rows), "rows_open": counts["open"],
+        "rows_expired": counts["expired"], "rows_unknown": counts["unknown"], "coverage_complete": len(rows) == len(reports),
+    }
+    (out / "coverage.json").write_text(json.dumps(coverage, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps(coverage, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

scripts/extract_offers.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Deterministically extract factual offer fields without retaining notice prose."""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+from datetime import date, datetime, timezone
+from pathlib import Path
+
+FORBIDDEN_KEYS = {"activation_code", "enrollment_code", "addressee", "address", "phone", "email", "mailing_address"}
+MONTHS = "January|February|March|April|May|June|July|August|September|October|November|December"
+PROVIDERS = ("Experian IdentityWorks", "Experian", "Equifax", "TransUnion", "Kroll", "IDX", "AllClear", "Cyberscout")
+EXPOSURES = ((r"social security", "Social Security number"), (r"driver.?s license", "Driver's license number"), (r"financial account", "Financial account information"), (r"health information", "Health information"), (r"date of birth", "Date of birth"), (r"name", "Name"))
+
+
+def clean(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def text_from_pdf(path: str) -> str:
+    result = subprocess.run(["pdftotext", "-layout", path, "-"], check=True, capture_output=True, text=True)
+    return result.stdout
+
+
+def parse_date(value: str) -> str | None:
+    value = value.strip().replace(",", "")
+    for pattern in ("%B %d %Y", "%b %d %Y", "%m/%d/%Y"):
+        try:
+            return datetime.strptime(value, pattern).date().isoformat()
+        except ValueError:
+            pass
+    return None
+
+
+def deadline_from(text: str) -> tuple[str | None, str | None]:
+    pattern = rf"(?:enrol(?:l(?:ment)?)?|register|sign\s*up)\b.{{0,100}}?(?:by|before|until)\s+(({MONTHS})\s+\d{{1,2}},?\s+\d{{4}}|\d{{1,2}}/\d{{1,2}}/\d{{4}})"
+    matches = list(re.finditer(pattern, text, flags=re.I | re.S))
+    parsed = []
+    for match in matches:
+        iso = parse_date(match.group(1))
+        if iso:
+            zone = re.search(r"\b(UTC|PST|PDT|EST|EDT|CST|CDT|MST|MDT|Pacific Time|Eastern Time|Central Time|Mountain Time)\b", text[match.end():match.end() + 45], flags=re.I)
+            parsed.append((iso, zone.group(1).upper() if zone else None))
+    unique = {(item[0], item[1]) for item in parsed}
+    return next(iter(unique)) if len(unique) == 1 else (None, None)
+
+
+def deadline_status(deadline: str | None, built_at: str) -> str:
+    if not deadline:
+        return "unknown"
+    today = datetime.fromisoformat(built_at.replace("Z", "+00:00")).date()
+    printed = date.fromisoformat(deadline)
+    if printed >= today:
+        return "open"
+    if printed < today:
+        return "expired"
+    return "unknown"
+
+
+def provider_from(text: str) -> str | None:
+    if re.search(r"enroll\.krollmonitoring\.com", text, flags=re.I):
+        return "Kroll"
+    enrollment_provider = re.search(r"Visit\s+(?:the\s+)?(Experian IdentityWorks|Experian|Equifax|TransUnion|Kroll|IDX|AllClear|Cyberscout)(?:\s+website)?\s+(?:to\s+)?enroll", text, flags=re.I)
+    if enrollment_provider:
+        return enrollment_provider.group(1)
+    return next((name for name in PROVIDERS if re.search(re.escape(name), text, flags=re.I)), None)
+
+
+def extract(record: dict, text: str, built_at: str) -> dict:
+    deadline, zone = deadline_from(text)
+    provider = provider_from(text)
+    duration = re.search(r"\(?([0-9]{1,2})\)?\s*(months?)\b", text, flags=re.I)
+    months = None
+    duration_text = None
+    if duration:
+        raw_number, unit = duration.group(1), duration.group(2).lower()
+        months = int(raw_number) * (12 if unit.startswith("year") else 1)
+        duration_text = f"{raw_number} {unit}"
+    exposure_section = re.search(r"(?:what information was involved|information involved).*?(?:what we are doing|what you can do)", text, flags=re.I | re.S)
+    lower = exposure_section.group(0).lower() if exposure_section else ""
+    exposed = [label for needle, label in EXPOSURES if re.search(needle, lower)]
+    remedy_type = "identity protection" if provider else ("credit monitoring" if re.search(r"credit monitoring", text, flags=re.I) else None)
+    fields = {
+        "id": record["id"], "organization": record.get("organization"), "breach_dates": record.get("breach_dates", []),
+        "reported_date": record.get("reported_date"), "data_exposed": exposed, "remedy_type": remedy_type,
+        "remedy_provider": provider, "remedy_duration_months": months, "remedy_duration_text": duration_text,
+        "enrollment_deadline": deadline, "enrollment_deadline_timezone": zone,
+        "deadline_status": deadline_status(deadline, built_at), "source_report_url": record["report_url"],
+        "source_notice_url": record["source_notice_url"], "source_notice_sha256": record["source_notice_sha256"],
+        "source_accessed_at": record["source_accessed_at"],
+    }
+    fields["extraction_confidence"] = round((sum(value is not None and value != [] for value in (fields["organization"], provider, months, deadline)) / 4), 2)
+    return {key: value for key, value in fields.items() if key not in FORBIDDEN_KEYS}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--notices", default="build/notices/manifest.jsonl")
+    parser.add_argument("--out", default="build/extracted.jsonl")
+    parser.add_argument("--built-at", default=datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"))
+    args = parser.parse_args()
+    rows, failures = [], 0
+    for line in Path(args.notices).read_text(encoding="utf-8").splitlines():
+        record = json.loads(line)
+        if "pdf_path" not in record:
+            failures += 1
+            continue
+        try:
+            rows.append(extract(record, text_from_pdf(record["pdf_path"]), args.built_at))
+        except (OSError, subprocess.CalledProcessError):
+            failures += 1
+    Path(args.out).write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+    print(json.dumps({"rows": len(rows), "extraction_failures": failures, "built_at": args.built_at}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

scripts/fetch_notices.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Fetch report pages and linked PDFs as local, uncommitted build inputs."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from extract_offers import deadline_from, text_from_pdf
+from fetch_registry import fetch
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def receipt(url: str, payload: bytes, content_type: str, accessed_at: str, attempts: int) -> dict:
+    return {"url": url, "accessed_at": accessed_at, "size": len(payload), "content_type": content_type, "sha256": hashlib.sha256(payload).hexdigest(), "acquisition_attempts": attempts}
+
+
+def notice_url(report_html: str) -> str | None:
+    match = re.search(r'href="(https://oag\.ca\.gov/system/files/[^"]+\.pdf[^"]*)"', report_html, flags=re.I)
+    return match.group(1) if match else None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--reports", default="build/reports.jsonl")
+    parser.add_argument("--out-dir", default="build/notices")
+    parser.add_argument("--manifest", default="build/source-manifest.json")
+    parser.add_argument("--only-id")
+    parser.add_argument("--max-reports", type=int, default=25)
+    parser.add_argument("--start-index", type=int, default=0)
+    parser.add_argument("--min-explicit-deadlines", type=int, default=0)
+    parser.add_argument("--built-at", default=None)
+    args = parser.parse_args()
+    reports = [json.loads(line) for line in Path(args.reports).read_text(encoding="utf-8").splitlines() if line]
+    if args.only_id:
+        reports = [report for report in reports if report["id"] == args.only_id]
+    reports = reports[args.start_index:args.start_index + args.max_reports]
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    manifest_path = Path(args.manifest)
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8")) if manifest_path.exists() else []
+    output = []
+    seen = set()
+    explicit_deadlines = 0
+    attempted = 0
+    for report in reports:
+        attempted += 1
+        accessed_at = utc_now()
+        try:
+            page, page_type, page_attempts = fetch(report["report_url"])
+            manifest.append(receipt(report["report_url"], page, page_type, accessed_at, page_attempts))
+            url = notice_url(page.decode("utf-8", errors="replace"))
+            if not url:
+                continue
+            pdf, pdf_type, pdf_attempts = fetch(url)
+            item = receipt(url, pdf, pdf_type, accessed_at, pdf_attempts)
+            manifest.append(item)
+            identity = (report["report_url"], item["sha256"])
+            if identity in seen:
+                continue
+            seen.add(identity)
+            path = out_dir / f'{report["id"]}.pdf'
+            path.write_bytes(pdf)
+            output.append({**report, "source_notice_url": url, "source_notice_sha256": item["sha256"], "source_accessed_at": accessed_at, "pdf_path": str(path)})
+            try:
+                explicit_deadlines += bool(deadline_from(text_from_pdf(str(path)))[0])
+            except (OSError, RuntimeError, subprocess.CalledProcessError):
+                pass
+            if args.min_explicit_deadlines and explicit_deadlines >= args.min_explicit_deadlines:
+                break
+        except Exception as exc:
+            output.append({**report, "error": type(exc).__name__})
+    with (out_dir / "manifest.jsonl").open("w", encoding="utf-8") as handle:
+        for item in output:
+            handle.write(json.dumps(item, sort_keys=True) + "\n")
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps({"report_pages_attempted": attempted, "notice_rows": len(output), "pdfs_fetched": sum("pdf_path" in item for item in output), "explicit_deadline_candidates": explicit_deadlines}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

scripts/fetch_registry.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Fetch the official registry and make a local, hashed source receipt."""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import re
+from datetime import datetime, timezone
+from http.client import IncompleteRead
+from html import unescape
+from time import sleep
+from pathlib import Path
+from urllib.error import ContentTooShortError
+from urllib.request import Request, urlopen
+
+REGISTRY_URL = "https://oag.ca.gov/privacy/databreach/list"
+CSV_URL = "https://oag.ca.gov/privacy/databreach/list-export"
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def fetch(url: str, *, opener=urlopen, pause=sleep) -> tuple[bytes, str, int]:
+    """Read a source completely, retrying only incomplete/truncated acquisition."""
+    request = Request(url, headers={"User-Agent": "BreachClock/0.1 (+https://cybernative.ai)"})
+    for attempt in range(1, 4):
+        try:
+            with opener(request, timeout=60) as response:
+                return response.read(), response.headers.get_content_type(), attempt
+        except (IncompleteRead, ContentTooShortError):
+            if attempt == 3:
+                raise
+            pause(0.2 * attempt)
+    raise AssertionError("unreachable")
+
+
+def receipt(url: str, payload: bytes, content_type: str, accessed_at: str, attempts: int) -> dict:
+    return {"url": url, "accessed_at": accessed_at, "size": len(payload), "content_type": content_type, "sha256": hashlib.sha256(payload).hexdigest(), "acquisition_attempts": attempts}
+
+
+def plain(value: str) -> str:
+    return re.sub(r"\s+", " ", unescape(re.sub(r"<[^>]+>", " ", value))).strip()
+
+
+def iso_date(value: str) -> str | None:
+    value = value.strip()
+    match = re.search(r"(\d{2})/(\d{2})/(\d{4})", value)
+    if not match:
+        return None
+    return f"{match.group(3)}-{match.group(1)}-{match.group(2)}"
+
+
+def parse_reports(html: str) -> list[dict]:
+    reports = []
+    for row in re.findall(r"<tr[^>]*>(.*?)</tr>", html, flags=re.S | re.I):
+        link = re.search(r'href="(https://oag\.ca\.gov/ecrime/databreach/reports/(sb24-\d+))"[^>]*>(.*?)</a>', row, flags=re.S | re.I)
+        if not link:
+            continue
+        cells = re.findall(r"<td[^>]*>(.*?)</td>", row, flags=re.S | re.I)
+        dates = [iso_date(value) for value in re.findall(r">([^<]*\d{2}/\d{2}/\d{4}[^<]*)<", row)]
+        reports.append({
+            "id": link.group(2), "report_url": link.group(1), "organization": plain(link.group(3)),
+            "breach_dates": [date for date in dates[:-1] if date], "reported_date": dates[-1] if dates else None,
+        })
+    return reports
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--build-dir", default="build")
+    args = parser.parse_args()
+    build = Path(args.build_dir)
+    build.mkdir(parents=True, exist_ok=True)
+    accessed_at = utc_now()
+    csv_bytes, csv_type, csv_attempts = fetch(CSV_URL)
+    html_bytes, html_type, html_attempts = fetch(REGISTRY_URL)
+    (build / "registry.csv").write_bytes(csv_bytes)
+    (build / "registry.html").write_bytes(html_bytes)
+    reports = parse_reports(html_bytes.decode("utf-8", errors="replace"))
+    with (build / "reports.jsonl").open("w", encoding="utf-8") as handle:
+        for report in reports:
+            handle.write(json.dumps(report, sort_keys=True) + "\n")
+    csv_rows = list(csv.DictReader(csv_bytes.decode("utf-8-sig").splitlines()))
+    manifest = [receipt(CSV_URL, csv_bytes, csv_type, accessed_at, csv_attempts), receipt(REGISTRY_URL, html_bytes, html_type, accessed_at, html_attempts)]
+    (build / "source-manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps({"csv_records": len(csv_rows), "report_links": len(reports), "manifest": str(build / "source-manifest.json")}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

tests/test_pipeline.py

@@ -0,0 +1,106 @@
+import importlib.util
+from http.client import IncompleteRead
+import json
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load(name):
+    spec = importlib.util.spec_from_file_location(name, ROOT / "scripts" / f"{name}.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+extract = load("extract_offers")
+transport = load("fetch_registry")
+
+
+class OfferExtractionTests(unittest.TestCase):
+    def record(self, identifier="sb24-626307", organization="Wilmer Cutler Pickering Hale and Dorr LLP"):
+        return {"id": identifier, "organization": organization, "breach_dates": ["2026-05-08"], "reported_date": "2026-07-10", "report_url": f"https://oag.ca.gov/ecrime/databreach/reports/{identifier}", "source_notice_url": "https://oag.ca.gov/system/files/example.pdf", "source_notice_sha256": "a" * 64, "source_accessed_at": "2026-07-30T00:00:00Z"}
+
+    def test_verified_fixture_values(self):
+        text = "Wilmer Cutler Pickering Hale and Dorr LLP offers Experian IdentityWorks for 24 months. Name and Social Security number were involved. You must enroll by October 30, 2026 at 23:59 UTC."
+        row = extract.extract(self.record(), text, "2026-07-30T00:00:00Z")
+        self.assertEqual(row["organization"], "Wilmer Cutler Pickering Hale and Dorr LLP")
+        self.assertEqual(row["breach_dates"], ["2026-05-08"])
+        self.assertEqual(row["remedy_provider"], "Experian IdentityWorks")
+        self.assertEqual(row["remedy_duration_months"], 24)
+        self.assertEqual(row["enrollment_deadline"], "2026-10-30")
+        self.assertEqual(row["enrollment_deadline_timezone"], "UTC")
+        self.assertEqual(row["deadline_status"], "open")
+
+    def test_ambiguous_deadlines_are_unknown(self):
+        row = extract.extract(self.record(), "Enroll by October 30, 2026. Register before November 1, 2026.", "2026-07-30T00:00:00Z")
+        self.assertIsNone(row["enrollment_deadline"])
+        self.assertEqual(row["deadline_status"], "unknown")
+
+    def test_missing_remedy_stays_null(self):
+        row = extract.extract(self.record(), "Enroll by October 30, 2026 UTC.", "2026-07-30T00:00:00Z")
+        self.assertIsNone(row["remedy_type"])
+        self.assertIsNone(row["remedy_provider"])
+        self.assertIsNone(row["remedy_duration_months"])
+
+    def test_multiple_breach_dates_are_preserved(self):
+        record = self.record()
+        record["breach_dates"] = ["2026-05-08", "2026-05-09"]
+        self.assertEqual(extract.extract(record, "", "2026-07-30T00:00:00Z")["breach_dates"], ["2026-05-08", "2026-05-09"])
+
+    def test_repeated_organizations_are_distinct_source_rows(self):
+        first = extract.extract(self.record("sb24-1", "Example Inc."), "", "2026-07-30T00:00:00Z")
+        second = extract.extract(self.record("sb24-2", "Example Inc."), "", "2026-07-30T00:00:00Z")
+        self.assertNotEqual(first["id"], second["id"])
+        self.assertEqual(first["organization"], second["organization"])
+
+    def test_explicit_timezone_and_person_fields_are_safe(self):
+        row = extract.extract(self.record(), "Enroll before 10/30/2026 PDT. Morgan Example lives at 10 Example Street.", "2026-07-30T00:00:00Z")
+        self.assertEqual(row["enrollment_deadline_timezone"], "PDT")
+        self.assertFalse({"activation_code", "enrollment_code", "addressee", "address", "phone", "email", "mailing_address"} & set(row))
+        self.assertNotIn("Morgan Example", json.dumps(row))
+        self.assertNotIn("10 Example Street", json.dumps(row))
+
+
+    def test_same_day_explicit_deadline_is_open(self):
+        row = extract.extract(self.record(), "Enroll by July 30, 2026 UTC.", "2026-07-30T18:00:00Z")
+        self.assertEqual(row["deadline_status"], "open")
+
+
+class TransportTests(unittest.TestCase):
+    def test_incomplete_read_retries_once_then_records_success(self):
+        calls = []
+
+        class Response:
+            headers = type("Headers", (), {"get_content_type": lambda self: "application/pdf"})()
+
+            def __init__(self, payload):
+                self.payload = payload
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *_):
+                return False
+
+            def read(self):
+                if isinstance(self.payload, Exception):
+                    raise self.payload
+                return self.payload
+
+        payloads = [IncompleteRead(b"partial", 12), b"complete notice"]
+
+        def opener(_request, timeout):
+            calls.append(timeout)
+            return Response(payloads.pop(0))
+
+        body, content_type, attempts = transport.fetch("https://example.test/notice.pdf", opener=opener, pause=lambda _: None)
+        self.assertEqual(body, b"complete notice")
+        self.assertEqual(content_type, "application/pdf")
+        self.assertEqual(attempts, 2)
+        self.assertEqual(calls, [60, 60])
+
+
+if __name__ == "__main__":
+    unittest.main()