feat(uyap): accelerate nationwide discovery

Author: onatozmenn

README.md

@@ -253,6 +253,7 @@ one outstanding window per province:
 ```powershell
 # Phase 1: metadata-only scan across all 81 provinces (no document download)
 sold uyap campaign --all-provinces --phase discover `
+  --concurrency 8 `
   --cdp-endpoint http://127.0.0.1:9222
 
 # Phase 2: revisit only windows containing new/incomplete candidates and download only queued KAYIT NOs
@@ -272,31 +273,37 @@ sold uyap campaign --all-provinces --phase discover `
 
 The campaign is faster without weakening provenance:
 
+- discovery uses the authenticated page's observed same-origin history endpoint with at most 8 concurrent
+  requests by default (`--concurrency 1..16`); `--ui` retains the serial form-driven fallback;
 - provinces with measured sold-card yield run first; cold start prioritizes İstanbul, Ankara, İzmir, etc.;
 - newest windows run first and completed phase-specific checkpoints are skipped;
+- each endpoint response remains bound to its province/date/page payload, while the UI fallback keeps its
+  click-scoped stale-response guards;
 - a discovery page performs one locked candidate-store write instead of one full rewrite per card;
-- click-scoped, date-bound response evidence prevents stale AJAX cards or zero banners from being attributed
-  to the next province/window;
 - windows at the 200-result boundary split automatically; unsplittable saturated days remain explicit blockers;
 - page coverage and parsed-card cardinality must match source metadata before a window can become complete;
 - acquisition scans only queued windows and binds each KAYIT NO to its discovered candidate identity;
 - elapsed time, throughput, split counts, deferred work and unresolved blockers are reported.
 
 Document modals remain serial inside one authenticated page. Parallel clicks/downloads on that shared DOM
-would risk cross-row artifact binding; the campaign gains throughput by eliminating redundant work instead.
+would risk cross-row artifact binding; only metadata discovery is concurrent.
 Bounded runs are intentionally resumable: deferred, saturated, truncated, stale, failed or cardinality-mismatched
 work is never reported as complete and returns a nonzero status for automation. Neither phase admits evidence:
 `sold uyap review` and explicit `sold uyap admit` remain separate.
 
