fix(scraper): validate fetched content matches requested law (issue #1035)

search_law_url no longer returns the first /van-ban/ link on the page (which
grabbed the site 'van ban moi' widget and stored unrelated text under correct
headers); it now only returns a result whose context contains the requested so
hieu. The download loop verifies the requested document number appears on the
fetched page before saving, recording misses to download_failures.json instead
of corrupting the corpus. Adds a 'verify' command to detect existing
number/type mismatches in downloaded files.

scripts/downloader.py

@@ -61,6 +61,32 @@ def slugify(text: str) -> str:
     return text.strip('-')
 
 
+DOC_CODE_RE = re.compile(r"\d+\s*/\s*\d{4}\s*/\s*(?:QH|UBTVQH|PL-UBTVQH|NQ)\d*", re.I)
+
+
+def extract_doc_codes(text: str) -> set[str]:
+    """Return every document number (e.g. '51/2014/QH13') found in text, normalized."""
+    return {re.sub(r"\s+", "", m).upper() for m in DOC_CODE_RE.findall(text or "")}
+
+
+def normalize_code(code: str | None) -> str:
+    return re.sub(r"\s+", "", code or "").upper()
+
+
+def content_matches_law(requested_number: str | None, fetched_text: str) -> bool:
+    """True only if the requested document number actually appears in the fetched page.
+
+    This is the guard against the corpus-corruption bug: the old scraper trusted
+    whatever URL search returned (often the site's "văn bản mới" / newest-document
+    widget) and stored that unrelated text under the correct front-matter header. We
+    now require the requested số hiệu to be present in the page before saving.
+    """
+    want = normalize_code(requested_number)
+    if not want:
+        return False  # no number to verify against -> treat as unverified
+    return want in extract_doc_codes(fetched_text)
+
+
 def create_front_matter(metadata: dict) -> str:
     """Create YAML front matter for markdown file."""
     lines = ["---"]
@@ -77,46 +103,62 @@ def create_front_matter(metadata: dict) -> str:
 
 
 def search_law_url(client: httpx.Client, name_vi: str, doc_number: str | None = None) -> str | None:
-    """Search for a law on thuvienphapluat.vn and return its URL."""
+    """Find a law's URL on thuvienphapluat.vn.
+
+    Only returns a URL we are confident points at the requested document: a result
+    whose link text / surrounding context contains the document number. Returns None
+    rather than guessing the first ``/van-ban/`` link on the page — the old behaviour
+    grabbed whatever link came first (typically the site's "văn bản mới" widget),
+    which is the root cause of the duplicated/mismatched corpus entries.
+    """
+    keyword = doc_number if doc_number else name_vi
+    params = {
+        "keyword": keyword,
+        "type": "0",
+        "match": "True",
+        "area": "0",
+        "status": "0",
+        "signer": "0",
+        "sort": "0",
+        "page": "1",
+    }
     try:
-        # Search by document number first if available
-        keyword = doc_number if doc_number else name_vi
-        params = {
-            "keyword": keyword,
-            "type": "0",
-            "match": "True",
-            "area": "0",
-            "status": "0",
-            "signer": "0",
-            "sort": "0",
-            "page": "1",
-        }
-
         response = client.get(SEARCH_URL, params=params, follow_redirects=True)
         response.raise_for_status()
-
-        soup = BeautifulSoup(response.text, "lxml")
-
-        # Find first matching result
-        for item in soup.select(".nqDoc, .doc-item, .search-result-item, [class*='item']"):
-            link = item.select_one("a[href*='/van-ban/']")
-            if link:
-                href = link.get("href", "")
-                if href:
-                    return urljoin(BASE_URL, href)
-
-        # Try alternative selectors
-        for link in soup.select("a[href*='/van-ban/']"):
-            href = link.get("href", "")
-            if href and "/van-ban/" in href:
-                return urljoin(BASE_URL, href)
-
-        return None
-
     except Exception as e:
         console.print(f"[yellow]Search failed for {name_vi}: {e}[/yellow]")
         return None
 
+    # A document-number search often redirects straight to the document page.
+    final_url = str(response.url)
+    if "/van-ban/" in final_url:
+        return final_url
+
+    soup = BeautifulSoup(response.text, "lxml")
+    want = normalize_code(doc_number)
+
+    # Collect every candidate result link together with its surrounding text.
+    candidates: list[tuple[str, str]] = []
+    for link in soup.select("a[href*='/van-ban/']"):
+        href = link.get("href", "")
+        if "/van-ban/" not in href:
+            continue
+        ctx = link.get_text(" ", strip=True)
+        parent = link.find_parent(["li", "div", "tr", "p"])
+        if parent:
+            ctx += " " + parent.get_text(" ", strip=True)
+        candidates.append((urljoin(BASE_URL, href), normalize_code(ctx)))
+
+    # Prefer the candidate whose context contains the requested document number.
+    if want:
+        for url, ctx_code in candidates:
+            if want in ctx_code:
+                return url
+        return None  # no confident match — do not guess
+
+    # No document number to disambiguate on: only safe when there is one result.
+    return candidates[0][0] if len(candidates) == 1 else None
+
 
 def fetch_law_content(client: httpx.Client, url: str) -> dict | None:
     """Fetch law content from thuvienphapluat.vn."""
@@ -157,8 +199,11 @@ def fetch_law_content(client: httpx.Client, url: str) -> dict | None:
         if issuer:
             metadata["issuing_body"] = issuer.get_text(strip=True)
 
-        # Main content
-        content_elem = soup.select_one(".doc-content, .noi-dung, .content, article")
+        # Main content (thuvienphapluat renders the doc body in #divContentDoc)
+        content_elem = soup.select_one(
+            "#divContentDoc, .content1, .cldivContentDocVn, "
+            ".doc-content, .noi-dung, .content, article"
+        )
         if content_elem:
             # Remove scripts and styles
             for tag in content_elem.select("script, style"):
@@ -174,6 +219,10 @@ def fetch_law_content(client: httpx.Client, url: str) -> dict | None:
                     tag.decompose()
                 metadata["content"] = body.get_text(separator="\n", strip=True)
 
+        # Document numbers detected on the page, used by the caller to verify the
+        # fetched page is actually the requested law before saving it.
+        metadata["found_numbers"] = sorted(extract_doc_codes(metadata.get("content", "")))
+
         return metadata
 
     except Exception as e:
@@ -341,6 +390,8 @@ def download(fetch_content: bool, delay: float, limit: int):
     console.print(f"Output directory: [cyan]{DATA_DIR}[/cyan]")
     console.print()
 
+    failures: list[dict] = []
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
@@ -375,8 +426,28 @@ def download(fetch_content: bool, delay: float, limit: int):
                         law["url"] = url
                         data = fetch_law_content(client, url)
                         if data:
-                            content = data.get("content")
+                            fetched = data.get("content", "") or ""
+                            # GUARD: only keep the text if the requested document
+                            # number is actually present on the fetched page. This
+                            # prevents storing an unrelated law under a correct header
+                            # (the duplicated/mismatched-entries bug).
+                            if content_matches_law(law.get("document_number"), fetched):
+                                content = fetched
+                            else:
+                                failures.append({
+                                    "id": law.get("id"),
+                                    "document_number": law.get("document_number"),
+                                    "url": url,
+                                    "found_numbers": data.get("found_numbers", []),
+                                })
                         time.sleep(delay)
+                    else:
+                        failures.append({
+                            "id": law.get("id"),
+                            "document_number": law.get("document_number"),
+                            "url": None,
+                            "found_numbers": [],
+                        })
 
                 filepath = save_law_file(law, content)
                 progress.advance(task)
@@ -387,6 +458,21 @@ def download(fetch_content: bool, delay: float, limit: int):
     console.print()
     console.print(f"[green]Done![/green] Files saved to [cyan]{DATA_DIR}[/cyan]")
 
+    if fetch_content:
+        verified = len(laws) - len(failures)
+        console.print(
+            f"Content verified for [green]{verified}[/green]/{len(laws)} "
+            f"(requested số hiệu found on page); [red]{len(failures)}[/red] unresolved."
+        )
+        if failures:
+            import json as _json
+            fpath = DATA_DIR.parent / "download_failures.json"
+            fpath.write_text(_json.dumps(failures, ensure_ascii=False, indent=2), encoding="utf-8")
+            console.print(
+                f"Unresolved entries -> [cyan]{fpath}[/cyan] "
+                f"(their content was NOT saved, to avoid corrupting the corpus; re-run to retry)."
+            )
+
 
 @cli.command()
 def stats():
@@ -435,6 +521,52 @@ def list_files():
         console.print(f"  ... and {len(files) - 20} more")
 
 
+@cli.command()
+def verify():
+    """Verify downloaded files: does each file's document number appear in its body?
+
+    Catches the duplicated/mismatched-content bug (issue #1035) where the front-matter
+    header is correct but the body is a different document.
+    """
+    if not DATA_DIR.exists():
+        console.print("[yellow]No data directory found[/yellow]")
+        return
+
+    files = sorted(DATA_DIR.rglob("*.md"))
+    wrong_number, wrong_type = [], []
+    for f in files:
+        text = f.read_text(encoding="utf-8")
+        m = re.search(r'document_number:\s*"?([^"\n]+)', text)
+        want = normalize_code(m.group(1)) if m else ""
+        tm = re.search(r'^type:\s*"?([^"\n]+)', text, re.M)
+        ftype = (tm.group(1).strip() if tm else "").lower()
+        body = text.split("## Nội dung", 1)[-1] if "## Nội dung" in text else text
+        found = extract_doc_codes(body)
+
+        # (1) requested số hiệu must appear in the body
+        if want and want not in found:
+            wrong_number.append((f.name, want, sorted(found)[:3]))
+
+        # (2) a law/code/constitution must not actually be a resolution/decree
+        kind = re.search(r"\n\s*(NGHỊ QUYẾT|NGHỊ ĐỊNH|BỘ LUẬT|LUẬT|HIẾN PHÁP|PHÁP LỆNH)\s*\n", body)
+        bk = kind.group(1) if kind else ""
+        if ftype in ("law", "code", "constitution") and bk in ("NGHỊ QUYẾT", "NGHỊ ĐỊNH"):
+            wrong_type.append((f.name, ftype, bk))
+
+    bad = len(wrong_number) + len(wrong_type)
+    console.print(
+        f"Checked [green]{len(files)}[/green] files; "
+        f"[red]{len(wrong_number)}[/red] với số hiệu header không có trong body, "
+        f"[red]{len(wrong_type)}[/red] là nghị quyết/nghị định bị gán nhãn luật"
+    )
+    for name, want, found in wrong_number[:20]:
+        console.print(f"  [yellow]{name}[/yellow]: header={want}, body has {found or 'none'}")
+    for name, ftype, bk in wrong_type[:20]:
+        console.print(f"  [magenta]{name}[/magenta]: type={ftype} but body is {bk}")
+    if bad == 0:
+        console.print("[green]All files consistent.[/green]")
+
+
 def main():
     cli()