Deploy OpenClaw PR API

README.md

@@ -20,6 +20,12 @@ tags:
 
 Machine-oriented API for PR similarity search.
 
+Canonical storage roles:
+
+- dataset repo: published latest state and canonical current analysis
+- mounted bucket: mutable operational cache only
+- Space disk: ephemeral runtime storage
+
 Defaults for this deployment:
 
 - repo: `openclaw/openclaw`

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slop-farmer"
-version = "0.1.0"
+version = "0.1.1"
 description = "GitHub-to-Hub data pipeline for transformers issue and PR triage research."
 readme = "README.md"
 requires-python = ">=3.13.5"
@@ -12,7 +12,7 @@ dependencies = [
   "duckdb>=1.2.2",
   "pyarrow>=18.0.0",
   "fastapi>=0.115.0",
-  "huggingface_hub>=0.30.0",
+  "huggingface_hub>=1.11.0",
   "pydantic>=2.11",
   "PyYAML>=6.0.2",
   "rank-bm25>=0.2.2",
@@ -60,13 +60,6 @@ select = [
 ]
 ignore = ["E501"]
 
-[tool.slop-farmer.analyze]
-output-dir = "eval_data"
-hf-repo-id = "evalstate/transformers-pr"
-ranking-backend = "hybrid"
-model = "gpt-5.4-mini"
-max-clusters = 10
-
 [tool.slop-farmer.dashboard-data]
 output-dir = "web/public/data"
 window-days = 14

src/slop_farmer.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: slop-farmer
-Version: 0.1.0
+Version: 0.1.1
 Summary: GitHub-to-Hub data pipeline for transformers issue and PR triage research.
 Requires-Python: >=3.13.5
 Description-Content-Type: text/markdown
 Requires-Dist: duckdb>=1.2.2
 Requires-Dist: pyarrow>=18.0.0
 Requires-Dist: fastapi>=0.115.0
-Requires-Dist: huggingface_hub>=0.30.0
+Requires-Dist: huggingface_hub>=1.11.0
 Requires-Dist: pydantic>=2.11
 Requires-Dist: PyYAML>=6.0.2
 Requires-Dist: rank-bm25>=0.2.2
@@ -126,18 +126,25 @@ Authentication defaults:
 - GitHub: `GITHUB_TOKEN`, then `gh auth token`
 - Hugging Face: `HF_TOKEN`, otherwise existing `hf auth` login
 
-## Scheduled Hugging Face Job for `configs/transformers.yaml`
+## Canonical dataset upkeep
 
-To keep the Transformers dataset fresh on the Hub without relying on a local watermark,
-submit the repo's job script instead:
+`dataset_id` is the canonical latest dataset repo.
+
+Use the remote-first writer:
+
+```bash
+uv run slop-farmer --config configs/transformers.yaml refresh-dataset
+```
+
+Or submit the generic HF Job wrapper:
 
 ```bash
-scripts/submit_transformers_dataset_job.sh
+scripts/submit_dataset_job.sh
 ```
 
 By default this creates a scheduled HF Job that:
 
-- reads `configs/transformers.yaml`
+- reads `CONFIG_PATH` (defaults to `configs/transformers.yaml`)
 - refreshes `dataset_id` incrementally against the current Hub dataset state
 - regenerates the new contributor report
 - uploads the updated snapshot back to the dataset repo
@@ -146,20 +153,28 @@ Useful overrides:
 
 ```bash
 # fire once immediately instead of creating a schedule
-MODE=run scripts/submit_transformers_dataset_job.sh
+MODE=run scripts/submit_dataset_job.sh
 
 # change the cron schedule
-SCHEDULE="0 */6 * * *" scripts/submit_transformers_dataset_job.sh
+SCHEDULE="0 */6 * * *" scripts/submit_dataset_job.sh
 
 # optionally mount a writable HF bucket for temp files
 SCRATCH_BUCKET=evalstate/slop-farmer-scratch \
-  scripts/submit_transformers_dataset_job.sh
+  scripts/submit_dataset_job.sh
 ```
 
 Buckets are best treated here as optional scratch space via `TMPDIR`, not as the canonical
 published dataset. The repo's local analysis and PR-scope tooling already knows how to
 materialize versioned Hub **dataset repos**; it does not currently read HF buckets directly.
 
+Compatibility wrappers remain available:
+
+- `scripts/submit_transformers_dataset_job.sh`
+- `scripts/submit_openclaw_dataset_job.sh`
+
+For the current storage model and recommended modes, see
+[`docs/data-architecture.md`](docs/data-architecture.md).
+
 ## Analyze a Hub dataset
 
 You can analyze the published Hugging Face dataset directly without scraping GitHub again:
@@ -176,15 +191,12 @@ This materializes the dataset-viewer parquet export into a local snapshot cache
 
 Repo-local defaults for `analyze` can be stored in `pyproject.toml` under `[tool.slop-farmer.analyze]`. This repo currently defaults to:
 
-- `output-dir = "eval_data"`
-- `hf-repo-id = "evalstate/transformers-pr"`
-- `ranking-backend = "hybrid"`
-- `model = "gpt-5-mini?reasoning=low"`
+- `dashboard-data.output-dir = "web/public/data"`
 
-So from repo root you can now usually just run:
+For repo-specific remote-first analysis, prefer a YAML config with `dataset_id`, e.g.:
 
 ```bash
-uv run slop-farmer analyze
+uv run slop-farmer --config configs/openclaw.yaml analyze
 ```
 
 ## Cluster open PRs by code scope
@@ -353,15 +365,19 @@ scrape:
 Then commands stay aligned without repeating repo/workspace/window settings:
 
 ```bash
-uv run slop-farmer --config configs/diffusers.yaml scrape --publish
+uv run slop-farmer --config configs/diffusers.yaml refresh-dataset
 uv run slop-farmer --config configs/diffusers.yaml analyze
 uv run slop-farmer --config configs/diffusers.yaml pr-scope
+uv run slop-farmer --config configs/diffusers.yaml pr-search refresh
 uv run slop-farmer --config configs/diffusers.yaml new-contributor-report
 uv run slop-farmer --config configs/diffusers.yaml dashboard-data
-uv run slop-farmer --config configs/diffusers.yaml publish-snapshot
 uv run slop-farmer --config configs/diffusers.yaml deploy-dashboard --refresh-contributors
+uv run slop-farmer --config configs/diffusers.yaml dataset-status
 ```
 
+Those reader commands default to `dataset_id` when configured. Pass `--snapshot-dir` to force
+an explicit local snapshot instead.
+
 If you run `analyze` before `publish-snapshot`, the uploaded snapshot will also include
 `analysis-state/`, which makes the hybrid cache portable across machines and reusable in
 later snapshots when `analysis.cached_analysis: true` is enabled.

src/slop_farmer.egg-info/SOURCES.txt

@@ -11,6 +11,8 @@ src/slop_farmer.egg-info/requires.txt
 src/slop_farmer.egg-info/top_level.txt
 src/slop_farmer/app/__init__.py
 src/slop_farmer/app/cli.py
+src/slop_farmer/app/dataset_refresh.py
+src/slop_farmer/app/dataset_status.py
 src/slop_farmer/app/deploy.py
 src/slop_farmer/app/duplicate_prs.py
 src/slop_farmer/app/hf_checkpoint_import.py
@@ -21,8 +23,10 @@ src/slop_farmer/app/publish.py
 src/slop_farmer/app/snapshot_state.py
 src/slop_farmer/app/workflow.py
 src/slop_farmer/data/__init__.py
+src/slop_farmer/data/dataset_card.py
 src/slop_farmer/data/ghreplica_api.py
 src/slop_farmer/data/github_api.py
+src/slop_farmer/data/hf_dataset_repo.py
 src/slop_farmer/data/http.py
 src/slop_farmer/data/links.py
 src/slop_farmer/data/normalize.py
@@ -30,9 +34,11 @@ src/slop_farmer/data/parquet_io.py
 src/slop_farmer/data/search_duckdb.py
 src/slop_farmer/data/snapshot_materialize.py
 src/slop_farmer/data/snapshot_paths.py
+src/slop_farmer/data/snapshot_source.py
 src/slop_farmer/reports/__init__.py
 src/slop_farmer/reports/analysis.py
 src/slop_farmer/reports/analysis_cache.py
+src/slop_farmer/reports/analysis_service.py
 src/slop_farmer/reports/canonical_duplicate_pr.py
 src/slop_farmer/reports/dashboard.py
 src/slop_farmer/reports/duplicate_prs.py
@@ -49,6 +55,7 @@ tests/test_canonical_duplicate_pr.py
 tests/test_cli.py
 tests/test_config.py
 tests/test_dashboard.py
+tests/test_dataset_status.py
 tests/test_farmer_setup_assets.py
 tests/test_ghreplica_api.py
 tests/test_github_api.py

src/slop_farmer.egg-info/requires.txt

@@ -1,7 +1,7 @@
 duckdb>=1.2.2
 pyarrow>=18.0.0
 fastapi>=0.115.0
-huggingface_hub>=0.30.0
+huggingface_hub>=1.11.0
 pydantic>=2.11
 PyYAML>=6.0.2
 rank-bm25>=0.2.2

src/slop_farmer/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

src/slop_farmer/app/analysis_id.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from slop_farmer.app_config import command_defaults
+from slop_farmer.data.parquet_io import read_json
+from slop_farmer.data.snapshot_paths import ROOT_MANIFEST_FILENAME, resolve_snapshot_dir_from_output
+
+MODEL_SLUG_PATTERN = re.compile(r"[^a-z0-9]+")
+
+
+def model_slug(model: str) -> str:
+    base = model.split("?", 1)[0].strip().lower()
+    slug = MODEL_SLUG_PATTERN.sub("", base)
+    return slug or "model"
+
+
+def build_analysis_id(
+    *,
+    snapshot_id: str,
+    model: str,
+    ranking_backend: str,
+    suffix: str | None = None,
+) -> str:
+    parts = [
+        MODEL_SLUG_PATTERN.sub("", ranking_backend.strip().lower()) or "analysis",
+        model_slug(model),
+        snapshot_id.strip().lower(),
+    ]
+    if suffix:
+        normalized_suffix = MODEL_SLUG_PATTERN.sub("-", suffix.strip().lower()).strip("-")
+        if normalized_suffix:
+            parts.append(normalized_suffix)
+    return "-".join(parts)
+
+
+def analysis_id_from_snapshot(
+    *,
+    snapshot_dir: Path,
+    model: str,
+    ranking_backend: str,
+    suffix: str | None = None,
+) -> str:
+    manifest_path = snapshot_dir / ROOT_MANIFEST_FILENAME
+    manifest = read_json(manifest_path) if manifest_path.exists() else {}
+    if not isinstance(manifest, dict):
+        raise ValueError(f"Snapshot manifest at {manifest_path} must contain a JSON object.")
+    snapshot_id = str(manifest.get("snapshot_id") or snapshot_dir.name).strip()
+    if not snapshot_id:
+        raise ValueError(f"Could not resolve snapshot_id from {manifest_path}")
+    return build_analysis_id(
+        snapshot_id=snapshot_id,
+        model=model,
+        ranking_backend=ranking_backend,
+        suffix=suffix,
+    )
+
+
+def analysis_id_from_config(
+    *,
+    config_path: Path,
+    output_dir: Path | None = None,
+    snapshot_dir: Path | None = None,
+    model: str | None = None,
+    ranking_backend: str | None = None,
+    suffix: str | None = None,
+) -> str:
+    defaults = command_defaults("analyze", config_path=config_path)
+    resolved_snapshot_dir = resolve_snapshot_dir_from_output(
+        Path(output_dir or defaults.get("output-dir", "data")),
+        snapshot_dir,
+    )
+    resolved_model = str(model or defaults.get("model", "gpt-5.4-mini?service_tier=flex"))
+    resolved_backend = str(ranking_backend or defaults.get("ranking-backend", "hybrid"))
+    return analysis_id_from_snapshot(
+        snapshot_dir=resolved_snapshot_dir,
+        model=resolved_model,
+        ranking_backend=resolved_backend,
+        suffix=suffix,
+    )

src/slop_farmer/app/cli.py

@@ -13,15 +13,17 @@ from slop_farmer.config import (
     AnalysisOptions,
     CheckpointImportOptions,
     DashboardDataOptions,
+    DatasetRefreshOptions,
+    DatasetStatusOptions,
     DeployDashboardOptions,
-    FullPipelineOptions,
     MarkdownReportOptions,
     NewContributorReportOptions,
     PipelineOptions,
     PrScopeOptions,
     PrSearchRefreshOptions,
-    PublishSnapshotOptions,
+    PublishAnalysisArtifactsOptions,
     RepoRef,
+    SaveCacheOptions,
     SnapshotAdoptOptions,
 )
 from slop_farmer.reports.duplicate_prs import DEFAULT_DUPLICATE_PR_MODEL
@@ -29,6 +31,16 @@ from slop_farmer.reports.duplicate_prs import DEFAULT_DUPLICATE_PR_MODEL
 CommandHandler = Callable[[argparse.Namespace, Path | None], None]
 
 
+def _int_at_least(minimum: int) -> Callable[[str], int]:
+    def parse(raw: str) -> int:
+        value = int(raw)
+        if value < minimum:
+            raise argparse.ArgumentTypeError(f"expected integer >= {minimum}")
+        return value
+
+    return parse
+
+
 def build_parser(*, config_path: Path | None = None) -> argparse.ArgumentParser:
     defaults = _load_parser_defaults(config_path)
 
@@ -41,6 +53,7 @@ def build_parser(*, config_path: Path | None = None) -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers(dest="command", required=True)
 
     _add_scrape_parser(subparsers, defaults["scrape"])
+    _add_refresh_dataset_parser(subparsers, defaults["refresh-dataset"])
     _add_analyze_parser(subparsers, defaults["analyze"])
     _add_pr_scope_parser(subparsers, defaults["pr-scope"])
     _add_checkpoint_import_parser(subparsers, defaults["import-hf-checkpoint"])
@@ -50,15 +63,17 @@ def build_parser(*, config_path: Path | None = None) -> argparse.ArgumentParser:
     _add_pr_search_parser(subparsers, defaults["pr-search"])
     _add_new_contributor_report_parser(subparsers, defaults["new-contributor-report"])
     _add_dashboard_data_parser(subparsers, defaults["dashboard-data"])
-    _add_publish_snapshot_parser(subparsers, defaults["publish-snapshot"])
+    _add_publish_analysis_artifacts_parser(subparsers, defaults["publish-analysis-artifacts"])
+    _add_save_cache_parser(subparsers, defaults["save-cache"])
     _add_deploy_dashboard_parser(subparsers, defaults["deploy-dashboard"])
-    _add_full_pipeline_parser(subparsers, defaults["full-pipeline"])
+    _add_dataset_status_parser(subparsers, defaults["dataset-status"])
     return parser
 
 
 def _load_parser_defaults(config_path: Path | None) -> dict[str, dict[str, Any]]:
     commands = (
         "scrape",
+        "refresh-dataset",
         "analyze",
         "import-hf-checkpoint",
         "pr-scope",
@@ -66,9 +81,10 @@ def _load_parser_defaults(config_path: Path | None) -> dict[str, dict[str, Any]]
         "adopt-snapshot",
         "new-contributor-report",
         "dashboard-data",
-        "publish-snapshot",
+        "publish-analysis-artifacts",
+        "save-cache",
         "deploy-dashboard",
-        "full-pipeline",
+        "dataset-status",
     )
     return {command: command_defaults(command, config_path=config_path) for command in commands}
 
@@ -141,52 +157,110 @@ def _add_scrape_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
         help="Fetch issue timeline events for linkage rows.",
     )
     scrape.add_argument(
-        "--publish",
+        "--new-contributor-report",
+        dest="new_contributor_report",
         action="store_true",
-        default=bool(defaults.get("publish", False)),
-        help="Upload the snapshot to the Hugging Face Hub.",
+        default=defaults.get("new-contributor-report"),
+        help="Generate new contributor dataset/report artifacts for the local snapshot.",
+    )
+    scrape.add_argument(
+        "--no-new-contributor-report",
+        dest="new_contributor_report",
+        action="store_false",
+        help="Skip new contributor dataset/report generation.",
+    )
+    scrape.add_argument(
+        "--new-contributor-window-days",
+        type=int,
+        default=int(defaults.get("new-contributor-window-days", 42)),
+        help="Recent public activity window for contributor enrichment.",
     )
     scrape.add_argument(
+        "--new-contributor-max-authors",
+        type=int,
+        default=int(defaults.get("new-contributor-max-authors", 25)),
+        help="Maximum number of contributors to include in the new contributor report. Use 0 for no cap.",
+    )
+
+
+def _add_refresh_dataset_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
+    refresh = subparsers.add_parser(
+        "refresh-dataset",
+        help="Refresh the canonical Hugging Face dataset repo from remote watermark state.",
+    )
+    refresh.add_argument(
+        "--repo",
+        default=defaults.get("repo", "huggingface/transformers"),
+        help="GitHub repository in owner/name form.",
+    )
+    refresh.add_argument(
         "--hf-repo-id",
         default=defaults.get("hf-repo-id"),
-        help="Hub dataset repo ID used with --publish.",
+        required=defaults.get("hf-repo-id") is None,
+        help="Canonical Hugging Face dataset repo id to refresh.",
     )
-    scrape.add_argument(
-        "--private-hf-repo",
+    refresh.add_argument("--max-issues", type=int, default=defaults.get("max-issues"))
+    refresh.add_argument("--max-prs", type=int, default=defaults.get("max-prs"))
+    refresh.add_argument(
+        "--max-issue-comments", type=int, default=defaults.get("max-issue-comments")
+    )
+    refresh.add_argument(
+        "--max-reviews-per-pr", type=int, default=defaults.get("max-reviews-per-pr")
+    )
+    refresh.add_argument(
+        "--max-review-comments-per-pr",
+        type=int,
+        default=defaults.get("max-review-comments-per-pr"),
+    )
+    refresh.add_argument(
+        "--fetch-timeline",
         action="store_true",
-        default=bool(defaults.get("private-hf-repo", False)),
-        help="Create the Hub dataset repo as private.",
+        default=bool(defaults.get("fetch-timeline", False)),
     )
-    scrape.add_argument(
+    refresh.add_argument(
         "--new-contributor-report",
         dest="new_contributor_report",
         action="store_true",
-        default=defaults.get("new-contributor-report"),
-        help="Generate new contributor dataset/report artifacts. Defaults to enabled when --publish is used.",
+        default=bool(defaults.get("new-contributor-report", True)),
     )
-    scrape.add_argument(
+    refresh.add_argument(
         "--no-new-contributor-report",
         dest="new_contributor_report",
         action="store_false",
-        help="Skip new contributor dataset/report generation.",
     )
-    scrape.add_argument(
+    refresh.add_argument(
         "--new-contributor-window-days",
         type=int,
         default=int(defaults.get("new-contributor-window-days", 42)),
-        help="Recent public activity window for contributor enrichment.",
     )
-    scrape.add_argument(
+    refresh.add_argument(
         "--new-contributor-max-authors",
         type=int,
         default=int(defaults.get("new-contributor-max-authors", 25)),
-        help="Maximum number of contributors to include in the new contributor report. Use 0 for no cap.",
+    )
+    refresh.add_argument("--http-timeout", type=int, default=300)
+    refresh.add_argument("--http-max-retries", type=int, default=8)
+    refresh.add_argument("--checkpoint-every-comments", type=int, default=1000)
+    refresh.add_argument("--checkpoint-every-prs", type=int, default=25)
+    refresh.add_argument(
+        "--private-hf-repo",
+        dest="private_hf_repo",
+        action="store_true",
+        default=bool(defaults.get("private-hf-repo", False)),
+        help="Create the target dataset repo as private if needed.",
+    )
+    refresh.add_argument(
+        "--private",
+        dest="private_hf_repo",
+        action="store_true",
+        help=argparse.SUPPRESS,
     )
 
 
 def _add_analyze_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
     analyze = subparsers.add_parser(
-        "analyze", help="Analyze a local snapshot and write a shortlist JSON report."
+        "analyze",
+        help="Analyze a snapshot and write a local JSON report. Canonical publication is separate.",
     )
     analyze.add_argument(
         "--snapshot-dir",
@@ -200,7 +274,7 @@ def _add_analyze_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
     analyze.add_argument(
         "--hf-repo-id",
         default=defaults.get("hf-repo-id"),
-        help="Analyze a Hugging Face dataset repo by materializing its parquet export locally.",
+        help="Analyze a canonical Hugging Face dataset repo by materializing a self-consistent published snapshot locally.",
     )
     analyze.add_argument(
         "--hf-revision",
@@ -223,7 +297,7 @@ def _add_analyze_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
     )
     analyze.add_argument(
         "--model",
-        default=defaults.get("model", "gpt-5-mini?reasoning=low"),
+        default=defaults.get("model", "gpt-5.4-mini?service_tier=flex"),
         help="Model string used by fast-agent when enabled.",
     )
     analyze.add_argument(
@@ -232,6 +306,15 @@ def _add_analyze_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
         default=int(defaults.get("max-clusters", 10)),
         help="Maximum number of meta clusters to include in the report.",
     )
+    analyze.add_argument(
+        "--hybrid-llm-concurrency",
+        type=_int_at_least(1),
+        default=int(defaults.get("hybrid-llm-concurrency", 1)),
+        help=(
+            "Maximum number of hybrid LLM review units to run at once. "
+            "Use 1 to minimize provider pressure."
+        ),
+    )
     analyze.add_argument(
         "--open-prs-only",
         action="store_true",
@@ -637,6 +720,61 @@ def _add_pr_search_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
     status.add_argument("--repo", help="Optional repo override.")
     status.add_argument("--json", action="store_true", help="Emit JSON.")
 
+    contributor = pr_search_subparsers.add_parser(
+        "contributor", help="Show indexed contributor summary for one author login."
+    )
+    contributor.add_argument("login", help="GitHub author login to query.")
+    contributor.add_argument(
+        "--db",
+        type=Path,
+        default=Path(defaults["db"]) if defaults.get("db") else None,
+        help="DuckDB file path. Defaults to <output-dir>/state/pr-search.duckdb.",
+    )
+    contributor.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path(defaults.get("output-dir", "data")),
+    )
+    contributor.add_argument("--repo", help="Optional repo override.")
+    contributor.add_argument("--json", action="store_true", help="Emit JSON.")
+
+    contributor_prs = pr_search_subparsers.add_parser(
+        "contributor-prs", help="List indexed PRs for one contributor login."
+    )
+    contributor_prs.add_argument("login", help="GitHub author login to query.")
+    contributor_prs.add_argument(
+        "--db",
+        type=Path,
+        default=Path(defaults["db"]) if defaults.get("db") else None,
+        help="DuckDB file path. Defaults to <output-dir>/state/pr-search.duckdb.",
+    )
+    contributor_prs.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path(defaults.get("output-dir", "data")),
+    )
+    contributor_prs.add_argument("--repo", help="Optional repo override.")
+    contributor_prs.add_argument("--limit", type=int, default=20, help="Maximum rows to show.")
+    contributor_prs.add_argument("--json", action="store_true", help="Emit JSON.")
+
+    pr_contributor = pr_search_subparsers.add_parser(
+        "pr-contributor", help="Show contributor summary for the author of one indexed PR."
+    )
+    pr_contributor.add_argument("pr_number", type=int, help="Pull request number to query.")
+    pr_contributor.add_argument(
+        "--db",
+        type=Path,
+        default=Path(defaults["db"]) if defaults.get("db") else None,
+        help="DuckDB file path. Defaults to <output-dir>/state/pr-search.duckdb.",
+    )
+    pr_contributor.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path(defaults.get("output-dir", "data")),
+    )
+    pr_contributor.add_argument("--repo", help="Optional repo override.")
+    pr_contributor.add_argument("--json", action="store_true", help="Emit JSON.")
+
 
 def _add_new_contributor_report_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
     new_contributor = subparsers.add_parser(
@@ -659,6 +797,24 @@ def _add_new_contributor_report_parser(subparsers: Any, defaults: dict[str, Any]
     new_contributor.add_argument(
         "--json-output", type=Path, help="Optional JSON output path. Defaults next to the snapshot."
     )
+    new_contributor.add_argument(
+        "--hf-repo-id",
+        default=defaults.get("hf-repo-id"),
+        help="Analyze a Hugging Face dataset repo by materializing its parquet export locally.",
+    )
+    new_contributor.add_argument(
+        "--hf-revision",
+        default=defaults.get("hf-revision"),
+        help="Optional Hub revision for metadata and README download.",
+    )
+    new_contributor.add_argument(
+        "--hf-materialize-dir",
+        type=Path,
+        default=Path(defaults["hf-materialize-dir"])
+        if defaults.get("hf-materialize-dir")
+        else None,
+        help="Optional local directory used when materializing an HF dataset snapshot.",
+    )
     new_contributor.add_argument(
         "--window-days",
         type=int,
@@ -690,17 +846,35 @@ def _add_dashboard_data_parser(subparsers: Any, defaults: dict[str, Any]) -> Non
     dashboard.add_argument(
         "--analysis-input",
         type=Path,
-        help="Optional analysis report JSON. Defaults to analysis-report.json in the snapshot.",
+        help="Optional analysis report JSON override. Defaults to canonical published current analysis when available, otherwise falls back to snapshot-local analysis files.",
     )
     dashboard.add_argument(
         "--contributors-input",
         type=Path,
-        help="Optional new contributor report JSON. Defaults to new-contributors-report.json in the snapshot.",
+        help="Optional contributor report JSON override. Defaults to the materialized snapshot's new-contributors-report.json.",
     )
     dashboard.add_argument(
         "--pr-scope-input",
         type=Path,
-        help="Optional PR scope cluster JSON. Defaults to pr-scope-clusters.json in the snapshot.",
+        help="Optional PR scope cluster JSON override. Defaults to the materialized snapshot's pr-scope-clusters.json.",
+    )
+    dashboard.add_argument(
+        "--hf-repo-id",
+        default=defaults.get("hf-repo-id"),
+        help="Materialize the canonical Hugging Face dataset repo instead of using the latest local snapshot.",
+    )
+    dashboard.add_argument(
+        "--hf-revision",
+        default=defaults.get("hf-revision"),
+        help="Optional Hub revision for metadata and README download.",
+    )
+    dashboard.add_argument(
+        "--hf-materialize-dir",
+        type=Path,
+        default=Path(defaults["hf-materialize-dir"])
+        if defaults.get("hf-materialize-dir")
+        else None,
+        help="Optional local directory used when materializing an HF dataset snapshot.",
     )
     dashboard.add_argument(
         "--window-days",
@@ -710,27 +884,77 @@ def _add_dashboard_data_parser(subparsers: Any, defaults: dict[str, Any]) -> Non
     )
 
 
-def _add_publish_snapshot_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
-    publish_snapshot = subparsers.add_parser(
-        "publish-snapshot",
-        help="Publish an existing local snapshot to a Hugging Face dataset repo.",
+def _add_publish_analysis_artifacts_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
+    publish_analysis = subparsers.add_parser(
+        "publish-analysis-artifacts",
+        help="Publish archived and optional canonical hybrid analysis artifacts to a dataset repo.",
     )
-    publish_snapshot.add_argument(
+    publish_analysis.add_argument(
         "--output-dir",
         type=Path,
         default=Path(defaults.get("output-dir", "data")),
         help="Pipeline workspace root containing snapshots/latest.json.",
     )
-    publish_snapshot.add_argument(
-        "--snapshot-dir", type=Path, help="Optional explicit snapshot directory to upload."
+    publish_analysis.add_argument(
+        "--snapshot-dir",
+        type=Path,
+        help="Optional explicit snapshot directory containing analysis-report-hybrid.json.",
     )
-    publish_snapshot.add_argument(
+    publish_analysis.add_argument(
+        "--analysis-input",
+        type=Path,
+        help="Optional explicit hybrid analysis report JSON to publish instead of snapshot-dir discovery.",
+    )
+    publish_analysis.add_argument(
         "--hf-repo-id",
         default=defaults.get("hf-repo-id"),
         required=defaults.get("hf-repo-id") is None,
         help="Target Hugging Face dataset repo id.",
     )
-    publish_snapshot.add_argument(
+    publish_analysis.add_argument("--analysis-id", required=True, help="Immutable analysis run id.")
+    publish_analysis.add_argument(
+        "--canonical",
+        action="store_true",
+        default=bool(defaults.get("canonical", False)),
+        help="Also update the stable analysis/current canonical alias.",
+    )
+    publish_analysis.add_argument(
+        "--save-cache",
+        action="store_true",
+        default=bool(defaults.get("save-cache", False)),
+        help="Also upload snapshot-local analysis-state/ as mutable operational cache at repo-root analysis-state/.",
+    )
+    publish_analysis.add_argument(
+        "--private-hf-repo",
+        action="store_true",
+        default=bool(defaults.get("private-hf-repo", False)),
+        help="Create the target dataset repo as private if needed.",
+    )
+
+
+def _add_save_cache_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
+    save_cache = subparsers.add_parser(
+        "save-cache",
+        help="Upload snapshot-local analysis-state/ as mutable operational cache to a dataset repo.",
+    )
+    save_cache.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path(defaults.get("output-dir", "data")),
+        help="Pipeline workspace root containing snapshots/latest.json.",
+    )
+    save_cache.add_argument(
+        "--snapshot-dir",
+        type=Path,
+        help="Optional explicit snapshot directory containing analysis-state/.",
+    )
+    save_cache.add_argument(
+        "--hf-repo-id",
+        default=defaults.get("hf-repo-id"),
+        required=defaults.get("hf-repo-id") is None,
+        help="Target Hugging Face dataset repo id.",
+    )
+    save_cache.add_argument(
         "--private-hf-repo",
         action="store_true",
         default=bool(defaults.get("private-hf-repo", False)),
@@ -740,7 +964,8 @@ def _add_publish_snapshot_parser(subparsers: Any, defaults: dict[str, Any]) -> N
 
 def _add_deploy_dashboard_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
     deploy_dashboard = subparsers.add_parser(
-        "deploy-dashboard", help="Build and publish the static dashboard to a Hugging Face Space."
+        "deploy-dashboard",
+        help="Build and publish the static dashboard to a Hugging Face Space from a materialized dataset view.",
     )
     deploy_dashboard.add_argument(
         "--pipeline-data-dir",
@@ -756,10 +981,37 @@ def _add_deploy_dashboard_parser(subparsers: Any, defaults: dict[str, Any]) -> N
         help="Optional snapshot directory to publish. Defaults to the latest snapshot in --pipeline-data-dir.",
     )
     deploy_dashboard.add_argument(
-        "--analysis-input", type=Path, help="Optional analysis report JSON override."
+        "--analysis-input",
+        type=Path,
+        help="Optional analysis report JSON override. Omit to prefer canonical published current analysis when available.",
+    )
+    deploy_dashboard.add_argument(
+        "--contributors-input",
+        type=Path,
+        help="Optional contributor report JSON override.",
+    )
+    deploy_dashboard.add_argument(
+        "--pr-scope-input",
+        type=Path,
+        help="Optional PR scope cluster JSON override.",
+    )
+    deploy_dashboard.add_argument(
+        "--hf-repo-id",
+        default=defaults.get("hf-repo-id"),
+        help="Materialize the canonical Hugging Face dataset repo instead of using the latest local snapshot.",
     )
     deploy_dashboard.add_argument(
-        "--contributors-input", type=Path, help="Optional contributor report JSON override."
+        "--hf-revision",
+        default=defaults.get("hf-revision"),
+        help="Optional Hub revision for metadata and README download.",
+    )
+    deploy_dashboard.add_argument(
+        "--hf-materialize-dir",
+        type=Path,
+        default=Path(defaults["hf-materialize-dir"])
+        if defaults.get("hf-materialize-dir")
+        else None,
+        help="Optional local directory used when materializing an HF dataset snapshot.",
     )
     deploy_dashboard.add_argument(
         "--refresh-contributors",
@@ -817,71 +1069,29 @@ def _add_deploy_dashboard_parser(subparsers: Any, defaults: dict[str, Any]) -> N
     )
 
 
-def _add_full_pipeline_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
-    full_pipeline = subparsers.add_parser(
-        "full-pipeline",
-        help="Run scrape, publish, analyze, markdown export, and dashboard export for one repo.",
-    )
-    full_pipeline.add_argument(
-        "--repo",
-        default=defaults.get("repo"),
-        required=defaults.get("repo") is None,
-        help="GitHub repository in owner/name form.",
-    )
-    full_pipeline.add_argument(
-        "--dataset",
-        default=defaults.get("dataset"),
-        required=defaults.get("dataset") is None,
-        help="Target Hugging Face dataset repo id.",
+def _add_dataset_status_parser(subparsers: Any, defaults: dict[str, Any]) -> None:
+    dataset_status = subparsers.add_parser(
+        "dataset-status",
+        help="Inspect canonical dataset freshness and the local latest pointer.",
     )
-    full_pipeline.add_argument("--model", default=defaults.get("model", "gpt-5-mini?reasoning=low"))
-    full_pipeline.add_argument(
-        "--workspace-root",
+    dataset_status.add_argument("--repo", default=defaults.get("repo"))
+    dataset_status.add_argument(
+        "--output-dir",
         type=Path,
-        default=Path(defaults.get("workspace-root", "runs")),
-    )
-    full_pipeline.add_argument("--private-hf-repo", action="store_true")
-    full_pipeline.add_argument(
-        "--ranking-backend",
-        choices=("hybrid", "deterministic"),
-        default=defaults.get("ranking-backend", "hybrid"),
-    )
-    full_pipeline.add_argument(
-        "--max-clusters", type=int, default=int(defaults.get("max-clusters", 10))
-    )
-    full_pipeline.add_argument(
-        "--fetch-timeline", dest="fetch_timeline", action="store_true", default=True
-    )
-    full_pipeline.add_argument("--no-fetch-timeline", dest="fetch_timeline", action="store_false")
-    full_pipeline.add_argument(
-        "--dashboard-window-days",
-        type=int,
-        default=int(defaults.get("dashboard-window-days", 14)),
-    )
-    full_pipeline.add_argument(
-        "--new-contributor-window-days",
-        type=int,
-        default=int(defaults.get("new-contributor-window-days", 42)),
-    )
-    full_pipeline.add_argument(
-        "--new-contributor-max-authors",
-        type=int,
-        default=int(defaults.get("new-contributor-max-authors", 25)),
-        help="Contributor enrichment cap override. Full pipeline treats 0 as no cap and currently forces no cap.",
-    )
-    full_pipeline.add_argument(
-        "--issue-max-age-days", type=int, default=defaults.get("issue-max-age-days")
+        default=Path(defaults.get("output-dir", "data")),
+        help="Local workspace root containing snapshots/latest.json.",
     )
-    full_pipeline.add_argument(
-        "--pr-max-age-days", type=int, default=defaults.get("pr-max-age-days")
+    dataset_status.add_argument(
+        "--hf-repo-id",
+        default=defaults.get("hf-repo-id"),
+        help="Canonical Hugging Face dataset repo id to inspect.",
     )
-    full_pipeline.add_argument("--max-issues", type=int, default=defaults.get("max-issues"))
-    full_pipeline.add_argument("--max-prs", type=int, default=defaults.get("max-prs"))
-    full_pipeline.add_argument(
-        "--open-prs-only",
-        action="store_true",
-        default=bool(defaults.get("open-prs-only", False)),
+    dataset_status.add_argument(
+        "--hf-revision",
+        default=defaults.get("hf-revision"),
+        help="Optional Hub revision for metadata and README download.",
     )
+    dataset_status.add_argument("--json", action="store_true", help="Emit machine-readable JSON.")
 
 
 # Dispatch helpers
@@ -905,9 +1115,7 @@ def _resolve_hf_inputs(args: argparse.Namespace) -> tuple[str | None, str | None
 def _run_scrape(args: argparse.Namespace, config_path: Path | None) -> None:
     from slop_farmer.app.pipeline import run_pipeline
 
-    new_contributor_report = args.new_contributor_report
-    if new_contributor_report is None:
-        new_contributor_report = bool(args.publish)
+    new_contributor_report = bool(args.new_contributor_report)
     options = PipelineOptions(
         repo=RepoRef.parse(args.repo),
         output_dir=args.output_dir,
@@ -921,9 +1129,6 @@ def _run_scrape(args: argparse.Namespace, config_path: Path | None) -> None:
         max_reviews_per_pr=args.max_reviews_per_pr,
         max_review_comments_per_pr=args.max_review_comments_per_pr,
         fetch_timeline=args.fetch_timeline,
-        publish=args.publish,
-        hf_repo_id=args.hf_repo_id,
-        private_hf_repo=args.private_hf_repo,
         new_contributor_report=new_contributor_report,
         new_contributor_window_days=args.new_contributor_window_days,
         new_contributor_max_authors=args.new_contributor_max_authors,
@@ -933,6 +1138,34 @@ def _run_scrape(args: argparse.Namespace, config_path: Path | None) -> None:
     print(run_pipeline(options))
 
 
+def _run_refresh_dataset(args: argparse.Namespace, config_path: Path | None) -> None:
+    from slop_farmer.app.dataset_refresh import run_dataset_refresh
+
+    refresh_defaults = command_defaults("refresh-dataset", config_path=config_path)
+    result = run_dataset_refresh(
+        DatasetRefreshOptions(
+            repo=RepoRef.parse(args.repo),
+            hf_repo_id=args.hf_repo_id,
+            private_hf_repo=args.private_hf_repo,
+            max_issues=args.max_issues,
+            max_prs=args.max_prs,
+            max_issue_comments=args.max_issue_comments,
+            max_reviews_per_pr=args.max_reviews_per_pr,
+            max_review_comments_per_pr=args.max_review_comments_per_pr,
+            fetch_timeline=args.fetch_timeline,
+            new_contributor_report=args.new_contributor_report,
+            new_contributor_window_days=args.new_contributor_window_days,
+            new_contributor_max_authors=args.new_contributor_max_authors,
+            http_timeout=args.http_timeout,
+            http_max_retries=args.http_max_retries,
+            checkpoint_every_comments=args.checkpoint_every_comments,
+            checkpoint_every_prs=args.checkpoint_every_prs,
+            cluster_suppression_rules=tuple(refresh_defaults.get("cluster-suppression-rules", ())),
+        )
+    )
+    print(json.dumps(result, indent=2))
+
+
 def _run_analyze(args: argparse.Namespace, config_path: Path | None) -> None:
     from slop_farmer.reports.analysis import run_analysis
 
@@ -948,6 +1181,7 @@ def _run_analyze(args: argparse.Namespace, config_path: Path | None) -> None:
         ranking_backend=args.ranking_backend,
         model=args.model,
         max_clusters=args.max_clusters,
+        hybrid_llm_concurrency=args.hybrid_llm_concurrency,
         open_prs_only=args.open_prs_only,
         cached_analysis=bool(analyze_defaults.get("cached_analysis", False)),
         pr_template_cleanup_mode=str(
@@ -1041,12 +1275,18 @@ def _run_pr_search(args: argparse.Namespace, config_path: Path | None) -> None:
         explain_pr_search_pair,
         format_pr_search_candidate_clusters,
         format_pr_search_cluster,
+        format_pr_search_contributor,
+        format_pr_search_contributor_pulls,
         format_pr_search_pair,
         format_pr_search_probe,
+        format_pr_search_pull_contributor,
         format_pr_search_similar,
         format_pr_search_status,
         get_pr_search_candidate_clusters,
         get_pr_search_cluster,
+        get_pr_search_contributor,
+        get_pr_search_contributor_pulls,
+        get_pr_search_pull_contributor,
         get_pr_search_similar,
         get_pr_search_status,
         probe_pr_search_github,
@@ -1140,6 +1380,36 @@ def _run_pr_search(args: argparse.Namespace, config_path: Path | None) -> None:
         print(json.dumps(result, indent=2) if args.json else format_pr_search_status(result))
         return
 
+    if args.pr_search_command == "contributor":
+        result = get_pr_search_contributor(db_path, author_login=args.login, repo=args.repo)
+        print(json.dumps(result, indent=2) if args.json else format_pr_search_contributor(result))
+        return
+
+    if args.pr_search_command == "contributor-prs":
+        result = get_pr_search_contributor_pulls(
+            db_path,
+            author_login=args.login,
+            repo=args.repo,
+            limit=args.limit,
+        )
+        print(
+            json.dumps(result, indent=2)
+            if args.json
+            else format_pr_search_contributor_pulls(result)
+        )
+        return
+
+    if args.pr_search_command == "pr-contributor":
+        result = get_pr_search_pull_contributor(
+            db_path,
+            pr_number=args.pr_number,
+            repo=args.repo,
+        )
+        print(
+            json.dumps(result, indent=2) if args.json else format_pr_search_pull_contributor(result)
+        )
+        return
+
     raise ValueError(f"Unsupported pr-search command: {args.pr_search_command}")
 
 
@@ -1181,6 +1451,7 @@ def _run_new_contributor_report(args: argparse.Namespace, config_path: Path | No
     del config_path
     from slop_farmer.reports.new_contributor_report import run_new_contributor_report
 
+    hf_repo_id, hf_revision, hf_materialize_dir = _resolve_hf_inputs(args)
     print(
         run_new_contributor_report(
             NewContributorReportOptions(
@@ -1188,6 +1459,9 @@ def _run_new_contributor_report(args: argparse.Namespace, config_path: Path | No
                 output_dir=args.output_dir,
                 output=args.output,
                 json_output=args.json_output,
+                hf_repo_id=hf_repo_id,
+                hf_revision=hf_revision,
+                hf_materialize_dir=hf_materialize_dir,
                 window_days=args.window_days,
                 max_authors=args.max_authors,
             )
@@ -1199,6 +1473,7 @@ def _run_dashboard_data(args: argparse.Namespace, config_path: Path | None) -> N
     from slop_farmer.reports.dashboard import run_dashboard_data
 
     dashboard_defaults = command_defaults("dashboard-data", config_path=config_path)
+    hf_repo_id, hf_revision, hf_materialize_dir = _resolve_hf_inputs(args)
     print(
         run_dashboard_data(
             DashboardDataOptions(
@@ -1207,6 +1482,9 @@ def _run_dashboard_data(args: argparse.Namespace, config_path: Path | None) -> N
                 analysis_input=args.analysis_input,
                 contributors_input=args.contributors_input,
                 pr_scope_input=args.pr_scope_input,
+                hf_repo_id=hf_repo_id,
+                hf_revision=hf_revision,
+                hf_materialize_dir=hf_materialize_dir,
                 window_days=args.window_days,
                 snapshot_root=(
                     Path(dashboard_defaults["snapshot-root"])
@@ -1222,6 +1500,7 @@ def _run_deploy_dashboard(args: argparse.Namespace, config_path: Path | None) ->
     del config_path
     from slop_farmer.app.deploy import run_deploy_dashboard
 
+    hf_repo_id, hf_revision, hf_materialize_dir = _resolve_hf_inputs(args)
     run_deploy_dashboard(
         DeployDashboardOptions(
             pipeline_data_dir=args.pipeline_data_dir,
@@ -1229,6 +1508,10 @@ def _run_deploy_dashboard(args: argparse.Namespace, config_path: Path | None) ->
             snapshot_dir=args.snapshot_dir,
             analysis_input=args.analysis_input,
             contributors_input=args.contributors_input,
+            pr_scope_input=args.pr_scope_input,
+            hf_repo_id=hf_repo_id,
+            hf_revision=hf_revision,
+            hf_materialize_dir=hf_materialize_dir,
             refresh_contributors=args.refresh_contributors,
             dashboard_window_days=args.dashboard_window_days,
             contributor_window_days=args.contributor_window_days,
@@ -1247,44 +1530,60 @@ def _run_deploy_dashboard(args: argparse.Namespace, config_path: Path | None) ->
     )
 
 
-def _run_publish_snapshot(args: argparse.Namespace, config_path: Path | None) -> None:
+def _run_dataset_status(args: argparse.Namespace, config_path: Path | None) -> None:
     del config_path
-    from slop_farmer.app.publish import run_publish_snapshot
+    from slop_farmer.app.dataset_status import format_dataset_status, get_dataset_status
 
-    run_publish_snapshot(
-        PublishSnapshotOptions(
+    result = get_dataset_status(
+        DatasetStatusOptions(
+            repo=args.repo,
             output_dir=args.output_dir,
-            snapshot_dir=args.snapshot_dir,
             hf_repo_id=args.hf_repo_id,
-            private_hf_repo=args.private_hf_repo,
+            hf_revision=args.hf_revision,
+            json_output=args.json,
         )
     )
+    print(json.dumps(result, indent=2) if args.json else format_dataset_status(result))
 
 
-def _run_full_pipeline(args: argparse.Namespace, config_path: Path | None) -> None:
+def _run_publish_analysis_artifacts(args: argparse.Namespace, config_path: Path | None) -> None:
     del config_path
-    from slop_farmer.app.workflow import run_full_pipeline
+    from slop_farmer.app.publish_analysis import run_publish_analysis_artifacts
 
     print(
-        run_full_pipeline(
-            FullPipelineOptions(
-                repo=RepoRef.parse(args.repo),
-                dataset=args.dataset,
-                model=args.model,
-                workspace_root=args.workspace_root,
-                private_hf_repo=args.private_hf_repo,
-                ranking_backend=args.ranking_backend,
-                max_clusters=args.max_clusters,
-                fetch_timeline=args.fetch_timeline,
-                dashboard_window_days=args.dashboard_window_days,
-                new_contributor_window_days=args.new_contributor_window_days,
-                new_contributor_max_authors=args.new_contributor_max_authors,
-                issue_max_age_days=args.issue_max_age_days,
-                pr_max_age_days=args.pr_max_age_days,
-                max_issues=args.max_issues,
-                max_prs=args.max_prs,
-                open_prs_only=args.open_prs_only,
-            )
+        json.dumps(
+            run_publish_analysis_artifacts(
+                PublishAnalysisArtifactsOptions(
+                    output_dir=args.output_dir,
+                    snapshot_dir=args.snapshot_dir,
+                    analysis_input=args.analysis_input,
+                    hf_repo_id=args.hf_repo_id,
+                    analysis_id=args.analysis_id,
+                    canonical=args.canonical,
+                    save_cache=args.save_cache,
+                    private_hf_repo=args.private_hf_repo,
+                )
+            ),
+            indent=2,
+        )
+    )
+
+
+def _run_save_cache(args: argparse.Namespace, config_path: Path | None) -> None:
+    del config_path
+    from slop_farmer.app.save_cache import run_save_cache
+
+    print(
+        json.dumps(
+            run_save_cache(
+                SaveCacheOptions(
+                    output_dir=args.output_dir,
+                    snapshot_dir=args.snapshot_dir,
+                    hf_repo_id=args.hf_repo_id,
+                    private_hf_repo=args.private_hf_repo,
+                )
+            ),
+            indent=2,
         )
     )
 
@@ -1296,6 +1595,7 @@ def main() -> None:
 
     handlers: dict[str, CommandHandler] = {
         "scrape": _run_scrape,
+        "refresh-dataset": _run_refresh_dataset,
         "analyze": _run_analyze,
         "markdown-report": _run_markdown_report,
         "duplicate-prs": _run_duplicate_prs,
@@ -1306,8 +1606,9 @@ def main() -> None:
         "new-contributor-report": _run_new_contributor_report,
         "dashboard-data": _run_dashboard_data,
         "deploy-dashboard": _run_deploy_dashboard,
-        "publish-snapshot": _run_publish_snapshot,
-        "full-pipeline": _run_full_pipeline,
+        "dataset-status": _run_dataset_status,
+        "publish-analysis-artifacts": _run_publish_analysis_artifacts,
+        "save-cache": _run_save_cache,
     }
     handler = handlers.get(args.command)
     if handler is None:

src/slop_farmer/app/dataset_refresh.py

@@ -17,6 +17,7 @@ from slop_farmer.app_config import command_defaults, extract_cli_config_path
 from slop_farmer.config import (
     DatasetRefreshOptions,
     NewContributorReportOptions,
+    PrScopeOptions,
     RepoRef,
     resolve_github_token,
 )
@@ -48,6 +49,7 @@ from slop_farmer.data.parquet_io import (
     write_text,
 )
 from slop_farmer.reports.new_contributor_report import run_new_contributor_report
+from slop_farmer.reports.pr_scope import run_pr_scope_report
 
 PRIMARY_KEYS: dict[str, tuple[str, ...]] = {
     "issues": ("github_id",),
@@ -318,6 +320,9 @@ def _build_argument_parser(*, config_path: Path | None = None) -> argparse.Argum
         default=bool(defaults.get("private-hf-repo", False)),
     )
     parser.add_argument("--private", dest="private_hf_repo", action="store_true")
+    parser.set_defaults(
+        cluster_suppression_rules=tuple(defaults.get("cluster-suppression-rules", ()))
+    )
     return parser
 
 
@@ -872,7 +877,7 @@ def run_dataset_refresh(options: DatasetRefreshOptions) -> dict[str, Any]:
             table_name: merge_rows(table_name, previous_tables[table_name], delta_rows)
             for table_name, delta_rows in delta_tables.items()
         }
-        manifest = {
+        manifest: dict[str, Any] = {
             "repo": repo_slug,
             "snapshot_id": sid,
             "crawl_started_at": crawl_started_at,
@@ -918,8 +923,27 @@ def run_dataset_refresh(options: DatasetRefreshOptions) -> dict[str, Any]:
         )
         write_parquet(issue_comment_rows, output_root / "issue_comments.parquet", "comments")
         write_parquet(pr_comment_rows, output_root / "pr_comments.parquet", "comments")
+        archived_snapshot_dir = output_root / "snapshots" / sid
+        archived_snapshot_dir.mkdir(parents=True, exist_ok=True)
+        write_json(manifest, output_root / "manifest.json")
+        log("Generating PR scope clusters")
+        pr_scope_path = run_pr_scope_report(
+            PrScopeOptions(
+                snapshot_dir=output_root,
+                output_dir=output_root,
+                output=output_root / "pr-scope-clusters.json",
+                hf_repo_id=None,
+                hf_revision=None,
+                hf_materialize_dir=None,
+                cluster_suppression_rules=options.cluster_suppression_rules,
+            )
+        )
+        shutil.copy2(pr_scope_path, archived_snapshot_dir / pr_scope_path.name)
+        artifacts: dict[str, str] = {
+            "pr_scope_clusters_json": pr_scope_path.name,
+            "archived_pr_scope_clusters_json": f"snapshots/{sid}/{pr_scope_path.name}",
+        }
         if options.new_contributor_report:
-            write_json(manifest, output_root / "manifest.json")
             log("Generating new contributor dataset/report artifacts")
             run_new_contributor_report(
                 NewContributorReportOptions(
@@ -937,11 +961,14 @@ def run_dataset_refresh(options: DatasetRefreshOptions) -> dict[str, Any]:
             manifest["counts"]["new_contributors"] = len(
                 read_parquet_rows(output_root / "new_contributors.parquet")
             )
-            manifest["artifacts"] = {
-                "new_contributors_parquet": "new_contributors.parquet",
-                "new_contributors_json": "new-contributors-report.json",
-                "new_contributors_markdown": "new-contributors-report.md",
-            }
+            artifacts.update(
+                {
+                    "new_contributors_parquet": "new_contributors.parquet",
+                    "new_contributors_json": "new-contributors-report.json",
+                    "new_contributors_markdown": "new-contributors-report.md",
+                }
+            )
+        manifest["artifacts"] = artifacts
         manifest["watermark"].pop("previous_snapshot_dir", None)
         write_json(manifest, output_root / "manifest.json")
         write_text(
@@ -962,7 +989,7 @@ def run_dataset_refresh(options: DatasetRefreshOptions) -> dict[str, Any]:
             },
             output_root / "state" / "watermark.json",
         )
-        write_json(manifest, output_root / "snapshots" / sid / "manifest.json")
+        write_json(manifest, archived_snapshot_dir / "manifest.json")
         write_json(
             {
                 "repo": repo_slug,
@@ -1012,6 +1039,7 @@ def main(argv: list[str] | None = None) -> None:
             http_max_retries=args.http_max_retries,
             checkpoint_every_comments=args.checkpoint_every_comments,
             checkpoint_every_prs=args.checkpoint_every_prs,
+            cluster_suppression_rules=tuple(args.cluster_suppression_rules),
         )
     )
     print(json.dumps(result, indent=2))

src/slop_farmer/app/dataset_status.py

@@ -15,6 +15,14 @@ from slop_farmer.data.hf_dataset_repo import (
     stable_snapshot_candidates,
 )
 from slop_farmer.data.parquet_io import read_json
+from slop_farmer.data.snapshot_paths import (
+    CONTRIBUTOR_ARTIFACT_FILENAMES,
+    CURRENT_ANALYSIS_MANIFEST_PATH,
+    PR_SCOPE_CLUSTERS_FILENAME,
+    SNAPSHOTS_LATEST_PATH,
+    load_current_analysis_manifest,
+    repo_relative_path_to_local,
+)
 
 
 def _coerce_datetime(value: Any) -> datetime | None:
@@ -51,17 +59,41 @@ def _local_status(output_dir: Path) -> dict[str, Any] | None:
     if not latest_path.exists():
         return None
     payload = read_json(latest_path)
-    snapshot_dir = payload.get("snapshot_dir")
-    manifest = {}
-    if isinstance(snapshot_dir, str) and snapshot_dir:
-        manifest_path = Path(snapshot_dir).resolve() / "manifest.json"
+    snapshot_dir_raw = payload.get("snapshot_dir")
+    manifest: dict[str, Any] = {}
+    snapshot_dir: Path | None = None
+    if isinstance(snapshot_dir_raw, str) and snapshot_dir_raw:
+        snapshot_dir = Path(snapshot_dir_raw).resolve()
+        manifest_path = snapshot_dir / "manifest.json"
         if manifest_path.exists():
             manifest = read_json(manifest_path)
+    current_analysis = _local_current_analysis(snapshot_dir)
     return {
         "latest_path": str(latest_path),
         "latest_pointer": payload,
-        "snapshot_dir": snapshot_dir,
+        "snapshot_dir": snapshot_dir_raw,
         "snapshot_id": manifest.get("snapshot_id") or payload.get("latest_snapshot_id"),
+        "current_analysis": current_analysis,
+    }
+
+
+def _local_current_analysis(snapshot_dir: Path | None) -> dict[str, Any]:
+    if snapshot_dir is None:
+        return {"present": False}
+    manifest_path = repo_relative_path_to_local(snapshot_dir, CURRENT_ANALYSIS_MANIFEST_PATH)
+    if not manifest_path.exists():
+        return {"present": False}
+    try:
+        manifest = load_current_analysis_manifest(manifest_path)
+    except ValueError as exc:
+        return {"present": True, "valid": False, "detail": str(exc)}
+    return {
+        "present": True,
+        "valid": True,
+        "snapshot_id": manifest["snapshot_id"],
+        "analysis_id": manifest["analysis_id"],
+        "variant": manifest["variant"],
+        "published_at": manifest["published_at"],
     }
 
 
@@ -73,7 +105,7 @@ def _remote_status(repo_id: str, revision: str | None) -> dict[str, Any]:
         latest_pointer = load_remote_json_file(
             api,
             repo_id,
-            "snapshots/latest.json",
+            SNAPSHOTS_LATEST_PATH,
             root,
             revision=revision,
         )
@@ -98,27 +130,32 @@ def _remote_status(repo_id: str, revision: str | None) -> dict[str, Any]:
                     continue
                 manifest = read_json(downloaded)
                 break
-        snapshot_prefix = (
-            str(latest_pointer.get("snapshot_dir") or "").strip("/")
+        current_analysis = _remote_current_analysis(
+            api,
+            repo_id,
+            root,
+            revision=revision,
+            remote_paths=remote_paths,
+            latest_pointer=latest_pointer,
+        )
+        latest_snapshot_id = (
+            str(latest_pointer.get("latest_snapshot_id"))
             if isinstance(latest_pointer, dict)
-            else ""
+            else None
         )
-        contributors_present = any(
-            path in remote_paths
-            for path in (
-                "new_contributors.parquet",
-                "new-contributors-report.json",
-                "new-contributors-report.md",
-            )
+        archived_run_manifests = sorted(
+            path
+            for path in remote_paths
+            if path.startswith("snapshots/")
+            and "/analysis-runs/" in path
+            and path.endswith("/manifest.json")
         )
-        if snapshot_prefix:
-            contributors_present = contributors_present or any(
-                path in remote_paths
-                for path in (
-                    f"{snapshot_prefix}/new_contributors.parquet",
-                    f"{snapshot_prefix}/new-contributors-report.json",
-                    f"{snapshot_prefix}/new-contributors-report.md",
-                )
+        current_snapshot_run_count = 0
+        if latest_snapshot_id:
+            current_snapshot_run_count = sum(
+                1
+                for path in archived_run_manifests
+                if path.startswith(f"snapshots/{latest_snapshot_id}/analysis-runs/")
             )
         extracted_at = manifest.get("extracted_at") if manifest else None
         return {
@@ -127,12 +164,75 @@ def _remote_status(repo_id: str, revision: str | None) -> dict[str, Any]:
             "latest_pointer": latest_pointer,
             "watermark": watermark,
             "manifest": manifest,
-            "contributors_present": contributors_present,
+            "cheap_artifacts": {
+                "pr_scope_clusters": _remote_has_latest_artifact(
+                    remote_paths,
+                    latest_pointer,
+                    PR_SCOPE_CLUSTERS_FILENAME,
+                ),
+                "contributors": all(
+                    _remote_has_latest_artifact(remote_paths, latest_pointer, filename)
+                    for filename in CONTRIBUTOR_ARTIFACT_FILENAMES
+                ),
+            },
+            "current_analysis": current_analysis,
+            "archived_analysis_runs": {
+                "count": len(archived_run_manifests),
+                "current_snapshot_count": current_snapshot_run_count,
+            },
             "remote_path_count": len(remote_paths),
             "age": _age_summary(extracted_at),
         }
 
 
+def _remote_current_analysis(
+    api: HfApi,
+    repo_id: str,
+    root: Path,
+    *,
+    revision: str | None,
+    remote_paths: set[str],
+    latest_pointer: dict[str, Any] | None,
+) -> dict[str, Any]:
+    if CURRENT_ANALYSIS_MANIFEST_PATH not in remote_paths:
+        return {"present": False}
+    downloaded = load_remote_file(
+        api,
+        repo_id,
+        CURRENT_ANALYSIS_MANIFEST_PATH,
+        root,
+        revision=revision,
+    )
+    if downloaded is None:
+        return {"present": False}
+    try:
+        manifest = load_current_analysis_manifest(downloaded)
+    except ValueError as exc:
+        return {"present": True, "valid": False, "detail": str(exc)}
+    latest_snapshot_id = (
+        str(latest_pointer.get("latest_snapshot_id")) if isinstance(latest_pointer, dict) else None
+    )
+    return {
+        "present": True,
+        "valid": True,
+        "snapshot_id": manifest["snapshot_id"],
+        "analysis_id": manifest["analysis_id"],
+        "variant": manifest["variant"],
+        "published_at": manifest["published_at"],
+        "matches_latest_snapshot": manifest["snapshot_id"] == latest_snapshot_id,
+        "artifact_count": len(manifest["artifacts"]),
+    }
+
+
+def _remote_has_latest_artifact(
+    remote_paths: set[str],
+    latest_pointer: dict[str, Any] | None,
+    filename: str,
+) -> bool:
+    candidates = stable_snapshot_candidates(latest_pointer, filename)
+    return any(candidate in remote_paths for candidate in candidates)
+
+
 def get_dataset_status(options: DatasetStatusOptions) -> dict[str, Any]:
     remote = _remote_status(options.hf_repo_id, options.hf_revision) if options.hf_repo_id else None
     local = _local_status(options.output_dir)
@@ -156,6 +256,9 @@ def format_dataset_status(status: dict[str, Any]) -> str:
     watermark = remote.get("watermark") or {}
     latest_pointer = remote.get("latest_pointer") or {}
     age = remote.get("age") or {}
+    current_analysis = remote.get("current_analysis") or {}
+    cheap_artifacts = remote.get("cheap_artifacts") or {}
+    archived_runs = remote.get("archived_analysis_runs") or {}
     lines = [
         f"Repo: {status.get('repo') or '?'}",
         f"Dataset: {status.get('dataset_id') or 'not configured'}",
@@ -166,10 +269,32 @@ def format_dataset_status(status: dict[str, Any]) -> str:
                 f"Remote latest snapshot: {manifest.get('snapshot_id') or latest_pointer.get('latest_snapshot_id') or '?'}",
                 f"Remote extracted at: {manifest.get('extracted_at') or '?'}",
                 f"Remote next_since: {watermark.get('next_since') or latest_pointer.get('next_since') or '?'}",
-                f"Contributor artifacts: {'yes' if remote.get('contributors_present') else 'no'}",
-                f"Freshness: {age.get('summary') or 'unknown'} ({age.get('staleness') or 'unknown'})",
+                f"PR scope artifact: {'yes' if cheap_artifacts.get('pr_scope_clusters') else 'no'}",
+                f"Contributor artifacts: {'yes' if cheap_artifacts.get('contributors') else 'no'}",
             ]
         )
+        if current_analysis.get("present"):
+            if current_analysis.get("valid") is False:
+                lines.append(f"Current analysis: invalid ({current_analysis.get('detail')})")
+            else:
+                lines.append(
+                    "Current analysis: "
+                    f"snapshot={current_analysis.get('snapshot_id')} "
+                    f"analysis_id={current_analysis.get('analysis_id')}"
+                )
+                lines.append(
+                    "Current analysis matches latest snapshot: "
+                    f"{'yes' if current_analysis.get('matches_latest_snapshot') else 'no'}"
+                )
+        else:
+            lines.append("Current analysis: none")
+        lines.append(
+            "Archived analysis runs: "
+            f"{archived_runs.get('count', 0)} total, {archived_runs.get('current_snapshot_count', 0)} for latest snapshot"
+        )
+        lines.append(
+            f"Freshness: {age.get('summary') or 'unknown'} ({age.get('staleness') or 'unknown'})"
+        )
     if local:
         lines.extend(
             [
@@ -177,6 +302,15 @@ def format_dataset_status(status: dict[str, Any]) -> str:
                 f"Local snapshot id: {local.get('snapshot_id') or '?'}",
             ]
         )
+        local_current_analysis = local.get("current_analysis") or {}
+        if local_current_analysis.get("present"):
+            lines.append(
+                "Local current analysis: "
+                f"snapshot={local_current_analysis.get('snapshot_id')} "
+                f"analysis_id={local_current_analysis.get('analysis_id')}"
+            )
+        else:
+            lines.append("Local current analysis: none")
     else:
         lines.append("Local latest pointer: none")
     return "\n".join(lines)

src/slop_farmer/app/deploy.py

@@ -5,6 +5,7 @@ import subprocess
 from pathlib import Path
 
 from slop_farmer.config import DeployDashboardOptions
+from slop_farmer.data.snapshot_source import resolve_snapshot_source_dir
 
 
 def run_deploy_dashboard(options: DeployDashboardOptions) -> None:
@@ -17,6 +18,16 @@ def run_deploy_dashboard(options: DeployDashboardOptions) -> None:
         {
             "PIPELINE_DATA_DIR": str(options.pipeline_data_dir),
             "WEB_DIR": str(options.web_dir),
+            "SNAPSHOT_DIR": str(
+                resolve_snapshot_source_dir(
+                    snapshot_dir=options.snapshot_dir,
+                    local_snapshots_root=options.pipeline_data_dir.resolve() / "snapshots",
+                    hf_repo_id=options.hf_repo_id,
+                    hf_revision=options.hf_revision,
+                    hf_materialize_dir=options.hf_materialize_dir,
+                    hf_output_dir=options.pipeline_data_dir,
+                )
+            ),
             "DASHBOARD_WINDOW_DAYS": str(options.dashboard_window_days),
             "CONTRIBUTOR_WINDOW_DAYS": str(options.contributor_window_days),
             "CONTRIBUTOR_MAX_AUTHORS": str(options.contributor_max_authors),
@@ -28,12 +39,12 @@ def run_deploy_dashboard(options: DeployDashboardOptions) -> None:
             "SPACE_SHORT_DESCRIPTION": options.space_short_description,
         }
     )
-    if options.snapshot_dir is not None:
-        env["SNAPSHOT_DIR"] = str(options.snapshot_dir)
     if options.analysis_input is not None:
-        env["ANALYSIS_INPUT"] = str(options.analysis_input)
+        env["ANALYSIS_INPUT"] = str(options.analysis_input.resolve())
     if options.contributors_input is not None:
-        env["CONTRIBUTORS_INPUT"] = str(options.contributors_input)
+        env["CONTRIBUTORS_INPUT"] = str(options.contributors_input.resolve())
+    if options.pr_scope_input is not None:
+        env["PR_SCOPE_INPUT"] = str(options.pr_scope_input.resolve())
     if options.refresh_contributors:
         env["REFRESH_CONTRIBUTORS"] = "1"
     if options.private_space:

src/slop_farmer/app/hf_checkpoint_import.py

@@ -26,8 +26,9 @@ from typing import Any
 
 from huggingface_hub import HfApi, hf_hub_download
 
-from slop_farmer.app.publish import publish_snapshot
+from slop_farmer.app.publish_dataset_snapshot import publish_dataset_snapshot
 from slop_farmer.config import CheckpointImportOptions
+from slop_farmer.data.dataset_card import build_hf_dataset_card
 from slop_farmer.data.links import build_pr_duplicate_candidate_rows, build_text_link_rows
 from slop_farmer.data.parquet_io import (
     SCHEMAS,
@@ -106,7 +107,9 @@ def import_hf_checkpoint(options: CheckpointImportOptions) -> Path:
         force=options.force,
     )
     if options.publish_repo_id:
-        publish_snapshot(snapshot_dir, options.publish_repo_id, private=options.private_hf_repo)
+        publish_dataset_snapshot(
+            snapshot_dir, options.publish_repo_id, private=options.private_hf_repo
+        )
     return snapshot_dir
 
 
@@ -455,76 +458,15 @@ def _viewer_comment_rows(
 def _dataset_card(
     repo_slug: str, snapshot_id: str, source_repo_id: str, checkpoint_root: str
 ) -> str:
-    return f"""---
-pretty_name: Transformers PR Slop Dataset
-configs:
-- config_name: issues
-  data_files:
-  - split: train
-    path: issues.parquet
-  default: true
-- config_name: prs
-  data_files:
-  - split: train
-    path: pull_requests.parquet
-- config_name: issue_comments
-  data_files:
-  - split: train
-    path: issue_comments.parquet
-- config_name: pr_comments
-  data_files:
-  - split: train
-    path: pr_comments.parquet
-- config_name: pr_reviews
-  data_files:
-  - split: train
-    path: reviews.parquet
-- config_name: pr_files
-  data_files:
-  - split: train
-    path: pr_files.parquet
-- config_name: pr_diffs
-  data_files:
-  - split: train
-    path: pr_diffs.parquet
-- config_name: review_comments
-  data_files:
-  - split: train
-    path: review_comments.parquet
-- config_name: links
-  data_files:
-  - split: train
-    path: links.parquet
-- config_name: events
-  data_files:
-  - split: train
-    path: events.parquet
----
----
-
-# Transformers PR Slop Dataset
-
-Imported checkpoint snapshot for `{repo_slug}`.
-
-Files:
-- `issues.parquet`
-- `pull_requests.parquet`
-- `comments.parquet`
-- `issue_comments.parquet`
-- `pr_comments.parquet`
-- `reviews.parquet`
-- `pr_files.parquet`
-- `pr_diffs.parquet`
-- `review_comments.parquet`
-- `links.parquet`
-- `events.parquet`
-
-Notes:
-- source HF dataset: `{source_repo_id}`
-- source checkpoint root: `{checkpoint_root}`
-- latest imported checkpoint: `{snapshot_id}`
-- links were regenerated locally from text references and timeline events
-"""
+    return build_hf_dataset_card(
+        repo_slug,
+        snapshot_id,
+        notes=[
+            f"source HF dataset: `{source_repo_id}`",
+            f"source checkpoint root: `{checkpoint_root}`",
+            "links were regenerated locally from text references and timeline events",
+        ],
+    )
 
 
 def _snapshot_dir_name(source_repo_id: str, checkpoint_id: str) -> str:

src/slop_farmer/app/pipeline.py

@@ -7,8 +7,8 @@ from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any, Protocol
 
-from slop_farmer.app.publish import publish_snapshot
 from slop_farmer.config import NewContributorReportOptions, PipelineOptions, resolve_github_token
+from slop_farmer.data.dataset_card import build_hf_dataset_card
 from slop_farmer.data.github_api import GitHubClient
 from slop_farmer.data.links import build_pr_duplicate_candidate_rows, build_text_link_rows
 from slop_farmer.data.normalize import (
@@ -112,96 +112,14 @@ def _reference_time_for_age_caps(crawl_started_at: str) -> datetime:
 def _dataset_card(
     repo: str, snapshot_id: str, manifest: dict[str, Any], *, include_new_contributors: bool = False
 ) -> str:
-    new_contributor_config = ""
-    new_contributor_file = ""
-    if include_new_contributors:
-        new_contributor_config = """- config_name: new_contributors
-  data_files:
-  - split: train
-    path: new_contributors.parquet
-"""
-        new_contributor_file = """- `new_contributors.parquet`
-- `new-contributors-report.json`
-- `new-contributors-report.md`
-"""
-    return f"""---
-pretty_name: Transformers PR Slop Dataset
-configs:
-- config_name: issues
-  data_files:
-  - split: train
-    path: issues.parquet
-  default: true
-- config_name: prs
-  data_files:
-  - split: train
-    path: pull_requests.parquet
-- config_name: issue_comments
-  data_files:
-  - split: train
-    path: issue_comments.parquet
-- config_name: pr_comments
-  data_files:
-  - split: train
-    path: pr_comments.parquet
-- config_name: pr_reviews
-  data_files:
-  - split: train
-    path: reviews.parquet
-- config_name: pr_files
-  data_files:
-  - split: train
-    path: pr_files.parquet
-- config_name: pr_diffs
-  data_files:
-  - split: train
-    path: pr_diffs.parquet
-- config_name: review_comments
-  data_files:
-  - split: train
-    path: review_comments.parquet
-- config_name: links
-  data_files:
-  - split: train
-    path: links.parquet
-- config_name: events
-  data_files:
-  - split: train
-    path: events.parquet
-{new_contributor_config}---
----
-
-# Transformers PR Slop Dataset
-
-Normalized snapshots of issues, pull requests, comments, reviews, and linkage data from `{repo}`.
-
-Files:
-- `issues.parquet`
-- `pull_requests.parquet`
-- `comments.parquet`
-- `issue_comments.parquet` (derived view of issue discussion comments)
-- `pr_comments.parquet` (derived view of pull request discussion comments)
-- `reviews.parquet`
-- `pr_files.parquet`
-- `pr_diffs.parquet`
-- `review_comments.parquet`
-- `links.parquet`
-- `events.parquet`
-{new_contributor_file}
-
-Use:
-- duplicate PR and issue analysis
-- triage and ranking experiments
-- eval set creation
-
-Notes:
-- updated daily
-- latest snapshot: `{snapshot_id}`
-- raw data only; no labels or moderation decisions
-- PR metadata, file-level patch hunks, and full unified diffs are included
-- new contributor reviewer artifacts are included when generated for the snapshot
-- full file contents for changed files are not included
-"""
+    notes = ["new contributor reviewer artifacts are included"] if include_new_contributors else []
+    del manifest
+    return build_hf_dataset_card(
+        repo,
+        snapshot_id,
+        include_new_contributors=include_new_contributors,
+        notes=notes,
+    )
 
 
 def _viewer_comment_rows(
@@ -982,9 +900,6 @@ def run_pipeline(options: PipelineOptions, client: GitHubClientLike | None = Non
             "issue_max_age_days": options.issue_max_age_days,
             "pr_max_age_days": options.pr_max_age_days,
             "fetch_timeline": options.fetch_timeline,
-            "publish": options.publish,
-            "hf_repo_id": options.hf_repo_id,
-            "private_hf_repo": options.private_hf_repo,
             "new_contributor_report": options.new_contributor_report,
             "new_contributor_window_days": options.new_contributor_window_days,
             "new_contributor_max_authors": options.new_contributor_max_authors,
@@ -1045,6 +960,9 @@ def run_pipeline(options: PipelineOptions, client: GitHubClientLike | None = Non
                 output_dir=options.output_dir,
                 output=None,
                 json_output=None,
+                hf_repo_id=None,
+                hf_revision=None,
+                hf_materialize_dir=None,
                 window_days=options.new_contributor_window_days,
                 max_authors=options.new_contributor_max_authors,
             )
@@ -1094,12 +1012,5 @@ def run_pipeline(options: PipelineOptions, client: GitHubClientLike | None = Non
     _log(f"Updated watermark state: {_watermark_path(options.output_dir)}")
 
     _clear_checkpoint(options.output_dir, snapshot_dir)
-    if options.publish:
-        if not options.hf_repo_id:
-            raise ValueError("--publish requires --hf-repo-id")
-        publish_snapshot(
-            snapshot_dir, options.hf_repo_id, private=options.private_hf_repo, log=_log
-        )
-
     _log(f"Snapshot complete: {snapshot_dir}")
     return snapshot_dir

src/slop_farmer/app/pr_search.py

@@ -10,9 +10,12 @@ get_pr_search_status = pr_search_service.get_pr_search_status
 get_pr_search_similar = pr_search_service.get_pr_search_similar
 get_pr_search_similar_lookup = pr_search_service.get_pr_search_similar_lookup
 get_pr_search_candidate_clusters = pr_search_service.get_pr_search_candidate_clusters
+get_pr_search_contributor = pr_search_service.get_pr_search_contributor
+get_pr_search_contributor_pulls = pr_search_service.get_pr_search_contributor_pulls
 get_pr_search_clusters = pr_search_service.get_pr_search_clusters
 list_pr_search_clusters = pr_search_service.list_pr_search_clusters
 get_pr_search_cluster = pr_search_service.get_pr_search_cluster
+get_pr_search_pull_contributor = pr_search_service.get_pr_search_pull_contributor
 explain_pr_search_pair = pr_search_service.explain_pr_search_pair
 probe_pr_search_live = pr_search_service.probe_pr_search_live
 probe_pr_search_github = pr_search_service.probe_pr_search_github
@@ -31,6 +34,7 @@ def format_pr_search_status(result: Mapping[str, Any]) -> str:
             (
                 "Rows: "
                 f"documents={counts['documents']} "
+                f"contributors={counts.get('contributors', 0)} "
                 f"features={counts['features']} "
                 f"neighbors={counts['neighbors']} "
                 f"clusters={counts['clusters']} "
@@ -245,3 +249,73 @@ def format_pr_search_probe(result: Mapping[str, Any]) -> str:
             if row.get("reason"):
                 lines.append(f"   reason: {row['reason']}")
     return "\n".join(lines)
+
+
+def format_pr_search_contributor(result: Mapping[str, Any]) -> str:
+    contributor = result["contributor"]
+    lines = [
+        f"Contributor {contributor['author_login']}",
+        f"Repo: {result['repo']}",
+        f"Snapshot: {result['snapshot_id']}",
+        f"Name: {contributor.get('name') or '-'}",
+        f"Profile: {contributor.get('profile_url') or '-'}",
+        f"Association: {contributor.get('repo_association') or '-'}",
+        f"First seen in snapshot: {'yes' if contributor.get('first_seen_in_snapshot') else 'no'}",
+        (
+            "Scores: "
+            f"follow-through={contributor.get('follow_through_score') or '-'} "
+            f"breadth={contributor.get('breadth_score') or '-'} "
+            f"risk={contributor.get('automation_risk_signal') or '-'}"
+        ),
+        f"Heuristic: {contributor.get('heuristic_note') or '-'}",
+        f"Public orgs: {', '.join(contributor.get('public_orgs') or []) or '-'}",
+        "",
+        "Recent indexed PRs:",
+    ]
+    pulls = result.get("pulls") or []
+    if not pulls:
+        lines.append("- none")
+        return "\n".join(lines)
+    for row in pulls:
+        lines.append(
+            f"- PR #{row['pr_number']}: {row.get('title') or ''} "
+            f"[state={row.get('state') or '-'} merged={'yes' if row.get('merged') else 'no'}]"
+        )
+    return "\n".join(lines)
+
+
+def format_pr_search_contributor_pulls(result: Mapping[str, Any]) -> str:
+    contributor = result["contributor"]
+    lines = [
+        f"Contributor PRs: {contributor['author_login']}",
+        f"Repo: {result['repo']}",
+        f"Snapshot: {result['snapshot_id']}",
+        f"Pull requests: {result.get('pull_count', len(result.get('pulls') or []))}",
+        "",
+    ]
+    pulls = result.get("pulls") or []
+    if not pulls:
+        lines.append("No indexed PRs found for that contributor.")
+        return "\n".join(lines)
+    for row in pulls:
+        lines.append(
+            f"- PR #{row['pr_number']}: {row.get('title') or ''} "
+            f"(updated={row.get('updated_at') or '-'}, state={row.get('state') or '-'})"
+        )
+    return "\n".join(lines)
+
+
+def format_pr_search_pull_contributor(result: Mapping[str, Any]) -> str:
+    pr = result["pr"]
+    contributor = result["contributor"]
+    return "\n".join(
+        [
+            f"PR #{pr['pr_number']}: {pr.get('title') or ''}",
+            f"Author: {contributor['author_login']}",
+            f"Risk: {contributor.get('automation_risk_signal') or '-'}",
+            f"Follow-through: {contributor.get('follow_through_score') or '-'}",
+            f"Breadth: {contributor.get('breadth_score') or '-'}",
+            f"Heuristic: {contributor.get('heuristic_note') or '-'}",
+            f"Profile: {contributor.get('profile_url') or '-'}",
+        ]
+    )

src/slop_farmer/app/pr_search_api.py

@@ -12,10 +12,23 @@ from fastapi.responses import JSONResponse
 from slop_farmer.config import PrSearchRefreshOptions
 from slop_farmer.data.ghreplica_api import GhReplicaProbeUnavailableError, GhrProbeClient
 from slop_farmer.data.snapshot_materialize import materialize_hf_dataset_snapshot
-from slop_farmer.data.snapshot_paths import default_hf_materialize_dir
+from slop_farmer.data.snapshot_paths import (
+    CURRENT_ANALYSIS_MANIFEST_PATH,
+    default_hf_materialize_dir,
+)
+from slop_farmer.reports.analysis_service import (
+    get_analysis_best,
+    get_analysis_meta_bug,
+    get_analysis_status,
+    get_pr_analysis,
+    list_analysis_duplicate_prs,
+    list_analysis_meta_bugs,
+)
 from slop_farmer.reports.pr_search_service import (
     get_pr_search_cluster,
     get_pr_search_clusters,
+    get_pr_search_contributor_pulls,
+    get_pr_search_pull_contributor,
     get_pr_search_similar_lookup,
     get_pr_search_status,
     list_pr_search_clusters,
@@ -120,7 +133,7 @@ def create_app(settings: PrSearchApiSettings | None = None) -> FastAPI:
             app.state.startup_error = str(exc)
         yield
 
-    app = FastAPI(title="slop PR search API", version="0.1.0", lifespan=lifespan)
+    app = FastAPI(title="slop PR search API", version="0.1.1", lifespan=lifespan)
 
     @app.exception_handler(ValueError)
     async def handle_value_error(_request: Request, exc: ValueError) -> JSONResponse:
@@ -156,11 +169,13 @@ def create_app(settings: PrSearchApiSettings | None = None) -> FastAPI:
         contributor_snapshot_dir = _surface_snapshot_dir(
             settings, repo_slug, surface="contributors"
         )
-        surface_payload = {
-            "issues": get_snapshot_surfaces(issue_snapshot_dir)["issues"],
-            "contributors": get_snapshot_surfaces(contributor_snapshot_dir)["contributors"],
+        return {
+            **status,
+            "surfaces": {
+                "issues": get_snapshot_surfaces(issue_snapshot_dir)["issues"],
+                "contributors": get_snapshot_surfaces(contributor_snapshot_dir)["contributors"],
+            },
         }
-        return {**status, "surfaces": surface_payload}
 
     @app.get("/v1/repos/{owner}/{repo}/pulls/{number}/similar")
     async def pr_similar(
@@ -238,6 +253,166 @@ def create_app(settings: PrSearchApiSettings | None = None) -> FastAPI:
             ),
         )
 
+    @app.get("/v1/repos/{owner}/{repo}/contributors/{login}/pulls")
+    async def contributor_pulls(
+        owner: str,
+        repo: str,
+        login: str,
+        request: Request,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return get_pr_search_contributor_pulls(
+            settings.index_path,
+            repo=repo_slug,
+            author_login=login,
+            limit=_limit(
+                limit, default=settings.similar_limit_default, maximum=settings.similar_limit_max
+            ),
+        )
+
+    @app.get("/v1/repos/{owner}/{repo}/pulls/{number}/contributor")
+    async def pull_contributor(
+        owner: str,
+        repo: str,
+        number: int,
+        request: Request,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return get_pr_search_pull_contributor(settings.index_path, repo=repo_slug, pr_number=number)
+
+    @app.get("/v1/repos/{owner}/{repo}/analysis/status")
+    async def analysis_status(
+        owner: str,
+        repo: str,
+        request: Request,
+        variant: Literal["auto", "hybrid", "deterministic"] = "auto",
+        snapshot_id: str | None = None,
+        analysis_id: str | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return get_analysis_status(
+            settings.index_path,
+            repo=repo_slug,
+            variant=variant,
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+        )
+
+    @app.get("/v1/repos/{owner}/{repo}/pulls/{number}/analysis")
+    async def pr_analysis(
+        owner: str,
+        repo: str,
+        number: int,
+        request: Request,
+        variant: Literal["auto", "hybrid", "deterministic"] = "auto",
+        snapshot_id: str | None = None,
+        analysis_id: str | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return get_pr_analysis(
+            settings.index_path,
+            repo=repo_slug,
+            pr_number=number,
+            variant=variant,
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+        )
+
+    @app.get("/v1/repos/{owner}/{repo}/analysis/meta-bugs")
+    async def analysis_meta_bugs(
+        owner: str,
+        repo: str,
+        request: Request,
+        limit: int | None = None,
+        variant: Literal["auto", "hybrid", "deterministic"] = "auto",
+        snapshot_id: str | None = None,
+        analysis_id: str | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return list_analysis_meta_bugs(
+            settings.index_path,
+            repo=repo_slug,
+            variant=variant,
+            limit=_limit(
+                limit,
+                default=settings.cluster_list_limit_default,
+                maximum=settings.cluster_list_limit_max,
+            ),
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+        )
+
+    @app.get("/v1/repos/{owner}/{repo}/analysis/meta-bugs/{cluster_id}")
+    async def analysis_meta_bug(
+        owner: str,
+        repo: str,
+        cluster_id: str,
+        request: Request,
+        variant: Literal["auto", "hybrid", "deterministic"] = "auto",
+        snapshot_id: str | None = None,
+        analysis_id: str | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return get_analysis_meta_bug(
+            settings.index_path,
+            repo=repo_slug,
+            cluster_id=cluster_id,
+            variant=variant,
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+        )
+
+    @app.get("/v1/repos/{owner}/{repo}/analysis/duplicate-prs")
+    async def analysis_duplicate_prs(
+        owner: str,
+        repo: str,
+        request: Request,
+        limit: int | None = None,
+        variant: Literal["auto", "hybrid", "deterministic"] = "auto",
+        snapshot_id: str | None = None,
+        analysis_id: str | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return list_analysis_duplicate_prs(
+            settings.index_path,
+            repo=repo_slug,
+            variant=variant,
+            limit=_limit(
+                limit,
+                default=settings.cluster_list_limit_default,
+                maximum=settings.cluster_list_limit_max,
+            ),
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+        )
+
+    @app.get("/v1/repos/{owner}/{repo}/analysis/best")
+    async def analysis_best(
+        owner: str,
+        repo: str,
+        request: Request,
+        variant: Literal["auto", "hybrid", "deterministic"] = "auto",
+        snapshot_id: str | None = None,
+        analysis_id: str | None = None,
+    ) -> dict[str, Any]:
+        settings = request.app.state.settings
+        repo_slug = _repo_slug(settings, owner, repo)
+        return get_analysis_best(
+            settings.index_path,
+            repo=repo_slug,
+            variant=variant,
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+        )
+
     @app.get("/v1/repos/{owner}/{repo}/issues/status")
     async def issue_status(
         owner: str,
@@ -364,7 +539,9 @@ def create_app(settings: PrSearchApiSettings | None = None) -> FastAPI:
     ) -> dict[str, Any]:
         settings = request.app.state.settings
         repo_slug = _repo_slug(settings, owner, repo)
-        return get_contributor_status(_surface_snapshot_dir(settings, repo_slug, surface="contributors"))
+        return get_contributor_status(
+            _surface_snapshot_dir(settings, repo_slug, surface="contributors")
+        )
 
     @app.get("/v1/repos/{owner}/{repo}/contributors")
     async def contributors(
@@ -531,7 +708,9 @@ def _surface_available(snapshot_dir: Path, *, surface: Literal["issues", "contri
     if not snapshot_dir.exists():
         return False
     if surface == "issues":
-        return any(snapshot_dir.glob("analysis-report*.json"))
+        return (snapshot_dir / CURRENT_ANALYSIS_MANIFEST_PATH).exists() or any(
+            snapshot_dir.glob("analysis-report*.json")
+        )
     return (snapshot_dir / "new-contributors-report.json").exists()
 
 
@@ -558,6 +737,10 @@ def _looks_not_found(exc: ValueError) -> bool:
     message = str(exc).lower()
     return (
         "not found" in message
+        or "analysis report was not found" in message
+        or "no analysis report was found" in message
+        or "published analysis" in message
+        or "materialized snapshot" in message
         or "no active pr search run" in message
         or "was not found in the active indexed universe" in message
     )

src/slop_farmer/app/publish_analysis.py

@@ -0,0 +1,366 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Protocol, cast
+
+from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download
+
+from slop_farmer.app.save_cache import _save_analysis_cache_api
+from slop_farmer.config import PublishAnalysisArtifactsOptions
+from slop_farmer.data.parquet_io import read_json
+from slop_farmer.data.snapshot_paths import (
+    ANALYSIS_REPORT_FILENAME_BY_VARIANT,
+    HYBRID_ANALYSIS_REVIEWS_FILENAME,
+    ROOT_MANIFEST_FILENAME,
+    analysis_run_artifact_path,
+    analysis_run_manifest_path,
+    archived_snapshot_manifest_path,
+    build_archived_analysis_run_manifest,
+    build_current_analysis_manifest,
+    current_analysis_artifact_path,
+    resolve_snapshot_dir_from_output,
+)
+
+
+class HubApiLike(Protocol):
+    def create_repo(
+        self,
+        repo_id: str,
+        *,
+        repo_type: str,
+        private: bool,
+        exist_ok: bool,
+    ) -> None: ...
+
+    def create_commit(
+        self,
+        repo_id: str,
+        operations: Iterable[CommitOperationAdd],
+        *,
+        commit_message: str,
+        repo_type: str,
+    ) -> Any: ...
+
+    def upload_folder(
+        self,
+        *,
+        repo_id: str,
+        folder_path: Path,
+        path_in_repo: str,
+        repo_type: str,
+        commit_message: str,
+    ) -> None: ...
+
+
+@dataclass(frozen=True, slots=True)
+class PublishableAnalysisArtifacts:
+    repo: str
+    snapshot_id: str
+    model: str | None
+    report_path: Path
+    reviews_path: Path | None
+    report_payload: dict[str, Any]
+
+
+def run_publish_analysis_artifacts(options: PublishAnalysisArtifactsOptions) -> dict[str, Any]:
+    snapshot_dir = resolve_snapshot_dir_from_output(options.output_dir, options.snapshot_dir)
+    return publish_analysis_artifacts(
+        snapshot_dir=snapshot_dir,
+        analysis_input=options.analysis_input,
+        hf_repo_id=options.hf_repo_id,
+        analysis_id=options.analysis_id,
+        canonical=options.canonical,
+        save_cache=options.save_cache,
+        private=options.private_hf_repo,
+    )
+
+
+def publish_analysis_artifacts(
+    *,
+    snapshot_dir: Path,
+    analysis_input: Path | None,
+    hf_repo_id: str,
+    analysis_id: str,
+    canonical: bool,
+    private: bool,
+    save_cache: bool = False,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    return _publish_analysis_artifacts_api(
+        cast("HubApiLike", HfApi()),
+        snapshot_dir=snapshot_dir,
+        analysis_input=analysis_input,
+        hf_repo_id=hf_repo_id,
+        analysis_id=analysis_id,
+        canonical=canonical,
+        private=private,
+        save_cache=save_cache,
+        log=log,
+    )
+
+
+def _publish_analysis_artifacts_api(
+    api: HubApiLike,
+    *,
+    snapshot_dir: Path,
+    analysis_input: Path | None = None,
+    hf_repo_id: str,
+    analysis_id: str,
+    canonical: bool,
+    private: bool,
+    save_cache: bool = False,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    artifacts = _discover_publishable_analysis(snapshot_dir, analysis_input=analysis_input)
+    published_at = _iso_now()
+    channel = "canonical" if canonical else "comparison"
+    archived_manifest = build_archived_analysis_run_manifest(
+        repo=artifacts.repo,
+        snapshot_id=artifacts.snapshot_id,
+        analysis_id=analysis_id,
+        variant="hybrid",
+        channel=channel,
+        model=artifacts.model,
+        published_at=published_at,
+        include_hybrid_reviews=artifacts.reviews_path is not None,
+    )
+    current_manifest = (
+        build_current_analysis_manifest(
+            repo=artifacts.repo,
+            snapshot_id=artifacts.snapshot_id,
+            analysis_id=analysis_id,
+            variant="hybrid",
+            channel=channel,
+            model=artifacts.model,
+            published_at=published_at,
+            include_hybrid_reviews=artifacts.reviews_path is not None,
+        )
+        if canonical
+        else None
+    )
+    snapshot_manifest = _updated_snapshot_manifest(
+        snapshot_dir=snapshot_dir,
+        hf_repo_id=hf_repo_id,
+        snapshot_id=artifacts.snapshot_id,
+        analysis_id=analysis_id,
+        archived_manifest=archived_manifest,
+        canonical=canonical,
+    )
+    operations = _commit_operations(
+        artifacts=artifacts,
+        analysis_id=analysis_id,
+        archived_manifest=archived_manifest,
+        current_manifest=current_manifest,
+        snapshot_manifest=snapshot_manifest,
+    )
+
+    if log:
+        log(f"Ensuring Hub dataset repo exists: {hf_repo_id}")
+    api.create_repo(hf_repo_id, repo_type="dataset", private=private, exist_ok=True)
+    if log:
+        log(f"Publishing analysis {analysis_id} for snapshot {artifacts.snapshot_id}")
+    api.create_commit(
+        hf_repo_id,
+        operations,
+        commit_message=f"Publish analysis {analysis_id} for snapshot {artifacts.snapshot_id}",
+        repo_type="dataset",
+    )
+    cache_result = (
+        _save_analysis_cache_api(
+            api,
+            snapshot_dir=snapshot_dir,
+            hf_repo_id=hf_repo_id,
+            private=private,
+            log=log,
+        )
+        if save_cache
+        else None
+    )
+    result: dict[str, Any] = {
+        "repo": artifacts.repo,
+        "dataset_id": hf_repo_id,
+        "snapshot_id": artifacts.snapshot_id,
+        "analysis_id": analysis_id,
+        "canonical": canonical,
+        "save_cache": save_cache,
+        "published_at": published_at,
+        "artifact_paths": [operation.path_in_repo for operation in operations],
+    }
+    if cache_result is not None:
+        result["cache"] = cache_result
+    if log:
+        log(f"Published analysis artifacts to {hf_repo_id}")
+    return result
+
+
+def _discover_publishable_analysis(
+    snapshot_dir: Path, *, analysis_input: Path | None
+) -> PublishableAnalysisArtifacts:
+    manifest_path = snapshot_dir / ROOT_MANIFEST_FILENAME
+    if not manifest_path.exists():
+        raise FileNotFoundError(f"Snapshot manifest is missing: {manifest_path}")
+    manifest = read_json(manifest_path)
+    if not isinstance(manifest, dict):
+        raise ValueError(f"Snapshot manifest at {manifest_path} must contain a JSON object.")
+    snapshot_id = str(manifest.get("snapshot_id") or snapshot_dir.name).strip()
+    repo = str(manifest.get("repo") or "").strip()
+    if not repo:
+        raise ValueError(f"Snapshot manifest at {manifest_path} does not define repo.")
+
+    report_path = (
+        analysis_input.resolve()
+        if analysis_input is not None
+        else snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"]
+    )
+    if not report_path.exists():
+        raise FileNotFoundError(f"Hybrid analysis report is missing: {report_path}")
+    report_payload = read_json(report_path)
+    if not isinstance(report_payload, dict):
+        raise ValueError(f"Hybrid analysis report at {report_path} must contain a JSON object.")
+    report_snapshot_id = str(report_payload.get("snapshot_id") or snapshot_id).strip()
+    if report_snapshot_id != snapshot_id:
+        raise ValueError(
+            f"Hybrid analysis report snapshot_id {report_snapshot_id!r} does not match manifest snapshot_id {snapshot_id!r}."
+        )
+    report_repo = str(report_payload.get("repo") or repo).strip()
+    if report_repo != repo:
+        raise ValueError(
+            f"Hybrid analysis report repo {report_repo!r} does not match manifest repo {repo!r}."
+        )
+    model = report_payload.get("model")
+    if model is not None:
+        model = str(model)
+
+    reviews_path = report_path.with_name(f"{report_path.stem}.llm-reviews.json")
+    return PublishableAnalysisArtifacts(
+        repo=repo,
+        snapshot_id=snapshot_id,
+        model=model,
+        report_path=report_path,
+        reviews_path=reviews_path if reviews_path.exists() else None,
+        report_payload={str(key): value for key, value in report_payload.items()},
+    )
+
+
+def _updated_snapshot_manifest(
+    *,
+    snapshot_dir: Path,
+    hf_repo_id: str,
+    snapshot_id: str,
+    analysis_id: str,
+    archived_manifest: dict[str, Any],
+    canonical: bool,
+) -> dict[str, Any]:
+    manifest = _load_remote_snapshot_manifest(hf_repo_id, snapshot_id) or read_json(
+        snapshot_dir / ROOT_MANIFEST_FILENAME
+    )
+    if not isinstance(manifest, dict):
+        raise ValueError("Archived snapshot manifest must contain a JSON object.")
+    updated = {str(key): value for key, value in manifest.items()}
+    published_analysis: dict[str, Any] | Any = updated.get("published_analysis")
+    if not isinstance(published_analysis, dict):
+        published_analysis = {"schema_version": 1, "runs": {}}
+    runs: dict[str, Any] | Any = published_analysis.get("runs")
+    if not isinstance(runs, dict):
+        runs = {}
+    runs[analysis_id] = {
+        "analysis_id": analysis_id,
+        "variant": archived_manifest["variant"],
+        "channel": archived_manifest["channel"],
+        "model": archived_manifest.get("model"),
+        "published_at": archived_manifest["published_at"],
+        "manifest_path": analysis_run_manifest_path(snapshot_id, analysis_id),
+        "artifacts": archived_manifest["artifacts"],
+    }
+    published_analysis["schema_version"] = 1
+    published_analysis["runs"] = runs
+    if canonical:
+        published_analysis["canonical_analysis_id"] = analysis_id
+    updated["published_analysis"] = published_analysis
+    return updated
+
+
+def _load_remote_snapshot_manifest(hf_repo_id: str, snapshot_id: str) -> dict[str, Any] | None:
+    try:
+        downloaded = hf_hub_download(
+            repo_id=hf_repo_id,
+            repo_type="dataset",
+            filename=archived_snapshot_manifest_path(snapshot_id),
+        )
+    except Exception:
+        return None
+    payload = json.loads(Path(downloaded).read_text(encoding="utf-8"))
+    return payload if isinstance(payload, dict) else None
+
+
+def _commit_operations(
+    *,
+    artifacts: PublishableAnalysisArtifacts,
+    analysis_id: str,
+    archived_manifest: dict[str, Any],
+    current_manifest: dict[str, Any] | None,
+    snapshot_manifest: dict[str, Any],
+) -> list[CommitOperationAdd]:
+    report_filename = ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"]
+    operations = [
+        CommitOperationAdd(
+            path_in_repo=analysis_run_artifact_path(
+                artifacts.snapshot_id,
+                analysis_id,
+                report_filename,
+            ),
+            path_or_fileobj=artifacts.report_path,
+        ),
+        CommitOperationAdd(
+            path_in_repo=analysis_run_manifest_path(artifacts.snapshot_id, analysis_id),
+            path_or_fileobj=_json_bytes(archived_manifest),
+        ),
+        CommitOperationAdd(
+            path_in_repo=archived_snapshot_manifest_path(artifacts.snapshot_id),
+            path_or_fileobj=_json_bytes(snapshot_manifest),
+        ),
+    ]
+    if artifacts.reviews_path is not None:
+        operations.append(
+            CommitOperationAdd(
+                path_in_repo=analysis_run_artifact_path(
+                    artifacts.snapshot_id,
+                    analysis_id,
+                    HYBRID_ANALYSIS_REVIEWS_FILENAME,
+                ),
+                path_or_fileobj=artifacts.reviews_path,
+            )
+        )
+    if current_manifest is not None:
+        operations.extend(
+            [
+                CommitOperationAdd(
+                    path_in_repo=current_analysis_artifact_path(report_filename),
+                    path_or_fileobj=artifacts.report_path,
+                ),
+                CommitOperationAdd(
+                    path_in_repo=current_analysis_artifact_path(ROOT_MANIFEST_FILENAME),
+                    path_or_fileobj=_json_bytes(current_manifest),
+                ),
+            ]
+        )
+        if artifacts.reviews_path is not None:
+            operations.append(
+                CommitOperationAdd(
+                    path_in_repo=current_analysis_artifact_path(HYBRID_ANALYSIS_REVIEWS_FILENAME),
+                    path_or_fileobj=artifacts.reviews_path,
+                )
+            )
+    return operations
+
+
+def _json_bytes(payload: dict[str, Any]) -> bytes:
+    return (json.dumps(payload, indent=2, sort_keys=True) + "\n").encode("utf-8")
+
+
+def _iso_now() -> str:
+    return datetime.now(tz=UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")

src/slop_farmer/app/publish_dataset_snapshot.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Protocol, cast
+
+from huggingface_hub import HfApi
+
+
+class HubApiLike(Protocol):
+    def create_repo(
+        self, repo_id: str, *, repo_type: str, private: bool, exist_ok: bool
+    ) -> None: ...
+
+    def upload_folder(
+        self,
+        *,
+        repo_id: str,
+        folder_path: Path,
+        path_in_repo: str,
+        repo_type: str,
+        commit_message: str,
+    ) -> None: ...
+
+
+def publish_dataset_snapshot(
+    snapshot_dir: Path,
+    hf_repo_id: str,
+    *,
+    private: bool,
+    log: Callable[[str], None] | None = None,
+) -> None:
+    _publish_dataset_snapshot_api(
+        cast("HubApiLike", HfApi()),
+        snapshot_dir,
+        hf_repo_id,
+        private,
+        log=log,
+    )
+
+
+def _publish_dataset_snapshot_api(
+    api: HubApiLike,
+    snapshot_dir: Path,
+    hf_repo_id: str,
+    private: bool,
+    log: Callable[[str], None] | None = None,
+) -> None:
+    if log:
+        log(f"Ensuring Hub dataset repo exists: {hf_repo_id}")
+    api.create_repo(hf_repo_id, repo_type="dataset", private=private, exist_ok=True)
+    if log:
+        log(f"Uploading snapshot to Hub: {snapshot_dir}")
+    api.upload_folder(
+        repo_id=hf_repo_id,
+        folder_path=snapshot_dir,
+        path_in_repo=".",
+        repo_type="dataset",
+        commit_message=f"Add snapshot {snapshot_dir.name}",
+    )
+    if log:
+        log(f"Upload finished: {hf_repo_id}")

src/slop_farmer/app/save_cache.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Protocol, cast
+
+from huggingface_hub import HfApi
+
+from slop_farmer.config import SaveCacheOptions
+from slop_farmer.data.parquet_io import read_json
+from slop_farmer.data.snapshot_paths import ROOT_MANIFEST_FILENAME, resolve_snapshot_dir_from_output
+
+ANALYSIS_STATE_DIRNAME = "analysis-state"
+
+
+class HubApiLike(Protocol):
+    def create_repo(
+        self,
+        repo_id: str,
+        *,
+        repo_type: str,
+        private: bool,
+        exist_ok: bool,
+    ) -> None: ...
+
+    def upload_folder(
+        self,
+        *,
+        repo_id: str,
+        folder_path: Path,
+        path_in_repo: str,
+        repo_type: str,
+        commit_message: str,
+    ) -> None: ...
+
+
+def run_save_cache(options: SaveCacheOptions) -> dict[str, Any]:
+    snapshot_dir = resolve_snapshot_dir_from_output(options.output_dir, options.snapshot_dir)
+    return save_analysis_cache(
+        snapshot_dir=snapshot_dir,
+        hf_repo_id=options.hf_repo_id,
+        private=options.private_hf_repo,
+    )
+
+
+def save_analysis_cache(
+    *,
+    snapshot_dir: Path,
+    hf_repo_id: str,
+    private: bool,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    return _save_analysis_cache_api(
+        cast("HubApiLike", HfApi()),
+        snapshot_dir=snapshot_dir,
+        hf_repo_id=hf_repo_id,
+        private=private,
+        log=log,
+    )
+
+
+def _save_analysis_cache_api(
+    api: HubApiLike,
+    *,
+    snapshot_dir: Path,
+    hf_repo_id: str,
+    private: bool,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    cache_dir = snapshot_dir / ANALYSIS_STATE_DIRNAME
+    if not cache_dir.exists():
+        raise FileNotFoundError(f"Analysis cache directory is missing: {cache_dir}")
+    if not cache_dir.is_dir():
+        raise NotADirectoryError(f"Analysis cache path is not a directory: {cache_dir}")
+    artifact_paths = _cache_artifact_paths(cache_dir)
+    if not artifact_paths:
+        raise ValueError(f"Analysis cache directory is empty: {cache_dir}")
+
+    manifest_path = snapshot_dir / ROOT_MANIFEST_FILENAME
+    manifest = read_json(manifest_path) if manifest_path.exists() else {}
+    if not isinstance(manifest, dict):
+        raise ValueError(f"Snapshot manifest at {manifest_path} must contain a JSON object.")
+    snapshot_id = str(manifest.get("snapshot_id") or snapshot_dir.name).strip()
+    repo = str(manifest.get("repo") or "").strip()
+
+    if log:
+        log(f"Ensuring Hub dataset repo exists: {hf_repo_id}")
+    api.create_repo(hf_repo_id, repo_type="dataset", private=private, exist_ok=True)
+    if log:
+        log(f"Saving analysis cache for snapshot {snapshot_id}")
+    api.upload_folder(
+        repo_id=hf_repo_id,
+        folder_path=cache_dir,
+        path_in_repo=ANALYSIS_STATE_DIRNAME,
+        repo_type="dataset",
+        commit_message=f"Save analysis cache for snapshot {snapshot_id}",
+    )
+    result = {
+        "dataset_id": hf_repo_id,
+        "snapshot_id": snapshot_id,
+        "artifact_paths": [f"{ANALYSIS_STATE_DIRNAME}/{path}" for path in artifact_paths],
+    }
+    if repo:
+        result["repo"] = repo
+    if log:
+        log(f"Saved analysis cache to {hf_repo_id}")
+    return result
+
+
+def _cache_artifact_paths(cache_dir: Path) -> list[str]:
+    return sorted(
+        str(path.relative_to(cache_dir).as_posix())
+        for path in cache_dir.rglob("*")
+        if path.is_file()
+    )

src/slop_farmer/app_config.py

@@ -109,7 +109,6 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
     dashboard = payload.get("dashboard")
     analysis = payload.get("analysis")
     scrape = payload.get("scrape")
-    full_pipeline = payload.get("full-pipeline")
     pull_requests = payload.get("pull-requests")
     if dashboard is None:
         dashboard = {}
@@ -117,8 +116,6 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
         analysis = {}
     if scrape is None:
         scrape = {}
-    if full_pipeline is None:
-        full_pipeline = {}
     if pull_requests is None:
         pull_requests = {}
     if not isinstance(dashboard, dict):
@@ -127,8 +124,6 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
         raise ValueError(f"Expected analysis mapping in config file: {config_path}")
     if not isinstance(scrape, dict):
         raise ValueError(f"Expected scrape mapping in config file: {config_path}")
-    if not isinstance(full_pipeline, dict):
-        raise ValueError(f"Expected full-pipeline mapping in config file: {config_path}")
     if not isinstance(pull_requests, dict):
         raise ValueError(f"Expected pull-requests mapping in config file: {config_path}")
 
@@ -184,12 +179,26 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
             "new-contributor-window-days": contributor_window_days,
             "new-contributor-max-authors": contributor_max_authors,
         },
+        "refresh-dataset": {
+            "repo": repo,
+            "hf-repo-id": dataset_id,
+            "fetch-timeline": scrape.get("fetch-timeline"),
+            "max-issues": scrape.get("max-issues"),
+            "max-prs": scrape.get("max-prs"),
+            "max-issue-comments": scrape.get("max-issue-comments"),
+            "max-reviews-per-pr": scrape.get("max-reviews-per-pr"),
+            "max-review-comments-per-pr": scrape.get("max-review-comments-per-pr"),
+            "new-contributor-window-days": contributor_window_days,
+            "new-contributor-max-authors": contributor_max_authors,
+            "cluster-suppression-rules": cluster_suppression_rules,
+        },
         "analyze": {
             "output-dir": str(data_dir) if data_dir else None,
             "hf-repo-id": analysis.get("hf-repo-id", dataset_id),
             "model": analysis.get("model"),
             "ranking-backend": analysis.get("ranking_backend"),
             "max-clusters": analysis.get("max_clusters"),
+            "hybrid-llm-concurrency": analysis.get("hybrid_llm_concurrency"),
             "cached_analysis": analysis.get("cached_analysis"),
             "open-prs-only": analysis.get("open_prs_only"),
             "pr-template-cleanup-mode": pr_template_cleanup_mode,
@@ -201,6 +210,7 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
         },
         "pr-scope": {
             "output-dir": str(data_dir) if data_dir else None,
+            "hf-repo-id": dataset_id,
             "cluster-suppression-rules": cluster_suppression_rules,
         },
         "pr-search": {
@@ -210,32 +220,28 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
         },
         "new-contributor-report": {
             "output-dir": str(data_dir) if data_dir else None,
+            "hf-repo-id": dataset_id,
             "window-days": contributor_window_days,
             "max-authors": contributor_max_authors,
         },
         "dashboard-data": {
             "output-dir": str(dashboard_dir) if dashboard_dir else None,
             "snapshot-root": str(data_dir / "snapshots") if data_dir else None,
+            "hf-repo-id": dataset_id,
             "window-days": dashboard_window_days,
         },
-        "publish-snapshot": {
+        "publish-analysis-artifacts": {
             "output-dir": str(data_dir) if data_dir else None,
             "hf-repo-id": dataset_id,
         },
-        "full-pipeline": {
-            "repo": repo,
-            "dataset": dataset_id,
-            "workspace-root": str(workspace_path.parent) if workspace_path else None,
-            "model": analysis.get("model"),
-            "ranking-backend": analysis.get("ranking_backend"),
-            "max-clusters": analysis.get("max_clusters"),
-            "dashboard-window-days": dashboard_window_days,
-            "new-contributor-window-days": contributor_window_days,
-            "new-contributor-max-authors": contributor_max_authors,
+        "save-cache": {
+            "output-dir": str(data_dir) if data_dir else None,
+            "hf-repo-id": dataset_id,
         },
         "deploy-dashboard": {
             "pipeline-data-dir": str(data_dir) if data_dir else None,
             "web-dir": str(web_dir) if web_dir else None,
+            "hf-repo-id": dataset_id,
             "dashboard-window-days": dashboard_window_days,
             "contributor-window-days": contributor_window_days,
             "contributor-max-authors": contributor_max_authors,
@@ -248,6 +254,11 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
             "dataset-id": dataset_id,
             "space-tags": tags_value,
         },
+        "dataset-status": {
+            "repo": repo,
+            "output-dir": str(data_dir) if data_dir else None,
+            "hf-repo-id": dataset_id,
+        },
     }
     for command, values in defaults.items():
         defaults[command] = {key: value for key, value in values.items() if value is not None}
@@ -259,8 +270,8 @@ def _dashboard_config_defaults(config_path: Path) -> dict[str, dict[str, Any]]:
         defaults[command].update(_resolve_command_paths(config_path, values))
 
     defaults["scrape"].update(_resolve_command_paths(config_path, scrape))
+    defaults["refresh-dataset"].update(_resolve_command_paths(config_path, scrape))
     defaults["analyze"].update(_resolve_command_paths(config_path, analysis))
-    defaults["full-pipeline"].update(_resolve_command_paths(config_path, full_pipeline))
     return defaults
 
 

src/slop_farmer/config.py

@@ -81,9 +81,6 @@ class PipelineOptions:
     max_reviews_per_pr: int | None
     max_review_comments_per_pr: int | None
     fetch_timeline: bool
-    publish: bool
-    hf_repo_id: str | None
-    private_hf_repo: bool
     new_contributor_report: bool
     new_contributor_window_days: int
     new_contributor_max_authors: int
@@ -102,6 +99,7 @@ class AnalysisOptions:
     ranking_backend: str
     model: str
     max_clusters: int
+    hybrid_llm_concurrency: int = 1
     open_prs_only: bool = False
     cached_analysis: bool = False
     pr_template_cleanup_mode: str = "merge_defaults"
@@ -111,6 +109,10 @@ class AnalysisOptions:
     pr_template_line_patterns: tuple[str, ...] = ()
     cluster_suppression_rules: tuple[dict[str, Any], ...] = ()
 
+    def __post_init__(self) -> None:
+        if self.hybrid_llm_concurrency < 1:
+            raise ValueError("hybrid_llm_concurrency must be >= 1")
+
 
 @dataclass(slots=True)
 class MarkdownReportOptions:
@@ -127,6 +129,9 @@ class NewContributorReportOptions:
     json_output: Path | None
     window_days: int
     max_authors: int
+    hf_repo_id: str | None = None
+    hf_revision: str | None = None
+    hf_materialize_dir: Path | None = None
 
 
 @dataclass(slots=True)
@@ -137,17 +142,12 @@ class DashboardDataOptions:
     contributors_input: Path | None
     pr_scope_input: Path | None
     window_days: int
+    hf_repo_id: str | None = None
+    hf_revision: str | None = None
+    hf_materialize_dir: Path | None = None
     snapshot_root: Path | None = None
 
 
-@dataclass(slots=True)
-class PublishSnapshotOptions:
-    output_dir: Path
-    snapshot_dir: Path | None
-    hf_repo_id: str
-    private_hf_repo: bool
-
-
 @dataclass(slots=True)
 class DeployDashboardOptions:
     pipeline_data_dir: Path
@@ -155,6 +155,10 @@ class DeployDashboardOptions:
     snapshot_dir: Path | None
     analysis_input: Path | None
     contributors_input: Path | None
+    pr_scope_input: Path | None
+    hf_repo_id: str | None
+    hf_revision: str | None
+    hf_materialize_dir: Path | None
     refresh_contributors: bool
     dashboard_window_days: int
     contributor_window_days: int
@@ -216,20 +220,50 @@ class SnapshotAdoptOptions:
 
 
 @dataclass(slots=True)
-class FullPipelineOptions:
+class DatasetRefreshOptions:
     repo: RepoRef
-    dataset: str
-    model: str
-    workspace_root: Path
+    hf_repo_id: str
     private_hf_repo: bool
-    ranking_backend: str
-    max_clusters: int
+    max_issues: int | None
+    max_prs: int | None
+    max_issue_comments: int | None
+    max_reviews_per_pr: int | None
+    max_review_comments_per_pr: int | None
     fetch_timeline: bool
-    dashboard_window_days: int
+    new_contributor_report: bool
     new_contributor_window_days: int
     new_contributor_max_authors: int
-    issue_max_age_days: int | None
-    pr_max_age_days: int | None
-    max_issues: int | None
-    max_prs: int | None
-    open_prs_only: bool = False
+    http_timeout: int
+    http_max_retries: int
+    checkpoint_every_comments: int
+    checkpoint_every_prs: int
+    cluster_suppression_rules: tuple[dict[str, Any], ...] = ()
+
+
+@dataclass(slots=True)
+class PublishAnalysisArtifactsOptions:
+    output_dir: Path
+    snapshot_dir: Path | None
+    analysis_input: Path | None
+    hf_repo_id: str
+    analysis_id: str
+    canonical: bool = False
+    save_cache: bool = False
+    private_hf_repo: bool = False
+
+
+@dataclass(slots=True)
+class SaveCacheOptions:
+    output_dir: Path
+    snapshot_dir: Path | None
+    hf_repo_id: str
+    private_hf_repo: bool = False
+
+
+@dataclass(slots=True)
+class DatasetStatusOptions:
+    output_dir: Path
+    hf_repo_id: str | None
+    hf_revision: str | None
+    repo: str | None = None
+    json_output: bool = False

src/slop_farmer/data/search_duckdb.py

@@ -31,6 +31,7 @@ TABLE_COLUMNS: dict[str, tuple[str, ...]] = {
         "repo",
         "pr_number",
         "github_id",
+        "author_login",
         "state",
         "draft",
         "merged",
@@ -46,6 +47,48 @@ TABLE_COLUMNS: dict[str, tuple[str, ...]] = {
         "review_comments_count",
         "html_url",
     ),
+    "pr_search_contributors": (
+        "run_id",
+        "repo",
+        "snapshot_id",
+        "report_generated_at",
+        "window_days",
+        "author_login",
+        "name",
+        "profile_url",
+        "repo_pull_requests_url",
+        "repo_issues_url",
+        "repo_first_seen_at",
+        "repo_last_seen_at",
+        "repo_primary_artifact_count",
+        "repo_artifact_count",
+        "snapshot_issue_count",
+        "snapshot_pr_count",
+        "snapshot_comment_count",
+        "snapshot_review_count",
+        "snapshot_review_comment_count",
+        "repo_association",
+        "new_to_repo",
+        "first_seen_in_snapshot",
+        "report_reason",
+        "account_age_days",
+        "young_account",
+        "follow_through_score",
+        "breadth_score",
+        "automation_risk_signal",
+        "heuristic_note",
+        "public_orgs_json",
+        "visible_authored_pr_count",
+        "merged_pr_count",
+        "closed_unmerged_pr_count",
+        "open_pr_count",
+        "merged_pr_rate",
+        "closed_unmerged_pr_rate",
+        "still_open_pr_rate",
+        "distinct_repos_with_authored_prs",
+        "distinct_repos_with_open_prs",
+        "fetch_error",
+    ),
     "pr_scope_features": (
         "run_id",
         "repo",
@@ -144,6 +187,7 @@ CREATE TABLE IF NOT EXISTS pr_search_documents (
     repo VARCHAR,
     pr_number BIGINT,
     github_id BIGINT,
+    author_login VARCHAR,
     state VARCHAR,
     draft BOOLEAN,
     merged BOOLEAN,
@@ -159,6 +203,48 @@ CREATE TABLE IF NOT EXISTS pr_search_documents (
     review_comments_count BIGINT,
     html_url VARCHAR
 );
+CREATE TABLE IF NOT EXISTS pr_search_contributors (
+    run_id VARCHAR,
+    repo VARCHAR,
+    snapshot_id VARCHAR,
+    report_generated_at VARCHAR,
+    window_days BIGINT,
+    author_login VARCHAR,
+    name VARCHAR,
+    profile_url VARCHAR,
+    repo_pull_requests_url VARCHAR,
+    repo_issues_url VARCHAR,
+    repo_first_seen_at VARCHAR,
+    repo_last_seen_at VARCHAR,
+    repo_primary_artifact_count BIGINT,
+    repo_artifact_count BIGINT,
+    snapshot_issue_count BIGINT,
+    snapshot_pr_count BIGINT,
+    snapshot_comment_count BIGINT,
+    snapshot_review_count BIGINT,
+    snapshot_review_comment_count BIGINT,
+    repo_association VARCHAR,
+    new_to_repo BOOLEAN,
+    first_seen_in_snapshot BOOLEAN,
+    report_reason VARCHAR,
+    account_age_days BIGINT,
+    young_account BOOLEAN,
+    follow_through_score VARCHAR,
+    breadth_score VARCHAR,
+    automation_risk_signal VARCHAR,
+    heuristic_note VARCHAR,
+    public_orgs_json VARCHAR,
+    visible_authored_pr_count BIGINT,
+    merged_pr_count BIGINT,
+    closed_unmerged_pr_count BIGINT,
+    open_pr_count BIGINT,
+    merged_pr_rate DOUBLE,
+    closed_unmerged_pr_rate DOUBLE,
+    still_open_pr_rate DOUBLE,
+    distinct_repos_with_authored_prs BIGINT,
+    distinct_repos_with_open_prs BIGINT,
+    fetch_error VARCHAR
+);
 CREATE TABLE IF NOT EXISTS pr_scope_features (
     run_id VARCHAR,
     repo VARCHAR,
@@ -232,6 +318,8 @@ CREATE TABLE IF NOT EXISTS pr_scope_cluster_candidates (
 CREATE INDEX IF NOT EXISTS idx_pr_search_active_run_repo ON pr_search_active_run (repo);
 CREATE INDEX IF NOT EXISTS idx_pr_search_runs_repo_status ON pr_search_runs (repo, status);
 CREATE INDEX IF NOT EXISTS idx_pr_search_documents_run_pr ON pr_search_documents (run_id, pr_number);
+CREATE INDEX IF NOT EXISTS idx_pr_search_documents_run_author ON pr_search_documents (run_id, author_login);
+CREATE INDEX IF NOT EXISTS idx_pr_search_contributors_run_author ON pr_search_contributors (run_id, author_login);
 CREATE INDEX IF NOT EXISTS idx_pr_scope_features_run_pr ON pr_scope_features (run_id, pr_number);
 CREATE INDEX IF NOT EXISTS idx_pr_scope_run_artifacts_run ON pr_scope_run_artifacts (run_id);
 CREATE INDEX IF NOT EXISTS idx_pr_scope_neighbors_run_left ON pr_scope_neighbors (run_id, left_pr_number);
@@ -256,6 +344,9 @@ def connect_pr_search_db(path: Path, *, read_only: bool = False) -> duckdb.DuckD
 
 def ensure_pr_search_schema(connection: duckdb.DuckDBPyConnection) -> None:
     connection.execute(SCHEMA_SQL)
+    connection.execute(
+        "ALTER TABLE pr_search_documents ADD COLUMN IF NOT EXISTS author_login VARCHAR"
+    )
 
 
 def insert_rows(
@@ -353,6 +444,7 @@ def resolve_active_run(
 def get_run_counts(connection: duckdb.DuckDBPyConnection, *, run_id: str) -> dict[str, int]:
     return {
         "documents": _count(connection, "pr_search_documents", run_id),
+        "contributors": _count(connection, "pr_search_contributors", run_id),
         "features": _count(connection, "pr_scope_features", run_id),
         "run_artifacts": _count(connection, "pr_scope_run_artifacts", run_id),
         "neighbors": _count(connection, "pr_scope_neighbors", run_id),
@@ -375,6 +467,60 @@ def get_document(
     )
 
 
+def get_contributor(
+    connection: duckdb.DuckDBPyConnection,
+    *,
+    run_id: str,
+    author_login: str,
+) -> dict[str, Any] | None:
+    return fetch_one(
+        connection,
+        """
+        SELECT *
+        FROM pr_search_contributors
+        WHERE run_id = ? AND lower(author_login) = lower(?)
+        """,
+        [run_id, author_login],
+    )
+
+
+def get_contributor_pulls(
+    connection: duckdb.DuckDBPyConnection,
+    *,
+    run_id: str,
+    author_login: str,
+    limit: int,
+) -> list[dict[str, Any]]:
+    return fetch_rows(
+        connection,
+        """
+        SELECT
+            pr_number,
+            github_id,
+            author_login,
+            state,
+            draft,
+            merged,
+            title,
+            base_ref,
+            created_at,
+            updated_at,
+            merged_at,
+            additions,
+            deletions,
+            changed_files,
+            comments_count,
+            review_comments_count,
+            html_url
+        FROM pr_search_documents
+        WHERE run_id = ? AND lower(author_login) = lower(?)
+        ORDER BY updated_at DESC NULLS LAST, pr_number DESC
+        LIMIT ?
+        """,
+        [run_id, author_login, limit],
+    )
+
+
 def get_feature(
     connection: duckdb.DuckDBPyConnection,
     *,

src/slop_farmer/data/snapshot_materialize.py

@@ -5,13 +5,27 @@ import shutil
 import urllib.parse
 import urllib.request
 from datetime import UTC, datetime
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 from huggingface_hub import HfApi, hf_hub_download
 
 from slop_farmer.data.http import urlopen_with_retry
 from slop_farmer.data.parquet_io import read_json, write_text
+from slop_farmer.data.snapshot_paths import (
+    CONTRIBUTOR_ARTIFACT_FILENAMES,
+    CURRENT_ANALYSIS_MANIFEST_PATH,
+    LEGACY_ANALYSIS_FILENAMES,
+    PR_SCOPE_CLUSTERS_FILENAME,
+    RAW_TABLE_FILENAMES,
+    README_FILENAME,
+    ROOT_MANIFEST_FILENAME,
+    SNAPSHOTS_LATEST_PATH,
+    STATE_WATERMARK_PATH,
+    load_archived_analysis_run_manifest,
+    load_current_analysis_manifest,
+    repo_relative_path_to_local,
+)
 
 
 def materialize_hf_dataset_snapshot(
@@ -22,11 +36,13 @@ def materialize_hf_dataset_snapshot(
 ) -> Path:
     info = _hf_dataset_info(repo_id=repo_id, revision=revision, files_metadata=True)
     remote_paths = {sibling.rfilename for sibling in info.siblings}
-    if "snapshots/latest.json" in remote_paths:
+    resolved_revision = str(info.sha or revision or "main")
+    if SNAPSHOTS_LATEST_PATH in remote_paths:
         return _materialize_hf_snapshot_repo_snapshot(
             repo_id=repo_id,
             local_dir=local_dir,
-            revision=revision,
+            revision=resolved_revision,
+            requested_revision=revision,
             hf_sha=info.sha,
             remote_paths=remote_paths,
         )
@@ -34,14 +50,16 @@ def materialize_hf_dataset_snapshot(
         return _materialize_hf_root_snapshot(
             repo_id=repo_id,
             local_dir=local_dir,
-            revision=revision,
+            revision=resolved_revision,
+            requested_revision=revision,
             hf_sha=info.sha,
             remote_paths=remote_paths,
         )
     return _materialize_hf_dataset_viewer_snapshot(
         repo_id=repo_id,
         local_dir=local_dir,
-        revision=revision,
+        revision=resolved_revision,
+        requested_revision=revision,
         hf_sha=info.sha,
     )
 
@@ -50,84 +68,101 @@ def _materialize_hf_snapshot_repo_snapshot(
     *,
     repo_id: str,
     local_dir: Path,
-    revision: str | None,
+    revision: str,
+    requested_revision: str | None,
     hf_sha: str | None,
     remote_paths: set[str],
 ) -> Path:
     local_dir.mkdir(parents=True, exist_ok=True)
-    latest_path = hf_hub_download(
-        repo_id=repo_id,
-        repo_type="dataset",
-        filename="snapshots/latest.json",
-        revision=revision,
+    latest_download = Path(
+        hf_hub_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            filename=SNAPSHOTS_LATEST_PATH,
+            revision=revision,
+        )
     )
-    latest_payload = json.loads(Path(latest_path).read_text(encoding="utf-8"))
+    latest_payload = json.loads(latest_download.read_text(encoding="utf-8"))
     downloaded_files: set[str] = set()
+    _copy_downloaded_file(
+        latest_download, repo_relative_path_to_local(local_dir, SNAPSHOTS_LATEST_PATH)
+    )
+    downloaded_files.add(SNAPSHOTS_LATEST_PATH)
+
     for filename in (
-        "issues.parquet",
-        "pull_requests.parquet",
-        "comments.parquet",
-        "reviews.parquet",
-        "review_comments.parquet",
-        "pr_files.parquet",
-        "pr_diffs.parquet",
-        "links.parquet",
-        "events.parquet",
-        "manifest.json",
-        "analysis-report.json",
-        "analysis-report-hybrid.json",
-        "analysis-report-deterministic.json",
-        "new_contributors.parquet",
-        "new-contributors-report.json",
-        "new-contributors-report.md",
+        *RAW_TABLE_FILENAMES,
+        ROOT_MANIFEST_FILENAME,
+        PR_SCOPE_CLUSTERS_FILENAME,
+        *CONTRIBUTOR_ARTIFACT_FILENAMES,
+        *LEGACY_ANALYSIS_FILENAMES,
     ):
-        downloaded_path = _download_first_available_hf_file(
+        downloaded = _download_first_available_hf_file(
             repo_id=repo_id,
             revision=revision,
             filenames=_hf_latest_snapshot_candidates(latest_payload, filename),
         )
-        if downloaded_path is None:
+        if downloaded is None:
             continue
-        shutil.copy2(downloaded_path, local_dir / filename)
+        _copy_downloaded_file(downloaded, local_dir / filename)
         downloaded_files.add(filename)
-    downloaded_files.update(
-        _download_hf_analysis_state_files(
+
+    if STATE_WATERMARK_PATH in remote_paths:
+        _download_repo_file(
             repo_id=repo_id,
             revision=revision,
             local_dir=local_dir,
-            path_pairs=_hf_analysis_state_path_pairs(
-                remote_paths,
-                prefixes=_hf_latest_snapshot_prefixes(latest_payload),
-            ),
+            repo_path=STATE_WATERMARK_PATH,
+            downloaded_files=downloaded_files,
         )
+
+    _download_analysis_state_files(
+        repo_id=repo_id,
+        revision=revision,
+        local_dir=local_dir,
+        remote_paths=remote_paths,
+        downloaded_files=downloaded_files,
     )
 
-    readme_path = hf_hub_download(
+    _download_published_analysis_files(
         repo_id=repo_id,
-        repo_type="dataset",
-        filename="README.md",
-        revision=revision or "main",
+        revision=revision,
+        local_dir=local_dir,
+        remote_paths=remote_paths,
+        downloaded_files=downloaded_files,
     )
-    shutil.copy2(readme_path, local_dir / "README.md")
+
+    _download_repo_file(
+        repo_id=repo_id,
+        revision=revision,
+        local_dir=local_dir,
+        repo_path=README_FILENAME,
+        downloaded_files=downloaded_files,
+        required=False,
+    )
+
     manifest = (
-        read_json(local_dir / "manifest.json") if (local_dir / "manifest.json").exists() else {}
+        read_json(local_dir / ROOT_MANIFEST_FILENAME)
+        if (local_dir / ROOT_MANIFEST_FILENAME).exists()
+        else {}
     )
     manifest.setdefault("repo", _infer_repo_from_materialized_snapshot(local_dir))
     manifest.setdefault(
-        "snapshot_id", str(latest_payload.get("latest_snapshot_id") or hf_sha or local_dir.name)
+        "snapshot_id",
+        str(latest_payload.get("latest_snapshot_id") or hf_sha or local_dir.name),
     )
     manifest.update(
         {
             "source_type": "hf_snapshot_repo",
             "hf_repo_id": repo_id,
-            "hf_revision": revision,
+            "hf_revision": requested_revision,
+            "hf_resolved_revision": revision,
             "hf_sha": hf_sha,
             "materialized_at": _iso_now(),
             "downloaded_files": sorted(downloaded_files),
             "hf_latest_pointer": latest_payload,
         }
     )
-    write_text(json.dumps(manifest, indent=2) + "\n", local_dir / "manifest.json")
+    write_text(json.dumps(manifest, indent=2) + "\n", local_dir / ROOT_MANIFEST_FILENAME)
     return local_dir
 
 
@@ -135,60 +170,53 @@ def _materialize_hf_root_snapshot(
     *,
     repo_id: str,
     local_dir: Path,
-    revision: str | None,
+    revision: str,
+    requested_revision: str | None,
     hf_sha: str | None,
     remote_paths: set[str],
 ) -> Path:
     local_dir.mkdir(parents=True, exist_ok=True)
     downloaded_files: set[str] = set()
-    for filename in (
-        "issues.parquet",
-        "pull_requests.parquet",
-        "comments.parquet",
-        "reviews.parquet",
-        "review_comments.parquet",
-        "pr_files.parquet",
-        "pr_diffs.parquet",
-        "links.parquet",
-        "events.parquet",
-        "manifest.json",
-        "analysis-report.json",
-        "analysis-report-hybrid.json",
-        "analysis-report-deterministic.json",
-        "new_contributors.parquet",
-        "new-contributors-report.json",
-        "new-contributors-report.md",
+    for repo_path in (
+        *RAW_TABLE_FILENAMES,
+        ROOT_MANIFEST_FILENAME,
+        PR_SCOPE_CLUSTERS_FILENAME,
+        *CONTRIBUTOR_ARTIFACT_FILENAMES,
+        *LEGACY_ANALYSIS_FILENAMES,
+        SNAPSHOTS_LATEST_PATH,
+        STATE_WATERMARK_PATH,
+        README_FILENAME,
     ):
-        if filename not in remote_paths:
+        if repo_path not in remote_paths:
             continue
-        downloaded_path = hf_hub_download(
-            repo_id=repo_id,
-            repo_type="dataset",
-            filename=filename,
-            revision=revision,
-        )
-        shutil.copy2(downloaded_path, local_dir / filename)
-        downloaded_files.add(filename)
-    downloaded_files.update(
-        _download_hf_analysis_state_files(
+        _download_repo_file(
             repo_id=repo_id,
             revision=revision,
             local_dir=local_dir,
-            path_pairs=_hf_analysis_state_path_pairs(remote_paths, prefixes=[""]),
+            repo_path=repo_path,
+            downloaded_files=downloaded_files,
         )
+
+    _download_analysis_state_files(
+        repo_id=repo_id,
+        revision=revision,
+        local_dir=local_dir,
+        remote_paths=remote_paths,
+        downloaded_files=downloaded_files,
     )
 
-    if "README.md" in remote_paths:
-        readme_path = hf_hub_download(
-            repo_id=repo_id,
-            repo_type="dataset",
-            filename="README.md",
-            revision=revision or "main",
-        )
-        shutil.copy2(readme_path, local_dir / "README.md")
+    _download_published_analysis_files(
+        repo_id=repo_id,
+        revision=revision,
+        local_dir=local_dir,
+        remote_paths=remote_paths,
+        downloaded_files=downloaded_files,
+    )
 
     manifest = (
-        read_json(local_dir / "manifest.json") if (local_dir / "manifest.json").exists() else {}
+        read_json(local_dir / ROOT_MANIFEST_FILENAME)
+        if (local_dir / ROOT_MANIFEST_FILENAME).exists()
+        else {}
     )
     manifest.setdefault("repo", _infer_repo_from_materialized_snapshot(local_dir))
     manifest.setdefault("snapshot_id", hf_sha or local_dir.name)
@@ -196,13 +224,14 @@ def _materialize_hf_root_snapshot(
         {
             "source_type": "hf_root_snapshot",
             "hf_repo_id": repo_id,
-            "hf_revision": revision,
+            "hf_revision": requested_revision,
+            "hf_resolved_revision": revision,
             "hf_sha": hf_sha,
             "materialized_at": _iso_now(),
             "downloaded_files": sorted(downloaded_files),
         }
     )
-    write_text(json.dumps(manifest, indent=2) + "\n", local_dir / "manifest.json")
+    write_text(json.dumps(manifest, indent=2) + "\n", local_dir / ROOT_MANIFEST_FILENAME)
     return local_dir
 
 
@@ -210,7 +239,8 @@ def _materialize_hf_dataset_viewer_snapshot(
     *,
     repo_id: str,
     local_dir: Path,
-    revision: str | None,
+    revision: str,
+    requested_revision: str | None,
     hf_sha: str | None,
 ) -> Path:
     local_dir.mkdir(parents=True, exist_ok=True)
@@ -225,24 +255,165 @@ def _materialize_hf_dataset_viewer_snapshot(
     readme_path = hf_hub_download(
         repo_id=repo_id,
         repo_type="dataset",
-        filename="README.md",
-        revision=revision or "main",
+        filename=README_FILENAME,
+        revision=revision,
     )
-    shutil.copy2(readme_path, local_dir / "README.md")
+    shutil.copy2(readme_path, local_dir / README_FILENAME)
+    downloaded_files.add(README_FILENAME)
     manifest = {
         "repo": _infer_repo_from_materialized_snapshot(local_dir),
         "snapshot_id": hf_sha or local_dir.name,
         "source_type": "hf_dataset_viewer",
         "hf_repo_id": repo_id,
-        "hf_revision": revision,
+        "hf_revision": requested_revision,
+        "hf_resolved_revision": revision,
         "hf_sha": hf_sha,
         "materialized_at": _iso_now(),
         "downloaded_files": sorted(downloaded_files),
     }
-    write_text(json.dumps(manifest, indent=2) + "\n", local_dir / "manifest.json")
+    write_text(json.dumps(manifest, indent=2) + "\n", local_dir / ROOT_MANIFEST_FILENAME)
     return local_dir
 
 
+def _download_published_analysis_files(
+    *,
+    repo_id: str,
+    revision: str,
+    local_dir: Path,
+    remote_paths: set[str],
+    downloaded_files: set[str],
+) -> None:
+    if CURRENT_ANALYSIS_MANIFEST_PATH in remote_paths:
+        manifest_path = _download_repo_file(
+            repo_id=repo_id,
+            revision=revision,
+            local_dir=local_dir,
+            repo_path=CURRENT_ANALYSIS_MANIFEST_PATH,
+            downloaded_files=downloaded_files,
+        )
+        current_manifest = load_current_analysis_manifest(manifest_path)
+        for repo_path in _manifest_artifact_paths(current_manifest, include_archived=True):
+            if repo_path not in remote_paths:
+                continue
+            _download_repo_file(
+                repo_id=repo_id,
+                revision=revision,
+                local_dir=local_dir,
+                repo_path=repo_path,
+                downloaded_files=downloaded_files,
+            )
+
+    for repo_path in sorted(
+        path for path in remote_paths if _is_archived_analysis_manifest_path(path)
+    ):
+        manifest_path = _download_repo_file(
+            repo_id=repo_id,
+            revision=revision,
+            local_dir=local_dir,
+            repo_path=repo_path,
+            downloaded_files=downloaded_files,
+        )
+        archived_manifest = load_archived_analysis_run_manifest(manifest_path)
+        for artifact_path in _manifest_artifact_paths(archived_manifest, include_archived=False):
+            if artifact_path not in remote_paths:
+                continue
+            _download_repo_file(
+                repo_id=repo_id,
+                revision=revision,
+                local_dir=local_dir,
+                repo_path=artifact_path,
+                downloaded_files=downloaded_files,
+            )
+
+
+def _download_analysis_state_files(
+    *,
+    repo_id: str,
+    revision: str,
+    local_dir: Path,
+    remote_paths: set[str],
+    downloaded_files: set[str],
+) -> None:
+    for repo_path in sorted(
+        path for path in remote_paths if PurePosixPath(path).parts[:1] == ("analysis-state",)
+    ):
+        _download_repo_file(
+            repo_id=repo_id,
+            revision=revision,
+            local_dir=local_dir,
+            repo_path=repo_path,
+            downloaded_files=downloaded_files,
+        )
+
+
+def _manifest_artifact_paths(
+    payload: dict[str, Any],
+    *,
+    include_archived: bool,
+) -> list[str]:
+    paths = [
+        str(value) for value in (payload.get("artifacts") or {}).values() if isinstance(value, str)
+    ]
+    if include_archived:
+        paths.extend(
+            str(value)
+            for value in (payload.get("archived_artifacts") or {}).values()
+            if isinstance(value, str)
+        )
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for repo_path in paths:
+        normalized = repo_path.lstrip("./")
+        if not normalized or normalized in seen:
+            continue
+        seen.add(normalized)
+        deduped.append(normalized)
+    return deduped
+
+
+def _is_archived_analysis_manifest_path(repo_path: str) -> bool:
+    parts = PurePosixPath(repo_path).parts
+    return (
+        len(parts) == 5
+        and parts[0] == "snapshots"
+        and parts[2] == "analysis-runs"
+        and parts[4] == ROOT_MANIFEST_FILENAME
+    )
+
+
+def _download_repo_file(
+    *,
+    repo_id: str,
+    revision: str,
+    local_dir: Path,
+    repo_path: str,
+    downloaded_files: set[str],
+    required: bool = True,
+) -> Path:
+    try:
+        downloaded = Path(
+            hf_hub_download(
+                repo_id=repo_id,
+                repo_type="dataset",
+                filename=repo_path,
+                revision=revision,
+            )
+        )
+    except Exception:
+        if required:
+            raise
+        return local_dir / repo_path
+    destination = repo_relative_path_to_local(local_dir, repo_path)
+    _copy_downloaded_file(downloaded, destination)
+    downloaded_files.add(repo_path)
+    return destination
+
+
+def _copy_downloaded_file(downloaded_path: Path, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(downloaded_path, destination)
+
+
 def _hf_dataset_info(repo_id: str, revision: str | None, *, files_metadata: bool) -> Any:
     api = HfApi()
     try:
@@ -270,7 +441,7 @@ def _hf_dataset_parquet_urls(repo_id: str, revision: str | None = None) -> list[
 def _download_first_available_hf_file(
     *,
     repo_id: str,
-    revision: str | None,
+    revision: str,
     filenames: list[str],
 ) -> Path | None:
     for filename in filenames:
@@ -290,65 +461,24 @@ def _download_first_available_hf_file(
     return None
 
 
-def _download_hf_analysis_state_files(
-    *,
-    repo_id: str,
-    revision: str | None,
-    local_dir: Path,
-    path_pairs: list[tuple[str, str]],
-) -> set[str]:
-    downloaded_files: set[str] = set()
-    for remote_path, relative_path in path_pairs:
-        downloaded_path = Path(
-            hf_hub_download(
-                repo_id=repo_id,
-                repo_type="dataset",
-                filename=remote_path,
-                revision=revision,
-            )
-        )
-        destination = local_dir / "analysis-state" / relative_path
-        destination.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(downloaded_path, destination)
-        downloaded_files.add(str(Path("analysis-state") / relative_path))
-    return downloaded_files
-
-
-def _hf_analysis_state_path_pairs(
-    remote_paths: set[str],
-    *,
-    prefixes: list[str],
-) -> list[tuple[str, str]]:
-    pairs: list[tuple[str, str]] = []
-    seen_relative_paths: set[str] = set()
-    for prefix in prefixes:
-        base = f"{prefix.strip('/')}/analysis-state/" if prefix else "analysis-state/"
-        for remote_path in sorted(remote_paths):
-            if not remote_path.startswith(base):
-                continue
-            relative_path = remote_path.removeprefix(base)
-            if not relative_path or relative_path in seen_relative_paths:
-                continue
-            seen_relative_paths.add(relative_path)
-            pairs.append((remote_path, relative_path))
-    return pairs
-
-
 def _hf_latest_snapshot_candidates(latest_payload: dict[str, Any], filename: str) -> list[str]:
     candidates: list[str] = []
     manifest_path = str(latest_payload.get("manifest_path") or "").strip("/")
     snapshot_dir = str(latest_payload.get("snapshot_dir") or "").strip("/")
     latest_snapshot_id = str(latest_payload.get("latest_snapshot_id") or "").strip()
+    archived_manifest_path = str(latest_payload.get("archived_manifest_path") or "").strip("/")
 
-    if filename == "manifest.json" and manifest_path:
+    if filename == ROOT_MANIFEST_FILENAME and manifest_path:
         candidates.append(manifest_path)
     if snapshot_dir and snapshot_dir not in {".", "/"}:
         candidates.append(f"{snapshot_dir}/{filename}")
+    if filename == ROOT_MANIFEST_FILENAME and archived_manifest_path:
+        candidates.append(archived_manifest_path)
     if manifest_path and "/" in manifest_path:
         manifest_dir = manifest_path.rsplit("/", 1)[0]
         candidates.append(f"{manifest_dir}/{filename}")
     if latest_snapshot_id:
-        candidates.append(f"snapshots/{latest_snapshot_id}/{filename}")
+        candidates.append(str(PurePosixPath("snapshots") / latest_snapshot_id / filename))
     candidates.append(filename)
 
     seen: set[str] = set()
@@ -362,31 +492,6 @@ def _hf_latest_snapshot_candidates(latest_payload: dict[str, Any], filename: str
     return deduped
 
 
-def _hf_latest_snapshot_prefixes(latest_payload: dict[str, Any]) -> list[str]:
-    prefixes: list[str] = []
-    manifest_path = str(latest_payload.get("manifest_path") or "").strip("/")
-    snapshot_dir = str(latest_payload.get("snapshot_dir") or "").strip("/")
-    latest_snapshot_id = str(latest_payload.get("latest_snapshot_id") or "").strip()
-
-    if snapshot_dir and snapshot_dir not in {".", "/"}:
-        prefixes.append(snapshot_dir)
-    if manifest_path and "/" in manifest_path:
-        prefixes.append(manifest_path.rsplit("/", 1)[0])
-    if latest_snapshot_id:
-        prefixes.append(f"snapshots/{latest_snapshot_id}")
-    prefixes.append("")
-
-    seen: set[str] = set()
-    deduped: list[str] = []
-    for prefix in prefixes:
-        normalized = prefix.lstrip("./")
-        if normalized in seen:
-            continue
-        seen.add(normalized)
-        deduped.append(normalized)
-    return deduped
-
-
 def _download_url_to_path(url: str, destination: Path) -> None:
     destination.parent.mkdir(parents=True, exist_ok=True)
     urllib.request.urlretrieve(url, destination)
@@ -420,18 +525,8 @@ def _parquet_table_name(path: Path) -> str:
 def _infer_repo_from_materialized_snapshot(local_dir: Path) -> str:
     import pyarrow.parquet as pq
 
-    for table_name in (
-        "issues",
-        "pull_requests",
-        "comments",
-        "reviews",
-        "review_comments",
-        "pr_files",
-        "pr_diffs",
-        "links",
-        "events",
-    ):
-        path = local_dir / f"{table_name}.parquet"
+    for table_filename in RAW_TABLE_FILENAMES:
+        path = local_dir / table_filename
         if not path.exists():
             continue
         rows = pq.read_table(path).slice(0, 1).to_pylist()

src/slop_farmer/data/snapshot_paths.py

@@ -1,9 +1,63 @@
 from __future__ import annotations
 
-from pathlib import Path
+import re
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any
 
 from slop_farmer.data.parquet_io import read_json
 
+RAW_TABLE_FILENAMES: tuple[str, ...] = (
+    "issues.parquet",
+    "pull_requests.parquet",
+    "comments.parquet",
+    "reviews.parquet",
+    "review_comments.parquet",
+    "pr_files.parquet",
+    "pr_diffs.parquet",
+    "links.parquet",
+    "events.parquet",
+)
+VIEWER_SPLIT_FILENAMES: tuple[str, ...] = (
+    "issue_comments.parquet",
+    "pr_comments.parquet",
+)
+ROOT_MANIFEST_FILENAME = "manifest.json"
+README_FILENAME = "README.md"
+STATE_WATERMARK_PATH = "state/watermark.json"
+SNAPSHOTS_LATEST_PATH = "snapshots/latest.json"
+PR_SCOPE_CLUSTERS_FILENAME = "pr-scope-clusters.json"
+NEW_CONTRIBUTORS_PARQUET_FILENAME = "new_contributors.parquet"
+NEW_CONTRIBUTORS_REPORT_JSON_FILENAME = "new-contributors-report.json"
+NEW_CONTRIBUTORS_REPORT_MARKDOWN_FILENAME = "new-contributors-report.md"
+CONTRIBUTOR_ARTIFACT_FILENAMES: tuple[str, ...] = (
+    NEW_CONTRIBUTORS_PARQUET_FILENAME,
+    NEW_CONTRIBUTORS_REPORT_JSON_FILENAME,
+    NEW_CONTRIBUTORS_REPORT_MARKDOWN_FILENAME,
+)
+ANALYSIS_REPORT_FILENAME_BY_VARIANT: dict[str, str] = {
+    "deterministic": "analysis-report.json",
+    "hybrid": "analysis-report-hybrid.json",
+}
+HYBRID_ANALYSIS_REVIEWS_FILENAME = "analysis-report-hybrid.llm-reviews.json"
+LEGACY_ANALYSIS_FILENAMES: tuple[str, ...] = (
+    ANALYSIS_REPORT_FILENAME_BY_VARIANT["deterministic"],
+    ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"],
+    HYBRID_ANALYSIS_REVIEWS_FILENAME,
+)
+CURRENT_ANALYSIS_DIR = PurePosixPath("analysis/current")
+CURRENT_ANALYSIS_MANIFEST_PATH = str(CURRENT_ANALYSIS_DIR / ROOT_MANIFEST_FILENAME)
+ANALYSIS_MANIFEST_SCHEMA_VERSION = 1
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedAnalysisReportPath:
+    path: Path
+    variant: str
+    source: str
+    snapshot_id: str | None = None
+    analysis_id: str | None = None
+
 
 def default_hf_materialize_dir(output_dir: Path, repo_id: str, revision: str | None) -> Path:
     suffix = repo_id.replace("/", "--")
@@ -12,14 +66,241 @@ def default_hf_materialize_dir(output_dir: Path, repo_id: str, revision: str | N
     return output_dir.resolve() / "snapshots" / f"hf-{suffix}"
 
 
+def repo_relative_path_to_local(base_dir: Path, repo_relative_path: str) -> Path:
+    return base_dir.joinpath(*PurePosixPath(repo_relative_path).parts)
+
+
+def snapshot_artifact_path(snapshot_id: str, filename: str) -> str:
+    return str(PurePosixPath("snapshots") / snapshot_id / filename)
+
+
+def archived_snapshot_manifest_path(snapshot_id: str) -> str:
+    return snapshot_artifact_path(snapshot_id, ROOT_MANIFEST_FILENAME)
+
+
+def analysis_run_artifact_path(snapshot_id: str, analysis_id: str, filename: str) -> str:
+    return str(PurePosixPath("snapshots") / snapshot_id / "analysis-runs" / analysis_id / filename)
+
+
+def analysis_run_manifest_path(snapshot_id: str, analysis_id: str) -> str:
+    return analysis_run_artifact_path(snapshot_id, analysis_id, ROOT_MANIFEST_FILENAME)
+
+
+def current_analysis_artifact_path(filename: str) -> str:
+    return str(CURRENT_ANALYSIS_DIR / filename)
+
+
+def repo_key(repo_slug: str) -> str:
+    return _path_key(repo_slug)
+
+
+def model_key(model: str) -> str:
+    return _path_key(model)
+
+
+def build_current_analysis_manifest(
+    *,
+    repo: str,
+    snapshot_id: str,
+    analysis_id: str,
+    variant: str,
+    channel: str,
+    model: str | None,
+    published_at: str,
+    include_hybrid_reviews: bool,
+) -> dict[str, Any]:
+    artifacts = {
+        "hybrid": current_analysis_artifact_path(ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"]),
+    }
+    archived_artifacts = {
+        "hybrid": analysis_run_artifact_path(
+            snapshot_id,
+            analysis_id,
+            ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"],
+        )
+    }
+    if include_hybrid_reviews:
+        artifacts["hybrid_reviews"] = current_analysis_artifact_path(
+            HYBRID_ANALYSIS_REVIEWS_FILENAME
+        )
+        archived_artifacts["hybrid_reviews"] = analysis_run_artifact_path(
+            snapshot_id,
+            analysis_id,
+            HYBRID_ANALYSIS_REVIEWS_FILENAME,
+        )
+    payload = {
+        "schema_version": ANALYSIS_MANIFEST_SCHEMA_VERSION,
+        "repo": repo,
+        "snapshot_id": snapshot_id,
+        "analysis_id": analysis_id,
+        "variant": variant,
+        "channel": channel,
+        "model": model,
+        "published_at": published_at,
+        "artifacts": artifacts,
+        "archived_artifacts": archived_artifacts,
+    }
+    return validate_current_analysis_manifest(payload)
+
+
+def build_archived_analysis_run_manifest(
+    *,
+    repo: str,
+    snapshot_id: str,
+    analysis_id: str,
+    variant: str,
+    channel: str,
+    model: str | None,
+    published_at: str,
+    include_hybrid_reviews: bool,
+) -> dict[str, Any]:
+    artifacts = {
+        "hybrid": analysis_run_artifact_path(
+            snapshot_id,
+            analysis_id,
+            ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"],
+        )
+    }
+    if include_hybrid_reviews:
+        artifacts["hybrid_reviews"] = analysis_run_artifact_path(
+            snapshot_id,
+            analysis_id,
+            HYBRID_ANALYSIS_REVIEWS_FILENAME,
+        )
+    payload = {
+        "schema_version": ANALYSIS_MANIFEST_SCHEMA_VERSION,
+        "repo": repo,
+        "snapshot_id": snapshot_id,
+        "analysis_id": analysis_id,
+        "variant": variant,
+        "channel": channel,
+        "model": model,
+        "published_at": published_at,
+        "artifacts": artifacts,
+    }
+    return validate_archived_analysis_run_manifest(payload)
+
+
+def load_current_analysis_manifest(path: Path) -> dict[str, Any]:
+    payload = read_json(path)
+    if not isinstance(payload, dict):
+        raise ValueError(f"Current analysis manifest at {path} must contain a JSON object.")
+    return validate_current_analysis_manifest(payload)
+
+
+def load_archived_analysis_run_manifest(path: Path) -> dict[str, Any]:
+    payload = read_json(path)
+    if not isinstance(payload, dict):
+        raise ValueError(f"Archived analysis manifest at {path} must contain a JSON object.")
+    return validate_archived_analysis_run_manifest(payload)
+
+
+def resolve_default_dashboard_analysis_report(
+    snapshot_dir: Path,
+) -> ResolvedAnalysisReportPath | None:
+    current = resolve_current_analysis_report(snapshot_dir)
+    if current is not None and _analysis_matches_snapshot(snapshot_dir, current):
+        return current
+    return resolve_snapshot_local_analysis_report(snapshot_dir, variant="auto")
+
+
+def resolve_current_analysis_report(
+    snapshot_dir: Path,
+    *,
+    variant: str = "auto",
+) -> ResolvedAnalysisReportPath | None:
+    normalized = _normalize_analysis_variant(variant)
+    manifest_path = repo_relative_path_to_local(snapshot_dir, CURRENT_ANALYSIS_MANIFEST_PATH)
+    if not manifest_path.exists():
+        return None
+    manifest = load_current_analysis_manifest(manifest_path)
+    artifact_key = _analysis_artifact_key_for_variant(normalized, manifest_kind="current")
+    artifact_path = manifest.get("artifacts", {}).get(artifact_key)
+    if not isinstance(artifact_path, str) or not artifact_path:
+        message = (
+            f"Published current analysis manifest does not provide the {normalized} artifact."
+            if normalized != "auto"
+            else "Published current analysis manifest does not provide the canonical hybrid artifact."
+        )
+        raise ValueError(message)
+    report_path = repo_relative_path_to_local(snapshot_dir, artifact_path)
+    if not report_path.exists():
+        raise ValueError(
+            f"Published current analysis artifact {artifact_path!r} is missing from the materialized snapshot."
+        )
+    return ResolvedAnalysisReportPath(
+        path=report_path,
+        variant="hybrid" if artifact_key == "hybrid" else normalized,
+        source="current",
+        snapshot_id=str(manifest["snapshot_id"]),
+        analysis_id=str(manifest["analysis_id"]),
+    )
+
+
+def resolve_snapshot_local_analysis_report(
+    snapshot_dir: Path,
+    *,
+    variant: str = "auto",
+) -> ResolvedAnalysisReportPath | None:
+    normalized = _normalize_analysis_variant(variant)
+    if normalized == "auto":
+        hybrid_path = snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"]
+        if hybrid_path.exists():
+            return ResolvedAnalysisReportPath(
+                path=hybrid_path,
+                variant="hybrid",
+                source="snapshot",
+            )
+        deterministic_path = snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT["deterministic"]
+        if deterministic_path.exists():
+            return ResolvedAnalysisReportPath(
+                path=deterministic_path,
+                variant="deterministic",
+                source="snapshot",
+            )
+        return None
+    report_path = snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT[normalized]
+    if not report_path.exists():
+        return None
+    return ResolvedAnalysisReportPath(
+        path=report_path,
+        variant=normalized,
+        source="snapshot",
+    )
+
+
+def validate_current_analysis_manifest(payload: dict[str, Any]) -> dict[str, Any]:
+    validated = _validate_analysis_manifest(payload, require_archived_artifacts=True)
+    archived_artifacts = _validate_artifacts(
+        dict(validated["archived_artifacts"]),
+        expected_prefix=analysis_run_artifact_path(
+            str(validated["snapshot_id"]),
+            str(validated["analysis_id"]),
+            "",
+        ),
+    )
+    if set(archived_artifacts) != set(validated["artifacts"]):
+        raise ValueError("Current analysis manifest artifacts and archived_artifacts must match.")
+    validated["archived_artifacts"] = archived_artifacts
+    return validated
+
+
+def validate_archived_analysis_run_manifest(payload: dict[str, Any]) -> dict[str, Any]:
+    return _validate_analysis_manifest(payload, require_archived_artifacts=False)
+
+
 def load_latest_snapshot_pointer(snapshots_root: Path) -> Path | None:
-    latest_path = snapshots_root.resolve() / "latest.json"
+    resolved_snapshots_root = snapshots_root.resolve()
+    latest_path = resolved_snapshots_root / "latest.json"
     if not latest_path.exists():
         return None
     payload = read_json(latest_path)
     snapshot_dir = payload.get("snapshot_dir")
     if isinstance(snapshot_dir, str) and snapshot_dir:
-        return Path(snapshot_dir).resolve()
+        path = Path(snapshot_dir)
+        if path.is_absolute():
+            return path.resolve()
+        return (resolved_snapshots_root.parent / path).resolve()
     return None
 
 
@@ -46,3 +327,104 @@ def resolve_snapshot_dir_from_snapshots_root(
     if snapshot_dirs:
         return snapshot_dirs[-1].resolve()
     raise FileNotFoundError(f"Could not resolve a snapshot directory from {latest_path}")
+
+
+def _validate_analysis_manifest(
+    payload: dict[str, Any],
+    *,
+    require_archived_artifacts: bool,
+) -> dict[str, Any]:
+    validated = {str(key): value for key, value in payload.items()}
+    if validated.get("schema_version") != ANALYSIS_MANIFEST_SCHEMA_VERSION:
+        raise ValueError(
+            f"Unsupported analysis manifest schema version: {validated.get('schema_version')!r}"
+        )
+    for field in ("repo", "snapshot_id", "analysis_id", "variant", "channel", "published_at"):
+        if not isinstance(validated.get(field), str) or not str(validated[field]).strip():
+            raise ValueError(f"Analysis manifest field {field!r} must be a non-empty string.")
+        validated[field] = str(validated[field]).strip()
+    model = validated.get("model")
+    if model is not None and not isinstance(model, str):
+        raise ValueError("Analysis manifest field 'model' must be a string when present.")
+    artifacts = validated.get("artifacts")
+    if not isinstance(artifacts, dict):
+        raise ValueError("Analysis manifest field 'artifacts' must be an object.")
+    expected_prefix = (
+        current_analysis_artifact_path("")
+        if require_archived_artifacts
+        else analysis_run_artifact_path(
+            str(validated["snapshot_id"]),
+            str(validated["analysis_id"]),
+            "",
+        )
+    )
+    validated["artifacts"] = _validate_artifacts(dict(artifacts), expected_prefix=expected_prefix)
+    if require_archived_artifacts:
+        archived_artifacts = validated.get("archived_artifacts")
+        if not isinstance(archived_artifacts, dict):
+            raise ValueError(
+                "Current analysis manifest field 'archived_artifacts' must be an object."
+            )
+        validated["archived_artifacts"] = {
+            str(key): value for key, value in archived_artifacts.items()
+        }
+    return validated
+
+
+def _validate_artifacts(artifacts: dict[str, Any], *, expected_prefix: str) -> dict[str, str]:
+    normalized = {str(key): value for key, value in artifacts.items()}
+    hybrid_path = normalized.get("hybrid")
+    if not isinstance(hybrid_path, str) or not hybrid_path:
+        raise ValueError("Analysis manifest must include artifacts.hybrid.")
+    validated = {"hybrid": hybrid_path}
+    hybrid_reviews_path = normalized.get("hybrid_reviews")
+    if hybrid_reviews_path is not None:
+        if not isinstance(hybrid_reviews_path, str) or not hybrid_reviews_path:
+            raise ValueError(
+                "Analysis manifest artifacts.hybrid_reviews must be a non-empty string."
+            )
+        validated["hybrid_reviews"] = hybrid_reviews_path
+    for key, value in validated.items():
+        if not value.startswith(expected_prefix):
+            raise ValueError(
+                f"Analysis manifest artifact {key!r} must live under {expected_prefix!r}, got {value!r}."
+            )
+    return validated
+
+
+def _path_key(value: str) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", "-", value.strip().lower())
+    normalized = re.sub(r"-+", "-", normalized).strip("-")
+    if not normalized:
+        raise ValueError("Expected a non-empty path key value.")
+    return normalized
+
+
+def _analysis_matches_snapshot(
+    snapshot_dir: Path,
+    analysis_path: ResolvedAnalysisReportPath,
+) -> bool:
+    snapshot_manifest_path = snapshot_dir / ROOT_MANIFEST_FILENAME
+    if snapshot_manifest_path.exists():
+        snapshot_manifest = read_json(snapshot_manifest_path)
+        snapshot_id = snapshot_manifest.get("snapshot_id")
+        if snapshot_id is not None:
+            return str(snapshot_id) == str(analysis_path.snapshot_id)
+    return snapshot_dir.name == str(analysis_path.snapshot_id)
+
+
+def _normalize_analysis_variant(variant: str) -> str:
+    normalized = variant.strip().lower()
+    if normalized not in {"auto", "deterministic", "hybrid"}:
+        raise ValueError(
+            f"Unsupported analysis variant {variant!r}; expected auto, hybrid, or deterministic."
+        )
+    return normalized
+
+
+def _analysis_artifact_key_for_variant(variant: str, *, manifest_kind: str) -> str:
+    if variant in {"auto", "hybrid"}:
+        return "hybrid"
+    raise ValueError(
+        f"Published {manifest_kind} analysis only serves canonical hybrid artifacts; requested {variant!r}."
+    )

src/slop_farmer/reports/analysis.py

@@ -19,15 +19,12 @@ from rank_bm25 import BM25Okapi
 from slop_farmer.config import AnalysisOptions, MarkdownReportOptions
 from slop_farmer.data.links import build_text_link_rows
 from slop_farmer.data.parquet_io import read_json, read_parquet_rows, write_text
-from slop_farmer.data.snapshot_materialize import materialize_hf_dataset_snapshot
-from slop_farmer.data.snapshot_paths import (
-    default_hf_materialize_dir,
-    resolve_snapshot_dir_from_output,
-)
+from slop_farmer.data.snapshot_source import resolve_snapshot_source_dir
 from slop_farmer.reports.analysis_cache import (
     HYBRID_REVIEW_CACHE_SCHEMA_VERSION,
     PREPARED_REVIEW_UNIT_SCHEMA_VERSION,
     HybridReviewCacheEntry,
+    HybridReviewCacheKey,
     HybridReviewCacheManifest,
     HybridReviewCacheStore,
     HybridReviewSettingsFingerprint,
@@ -89,12 +86,12 @@ LLM_PROVIDER_ENV_VARS = (
     "DEEPSEEK_API_KEY",
 )
 LLM_PACKET_CHARS_PER_TOKEN = 4
-LLM_MAX_INPUT_TOKENS = 12_000
-LLM_MAX_NODES_PER_PACKET = 18
-LLM_MAX_SOFT_PAIRS_PER_PACKET = 24
-LLM_MAX_DIFF_CHARS_PER_ITEM = 400
-LLM_MAX_FILENAMES_PER_ITEM = 8
-LLM_SKIP_EVALUATOR_ABOVE_TOKENS = 6_000
+LLM_MAX_INPUT_TOKENS = 60_000
+LLM_MAX_NODES_PER_PACKET = 48
+LLM_MAX_SOFT_PAIRS_PER_PACKET = 72
+LLM_MAX_DIFF_CHARS_PER_ITEM = 1_200
+LLM_MAX_FILENAMES_PER_ITEM = 16
+LLM_SKIP_EVALUATOR_ABOVE_TOKENS = 60_000
 LLM_OVERFLOW_POLICY = "truncate_then_skip"
 LLM_SHARED_TARGET_MAX_NEIGHBORS_PER_PR = 3
 LLM_SHARED_TARGET_MAX_EXTRA_PAIRS_PER_TARGET = 18
@@ -311,6 +308,42 @@ class AnalysisBuildResult:
     llm_reviews: list[dict[str, Any]]
 
 
+@dataclass(frozen=True, slots=True)
+class SoftPairReviewUnitMeta:
+    label: str
+    component_index: int
+    component_count: int
+    review_unit_index: int
+    review_unit_count: int
+    cluster_id: str
+    prefix: str
+    nodes: tuple[str, ...]
+    soft_pairs: tuple[str, ...]
+    component_budget: PacketBudget
+    budget: PacketBudget
+    prepared_review_unit_hash: str | None
+    trimmed: bool
+    aggressively_trimmed: bool
+    split: bool
+
+
+@dataclass(frozen=True, slots=True)
+class PendingSoftPairReview:
+    meta: SoftPairReviewUnitMeta
+    prepared: PreparedLlmPacket
+    cache_key: HybridReviewCacheKey
+
+
+@dataclass(frozen=True, slots=True)
+class CompletedSoftPairReview:
+    meta: SoftPairReviewUnitMeta
+    result: ClusterAnalysisCallResult | None
+    status: str
+    reason: str | None
+    source: str | None
+    cache_hit: bool
+
+
 def _hybrid_review_cache_manifest() -> HybridReviewCacheManifest:
     return HybridReviewCacheManifest(
         cache_schema_version=HYBRID_REVIEW_CACHE_SCHEMA_VERSION,
@@ -766,18 +799,14 @@ def _artifact_suffix(row: dict[str, Any] | None, kind: str) -> str:
 
 
 def _resolve_snapshot_dir(options: AnalysisOptions) -> Path:
-    if options.hf_repo_id:
-        materialize_dir = options.hf_materialize_dir or default_hf_materialize_dir(
-            options.output_dir,
-            options.hf_repo_id,
-            options.hf_revision,
-        )
-        return materialize_hf_dataset_snapshot(
-            repo_id=options.hf_repo_id,
-            local_dir=materialize_dir,
-            revision=options.hf_revision,
-        ).resolve()
-    return resolve_snapshot_dir_from_output(options.output_dir, options.snapshot_dir)
+    return resolve_snapshot_source_dir(
+        snapshot_dir=options.snapshot_dir,
+        local_snapshots_root=options.output_dir.resolve() / "snapshots",
+        hf_repo_id=options.hf_repo_id,
+        hf_revision=options.hf_revision,
+        hf_materialize_dir=options.hf_materialize_dir,
+        hf_output_dir=options.output_dir,
+    )
 
 
 def _load_snapshot(snapshot_dir: Path) -> SnapshotData:
@@ -927,39 +956,46 @@ async def _build_report(snapshot: SnapshotData, options: AnalysisOptions) -> Ana
         review_comment_map=review_comment_map,
     )
     issue_soft_candidates = _issue_soft_candidates(issue_map, features, issue_hard_pairs)
-    accepted_issue_pairs, issue_llm_enabled, issue_llm_reviews = await _accepted_soft_pairs(
+    pr_soft_candidates, pr_pair_target_issues = _pr_duplicate_candidates(
         options=options,
         snapshot=snapshot,
+        issue_map=issue_map,
+        pr_map=pr_map,
         features=features,
-        hard_pairs=issue_hard_pairs,
-        soft_candidates=issue_soft_candidates,
-        label="issue",
-        hybrid_review_cache=hybrid_review_cache,
-        llm_available=llm_available,
+    )
+    review_semaphore = asyncio.Semaphore(options.hybrid_llm_concurrency)
+    (
+        (accepted_issue_pairs, issue_llm_enabled, issue_llm_reviews),
+        (accepted_pr_pairs, pr_llm_enabled, pr_llm_reviews),
+    ) = await asyncio.gather(
+        _accepted_soft_pairs(
+            options=options,
+            snapshot=snapshot,
+            features=features,
+            hard_pairs=issue_hard_pairs,
+            soft_candidates=issue_soft_candidates,
+            label="issue",
+            hybrid_review_cache=hybrid_review_cache,
+            llm_available=llm_available,
+            review_semaphore=review_semaphore,
+        ),
+        _accepted_soft_pairs(
+            options=options,
+            snapshot=snapshot,
+            features=features,
+            hard_pairs={},
+            soft_candidates=pr_soft_candidates,
+            label="pull_request",
+            hybrid_review_cache=hybrid_review_cache,
+            llm_available=llm_available,
+            review_semaphore=review_semaphore,
+        ),
     )
     issue_pairs = dict(issue_hard_pairs)
     for pair, detail in accepted_issue_pairs.items():
         issue_pairs.setdefault(pair, set()).update(
             detail.get("evidence_types") or {"soft_similarity"}
         )
-
-    pr_soft_candidates, pr_pair_target_issues = _pr_duplicate_candidates(
-        options=options,
-        snapshot=snapshot,
-        issue_map=issue_map,
-        pr_map=pr_map,
-        features=features,
-    )
-    accepted_pr_pairs, pr_llm_enabled, pr_llm_reviews = await _accepted_soft_pairs(
-        options=options,
-        snapshot=snapshot,
-        features=features,
-        hard_pairs={},
-        soft_candidates=pr_soft_candidates,
-        label="pull_request",
-        hybrid_review_cache=hybrid_review_cache,
-        llm_available=llm_available,
-    )
     pr_pairs: dict[tuple[str, str], set[str]] = {}
     for pair, detail in accepted_pr_pairs.items():
         pr_pairs.setdefault(pair, set()).update(detail.get("evidence_types") or {"soft_similarity"})
@@ -1873,28 +1909,21 @@ def _review_subpacket(packet: dict[str, Any], soft_pairs: list[dict[str, Any]])
     }
 
 
-def _split_packet_for_review(packet: dict[str, Any]) -> list[dict[str, Any]]:
-    if (
-        len(packet["nodes"]) <= LLM_MAX_NODES_PER_PACKET
-        and len(packet["soft_pairs"]) <= LLM_MAX_SOFT_PAIRS_PER_PACKET
-    ):
+def _split_packet_for_review(packet: dict[str, Any], model: str) -> list[dict[str, Any]]:
+    if not packet["soft_pairs"]:
+        return [packet]
+    if not _packet_over_budget(_estimate_packet_size(packet, model)):
         return [packet]
     batches: list[list[dict[str, Any]]] = []
     current_batch: list[dict[str, Any]] = []
-    current_nodes: set[str] = set()
     for soft_pair in sorted(packet["soft_pairs"], key=_soft_pair_review_sort_key):
-        pair_nodes = {str(soft_pair["left"]), str(soft_pair["right"])}
-        next_nodes = current_nodes | pair_nodes
-        if current_batch and (
-            len(current_batch) >= LLM_MAX_SOFT_PAIRS_PER_PACKET
-            or len(next_nodes) > LLM_MAX_NODES_PER_PACKET
-        ):
+        candidate_batch = [*current_batch, soft_pair]
+        candidate_packet = _review_subpacket(packet, candidate_batch)
+        if current_batch and _packet_over_budget(_estimate_packet_size(candidate_packet, model)):
             batches.append(current_batch)
             current_batch = [soft_pair]
-            current_nodes = set(pair_nodes)
             continue
-        current_batch.append(soft_pair)
-        current_nodes = next_nodes
+        current_batch = candidate_batch
     if current_batch:
         batches.append(current_batch)
     return [_review_subpacket(packet, batch) for batch in batches]
@@ -1985,7 +2014,8 @@ def _should_run_evaluator(
     aggressively_trimmed: bool,
     analyst_result: ClusterAnalystResponse,
 ) -> bool:
-    if split or aggressively_trimmed:
+    del split
+    if aggressively_trimmed:
         return False
     if budget.estimated_eval_tokens > LLM_SKIP_EVALUATOR_ABOVE_TOKENS:
         return False
@@ -2020,6 +2050,166 @@ def _packet_soft_pair_ids(packet: dict[str, Any]) -> list[str]:
     ]
 
 
+def _soft_pair_review_meta(
+    *,
+    label: str,
+    component_index: int,
+    component_count: int,
+    review_unit_index: int,
+    review_unit_count: int,
+    cluster_id: str,
+    component_budget: PacketBudget,
+    budget: PacketBudget,
+    prepared_review_unit_hash: str | None,
+    trimmed: bool,
+    aggressively_trimmed: bool,
+    split: bool,
+    packet: dict[str, Any],
+) -> SoftPairReviewUnitMeta:
+    prefix = (
+        f"LLM {label} soft-edge review {component_index}/{component_count}"
+        f" unit {review_unit_index}/{review_unit_count}"
+    )
+    return SoftPairReviewUnitMeta(
+        label=label,
+        component_index=component_index,
+        component_count=component_count,
+        review_unit_index=review_unit_index,
+        review_unit_count=review_unit_count,
+        cluster_id=cluster_id,
+        prefix=prefix,
+        nodes=tuple(str(node) for node in packet["nodes"]),
+        soft_pairs=tuple(_packet_soft_pair_ids(packet)),
+        component_budget=component_budget,
+        budget=budget,
+        prepared_review_unit_hash=prepared_review_unit_hash,
+        trimmed=trimmed,
+        aggressively_trimmed=aggressively_trimmed,
+        split=split,
+    )
+
+
+def _completed_soft_pair_review_sort_key(review: CompletedSoftPairReview) -> tuple[int, int]:
+    return (
+        review.meta.component_index,
+        review.meta.review_unit_index,
+    )
+
+
+def _soft_pair_review_record(
+    *,
+    review: CompletedSoftPairReview,
+    model: str,
+    accepted_nontrivial_soft_edge: bool,
+) -> dict[str, Any]:
+    result = review.result
+    return {
+        "label": review.meta.label,
+        "component_index": review.meta.component_index,
+        "component_count": review.meta.component_count,
+        "review_unit_index": review.meta.review_unit_index,
+        "review_unit_count": review.meta.review_unit_count,
+        "status": review.status,
+        "reason": review.reason,
+        "source": review.source,
+        "cache_hit": review.cache_hit,
+        "model": model,
+        "cluster_id": review.meta.cluster_id,
+        "nodes": list(review.meta.nodes),
+        "soft_pairs": list(review.meta.soft_pairs),
+        "prepared_review_unit_hash": review.meta.prepared_review_unit_hash,
+        "component_budget": _packet_budget_json(review.meta.component_budget),
+        "budget": _packet_budget_json(review.meta.budget),
+        "overflow_policy": LLM_OVERFLOW_POLICY,
+        "trimmed": review.meta.trimmed,
+        "aggressively_trimmed": review.meta.aggressively_trimmed,
+        "split": review.meta.split,
+        "analyst_result": (
+            None
+            if result is None or result.analyst_result is None
+            else result.analyst_result.model_dump(mode="json")
+        ),
+        "evaluator_result": (
+            None
+            if result is None or result.evaluator_result is None
+            else result.evaluator_result.model_dump(mode="json")
+        ),
+        "evaluator_used": False if result is None else result.evaluator_used,
+        "retried": False if result is None else result.retried,
+        "accepted_nontrivial_soft_edge": accepted_nontrivial_soft_edge,
+        "error_kind": None if result is None else result.error_kind,
+        "error_message": None if result is None else result.error_message,
+    }
+
+
+def _completed_soft_pair_review_from_result(
+    pending: PendingSoftPairReview,
+    result: ClusterAnalysisCallResult,
+) -> CompletedSoftPairReview:
+    return CompletedSoftPairReview(
+        meta=pending.meta,
+        result=result,
+        status="reviewed" if result.analyst_result is not None else "error",
+        reason=None,
+        source="llm",
+        cache_hit=False,
+    )
+
+
+async def _run_pending_soft_pair_review(
+    pending: PendingSoftPairReview,
+    *,
+    model: str,
+    review_semaphore: asyncio.Semaphore,
+) -> CompletedSoftPairReview:
+    async with review_semaphore:
+        try:
+            result = await _fast_agent_cluster_analysis(pending.prepared, model)
+        except Exception as exc:
+            result = ClusterAnalysisCallResult(
+                analyst_result=None,
+                evaluator_result=None,
+                error_kind=_classify_llm_error(exc),
+                error_message=_summarize_llm_error(exc),
+                evaluator_used=False,
+                retried=False,
+            )
+    return _completed_soft_pair_review_from_result(pending, result)
+
+
+async def _run_pending_soft_pair_reviews(
+    pending_reviews: list[PendingSoftPairReview],
+    *,
+    concurrency: int,
+    model: str,
+    review_semaphore: asyncio.Semaphore,
+) -> list[CompletedSoftPairReview]:
+    if not pending_reviews:
+        return []
+    if concurrency <= 1:
+        completed: list[CompletedSoftPairReview] = []
+        for pending in pending_reviews:
+            completed.append(
+                await _run_pending_soft_pair_review(
+                    pending,
+                    model=model,
+                    review_semaphore=review_semaphore,
+                )
+            )
+        return completed
+    tasks = [
+        asyncio.create_task(
+            _run_pending_soft_pair_review(
+                pending,
+                model=model,
+                review_semaphore=review_semaphore,
+            )
+        )
+        for pending in pending_reviews
+    ]
+    return await asyncio.gather(*tasks)
+
+
 async def _accepted_soft_pairs(
     *,
     options: AnalysisOptions,
@@ -2030,6 +2220,7 @@ async def _accepted_soft_pairs(
     label: str,
     hybrid_review_cache: HybridReviewCacheStore,
     llm_available: bool,
+    review_semaphore: asyncio.Semaphore,
 ) -> tuple[dict[tuple[str, str], dict[str, Any]], bool, list[dict[str, Any]]]:
     del snapshot
     if not soft_candidates:
@@ -2048,6 +2239,8 @@ async def _accepted_soft_pairs(
     for pair in soft_candidates:
         candidate_graph.setdefault(pair, set()).add("soft_similarity")
     component_payloads = _component_packets(features, candidate_graph, soft_candidates)
+    pending_reviews: list[PendingSoftPairReview] = []
+    completed_reviews: list[CompletedSoftPairReview] = []
     accepted: dict[tuple[str, str], dict[str, Any]] = dict(deterministic_accepts)
     llm_used = False
     review_records: list[dict[str, Any]] = []
@@ -2055,7 +2248,7 @@ async def _accepted_soft_pairs(
     for index, payload in enumerate(component_payloads, start=1):
         component_budget = _estimate_packet_size(payload, options.model)
         cluster_id = _cluster_id_from_nodes(payload["nodes"])
-        review_units = _split_packet_for_review(payload)
+        review_units = _split_packet_for_review(payload, options.model)
         if len(review_units) > 1:
             _analysis_log(
                 f"LLM {label} soft-edge review {index}/{total_components}: "
@@ -2064,10 +2257,6 @@ async def _accepted_soft_pairs(
                 f"est_tokens={component_budget.estimated_input_tokens})"
             )
         for unit_index, review_unit in enumerate(review_units, start=1):
-            prefix = (
-                f"LLM {label} soft-edge review {index}/{total_components}"
-                f" unit {unit_index}/{len(review_units)}"
-            )
             prepared = _prepare_packet_for_llm(
                 review_unit,
                 options.model,
@@ -2075,41 +2264,29 @@ async def _accepted_soft_pairs(
             )
             if prepared is None:
                 unit_budget = _estimate_packet_size(review_unit, options.model)
-                _analysis_log(
-                    f"{prefix}: skipped over-budget packet "
-                    f"(nodes={unit_budget.node_count}, soft_pairs={unit_budget.soft_pair_count}, "
-                    f"est_tokens={unit_budget.estimated_input_tokens}, overflow_policy={LLM_OVERFLOW_POLICY})"
-                )
-                review_records.append(
-                    {
-                        "label": label,
-                        "component_index": index,
-                        "component_count": total_components,
-                        "review_unit_index": unit_index,
-                        "review_unit_count": len(review_units),
-                        "status": "skipped",
-                        "reason": "over_budget_after_truncate",
-                        "source": None,
-                        "cache_hit": False,
-                        "model": options.model,
-                        "cluster_id": cluster_id,
-                        "nodes": list(review_unit["nodes"]),
-                        "soft_pairs": _packet_soft_pair_ids(review_unit),
-                        "prepared_review_unit_hash": None,
-                        "component_budget": _packet_budget_json(component_budget),
-                        "budget": _packet_budget_json(unit_budget),
-                        "overflow_policy": LLM_OVERFLOW_POLICY,
-                        "trimmed": True,
-                        "aggressively_trimmed": True,
-                        "split": len(review_units) > 1,
-                        "analyst_result": None,
-                        "evaluator_result": None,
-                        "evaluator_used": False,
-                        "retried": False,
-                        "accepted_nontrivial_soft_edge": False,
-                        "error_kind": None,
-                        "error_message": None,
-                    }
+                completed_reviews.append(
+                    CompletedSoftPairReview(
+                        meta=_soft_pair_review_meta(
+                            label=label,
+                            component_index=index,
+                            component_count=total_components,
+                            review_unit_index=unit_index,
+                            review_unit_count=len(review_units),
+                            cluster_id=cluster_id,
+                            component_budget=component_budget,
+                            budget=unit_budget,
+                            prepared_review_unit_hash=None,
+                            trimmed=True,
+                            aggressively_trimmed=True,
+                            split=len(review_units) > 1,
+                            packet=review_unit,
+                        ),
+                        result=None,
+                        status="skipped",
+                        reason="over_budget_after_truncate",
+                        source=None,
+                        cache_hit=False,
+                    )
                 )
                 continue
             prepared_review_unit = _prepared_review_unit_payload(prepared)
@@ -2118,85 +2295,113 @@ async def _accepted_soft_pairs(
                 model=options.model,
                 prepared_review_unit=prepared_review_unit,
             )
+            meta = _soft_pair_review_meta(
+                label=label,
+                component_index=index,
+                component_count=total_components,
+                review_unit_index=unit_index,
+                review_unit_count=len(review_units),
+                cluster_id=cluster_id,
+                component_budget=component_budget,
+                budget=prepared.budget,
+                prepared_review_unit_hash=cache_key.prepared_review_unit_hash,
+                trimmed=prepared.trimmed,
+                aggressively_trimmed=prepared.aggressively_trimmed,
+                split=prepared.split,
+                packet=prepared.packet,
+            )
             cached_entry = hybrid_review_cache.get(cache_key)
-            cache_hit = cached_entry is not None
             if cached_entry is not None:
-                result = _cluster_analysis_call_result_from_payload(cached_entry.result)
-                _analysis_log(
-                    f"{prefix}: cache hit "
-                    f"(nodes={prepared.budget.node_count}, soft_pairs={prepared.budget.soft_pair_count}, "
-                    f"est_tokens={prepared.budget.estimated_input_tokens}, model={options.model})"
-                )
-            else:
-                if not llm_available:
-                    _analysis_log(
-                        f"{prefix}: cache miss with fast-agent unavailable; "
-                        "keeping deterministic-only soft edges"
+                completed_reviews.append(
+                    CompletedSoftPairReview(
+                        meta=meta,
+                        result=_cluster_analysis_call_result_from_payload(cached_entry.result),
+                        status=(
+                            "reviewed"
+                            if cached_entry.result.get("analyst_result") is not None
+                            else "error"
+                        ),
+                        reason=None,
+                        source="cache",
+                        cache_hit=True,
                     )
-                    review_records.append(
-                        {
-                            "label": label,
-                            "component_index": index,
-                            "component_count": total_components,
-                            "review_unit_index": unit_index,
-                            "review_unit_count": len(review_units),
-                            "status": "skipped",
-                            "reason": "llm_unavailable_cache_miss",
-                            "source": None,
-                            "cache_hit": False,
-                            "model": options.model,
-                            "cluster_id": cluster_id,
-                            "nodes": list(prepared.packet["nodes"]),
-                            "soft_pairs": _packet_soft_pair_ids(prepared.packet),
-                            "prepared_review_unit_hash": cache_key.prepared_review_unit_hash,
-                            "component_budget": _packet_budget_json(component_budget),
-                            "budget": _packet_budget_json(prepared.budget),
-                            "overflow_policy": LLM_OVERFLOW_POLICY,
-                            "trimmed": prepared.trimmed,
-                            "aggressively_trimmed": prepared.aggressively_trimmed,
-                            "split": prepared.split,
-                            "analyst_result": None,
-                            "evaluator_result": None,
-                            "evaluator_used": False,
-                            "retried": False,
-                            "accepted_nontrivial_soft_edge": False,
-                            "error_kind": None,
-                            "error_message": None,
-                        }
+                )
+                continue
+            if not llm_available:
+                completed_reviews.append(
+                    CompletedSoftPairReview(
+                        meta=meta,
+                        result=None,
+                        status="skipped",
+                        reason="llm_unavailable_cache_miss",
+                        source=None,
+                        cache_hit=False,
                     )
-                    continue
+                )
+                continue
+            pending_reviews.append(
+                PendingSoftPairReview(
+                    meta=meta,
+                    prepared=prepared,
+                    cache_key=cache_key,
+                )
+            )
+    reviewed_from_cache = sum(1 for review in completed_reviews if review.cache_hit)
+    skipped_reviews = sum(1 for review in completed_reviews if review.status == "skipped")
+    _analysis_log(
+        f"LLM {label} soft-edge review scheduling: "
+        f"units={len(pending_reviews) + len(completed_reviews)}, "
+        f"cache_hits={reviewed_from_cache}, "
+        f"cache_misses={len(pending_reviews)}, "
+        f"skipped={skipped_reviews}, "
+        f"concurrency={options.hybrid_llm_concurrency}"
+    )
+    completed_reviews.extend(
+        await _run_pending_soft_pair_reviews(
+            pending_reviews,
+            concurrency=options.hybrid_llm_concurrency,
+            model=options.model,
+            review_semaphore=review_semaphore,
+        )
+    )
+    pending_by_position = {
+        (pending.meta.component_index, pending.meta.review_unit_index): pending
+        for pending in pending_reviews
+    }
+    for review in sorted(completed_reviews, key=_completed_soft_pair_review_sort_key):
+        accepted_nontrivial = False
+        pending = pending_by_position.get(
+            (review.meta.component_index, review.meta.review_unit_index)
+        )
+        result = review.result
+        if review.reason == "over_budget_after_truncate":
+            _analysis_log(
+                f"{review.meta.prefix}: skipped over-budget packet "
+                f"(nodes={review.meta.budget.node_count}, soft_pairs={review.meta.budget.soft_pair_count}, "
+                f"est_tokens={review.meta.budget.estimated_input_tokens}, overflow_policy={LLM_OVERFLOW_POLICY})"
+            )
+        elif review.reason == "llm_unavailable_cache_miss":
+            _analysis_log(
+                f"{review.meta.prefix}: cache miss with fast-agent unavailable; "
+                "keeping deterministic-only soft edges"
+            )
+        else:
+            if review.cache_hit:
                 _analysis_log(
-                    f"{prefix}: {prepared.budget.node_count} nodes, {prepared.budget.soft_pair_count} soft pairs, "
-                    f"est_tokens={prepared.budget.estimated_input_tokens}, model={options.model}"
-                    f"{' trimmed' if prepared.trimmed else ''}"
-                    f"{' split' if prepared.split else ''}"
+                    f"{review.meta.prefix}: cache hit "
+                    f"(nodes={review.meta.budget.node_count}, soft_pairs={review.meta.budget.soft_pair_count}, "
+                    f"est_tokens={review.meta.budget.estimated_input_tokens}, model={options.model})"
                 )
-                result = await _fast_agent_cluster_analysis(prepared, options.model)
-                if _cacheable_cluster_analysis_result(result):
-                    hybrid_review_cache.put(
-                        HybridReviewCacheEntry(
-                            key=cache_key,
-                            result=_cluster_analysis_call_result_payload(result),
-                            cached_at=_iso_now(),
-                            nodes=tuple(prepared.packet["nodes"]),
-                            soft_pairs=tuple(_packet_soft_pair_ids(prepared.packet)),
-                            budget=_packet_budget_json(prepared.budget),
-                            split=prepared.split,
-                            trimmed=prepared.trimmed,
-                            aggressively_trimmed=prepared.aggressively_trimmed,
-                        )
-                    )
-            accepted_nontrivial = False
-            if result.analyst_result is None:
-                if result.error_kind is not None:
+            if result is None or result.analyst_result is None:
+                if result is not None and result.error_kind is not None:
                     _analysis_log(
-                        f"{prefix}: {result.error_kind}"
-                        f" (nodes={prepared.budget.node_count}, soft_pairs={prepared.budget.soft_pair_count}, "
-                        f"est_tokens={prepared.budget.estimated_input_tokens}, "
+                        f"{review.meta.prefix}: {result.error_kind}"
+                        f" (nodes={review.meta.budget.node_count}, soft_pairs={review.meta.budget.soft_pair_count}, "
+                        f"est_tokens={review.meta.budget.estimated_input_tokens}, "
                         f"overflow_policy={LLM_OVERFLOW_POLICY})"
                     )
                 else:
-                    _analysis_log(f"{prefix}: no result")
+                    _analysis_log(f"{review.meta.prefix}: no result")
             else:
                 llm_used = True
                 verdicts = {
@@ -2205,18 +2410,28 @@ async def _accepted_soft_pairs(
                 }
                 accepted_count = sum(1 for verdict in verdicts.values() if verdict.accept)
                 rejected_count = sum(1 for verdict in verdicts.values() if not verdict.accept)
-                accepted_nontrivial = _accepted_nontrivial_soft_edge(
-                    prepared.packet, result.analyst_result
+                accepted_nontrivial = any(
+                    verdicts.get(_pair_key(*pair_id.split("|", 1))) is not None
+                    and verdicts[_pair_key(*pair_id.split("|", 1))].accept
+                    and not bool(
+                        soft_candidates[_pair_key(*pair_id.split("|", 1))].get(
+                            "deterministic_accept",
+                            True,
+                        )
+                    )
+                    for pair_id in review.meta.soft_pairs
                 )
                 evaluator_status = "used" if result.evaluator_used else "skipped"
                 _analysis_log(
-                    f"{prefix}: {accepted_count} accepted, {rejected_count} rejected, "
-                    f"evaluator={evaluator_status}, source={'cache' if cache_hit else 'llm'}"
+                    f"{review.meta.prefix}: {accepted_count} accepted, {rejected_count} rejected, "
+                    f"evaluator={evaluator_status}, source={review.source}"
                 )
                 if result.error_kind is not None:
-                    _analysis_log(f"{prefix}: {result.error_kind}; keeping analyst result")
-                for pair in prepared.packet["soft_pairs"]:
-                    normalized_pair = _pair_key(str(pair["left"]), str(pair["right"]))
+                    _analysis_log(
+                        f"{review.meta.prefix}: {result.error_kind}; keeping analyst result"
+                    )
+                for pair_id in review.meta.soft_pairs:
+                    normalized_pair = _pair_key(*pair_id.split("|", 1))
                     verdict = verdicts.get(normalized_pair)
                     if verdict is None:
                         continue
@@ -2224,45 +2439,31 @@ async def _accepted_soft_pairs(
                         accepted[normalized_pair] = soft_candidates[normalized_pair]
                     else:
                         accepted.pop(normalized_pair, None)
-            review_records.append(
-                {
-                    "label": label,
-                    "component_index": index,
-                    "component_count": total_components,
-                    "review_unit_index": unit_index,
-                    "review_unit_count": len(review_units),
-                    "status": "reviewed" if result.analyst_result is not None else "error",
-                    "reason": None,
-                    "source": "cache" if cache_hit else "llm",
-                    "cache_hit": cache_hit,
-                    "model": options.model,
-                    "cluster_id": cluster_id,
-                    "nodes": list(prepared.packet["nodes"]),
-                    "soft_pairs": _packet_soft_pair_ids(prepared.packet),
-                    "prepared_review_unit_hash": cache_key.prepared_review_unit_hash,
-                    "component_budget": _packet_budget_json(component_budget),
-                    "budget": _packet_budget_json(prepared.budget),
-                    "overflow_policy": LLM_OVERFLOW_POLICY,
-                    "trimmed": prepared.trimmed,
-                    "aggressively_trimmed": prepared.aggressively_trimmed,
-                    "split": prepared.split,
-                    "analyst_result": (
-                        None
-                        if result.analyst_result is None
-                        else result.analyst_result.model_dump(mode="json")
-                    ),
-                    "evaluator_result": (
-                        None
-                        if result.evaluator_result is None
-                        else result.evaluator_result.model_dump(mode="json")
-                    ),
-                    "evaluator_used": result.evaluator_used,
-                    "retried": result.retried,
-                    "accepted_nontrivial_soft_edge": accepted_nontrivial,
-                    "error_kind": result.error_kind,
-                    "error_message": result.error_message,
-                }
+                if (
+                    pending is not None
+                    and review.source == "llm"
+                    and _cacheable_cluster_analysis_result(result)
+                ):
+                    hybrid_review_cache.put(
+                        HybridReviewCacheEntry(
+                            key=pending.cache_key,
+                            result=_cluster_analysis_call_result_payload(result),
+                            cached_at=_iso_now(),
+                            nodes=tuple(pending.prepared.packet["nodes"]),
+                            soft_pairs=tuple(_packet_soft_pair_ids(pending.prepared.packet)),
+                            budget=_packet_budget_json(pending.prepared.budget),
+                            split=pending.prepared.split,
+                            trimmed=pending.prepared.trimmed,
+                            aggressively_trimmed=pending.prepared.aggressively_trimmed,
+                        )
+                    )
+        review_records.append(
+            _soft_pair_review_record(
+                review=review,
+                model=options.model,
+                accepted_nontrivial_soft_edge=accepted_nontrivial,
             )
+        )
     return accepted, llm_used, review_records
 
 

src/slop_farmer/reports/analysis_service.py

@@ -6,12 +6,16 @@ from typing import Any
 
 from slop_farmer.data.parquet_io import read_json
 from slop_farmer.data.search_duckdb import connect_pr_search_db, resolve_active_run
+from slop_farmer.data.snapshot_paths import (
+    ANALYSIS_REPORT_FILENAME_BY_VARIANT,
+    CURRENT_ANALYSIS_MANIFEST_PATH,
+    analysis_run_manifest_path,
+    load_archived_analysis_run_manifest,
+    load_current_analysis_manifest,
+    repo_relative_path_to_local,
+)
 
 ANALYSIS_VARIANTS = {"auto", "deterministic", "hybrid"}
-ANALYSIS_REPORT_FILENAMES = {
-    "deterministic": "analysis-report.json",
-    "hybrid": "analysis-report-hybrid.json",
-}
 
 
 @dataclass(frozen=True, slots=True)
@@ -28,6 +32,7 @@ class AnalysisContext:
     report_source: str
     variant_requested: str
     variant_used: str
+    analysis_id: str | None
 
 
 def get_analysis_status(
@@ -35,14 +40,15 @@ def get_analysis_status(
     *,
     repo: str | None = None,
     variant: str = "auto",
-    analysis_root: Path | None = None,
+    snapshot_id: str | None = None,
+    analysis_id: str | None = None,
 ) -> dict[str, Any]:
     active = _resolve_active_snapshot_context(db_path, repo=repo)
-    report_path, variant_used, report_source = _resolve_analysis_report_path(
+    report_path, variant_used, report_source, resolved_analysis_id = _resolve_analysis_report_path(
         active.snapshot_dir,
-        str(active.active_run["repo"]),
         variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
         required=False,
     )
     payload = {
@@ -55,7 +61,7 @@ def get_analysis_status(
     if report_path is None or variant_used is None or report_source is None:
         return payload
     report = _load_report(report_path)
-    return {
+    status = {
         **payload,
         "snapshot_id": str(report.get("snapshot_id") or active.active_run["snapshot_id"]),
         "variant_used": variant_used,
@@ -64,6 +70,9 @@ def get_analysis_status(
         "generated_at": report.get("generated_at"),
         "counts": _analysis_counts(report),
     }
+    if resolved_analysis_id is not None:
+        status["analysis_id"] = resolved_analysis_id
+    return status
 
 
 def get_pr_analysis(
@@ -72,13 +81,15 @@ def get_pr_analysis(
     pr_number: int,
     repo: str | None = None,
     variant: str = "auto",
-    analysis_root: Path | None = None,
+    snapshot_id: str | None = None,
+    analysis_id: str | None = None,
 ) -> dict[str, Any]:
     context = _load_analysis_context(
         db_path,
         repo=repo,
         variant=variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
     )
     meta_bug, rank = _find_meta_bug_for_pr(context.report, pr_number)
     duplicate_pr = _find_duplicate_pr_for_pr(context.report, pr_number)
@@ -97,13 +108,15 @@ def list_analysis_meta_bugs(
     repo: str | None = None,
     variant: str = "auto",
     limit: int = 50,
-    analysis_root: Path | None = None,
+    snapshot_id: str | None = None,
+    analysis_id: str | None = None,
 ) -> dict[str, Any]:
     context = _load_analysis_context(
         db_path,
         repo=repo,
         variant=variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
     )
     meta_bugs = [
         _meta_bug_payload(cluster, rank=index)
@@ -122,13 +135,15 @@ def get_analysis_meta_bug(
     cluster_id: str,
     repo: str | None = None,
     variant: str = "auto",
-    analysis_root: Path | None = None,
+    snapshot_id: str | None = None,
+    analysis_id: str | None = None,
 ) -> dict[str, Any]:
     context = _load_analysis_context(
         db_path,
         repo=repo,
         variant=variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
     )
     for index, cluster in enumerate(context.report.get("meta_bugs", []), start=1):
         if str(cluster.get("cluster_id")) != cluster_id:
@@ -147,13 +162,15 @@ def list_analysis_duplicate_prs(
     repo: str | None = None,
     variant: str = "auto",
     limit: int = 50,
-    analysis_root: Path | None = None,
+    snapshot_id: str | None = None,
+    analysis_id: str | None = None,
 ) -> dict[str, Any]:
     context = _load_analysis_context(
         db_path,
         repo=repo,
         variant=variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
     )
     duplicate_prs = [
         {"rank": index, **dict(entry)}
@@ -171,13 +188,15 @@ def get_analysis_best(
     *,
     repo: str | None = None,
     variant: str = "auto",
-    analysis_root: Path | None = None,
+    snapshot_id: str | None = None,
+    analysis_id: str | None = None,
 ) -> dict[str, Any]:
     context = _load_analysis_context(
         db_path,
         repo=repo,
         variant=variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
     )
     return {
         **_analysis_base_payload(context),
@@ -217,14 +236,15 @@ def _load_analysis_context(
     *,
     repo: str | None,
     variant: str,
-    analysis_root: Path | None,
+    snapshot_id: str | None,
+    analysis_id: str | None,
 ) -> AnalysisContext:
     active = _resolve_active_snapshot_context(db_path, repo=repo)
-    report_path, variant_used, report_source = _resolve_analysis_report_path(
+    report_path, variant_used, report_source, resolved_analysis_id = _resolve_analysis_report_path(
         active.snapshot_dir,
-        str(active.active_run["repo"]),
         variant,
-        analysis_root=analysis_root,
+        snapshot_id=snapshot_id,
+        analysis_id=analysis_id,
         required=True,
     )
     assert report_path is not None
@@ -237,59 +257,143 @@ def _load_analysis_context(
         report_source=report_source,
         variant_requested=_normalize_analysis_variant(variant),
         variant_used=variant_used,
+        analysis_id=resolved_analysis_id,
     )
 
 
 def _resolve_analysis_report_path(
     snapshot_dir: Path,
-    repo: str,
     variant: str,
     *,
-    analysis_root: Path | None,
+    snapshot_id: str | None,
+    analysis_id: str | None,
     required: bool,
-) -> tuple[Path | None, str | None, str | None]:
+) -> tuple[Path | None, str | None, str | None, str | None]:
     normalized = _normalize_analysis_variant(variant)
-    candidate_dirs = _candidate_analysis_dirs(
-        snapshot_dir=snapshot_dir,
-        repo=repo,
-        analysis_root=analysis_root,
-    )
-    if normalized == "auto":
-        for source, directory in candidate_dirs:
-            hybrid_path = directory / ANALYSIS_REPORT_FILENAMES["hybrid"]
-            if hybrid_path.exists():
-                return hybrid_path, "hybrid", source
-            deterministic_path = directory / ANALYSIS_REPORT_FILENAMES["deterministic"]
-            if deterministic_path.exists():
-                return deterministic_path, "deterministic", source
+    if (snapshot_id is None) != (analysis_id is None):
+        raise ValueError("snapshot_id and analysis_id must be provided together.")
+    if snapshot_id is not None and analysis_id is not None:
+        selection = _resolve_archived_analysis_report_path(
+            snapshot_dir,
+            snapshot_id=snapshot_id,
+            analysis_id=analysis_id,
+            variant=normalized,
+        )
+        if selection is not None:
+            return (*selection, analysis_id)
         if not required:
-            return None, None, None
+            return None, None, None, None
         raise ValueError(
-            "No analysis report was found for the current analysis path or active snapshot."
+            f"Published analysis run {analysis_id!r} for snapshot {snapshot_id!r} was not found."
         )
-    for source, directory in candidate_dirs:
-        report_path = directory / ANALYSIS_REPORT_FILENAMES[normalized]
-        if report_path.exists():
-            return report_path, normalized, source
+
+    current_manifest_path = repo_relative_path_to_local(
+        snapshot_dir, CURRENT_ANALYSIS_MANIFEST_PATH
+    )
+    if normalized == "deterministic":
+        selection = _resolve_snapshot_local_report_path(snapshot_dir, variant=normalized)
+        if selection is not None:
+            return (*selection, None)
+
+    if current_manifest_path.exists():
+        report_path, variant_used = _resolve_manifest_report_path(
+            snapshot_dir,
+            load_current_analysis_manifest(current_manifest_path),
+            variant=normalized,
+            manifest_kind="current",
+        )
+        return (
+            report_path,
+            variant_used,
+            "current",
+            str(load_current_analysis_manifest(current_manifest_path)["analysis_id"]),
+        )
+
+    selection = _resolve_snapshot_local_report_path(snapshot_dir, variant=normalized)
+    if selection is not None:
+        return (*selection, None)
     if not required:
-        return None, None, None
+        return None, None, None, None
     raise ValueError(
-        f"{normalized.capitalize()} analysis report was not found for the current analysis path or active snapshot."
+        "No analysis report was found for the current analysis view or active snapshot."
+    )
+
+
+def _resolve_archived_analysis_report_path(
+    snapshot_dir: Path,
+    *,
+    snapshot_id: str,
+    analysis_id: str,
+    variant: str,
+) -> tuple[Path, str, str] | None:
+    manifest_path = repo_relative_path_to_local(
+        snapshot_dir,
+        analysis_run_manifest_path(snapshot_id, analysis_id),
+    )
+    if not manifest_path.exists():
+        return None
+    report_path, variant_used = _resolve_manifest_report_path(
+        snapshot_dir,
+        load_archived_analysis_run_manifest(manifest_path),
+        variant=variant,
+        manifest_kind="archived",
     )
+    return report_path, variant_used, "archived"
 
 
-def _candidate_analysis_dirs(
+def _resolve_manifest_report_path(
+    snapshot_dir: Path,
+    manifest: dict[str, Any],
     *,
+    variant: str,
+    manifest_kind: str,
+) -> tuple[Path, str]:
+    artifact_key = _artifact_key_for_variant(variant, manifest_kind=manifest_kind)
+    artifacts = manifest.get("artifacts") or {}
+    artifact_path = artifacts.get(artifact_key)
+    if not isinstance(artifact_path, str) or not artifact_path:
+        message = (
+            f"Published {manifest_kind} analysis manifest does not provide the {variant} artifact."
+            if variant != "auto"
+            else f"Published {manifest_kind} analysis manifest does not provide the canonical hybrid artifact."
+        )
+        raise ValueError(message)
+    report_path = repo_relative_path_to_local(snapshot_dir, artifact_path)
+    if not report_path.exists():
+        raise ValueError(
+            f"Published {manifest_kind} analysis artifact {artifact_path!r} is missing from the materialized snapshot."
+        )
+    variant_used = "hybrid" if artifact_key == "hybrid" else variant
+    return report_path, variant_used
+
+
+def _artifact_key_for_variant(variant: str, *, manifest_kind: str) -> str:
+    if variant == "auto":
+        return "hybrid"
+    if variant == "hybrid":
+        return "hybrid"
+    raise ValueError(
+        f"Published {manifest_kind} analysis only serves canonical hybrid artifacts; requested {variant!r}."
+    )
+
+
+def _resolve_snapshot_local_report_path(
     snapshot_dir: Path,
-    repo: str,
-    analysis_root: Path | None,
-) -> list[tuple[str, Path]]:
-    owner, name = repo.split("/", 1)
-    candidates: list[tuple[str, Path]] = []
-    if analysis_root is not None:
-        candidates.append(("current", analysis_root / owner / name / "current"))
-    candidates.append(("snapshot", snapshot_dir))
-    return candidates
+    *,
+    variant: str,
+) -> tuple[Path, str, str] | None:
+    if variant == "auto":
+        hybrid_path = snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT["hybrid"]
+        if hybrid_path.exists():
+            return hybrid_path, "hybrid", "snapshot"
+        deterministic_path = snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT["deterministic"]
+        if deterministic_path.exists():
+            return deterministic_path, "deterministic", "snapshot"
+        return None
+    report_path = snapshot_dir / ANALYSIS_REPORT_FILENAME_BY_VARIANT[variant]
+    if not report_path.exists():
+        return None
+    return report_path, variant, "snapshot"
 
 
 def _normalize_analysis_variant(variant: str) -> str:
@@ -304,7 +408,7 @@ def _normalize_analysis_variant(variant: str) -> str:
 def _analysis_base_payload(context: AnalysisContext) -> dict[str, Any]:
     active_snapshot_id = str(context.active_run["snapshot_id"])
     snapshot_id = str(context.report.get("snapshot_id") or active_snapshot_id)
-    return {
+    payload = {
         "repo": str(context.active_run["repo"]),
         "snapshot_id": snapshot_id,
         "active_snapshot_id": active_snapshot_id,
@@ -315,6 +419,9 @@ def _analysis_base_payload(context: AnalysisContext) -> dict[str, Any]:
         "llm_enrichment": bool(context.report.get("llm_enrichment")),
         "generated_at": context.report.get("generated_at"),
     }
+    if context.analysis_id is not None:
+        payload["analysis_id"] = context.analysis_id
+    return payload
 
 
 def _analysis_counts(report: dict[str, Any]) -> dict[str, int]:

src/slop_farmer/reports/dashboard.py

@@ -8,7 +8,11 @@ from typing import Any
 
 from slop_farmer.config import DashboardDataOptions
 from slop_farmer.data.parquet_io import read_json, read_parquet_rows
-from slop_farmer.data.snapshot_paths import resolve_snapshot_dir_from_snapshots_root
+from slop_farmer.data.snapshot_paths import (
+    ResolvedAnalysisReportPath,
+    resolve_default_dashboard_analysis_report,
+)
+from slop_farmer.data.snapshot_source import resolve_snapshot_source_dir
 
 
 def run_dashboard_data(options: DashboardDataOptions) -> Path:
@@ -16,7 +20,8 @@ def run_dashboard_data(options: DashboardDataOptions) -> Path:
     manifest = _read_optional_json(snapshot_dir / "manifest.json")
     issues = read_parquet_rows(snapshot_dir / "issues.parquet")
     pull_requests = read_parquet_rows(snapshot_dir / "pull_requests.parquet")
-    analysis = _read_optional_json(options.analysis_input or snapshot_dir / "analysis-report.json")
+    analysis_path = _resolve_analysis_input(snapshot_dir, options.analysis_input)
+    analysis = _read_optional_json(analysis_path.path) if analysis_path is not None else {}
     contributor_report = _read_optional_json(
         options.contributors_input or snapshot_dir / "new-contributors-report.json"
     )
@@ -67,6 +72,21 @@ def run_dashboard_data(options: DashboardDataOptions) -> Path:
         "clustered_pr_count": sum(1 for row in prs if row["cluster_id"]),
         "contributor_count": len(contributors),
         "analysis_available": bool(analysis),
+        "analysis_source": None if analysis_path is None else analysis_path.source,
+        "analysis_variant": None if analysis_path is None else analysis_path.variant,
+        "analysis_snapshot_id": (
+            None
+            if analysis_path is None
+            else (
+                analysis_path.snapshot_id
+                or (
+                    str(analysis.get("snapshot_id")).strip()
+                    if analysis.get("snapshot_id") is not None
+                    else None
+                )
+            )
+        ),
+        "analysis_id": None if analysis_path is None else analysis_path.analysis_id,
         "contributors_available": bool(contributor_report),
         "pr_scope_available": bool(pr_scope_report),
         "pr_scope_cluster_count": len(pr_scope_clusters),
@@ -88,7 +108,29 @@ def _resolve_snapshot_dir(options: DashboardDataOptions) -> Path:
         if options.snapshot_root is not None
         else (Path("data") / "snapshots").resolve()
     )
-    return resolve_snapshot_dir_from_snapshots_root(snapshots_root, options.snapshot_dir)
+    return resolve_snapshot_source_dir(
+        snapshot_dir=options.snapshot_dir,
+        local_snapshots_root=snapshots_root,
+        hf_repo_id=options.hf_repo_id,
+        hf_revision=options.hf_revision,
+        hf_materialize_dir=options.hf_materialize_dir,
+        hf_output_dir=snapshots_root.parent,
+    )
+
+
+def _resolve_analysis_input(
+    snapshot_dir: Path, override_path: Path | None
+) -> ResolvedAnalysisReportPath | None:
+    if override_path is not None:
+        resolved = override_path.resolve()
+        if not resolved.exists():
+            raise FileNotFoundError(f"Dashboard analysis input not found: {resolved}")
+        return ResolvedAnalysisReportPath(
+            path=resolved,
+            variant=_analysis_variant_for_path(resolved),
+            source="override",
+        )
+    return resolve_default_dashboard_analysis_report(snapshot_dir)
 
 
 def _read_optional_json(path: Path) -> dict[str, Any]:
@@ -153,6 +195,14 @@ def _excerpt(value: Any, limit: int = 240) -> str | None:
     return compact[: limit - 1].rstrip() + "…"
 
 
+def _analysis_variant_for_path(path: Path) -> str:
+    if path.name == "analysis-report-hybrid.json":
+        return "hybrid"
+    if path.name == "analysis-report.json":
+        return "deterministic"
+    return "override"
+
+
 def _cluster_rows(
     analysis: dict[str, Any],
     issue_map: dict[int, dict[str, Any]],

src/slop_farmer/reports/new_contributor_report.py

@@ -12,7 +12,7 @@ from typing import Any
 from slop_farmer.config import NewContributorReportOptions, resolve_github_token
 from slop_farmer.data.http import urlopen_with_retry
 from slop_farmer.data.parquet_io import read_json, read_parquet_rows, write_parquet, write_text
-from slop_farmer.data.snapshot_paths import resolve_snapshot_dir_from_output
+from slop_farmer.data.snapshot_source import resolve_snapshot_source_dir
 from slop_farmer.reports.user_activity import summarize_user
 
 GRAPHQL_URL = "https://api.github.com/graphql"
@@ -131,7 +131,14 @@ def run_new_contributor_report(options: NewContributorReportOptions) -> Path:
 
 
 def _resolve_snapshot_dir(options: NewContributorReportOptions) -> Path:
-    return resolve_snapshot_dir_from_output(options.output_dir, options.snapshot_dir)
+    return resolve_snapshot_source_dir(
+        snapshot_dir=options.snapshot_dir,
+        local_snapshots_root=options.output_dir.resolve() / "snapshots",
+        hf_repo_id=options.hf_repo_id,
+        hf_revision=options.hf_revision,
+        hf_materialize_dir=options.hf_materialize_dir,
+        hf_output_dir=options.output_dir,
+    )
 
 
 def _load_snapshot(snapshot_dir: Path) -> dict[str, Any]:
@@ -244,7 +251,6 @@ def _report_contributors(
             previous_report_reusable
             and previous_entry is not None
             and not previous_entry.get("fetch_error")
-            and not known_via_prior_merged_pr
         ):
             contributors.append(
                 _reused_previous_report_entry(
@@ -256,6 +262,8 @@ def _report_contributors(
                 )
             )
             reused_previous_report += 1
+            if known_via_prior_merged_pr:
+                reused_known_merged += 1
             continue
         try:
             summary = summarize_user(row["author_login"], options.window_days, None)

src/slop_farmer/reports/pr_scope.py

@@ -42,11 +42,7 @@ from typing import Any
 from pydantic import BaseModel, Field
 
 from slop_farmer.data.parquet_io import read_json, read_parquet_rows
-from slop_farmer.data.snapshot_materialize import materialize_hf_dataset_snapshot
-from slop_farmer.data.snapshot_paths import (
-    default_hf_materialize_dir,
-    resolve_snapshot_dir_from_output,
-)
+from slop_farmer.data.snapshot_source import resolve_snapshot_source_dir
 from slop_farmer.reports.pr_heuristics import (
     compile_cluster_suppression_rules,
     suppressed_pull_request_reasons,
@@ -260,17 +256,14 @@ def run_pr_scope_report(options: Any) -> Path:
 
 
 def _resolve_snapshot_dir(options: Any) -> Path:
-    if options.hf_repo_id:
-        snapshot_dir = materialize_hf_dataset_snapshot(
-            repo_id=options.hf_repo_id,
-            local_dir=options.hf_materialize_dir
-            or default_hf_materialize_dir(
-                options.output_dir, options.hf_repo_id, options.hf_revision
-            ),
-            revision=options.hf_revision,
-        )
-        return snapshot_dir.resolve()
-    return resolve_snapshot_dir_from_output(options.output_dir, options.snapshot_dir)
+    return resolve_snapshot_source_dir(
+        snapshot_dir=options.snapshot_dir,
+        local_snapshots_root=options.output_dir.resolve() / "snapshots",
+        hf_repo_id=options.hf_repo_id,
+        hf_revision=options.hf_revision,
+        hf_materialize_dir=options.hf_materialize_dir,
+        hf_output_dir=options.output_dir,
+    )
 
 
 def _load_snapshot_context(snapshot_dir: Path) -> dict[str, Any]:

src/slop_farmer/reports/pr_search_scope.py

@@ -10,11 +10,7 @@ from typing import Any
 
 from slop_farmer.config import PrSearchRefreshOptions
 from slop_farmer.data.parquet_io import read_json, read_parquet_rows
-from slop_farmer.data.snapshot_materialize import materialize_hf_dataset_snapshot
-from slop_farmer.data.snapshot_paths import (
-    default_hf_materialize_dir,
-    resolve_snapshot_dir_from_output,
-)
+from slop_farmer.data.snapshot_source import resolve_snapshot_source_dir
 from slop_farmer.reports.pr_heuristics import (
     compile_cluster_suppression_rules,
     suppressed_pull_request_reasons,
@@ -36,17 +32,14 @@ DEFAULT_CANDIDATE_LIMIT = 5
 
 
 def resolve_pr_search_snapshot_dir(options: PrSearchRefreshOptions) -> Path:
-    if options.hf_repo_id:
-        snapshot_dir = materialize_hf_dataset_snapshot(
-            repo_id=options.hf_repo_id,
-            local_dir=options.hf_materialize_dir
-            or default_hf_materialize_dir(
-                options.output_dir, options.hf_repo_id, options.hf_revision
-            ),
-            revision=options.hf_revision,
-        )
-        return snapshot_dir.resolve()
-    return resolve_snapshot_dir_from_output(options.output_dir, options.snapshot_dir)
+    return resolve_snapshot_source_dir(
+        snapshot_dir=options.snapshot_dir,
+        local_snapshots_root=options.output_dir.resolve() / "snapshots",
+        hf_repo_id=options.hf_repo_id,
+        hf_revision=options.hf_revision,
+        hf_materialize_dir=options.hf_materialize_dir,
+        hf_output_dir=options.output_dir,
+    )
 
 
 def load_pr_search_snapshot(snapshot_dir: Path) -> dict[str, Any]:
@@ -54,6 +47,7 @@ def load_pr_search_snapshot(snapshot_dir: Path) -> dict[str, Any]:
     manifest = read_json(manifest_path) if manifest_path.exists() else {}
     pull_requests = read_parquet_rows(snapshot_dir / "pull_requests.parquet")
     pr_files = read_parquet_rows(snapshot_dir / "pr_files.parquet")
+    contributors = read_parquet_rows(snapshot_dir / "new_contributors.parquet")
     repo = manifest.get("repo") or (pull_requests[0].get("repo") if pull_requests else None) or ""
     snapshot_id = manifest.get("snapshot_id") or snapshot_dir.name
     return {
@@ -62,6 +56,7 @@ def load_pr_search_snapshot(snapshot_dir: Path) -> dict[str, Any]:
         "manifest": manifest,
         "pull_requests": pull_requests,
         "pr_files": pr_files,
+        "contributors": contributors,
     }
 
 
@@ -412,6 +407,7 @@ def _document_row(row: Mapping[str, Any]) -> dict[str, Any]:
     return {
         "pr_number": int(row["number"]),
         "github_id": row.get("github_id"),
+        "author_login": row.get("author_login"),
         "state": row.get("state"),
         "draft": bool(row.get("draft")),
         "merged": bool(row.get("merged")),

src/slop_farmer/reports/pr_search_service.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from collections.abc import Iterable, Mapping
+from collections.abc import Iterable, Mapping, Sequence
 from contextlib import suppress
 from pathlib import Path
 from typing import Any, Protocol
@@ -17,6 +17,8 @@ from slop_farmer.data.search_duckdb import (
     get_cluster,
     get_cluster_ids_for_prs,
     get_cluster_members,
+    get_contributor,
+    get_contributor_pulls,
     get_document,
     get_feature,
     get_pair_neighbor_row,
@@ -99,6 +101,16 @@ def run_pr_search_refresh(options: PrSearchRefreshOptions) -> dict[str, Any]:
             "pr_search_documents",
             _scoped_rows(artifacts["documents"], run_id=run_id, repo=repo),
         )
+        insert_rows(
+            connection,
+            "pr_search_contributors",
+            _contributor_rows(
+                snapshot["contributors"],
+                run_id=run_id,
+                repo=repo,
+                snapshot_id=str(snapshot["snapshot_id"]),
+            ),
+        )
         insert_rows(
             connection,
             "pr_scope_features",
@@ -290,6 +302,85 @@ def get_pr_search_candidate_clusters(
         connection.close()
 
 
+def get_pr_search_contributor(
+    db_path: Path,
+    *,
+    author_login: str,
+    repo: str | None = None,
+) -> dict[str, Any]:
+    connection = connect_pr_search_db(db_path, read_only=True)
+    try:
+        active_run = resolve_active_run(connection, repo=repo)
+        run_id = str(active_run["id"])
+        contributor = _require_contributor(connection, run_id=run_id, author_login=author_login)
+        pulls = _document_rows(
+            get_contributor_pulls(connection, run_id=run_id, author_login=author_login, limit=20)
+        )
+        return {
+            "repo": active_run["repo"],
+            "snapshot_id": active_run["snapshot_id"],
+            "run_id": run_id,
+            "contributor": contributor,
+            "pulls": pulls,
+            "pull_count": len(pulls),
+        }
+    finally:
+        connection.close()
+
+
+def get_pr_search_contributor_pulls(
+    db_path: Path,
+    *,
+    author_login: str,
+    repo: str | None = None,
+    limit: int = 20,
+) -> dict[str, Any]:
+    connection = connect_pr_search_db(db_path, read_only=True)
+    try:
+        active_run = resolve_active_run(connection, repo=repo)
+        run_id = str(active_run["id"])
+        contributor = _require_contributor(connection, run_id=run_id, author_login=author_login)
+        pulls = _document_rows(
+            get_contributor_pulls(connection, run_id=run_id, author_login=author_login, limit=limit)
+        )
+        return {
+            "repo": active_run["repo"],
+            "snapshot_id": active_run["snapshot_id"],
+            "run_id": run_id,
+            "contributor": contributor,
+            "pulls": pulls,
+            "pull_count": len(pulls),
+        }
+    finally:
+        connection.close()
+
+
+def get_pr_search_pull_contributor(
+    db_path: Path,
+    *,
+    pr_number: int,
+    repo: str | None = None,
+) -> dict[str, Any]:
+    connection = connect_pr_search_db(db_path, read_only=True)
+    try:
+        active_run = resolve_active_run(connection, repo=repo)
+        run_id = str(active_run["id"])
+        document = _require_document(connection, run_id=run_id, pr_number=pr_number)
+        author_login = str(document.get("author_login") or "").strip()
+        if not author_login:
+            raise ValueError(f"PR #{pr_number} does not have an indexed author_login.")
+        contributor = _require_contributor(connection, run_id=run_id, author_login=author_login)
+        return {
+            "repo": active_run["repo"],
+            "snapshot_id": active_run["snapshot_id"],
+            "run_id": run_id,
+            "pr": _without_json_fields(document),
+            "contributor": contributor,
+        }
+    finally:
+        connection.close()
+
+
 def get_pr_search_similar_lookup(
     db_path: Path,
     *,
@@ -801,6 +892,15 @@ def _require_feature(connection: Any, *, run_id: str, pr_number: int) -> dict[st
     return feature
 
 
+def _require_contributor(connection: Any, *, run_id: str, author_login: str) -> dict[str, Any]:
+    contributor = get_contributor(connection, run_id=run_id, author_login=author_login)
+    if contributor is None:
+        raise ValueError(
+            f"Contributor {author_login!r} was not found in the active indexed universe."
+        )
+    return _contributor_row(contributor)
+
+
 def _json_list(raw: Any) -> list[str]:
     if isinstance(raw, list):
         return [str(item) for item in raw]
@@ -838,6 +938,71 @@ def _without_json_fields(row: Mapping[str, Any]) -> dict[str, Any]:
     return {str(key): value for key, value in row.items() if not str(key).endswith("_json")}
 
 
+def _document_rows(rows: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
+    return [_without_json_fields(row) for row in rows]
+
+
+def _contributor_rows(
+    rows: list[Mapping[str, Any]],
+    *,
+    run_id: str,
+    repo: str,
+    snapshot_id: str,
+) -> list[dict[str, Any]]:
+    return [
+        {
+            "run_id": run_id,
+            "repo": repo,
+            "snapshot_id": snapshot_id,
+            "report_generated_at": row.get("report_generated_at"),
+            "window_days": row.get("window_days"),
+            "author_login": row.get("author_login"),
+            "name": row.get("name"),
+            "profile_url": row.get("profile_url"),
+            "repo_pull_requests_url": row.get("repo_pull_requests_url"),
+            "repo_issues_url": row.get("repo_issues_url"),
+            "repo_first_seen_at": row.get("repo_first_seen_at"),
+            "repo_last_seen_at": row.get("repo_last_seen_at"),
+            "repo_primary_artifact_count": row.get("repo_primary_artifact_count"),
+            "repo_artifact_count": row.get("repo_artifact_count"),
+            "snapshot_issue_count": row.get("snapshot_issue_count"),
+            "snapshot_pr_count": row.get("snapshot_pr_count"),
+            "snapshot_comment_count": row.get("snapshot_comment_count"),
+            "snapshot_review_count": row.get("snapshot_review_count"),
+            "snapshot_review_comment_count": row.get("snapshot_review_comment_count"),
+            "repo_association": row.get("repo_association"),
+            "new_to_repo": row.get("new_to_repo"),
+            "first_seen_in_snapshot": row.get("first_seen_in_snapshot"),
+            "report_reason": row.get("report_reason"),
+            "account_age_days": row.get("account_age_days"),
+            "young_account": row.get("young_account"),
+            "follow_through_score": row.get("follow_through_score"),
+            "breadth_score": row.get("breadth_score"),
+            "automation_risk_signal": row.get("automation_risk_signal"),
+            "heuristic_note": row.get("heuristic_note"),
+            "public_orgs_json": row.get("public_orgs"),
+            "visible_authored_pr_count": row.get("visible_authored_pr_count"),
+            "merged_pr_count": row.get("merged_pr_count"),
+            "closed_unmerged_pr_count": row.get("closed_unmerged_pr_count"),
+            "open_pr_count": row.get("open_pr_count"),
+            "merged_pr_rate": row.get("merged_pr_rate"),
+            "closed_unmerged_pr_rate": row.get("closed_unmerged_pr_rate"),
+            "still_open_pr_rate": row.get("still_open_pr_rate"),
+            "distinct_repos_with_authored_prs": row.get("distinct_repos_with_authored_prs"),
+            "distinct_repos_with_open_prs": row.get("distinct_repos_with_open_prs"),
+            "fetch_error": row.get("fetch_error"),
+        }
+        for row in rows
+    ]
+
+
+def _contributor_row(row: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        **_without_json_fields(row),
+        "public_orgs": _json_list(row.get("public_orgs_json")),
+    }
+
+
 def _normalize_lookup_mode(mode: str) -> str:
     normalized = mode.strip().lower()
     if normalized not in {"auto", "indexed", "live"}:

src/slop_farmer/reports/read_views.py

@@ -5,6 +5,11 @@ from pathlib import Path
 from typing import Any, Literal
 
 from slop_farmer.data.parquet_io import read_json, read_parquet_rows
+from slop_farmer.data.snapshot_paths import (
+    CURRENT_ANALYSIS_MANIFEST_PATH,
+    load_current_analysis_manifest,
+    repo_relative_path_to_local,
+)
 
 AnalysisVariant = Literal["auto", "hybrid", "deterministic"]
 
@@ -252,7 +257,8 @@ def get_issue_best(snapshot_dir: Path, *, variant: AnalysisVariant) -> dict[str,
 def get_contributor_status(snapshot_dir: Path) -> dict[str, Any]:
     metadata = _snapshot_metadata(snapshot_dir)
     report = _read_optional_json(snapshot_dir / "new-contributors-report.json")
-    contributors = report.get("contributors") if isinstance(report.get("contributors"), list) else []
+    raw_contributors = report.get("contributors")
+    contributors: list[Any] = raw_contributors if isinstance(raw_contributors, list) else []
     return {
         "repo": str(report.get("repo") or metadata.repo),
         "snapshot_id": str(report.get("snapshot_id") or metadata.snapshot_id),
@@ -321,7 +327,12 @@ def _analysis_context(
     snapshot_dir: Path,
     *,
     variant: AnalysisVariant,
-) -> tuple[_SnapshotMetadata, _AnalysisSelection | None, dict[int, dict[str, Any]], dict[int, dict[str, Any]]]:
+) -> tuple[
+    _SnapshotMetadata,
+    _AnalysisSelection | None,
+    dict[int, dict[str, Any]],
+    dict[int, dict[str, Any]],
+]:
     metadata = _snapshot_metadata(snapshot_dir)
     selection = _select_analysis_report(_analysis_candidates(snapshot_dir), variant=variant)
     issue_map, pr_map = _artifact_maps(snapshot_dir)
@@ -395,16 +406,38 @@ def _select_analysis_report(
 
 
 def _analysis_report_paths(snapshot_dir: Path) -> list[Path]:
-    ordered = [
-        snapshot_dir / "analysis-report-hybrid.json",
-        snapshot_dir / "analysis-report-deterministic.json",
-        snapshot_dir / "analysis-report.json",
-    ]
-    seen = {path.name for path in ordered}
+    ordered: list[Path] = []
+    current_manifest_path = repo_relative_path_to_local(
+        snapshot_dir, CURRENT_ANALYSIS_MANIFEST_PATH
+    )
+    if current_manifest_path.exists():
+        try:
+            current_manifest = load_current_analysis_manifest(current_manifest_path)
+        except ValueError:
+            current_manifest = None
+        if current_manifest is not None:
+            for artifact_path in (current_manifest.get("artifacts") or {}).values():
+                if not isinstance(artifact_path, str):
+                    continue
+                ordered.append(repo_relative_path_to_local(snapshot_dir, artifact_path))
     ordered.extend(
-        path for path in sorted(snapshot_dir.glob("analysis-report*.json")) if path.name not in seen
+        [
+            snapshot_dir / "analysis-report-hybrid.json",
+            snapshot_dir / "analysis-report-deterministic.json",
+            snapshot_dir / "analysis-report.json",
+        ]
+    )
+    seen: set[Path] = set()
+    deduped: list[Path] = []
+    for path in ordered:
+        if path in seen:
+            continue
+        seen.add(path)
+        deduped.append(path)
+    deduped.extend(
+        path for path in sorted(snapshot_dir.glob("analysis-report*.json")) if path not in seen
     )
-    return [path for path in ordered if path.exists()]
+    return [path for path in deduped if path.exists()]
 
 
 def _analysis_auto_priority(candidate: dict[str, Any]) -> tuple[int, str]:
@@ -448,15 +481,25 @@ def _analysis_counts(payload: dict[str, Any]) -> dict[str, int]:
     }
 
 
-def _artifact_maps(snapshot_dir: Path) -> tuple[dict[int, dict[str, Any]], dict[int, dict[str, Any]]]:
-    issue_rows = read_parquet_rows(snapshot_dir / "issues.parquet") if (snapshot_dir / "issues.parquet").exists() else []
+def _artifact_maps(
+    snapshot_dir: Path,
+) -> tuple[dict[int, dict[str, Any]], dict[int, dict[str, Any]]]:
+    issue_rows = (
+        read_parquet_rows(snapshot_dir / "issues.parquet")
+        if (snapshot_dir / "issues.parquet").exists()
+        else []
+    )
     pr_rows = (
         read_parquet_rows(snapshot_dir / "pull_requests.parquet")
         if (snapshot_dir / "pull_requests.parquet").exists()
         else []
     )
-    issue_map = {int(row["number"]): row for row in issue_rows if _coerce_int(row.get("number")) is not None}
-    pr_map = {int(row["number"]): row for row in pr_rows if _coerce_int(row.get("number")) is not None}
+    issue_map = {
+        int(row["number"]): row for row in issue_rows if _coerce_int(row.get("number")) is not None
+    }
+    pr_map = {
+        int(row["number"]): row for row in pr_rows if _coerce_int(row.get("number")) is not None
+    }
     return issue_map, pr_map
 
 
@@ -474,7 +517,9 @@ def _issue_cluster_summary(
     return {
         "rank": rank,
         "cluster_id": str(cluster.get("cluster_id") or f"cluster-{rank or 0}"),
-        "title": _cluster_title(cluster, issue_map, pr_map, canonical_issue_number, canonical_pr_number),
+        "title": _cluster_title(
+            cluster, issue_map, pr_map, canonical_issue_number, canonical_pr_number
+        ),
         "summary": cluster.get("summary"),
         "status": cluster.get("status"),
         "confidence": _coerce_float(cluster.get("confidence")),
@@ -518,7 +563,9 @@ def _cluster_url(
     issue_map: dict[int, dict[str, Any]],
     pr_map: dict[int, dict[str, Any]],
 ) -> str | None:
-    return _url_for_issue(canonical_issue_number, issue_map) or _url_for_pr(canonical_pr_number, pr_map)
+    return _url_for_issue(canonical_issue_number, issue_map) or _url_for_pr(
+        canonical_pr_number, pr_map
+    )
 
 
 def _duplicate_pr_summary(
@@ -605,7 +652,8 @@ def _pr_member_row(number: int, row: dict[str, Any] | None, *, role: str) -> dic
 
 
 def _contributor_summary(contributor: dict[str, Any], *, rank: int | None = None) -> dict[str, Any]:
-    activity = contributor.get("activity") if isinstance(contributor.get("activity"), dict) else {}
+    raw_activity = contributor.get("activity")
+    activity: dict[str, Any] = raw_activity if isinstance(raw_activity, dict) else {}
     return {
         "rank": rank,
         "author_login": contributor.get("author_login"),
@@ -629,7 +677,8 @@ def _contributor_summary(contributor: dict[str, Any], *, rank: int | None = None
 
 
 def _contributor_risk(contributor: dict[str, Any]) -> dict[str, Any]:
-    activity = contributor.get("activity") if isinstance(contributor.get("activity"), dict) else {}
+    raw_activity = contributor.get("activity")
+    activity: dict[str, Any] = raw_activity if isinstance(raw_activity, dict) else {}
     return {
         "automation_risk_signal": contributor.get("automation_risk_signal"),
         "heuristic_note": contributor.get("heuristic_note"),

uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "fast-agent-mcp"
-version = "0.6.18"
+version = "0.6.17"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "a2a-sdk" },
@@ -598,9 +598,9 @@ dependencies = [
     { name = "uvloop", marker = "sys_platform != 'win32'" },
     { name = "watchfiles" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/68/9f/a66344581177eb70cd817a58a3305c4b2c2b5f98661129c2cecc4aa36e77/fast_agent_mcp-0.6.18.tar.gz", hash = "sha256:5ee5624890a9670b6f1a912998807e0fd451aa1c7205d189a964764a988c7bc0", size = 2091443, upload-time = "2026-04-17T20:52:25.84Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/a1/b6b1045345d38b342da3def7723a2dc6a44faff9c01fee6d81afbd272d62/fast_agent_mcp-0.6.17.tar.gz", hash = "sha256:a920113d47ef2ab82be1bd63b77d3bf78f8f862a5a6e91f1fd0aa931850fb25f", size = 2091401, upload-time = "2026-04-16T21:48:43.334Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/49/63/d8942bde2e706c869f93835ea85a2015be0edf5772c4e9ec8939a1001172/fast_agent_mcp-0.6.18-py3-none-any.whl", hash = "sha256:67c0c011763a28b8d5779b5d4d5cdc61e6f3dbc8cd1a7227388229957429835f", size = 1573842, upload-time = "2026-04-17T20:52:28.807Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/ef/47e05d6fa95e04ed8ad60afac3ae29d8205894fb220ffde193bd33578f3a/fast_agent_mcp-0.6.17-py3-none-any.whl", hash = "sha256:a23c5a5ed8924e38809dabd31f994e5cc81b8c084e84632bb1eb246b257c4752", size = 1573794, upload-time = "2026-04-16T21:48:38.999Z" },
 ]
 
 [[package]]
@@ -820,34 +820,34 @@ wheels = [
 
 [[package]]
 name = "hf-xet"
-version = "1.4.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/09/08/23c84a26716382c89151b5b447b4beb19e3345f3a93d3b73009a71a57ad3/hf_xet-1.4.2.tar.gz", hash = "sha256:b7457b6b482d9e0743bd116363239b1fa904a5e65deede350fbc0c4ea67c71ea", size = 672357, upload-time = "2026-03-13T06:58:51.077Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/06/e8cf74c3c48e5485c7acc5a990d0d8516cdfb5fdf80f799174f1287cc1b5/hf_xet-1.4.2-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ac8202ae1e664b2c15cdfc7298cbb25e80301ae596d602ef7870099a126fcad4", size = 3796125, upload-time = "2026-03-13T06:58:33.177Z" },
-    { url = "https://files.pythonhosted.org/packages/66/d4/b73ebab01cbf60777323b7de9ef05550790451eb5172a220d6b9845385ec/hf_xet-1.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6d2f8ee39fa9fba9af929f8c0d0482f8ee6e209179ad14a909b6ad78ffcb7c81", size = 3555985, upload-time = "2026-03-13T06:58:31.797Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/e7/ded6d1bd041c3f2bca9e913a0091adfe32371988e047dd3a68a2463c15a2/hf_xet-1.4.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4642a6cf249c09da8c1f87fe50b24b2a3450b235bf8adb55700b52f0ea6e2eb6", size = 4212085, upload-time = "2026-03-13T06:58:24.323Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c1/a0a44d1f98934f7bdf17f7a915b934f9fca44bb826628c553589900f6df8/hf_xet-1.4.2-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:769431385e746c92dc05492dde6f687d304584b89c33d79def8367ace06cb555", size = 3988266, upload-time = "2026-03-13T06:58:22.887Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/82/be713b439060e7d1f1d93543c8053d4ef2fe7e6922c5b31642eaa26f3c4b/hf_xet-1.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c9dd1c1bc4cc56168f81939b0e05b4c36dd2d28c13dc1364b17af89aa0082496", size = 4188513, upload-time = "2026-03-13T06:58:40.858Z" },
-    { url = "https://files.pythonhosted.org/packages/21/a6/cbd4188b22abd80ebd0edbb2b3e87f2633e958983519980815fb8314eae5/hf_xet-1.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:fca58a2ae4e6f6755cc971ac6fcdf777ea9284d7e540e350bb000813b9a3008d", size = 4428287, upload-time = "2026-03-13T06:58:42.601Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/4e/84e45b25e2e3e903ed3db68d7eafa96dae9a1d1f6d0e7fc85120347a852f/hf_xet-1.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:163aab46854ccae0ab6a786f8edecbbfbaa38fcaa0184db6feceebf7000c93c0", size = 3665574, upload-time = "2026-03-13T06:58:53.881Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/71/c5ac2b9a7ae39c14e91973035286e73911c31980fe44e7b1d03730c00adc/hf_xet-1.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:09b138422ecbe50fd0c84d4da5ff537d27d487d3607183cd10e3e53f05188e82", size = 3528760, upload-time = "2026-03-13T06:58:52.187Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/0f/fcd2504015eab26358d8f0f232a1aed6b8d363a011adef83fe130bff88f7/hf_xet-1.4.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:949dcf88b484bb9d9276ca83f6599e4aa03d493c08fc168c124ad10b2e6f75d7", size = 3796493, upload-time = "2026-03-13T06:58:39.267Z" },
-    { url = "https://files.pythonhosted.org/packages/82/56/19c25105ff81731ca6d55a188b5de2aa99d7a2644c7aa9de1810d5d3b726/hf_xet-1.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:41659966020d59eb9559c57de2cde8128b706a26a64c60f0531fa2318f409418", size = 3555797, upload-time = "2026-03-13T06:58:37.546Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/e3/8933c073186849b5e06762aa89847991d913d10a95d1603eb7f2c3834086/hf_xet-1.4.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c588e21d80010119458dd5d02a69093f0d115d84e3467efe71ffb2c67c19146", size = 4212127, upload-time = "2026-03-13T06:58:30.539Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/01/f89ebba4e369b4ed699dcb60d3152753870996f41c6d22d3d7cac01310e1/hf_xet-1.4.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a296744d771a8621ad1d50c098d7ab975d599800dae6d48528ba3944e5001ba0", size = 3987788, upload-time = "2026-03-13T06:58:29.139Z" },
-    { url = "https://files.pythonhosted.org/packages/84/4d/8a53e5ffbc2cc33bbf755382ac1552c6d9af13f623ed125fe67cc3e6772f/hf_xet-1.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f563f7efe49588b7d0629d18d36f46d1658fe7e08dce3fa3d6526e1c98315e2d", size = 4188315, upload-time = "2026-03-13T06:58:48.017Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/b8/b7a1c1b5592254bd67050632ebbc1b42cc48588bf4757cb03c2ef87e704a/hf_xet-1.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5b2e0132c56d7ee1bf55bdb638c4b62e7106f6ac74f0b786fed499d5548c5570", size = 4428306, upload-time = "2026-03-13T06:58:49.502Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/0c/40779e45b20e11c7c5821a94135e0207080d6b3d76e7b78ccb413c6f839b/hf_xet-1.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:2f45c712c2fa1215713db10df6ac84b49d0e1c393465440e9cb1de73ecf7bbf6", size = 3665826, upload-time = "2026-03-13T06:58:59.88Z" },
-    { url = "https://files.pythonhosted.org/packages/51/4c/e2688c8ad1760d7c30f7c429c79f35f825932581bc7c9ec811436d2f21a0/hf_xet-1.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:6d53df40616f7168abfccff100d232e9d460583b9d86fa4912c24845f192f2b8", size = 3529113, upload-time = "2026-03-13T06:58:58.491Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/86/b40b83a2ff03ef05c4478d2672b1fc2b9683ff870e2b25f4f3af240f2e7b/hf_xet-1.4.2-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:71f02d6e4cdd07f344f6844845d78518cc7186bd2bc52d37c3b73dc26a3b0bc5", size = 3800339, upload-time = "2026-03-13T06:58:36.245Z" },
-    { url = "https://files.pythonhosted.org/packages/64/2e/af4475c32b4378b0e92a587adb1aa3ec53e3450fd3e5fe0372a874531c00/hf_xet-1.4.2-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:e9b38d876e94d4bdcf650778d6ebbaa791dd28de08db9736c43faff06ede1b5a", size = 3559664, upload-time = "2026-03-13T06:58:34.787Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/4c/781267da3188db679e601de18112021a5cb16506fe86b246e22c5401a9c4/hf_xet-1.4.2-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:77e8c180b7ef12d8a96739a4e1e558847002afe9ea63b6f6358b2271a8bdda1c", size = 4217422, upload-time = "2026-03-13T06:58:27.472Z" },
-    { url = "https://files.pythonhosted.org/packages/68/47/d6cf4a39ecf6c7705f887a46f6ef5c8455b44ad9eb0d391aa7e8a2ff7fea/hf_xet-1.4.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c3b3c6a882016b94b6c210957502ff7877802d0dbda8ad142c8595db8b944271", size = 3992847, upload-time = "2026-03-13T06:58:25.989Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/ef/e80815061abff54697239803948abc665c6b1d237102c174f4f7a9a5ffc5/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9d9a634cc929cfbaf2e1a50c0e532ae8c78fa98618426769480c58501e8c8ac2", size = 4193843, upload-time = "2026-03-13T06:58:44.59Z" },
-    { url = "https://files.pythonhosted.org/packages/54/75/07f6aa680575d9646c4167db6407c41340cbe2357f5654c4e72a1b01ca14/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6b0932eb8b10317ea78b7da6bab172b17be03bbcd7809383d8d5abd6a2233e04", size = 4432751, upload-time = "2026-03-13T06:58:46.533Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/71/193eabd7e7d4b903c4aa983a215509c6114915a5a237525ec562baddb868/hf_xet-1.4.2-cp37-abi3-win_amd64.whl", hash = "sha256:ad185719fb2e8ac26f88c8100562dbf9dbdcc3d9d2add00faa94b5f106aea53f", size = 3671149, upload-time = "2026-03-13T06:58:57.07Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/7e/ccf239da366b37ba7f0b36095450efae4a64980bdc7ec2f51354205fdf39/hf_xet-1.4.2-cp37-abi3-win_arm64.whl", hash = "sha256:32c012286b581f783653e718c1862aea5b9eb140631685bb0c5e7012c8719a87", size = 3533426, upload-time = "2026-03-13T06:58:55.46Z" },
+version = "1.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", hash = "sha256:8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113", size = 670477, upload-time = "2026-03-31T22:40:07.874Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/43/724d307b34e353da0abd476e02f72f735cdd2bc86082dee1b32ea0bfee1d/hf_xet-1.4.3-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7551659ba4f1e1074e9623996f28c3873682530aee0a846b7f2f066239228144", size = 3800935, upload-time = "2026-03-31T22:39:49.618Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/d2/8bee5996b699262edb87dbb54118d287c0e1b2fc78af7cdc41857ba5e3c4/hf_xet-1.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:bee693ada985e7045997f05f081d0e12c4c08bd7626dc397f8a7c487e6c04f7f", size = 3558942, upload-time = "2026-03-31T22:39:47.938Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/a1/e993d09cbe251196fb60812b09a58901c468127b7259d2bf0f68bf6088eb/hf_xet-1.4.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21644b404bb0100fe3857892f752c4d09642586fd988e61501c95bbf44b393a3", size = 4207657, upload-time = "2026-03-31T22:39:39.69Z" },
+    { url = "https://files.pythonhosted.org/packages/64/44/9eb6d21e5c34c63e5e399803a6932fa983cabdf47c0ecbcfe7ea97684b8c/hf_xet-1.4.3-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:987f09cfe418237812896a6736b81b1af02a3a6dcb4b4944425c4c4fca7a7cf8", size = 3986765, upload-time = "2026-03-31T22:39:37.936Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/7b/8ad6f16fdb82f5f7284a34b5ec48645bd575bdcd2f6f0d1644775909c486/hf_xet-1.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:60cf7fc43a99da0a853345cf86d23738c03983ee5249613a6305d3e57a5dca74", size = 4188162, upload-time = "2026-03-31T22:39:58.382Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/c4/39d6e136cbeea9ca5a23aad4b33024319222adbdc059ebcda5fc7d9d5ff4/hf_xet-1.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2815a49a7a59f3e2edf0cf113ae88e8cb2ca2a221bf353fb60c609584f4884d4", size = 4424525, upload-time = "2026-03-31T22:40:00.225Z" },
+    { url = "https://files.pythonhosted.org/packages/46/f2/adc32dae6bdbc367853118b9878139ac869419a4ae7ba07185dc31251b76/hf_xet-1.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:42ee323265f1e6a81b0e11094564fb7f7e0ec75b5105ffd91ae63f403a11931b", size = 3671610, upload-time = "2026-03-31T22:40:10.42Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/19/25d897dcc3f81953e0c2cde9ec186c7a0fee413eb0c9a7a9130d87d94d3a/hf_xet-1.4.3-cp313-cp313t-win_arm64.whl", hash = "sha256:27c976ba60079fb8217f485b9c5c7fcd21c90b0367753805f87cb9f3cdc4418a", size = 3528529, upload-time = "2026-03-31T22:40:09.106Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/36/3e8f85ca9fe09b8de2b2e10c63b3b3353d7dda88a0b3d426dffbe7b8313b/hf_xet-1.4.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5251d5ece3a81815bae9abab41cf7ddb7bcb8f56411bce0827f4a3071c92fdc6", size = 3801019, upload-time = "2026-03-31T22:39:56.651Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/9c/defb6cb1de28bccb7bd8d95f6e60f72a3d3fa4cb3d0329c26fb9a488bfe7/hf_xet-1.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1feb0f3abeacee143367c326a128a2e2b60868ec12a36c225afb1d6c5a05e6d2", size = 3558746, upload-time = "2026-03-31T22:39:54.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/bd/8d001191893178ff8e826e46ad5299446e62b93cd164e17b0ffea08832ec/hf_xet-1.4.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8b301fc150290ca90b4fccd079829b84bb4786747584ae08b94b4577d82fb791", size = 4207692, upload-time = "2026-03-31T22:39:46.246Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/6790b402803250e9936435613d3a78b9aaeee7973439f0918848dde58309/hf_xet-1.4.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:d972fbe95ddc0d3c0fc49b31a8a69f47db35c1e3699bf316421705741aab6653", size = 3986281, upload-time = "2026-03-31T22:39:44.648Z" },
+    { url = "https://files.pythonhosted.org/packages/51/56/ea62552fe53db652a9099eda600b032d75554d0e86c12a73824bfedef88b/hf_xet-1.4.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c5b48db1ee344a805a1b9bd2cda9b6b65fe77ed3787bd6e87ad5521141d317cd", size = 4187414, upload-time = "2026-03-31T22:40:04.951Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/f5/bc1456d4638061bea997e6d2db60a1a613d7b200e0755965ec312dc1ef79/hf_xet-1.4.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:22bdc1f5fb8b15bf2831440b91d1c9bbceeb7e10c81a12e8d75889996a5c9da8", size = 4424368, upload-time = "2026-03-31T22:40:06.347Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/76/ab597bae87e1f06d18d3ecb8ed7f0d3c9a37037fc32ce76233d369273c64/hf_xet-1.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0392c79b7cf48418cd61478c1a925246cf10639f4cd9d94368d8ca1e8df9ea07", size = 3672280, upload-time = "2026-03-31T22:40:16.401Z" },
+    { url = "https://files.pythonhosted.org/packages/62/05/2e462d34e23a09a74d73785dbed71cc5dbad82a72eee2ad60a72a554155d/hf_xet-1.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:681c92a07796325778a79d76c67011764ecc9042a8c3579332b61b63ae512075", size = 3528945, upload-time = "2026-03-31T22:40:14.995Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/9f/9c23e4a447b8f83120798f9279d0297a4d1360bdbf59ef49ebec78fe2545/hf_xet-1.4.3-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d0da85329eaf196e03e90b84c2d0aca53bd4573d097a75f99609e80775f98025", size = 3805048, upload-time = "2026-03-31T22:39:53.105Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f8/7aacb8e5f4a7899d39c787b5984e912e6c18b11be136ef13947d7a66d265/hf_xet-1.4.3-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:e23717ce4186b265f69afa66e6f0069fe7efbf331546f5c313d00e123dc84583", size = 3562178, upload-time = "2026-03-31T22:39:51.295Z" },
+    { url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08", size = 4212320, upload-time = "2026-03-31T22:39:42.922Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/46d493db155d2ee2801b71fb1b0fd67696359047fdd8caee2c914cc50c79/hf_xet-1.4.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:39f2d2e9654cd9b4319885733993807aab6de9dfbd34c42f0b78338d6617421f", size = 3991546, upload-time = "2026-03-31T22:39:41.335Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/f5/067363e1c96c6b17256910830d1b54099d06287e10f4ec6ec4e7e08371fc/hf_xet-1.4.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:49ad8a8cead2b56051aa84d7fce3e1335efe68df3cf6c058f22a65513885baac", size = 4193200, upload-time = "2026-03-31T22:40:01.936Z" },
+    { url = "https://files.pythonhosted.org/packages/42/4b/53951592882d9c23080c7644542fda34a3813104e9e11fa1a7d82d419cb8/hf_xet-1.4.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7716d62015477a70ea272d2d68cd7cad140f61c52ee452e133e139abfe2c17ba", size = 4429392, upload-time = "2026-03-31T22:40:03.492Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/21/75a6c175b4e79662ad8e62f46a40ce341d8d6b206b06b4320d07d55b188c/hf_xet-1.4.3-cp37-abi3-win_amd64.whl", hash = "sha256:6b591fcad34e272a5b02607485e4f2a1334aebf1bc6d16ce8eb1eb8978ac2021", size = 3677359, upload-time = "2026-03-31T22:40:13.619Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/7c/44314ecd0e89f8b2b51c9d9e5e7a60a9c1c82024ac471d415860557d3cd8/hf_xet-1.4.3-cp37-abi3-win_arm64.whl", hash = "sha256:7c2c7e20bcfcc946dc67187c203463f5e932e395845d098cc2a93f5b67ca0b47", size = 3533664, upload-time = "2026-03-31T22:40:12.152Z" },
 ]
 
 [[package]]
@@ -902,7 +902,7 @@ wheels = [
 
 [[package]]
 name = "huggingface-hub"
-version = "1.7.2"
+version = "1.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
@@ -915,9 +915,9 @@ dependencies = [
     { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/19/15/eafc1c57bf0f8afffb243dcd4c0cceb785e956acc17bba4d9bf2ae21fc9c/huggingface_hub-1.7.2.tar.gz", hash = "sha256:7f7e294e9bbb822e025bdb2ada025fa4344d978175a7f78e824d86e35f7ab43b", size = 724684, upload-time = "2026-03-20T10:36:08.767Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/89/e7aa12d8a6b9259bed10671abb25ae6fa437c0f88a86ecbf59617bae7759/huggingface_hub-1.11.0.tar.gz", hash = "sha256:15fb3713c7f9cdff7b808a94fd91664f661ab142796bb48c9cd9493e8d166278", size = 761749, upload-time = "2026-04-16T13:07:39.73Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/de/3ad061a05f74728927ded48c90b73521b9a9328c85d841bdefb30e01fb85/huggingface_hub-1.7.2-py3-none-any.whl", hash = "sha256:288f33a0a17b2a73a1359e2a5fd28d1becb2c121748c6173ab8643fb342c850e", size = 618036, upload-time = "2026-03-20T10:36:06.824Z" },
+    { url = "https://files.pythonhosted.org/packages/37/02/4f3f8997d1ea7fe0146b343e5e14bd065fa87af790d07e5576d31b31cc18/huggingface_hub-1.11.0-py3-none-any.whl", hash = "sha256:42a6de0afbfeb5e022222d36398f029679db4eb4778801aafda32257ae9131ab", size = 645499, upload-time = "2026-04-16T13:07:37.716Z" },
 ]
 
 [[package]]
@@ -2366,7 +2366,7 @@ wheels = [
 
 [[package]]
 name = "slop-farmer"
-version = "0.1.0"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "duckdb" },
@@ -2398,7 +2398,7 @@ requires-dist = [
     { name = "fast-agent-mcp", marker = "python_full_version >= '3.13.5' and extra == 'llm'", specifier = ">=0.6.16" },
     { name = "fastapi", specifier = ">=0.115.0" },
     { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.28.0" },
-    { name = "huggingface-hub", specifier = ">=0.30.0" },
+    { name = "huggingface-hub", specifier = ">=1.11.0" },
     { name = "pyarrow", specifier = ">=18.0.0" },
     { name = "pydantic", specifier = ">=2.11" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3.0" },