-> **Nationwide live run (2026-07-11).** A manually authenticated, user-controlled Chrome session completed
-> metadata discovery for **81/81 provinces** over `2026-07-05..2026-07-11`: **535 source result cards** and
-> **3 terminal `Satıldı` candidates**. Candidate-bound native acquisition completed **3/3** (Erzincan 2,
+> **Nationwide live run and fast-path reconciliation (2026-07-11).** A manually authenticated,
+> user-controlled Chrome session completed metadata discovery for **81/81 provinces** over
+> `2026-07-05..2026-07-11`. The bounded same-origin path completed in **6.34 seconds** using **155 requests**
+> at concurrency 8 and reconciled **2,190/2,190 source result cards**: all KAYIT IDs were unique, no identity
+> appeared in two provinces, and every province matched its declared source count. This corrects the earlier
+> serial-UI telemetry of 535 cards; both paths found the same **3 terminal `Satıldı` candidates**.
+> Candidate-bound native acquisition completed **3/3** (Erzincan 2,
 > Sakarya 1), leaving **0 queued candidates and 0 blockers**. Audit outcomes were one new
 > `ADMISSIBLE_COMPLETED_SALE` and two `PENDING_REVIEW`; **no record was admitted automatically**. The live
 > adapters bind search results to exact AJAX response/cardinality and document actions to exact KAYIT,
 > response URI, modal row and action fingerprint.
 
-> **Live status.** UYAP Live Browser Pilot 1 reached **`PASS`** on the real **2026/263 Esas** record. A later bounded Ankara batch (`2026-06-18..2026-06-24`) collected five terminal-sale cards through native UDF artifacts: two new records were explicitly admitted, two were identified as existing observations (one primary ID and one alias), and one remains blocked for human review. This is **not** an official API, does **not** automate authentication, is **not** unattended continuous ingestion, and does **not** prove universal layout coverage. The automated test suite remains fully offline.
+> **Live status.** UYAP Live Browser Pilot 1 reached **`PASS`** on the real **2026/263 Esas** record. A later bounded Ankara batch (`2026-06-18..2026-06-24`) collected five terminal-sale cards through native UDF artifacts: two new records were explicitly admitted, two were identified as existing observations (one primary ID and one alias), and one remains blocked for human review. The history endpoint is an observed internal same-origin interface, **not** an official public API. The workflow does **not** automate authentication, is **not** unattended continuous ingestion, and does **not** prove universal layout coverage. The automated test suite remains fully offline.
 
 ### UYAP Live Browser Pilot 1 (live verification)
 

docs/DEVELOPMENT_HISTORY.md

@@ -952,3 +952,27 @@ live-verified under this ownership chain. Final validation: **116 bulk/campaign
 **827 tests in the complete suite**. Independent review findings were incorporated into the final ownership
 guards before release; the post-fix audit found no P0/P1 correctness blocker. Persisted telemetry reconciles to
 81/81 complete provinces, 535 source cards, 3/3 acquired candidates, and an empty acquisition queue.
+
+## 2026-07-11 — Same-origin nationwide discovery acceleration
+
+Metadata discovery was moved from 81 serial UI form submissions to the history page's observed authenticated
+same-origin endpoint (`POST /pp/gecmisIhaleler_brd.ajx`). Authentication remains entirely manual. Province
+codes are read from the page's native `#historySearchIller` options; request concurrency is bounded to 8 by
+default (configurable from 1 through 16); page 1 determines source cardinality; and only required continuation
+pages are fetched. Dense windows still enter the existing adaptive date-split tree. Candidate persistence and
+phase-specific atomic checkpoints are unchanged, and native UDF acquisition remains serial and exact-KAYIT
+bound. The UI path remains available through `--ui`.
+
+The structured sale rule was taken from the live portal renderer rather than inferred from price or description:
+`satisDurumu == "0"` maps to visible `Satıldı`. Continuation responses use the portal's observed `-1` sentinel
+for an unchanged total count; the adapter retains page 1's total and reconciles every later page against it.
+Malformed responses, missing identities, incomplete pagination, count mismatches, session loss and unsplittable
+200-result saturation all remain non-complete checkpoints.
+
+An isolated live benchmark for `2026-07-05..2026-07-11` completed **81/81 provinces in 6.34 seconds** with
+concurrency 8 and 155 requests. It reconciled **2,190 fetched rows to 2,190 declared source rows**, with 2,190
+unique KAYIT IDs, zero cross-province duplicates and zero incomplete checkpoints, while finding the same three
+terminal `Satıldı` candidates as the prior run. This demonstrates that the earlier serial-UI telemetry of 535
+cards under-counted source coverage; it does not alter the already completed 3/3 candidate-bound acquisitions
+or admit any evidence. Focused validation after the change: **120 bulk/campaign tests passed**; the live
+two-province benchmark completed in 0.86 seconds and the nationwide benchmark completed in 6.34 seconds.

src/sold/cli.py

@@ -2390,6 +2390,8 @@ def uyap_campaign_cmd(
     max_provinces: Optional[int] = typer.Option(None, "--max-provinces", min=1, help="Bu koşuda en fazla işi olan il"),
     max_windows_per_province: Optional[int] = typer.Option(1, "--max-windows-per-province", min=1, help="İl başına bu koşuda en fazla gerçek arama penceresi"),
     max_records: Optional[int] = typer.Option(None, "--max-records", min=1, help="Acquire fazında toplam işlenecek en fazla kart"),
+    fast_discovery: bool = typer.Option(True, "--fast/--ui", help="Keşifte same-origin endpoint havuzu veya seri UI"),
+    concurrency: int = typer.Option(8, "--concurrency", min=1, max=16, help="Hızlı keşifte eşzamanlı istek sınırı"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Planı göster; tarayıcıya bağlanma"),
     store_dir: Optional[str] = typer.Option(None, help="Çalışma deposu / checkpoint dizini"),
     genuine_path: Optional[str] = typer.Option(None, help="Genuine uyap.json yolu (yalnız duplicate denetimi)"),
@@ -2398,9 +2400,9 @@ def uyap_campaign_cmd(
 ) -> None:
     """81-il UYAP kampanyası: önce hızlı keşif, sonra yalnız yeni adaylarda native-UDF edinimi.
 
-    Kimlik doğrulama daima kullanıcı tarafından yapılır. Kampanya admission yapmaz ve aynı sayfa üzerinde
-    paralel modal tıklaması kullanmaz; hız, boş pencereleri acquisition'da tekrar taramamak, newest-first
-    öncelik, ayrı checkpoint'ler ve yoğun pencereyi otomatik bölmekten gelir.
+    Kimlik doğrulama daima kullanıcı tarafından yapılır. Kampanya admission yapmaz. Keşif varsayılan
+    olarak oturumun same-origin JSON uç noktasını sınırlı bir havuzla kullanır; modal/native-UDF edinimi
+    seri kalır. ``--ui`` keşfi de eski seri form yoluna döndürür.
     """
     from .ingestion.uyap import BROWSER_PREREQUISITES
     from .ingestion.uyap.bulk import (
@@ -2496,8 +2498,10 @@ def uyap_campaign_cmd(
         if campaign_phase == PHASE_ACQUISITION else []
     )
 
+    discovery_mode = "fast" if fast_discovery else "ui"
     typer.secho(
-        f"UYAP campaign · faz={campaign_phase} · aktif il={len(active_provinces)} · görev={len(plan)}",
+        f"UYAP campaign · faz={campaign_phase} · aktif il={len(active_provinces)} · "
+        f"görev={len(plan)} · keşif={discovery_mode}",
         fg=typer.colors.CYAN, bold=True,
     )
     by_province: dict[str, int] = {}
@@ -2542,6 +2546,9 @@ def uyap_campaign_cmd(
         "discovery_incomplete": deferred_discovery_tasks,
         "queue_blockers": len(blockers),
         "saturated_unresolved": 0,
+        "requests": 0,
+        "elapsed_seconds": 0.0,
+        "requests_per_minute": 0.0,
     }
     blocking_reason = None
     blocking_reasons = {
@@ -2556,19 +2563,32 @@ def uyap_campaign_cmd(
     }
     remaining = max_records
     if campaign_phase == PHASE_DISCOVERY:
-        for province in active_provinces:
-            result = collector.run(
-                province, resolved_from, resolved_to, discovery_only=True, newest_first=True,
-                max_windows=max_windows_per_province,
-            )
+        if fast_discovery:
+            result = collector.run_fast_discovery(plan, concurrency=concurrency)
             totals["windows"] += result["windows_processed"]
             totals["cards"] += result["result_cards_inspected"]
             totals["saturated_unresolved"] += result["saturated_windows_unresolved"]
             totals["incomplete"] += int(result.get("acquisition_windows_incomplete") or 0)
             totals["discovery_incomplete"] += int(result.get("discovery_windows_incomplete") or 0)
+            totals["requests"] += int(result.get("request_count") or 0)
+            totals["elapsed_seconds"] += float(result.get("elapsed_seconds") or 0.0)
+            totals["requests_per_minute"] = float(result.get("requests_per_minute") or 0.0)
             if result.get("stopped_reason") in blocking_reasons:
                 blocking_reason = result["stopped_reason"]
-                break
+        else:
+            for province in active_provinces:
+                result = collector.run(
+                    province, resolved_from, resolved_to, discovery_only=True, newest_first=True,
+                    max_windows=max_windows_per_province,
+                )
+                totals["windows"] += result["windows_processed"]
+                totals["cards"] += result["result_cards_inspected"]
+                totals["saturated_unresolved"] += result["saturated_windows_unresolved"]
+                totals["incomplete"] += int(result.get("acquisition_windows_incomplete") or 0)
+                totals["discovery_incomplete"] += int(result.get("discovery_windows_incomplete") or 0)
+                if result.get("stopped_reason") in blocking_reasons:
+                    blocking_reason = result["stopped_reason"]
+                    break
     else:
         for task_index, task in enumerate(plan):
             if remaining is not None and remaining <= 0: