Sync ctx b62b78d (part 4)

GitHub commit: b62b78d704ec54b3ff43e333982eef713a33c8df

src/tests/test_ci_classifier.py

@@ -434,7 +434,7 @@ def test_no_test_policy_requires_tests_for_release_sync_artifact_scripts() -> No
     for script in (
         "scripts/sync_huggingface.py",
         "scripts/pack_full_wiki_tar.py",
-        "scripts/graph_artifact_guard.py",
+        "scripts/graph_release_manifest.py",
     ):
         result = evaluate_policy([script], (), {script: "+print('changed')\n"})
 
@@ -449,20 +449,15 @@ def test_ci_workflows_default_to_read_only_token_permissions() -> None:
         assert "\npermissions:\n  contents: read\n" in workflow
 
 
-def test_graph_artifact_job_uses_release_asset_fallback_for_lfs_budget() -> None:
+def test_graph_artifact_job_uses_exact_release_manifest() -> None:
     workflow = Path(".github/workflows/test.yml").read_text(encoding="utf-8")
 
-    assert "Resolve graph artifacts from release assets or targeted LFS" in workflow
-    assert "Resolving graph artifacts from release cache, or targeted Git LFS" in workflow
-    assert 'tag_name.startswith("graph-artifacts-")' in workflow
-    assert "sha256:{expected_oid} size:{expected_size}" in workflow
-    assert "Pointer for {path_name} is not in release cache" in workflow
-    assert "searching release caches before targeted Git LFS" in workflow
-    assert '"git", "lfs", "pull", "--include", path_name' in workflow
-    assert "GIT_LFS_ACTIVITYTIMEOUT" in workflow
-    assert "Hydrated {path_name} from" in workflow
-    assert "graph/wiki-graph-runtime.tar.gz" in workflow
+    assert "Resolve graph artifacts from exact release manifest" in workflow
+    assert (
+        "python scripts/graph_release_manifest.py hydrate --manifest graph/release-artifacts.json"
+    ) in workflow
     assert "python src/validate_graph_artifacts.py" in workflow
+    assert "git lfs" not in workflow.lower()
     assert "validating pointer metadata only" not in workflow
 
 
@@ -515,13 +510,11 @@ def test_publish_static_gate_uses_canonical_python_target() -> None:
 def test_publish_workflow_validates_and_uploads_graph_assets() -> None:
     workflow = Path(".github/workflows/publish.yml").read_text(encoding="utf-8")
 
-    assert "Resolve release graph artifacts from release assets" in workflow
-    assert "Resolving graph artifacts from release cache, or targeted Git LFS" in workflow
-    assert "searching release caches before targeted Git LFS" in workflow
-    assert '"git", "lfs", "pull", "--include", path_name' in workflow
-    assert "verify_hydrated_file(graph_tar, expected_oid, expected_size)" in workflow
-    assert 'tag_name.startswith("graph-artifacts-")' in workflow
-    assert "sha256:{expected_oid} size:{expected_size}" in workflow
+    assert "Resolve release graph artifacts from exact release manifest" in workflow
+    assert (
+        "python scripts/graph_release_manifest.py hydrate --manifest graph/release-artifacts.json"
+    ) in workflow
+    assert "git lfs" not in workflow.lower()
     assert "Validate release graph artifacts" in workflow
     assert "python src/validate_graph_artifacts.py" in workflow
     assert "python src/update_repo_stats.py --check" in workflow

src/tests/test_ci_preflight.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from datetime import datetime
 import hashlib
+import io
 import json
 import shlex
 from pathlib import Path
@@ -15,6 +16,7 @@ from scripts.ci_preflight import _run_no_test_policy_for_files
 from scripts.ci_preflight import Check
 from scripts.ci_preflight import PUBLIC_DOCS_TRACKER_TESTS
 from scripts.ci_preflight import select_checks
+from ctx.core.graph import release_artifacts
 
 
 def _checks_for(files: list[str], *, profile: str = "pr") -> list[Check]:
@@ -52,6 +54,11 @@ def _workflow_unit_linux_coverage_command() -> list[str]:
     return shlex.split(run)
 
 
+def _workflow_step_names(job: str) -> list[str]:
+    workflow = yaml.safe_load(Path(".github/workflows/test.yml").read_text(encoding="utf-8"))
+    return [str(step.get("name", "")) for step in workflow["jobs"][job]["steps"]]
+
+
 def test_pr_docs_workflow_tracker_tests_match_preflight() -> None:
     assert _workflow_docs_tracker_tests() == PUBLIC_DOCS_TRACKER_TESTS
 
@@ -82,6 +89,11 @@ def test_preflight_runs_source_gates_for_source_changes() -> None:
         for check in _checks_for(["src/ctx/adapters/generic/loop.py"])
         if check.name == "unit-linux equivalent"
     )
+    unit_hydrate = next(
+        check
+        for check in _checks_for(["src/ctx/adapters/generic/loop.py"])
+        if check.name == "hydrate benchmark catalog"
+    )
     lanes = local_fast_gate.group_checks(_checks_for(["src/ctx/adapters/generic/loop.py"]))
     lanes_by_name = {
         lane.name: [check.name for check in lane.checks]
@@ -97,7 +109,7 @@ def test_preflight_runs_source_gates_for_source_changes() -> None:
     assert "A-Z canary" in names
     assert "clean host contract" in names
     assert lanes_by_name == {
-        "unit": ["unit-linux equivalent"],
+        "unit": ["hydrate benchmark catalog", "unit-linux equivalent"],
         "canary": ["A-Z canary"],
         "contract": ["contract compatibility local"],
         "clean-host": ["clean host contract"],
@@ -109,6 +121,26 @@ def test_preflight_runs_source_gates_for_source_changes() -> None:
         "--max-worker-restart=0",
     )
     assert workflow_unit_command[-4:] == list(unit_check.argv[-4:])
+    assert unit_hydrate.argv == (
+        "python",
+        "scripts/graph_release_manifest.py",
+        "hydrate",
+        "--manifest",
+        "graph/release-artifacts.json",
+        "--repo-root",
+        ".",
+        "--artifact",
+        "graph/wiki-graph-runtime.tar.gz",
+    )
+
+
+@pytest.mark.parametrize("job", ["unit-linux", "test"])
+def test_clean_checkout_test_jobs_hydrate_runtime_catalog_before_pytest(job: str) -> None:
+    names = _workflow_step_names(job)
+
+    assert names.index("Resolve benchmark catalog from exact release manifest") < names.index(
+        "Run tests with coverage gate" if job == "unit-linux" else "Run tests without coverage"
+    )
 
 
 def test_xdist_auto_worker_count_is_resource_capped(monkeypatch) -> None:
@@ -150,12 +182,20 @@ def test_preflight_runs_graph_validation_for_graph_artifacts() -> None:
     graph_lane = next(lane for lane in lanes if lane.name == "graph")
     graph_names = [check.name for check in graph_lane.checks]
 
-    assert names.index("hydrate graph LFS") < names.index("graph artifact validation")
+    assert names.index("hydrate graph release assets") < names.index("graph artifact validation")
     assert "graph artifact validation" in names
     assert "no-test policy" not in names
     assert "unit-linux equivalent" not in names
-    assert graph_names == ["hydrate graph LFS", "graph artifact validation"]
-    assert graph_lane.checks[0].argv[1] == "scripts/ci_preflight.py"
+    assert graph_names == ["hydrate graph release assets", "graph artifact validation"]
+    assert graph_lane.checks[0].argv == (
+        "python",
+        "scripts/graph_release_manifest.py",
+        "hydrate",
+        "--manifest",
+        "graph/release-artifacts.json",
+        "--repo-root",
+        ".",
+    )
 
 
 def test_local_fast_whitespace_check_runs_against_base() -> None:
@@ -450,72 +490,120 @@ def test_local_fast_kept_worktree_paths_remain_in_summary(monkeypatch, tmp_path:
     assert removed == []
 
 
-def test_preflight_graph_lfs_pointer_verification(tmp_path: Path, monkeypatch) -> None:
-    monkeypatch.setattr(ci_preflight, "REPO_ROOT", tmp_path)
-    artifact = tmp_path / "graph" / "wiki-graph.tar.gz"
-    artifact.parent.mkdir()
-    payload = b"hydrated graph payload"
-    expected_sha256 = hashlib.sha256(payload).hexdigest()
-    artifact.write_text(
-        "version https://git-lfs.github.com/spec/v1\n"
-        f"oid sha256:{expected_sha256}\n"
-        f"size {len(payload)}\n",
+def _write_release_artifact_manifest(
+    root: Path,
+    *,
+    tracked_payload: bytes = b"tracked graph payload",
+    archive_payload: bytes = b"release archive payload",
+) -> Path:
+    manifest_path = root / "graph" / "release-artifacts.json"
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    payloads = {
+        "communities.json": tracked_payload,
+        "entity-overlays.jsonl": b"tracked overlay payload",
+        "skills-sh-catalog.json.gz": b"tracked catalog payload",
+        "wiki-graph-runtime.tar.gz": b"release runtime payload",
+        "wiki-graph.tar.gz": archive_payload,
+    }
+    specs = (
+        ("graph/communities.json", "communities.json", False),
+        ("graph/entity-overlays.jsonl", "entity-overlays.jsonl", False),
+        ("graph/skills-sh-catalog.json.gz", "skills-sh-catalog.json.gz", False),
+        ("graph/wiki-graph-runtime.tar.gz", "wiki-graph-runtime.tar.gz", True),
+        ("graph/wiki-graph.tar.gz", "wiki-graph.tar.gz", True),
+    )
+    manifest_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "repository": "stevesolun/ctx",
+                "source_release_tag": "v1.0.21",
+                "artifacts": [
+                    {
+                        "path": path,
+                        "asset_name": asset_name,
+                        "size": len(payloads[asset_name]),
+                        "sha256": hashlib.sha256(payloads[asset_name]).hexdigest(),
+                        "hydrate": hydrate,
+                    }
+                    for path, asset_name, hydrate in specs
+                ],
+            }
+        )
+        + "\n",
         encoding="utf-8",
     )
+    return manifest_path
 
-    pointer = ci_preflight._read_lfs_pointer(artifact)
 
-    assert pointer == ci_preflight.LfsPointer(
-        "graph/wiki-graph.tar.gz",
-        expected_sha256,
-        len(payload),
+def test_preflight_hydrates_missing_archives_from_exact_release_url(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci_preflight, "REPO_ROOT", tmp_path)
+    tracked_payload = b"tracked graph payload"
+    archive_payload = b"release archive payload"
+    manifest_path = _write_release_artifact_manifest(
+        tmp_path,
+        tracked_payload=tracked_payload,
+        archive_payload=archive_payload,
     )
-    artifact.write_bytes(payload)
-    ci_preflight._verify_hydrated_lfs_pointer(pointer)
+    tracked_assets = {
+        "communities.json": tracked_payload,
+        "entity-overlays.jsonl": b"tracked overlay payload",
+        "skills-sh-catalog.json.gz": b"tracked catalog payload",
+    }
+    for asset_name, payload in tracked_assets.items():
+        (tmp_path / "graph" / asset_name).write_bytes(payload)
+    release_assets = {
+        "wiki-graph-runtime.tar.gz": b"release runtime payload",
+        "wiki-graph.tar.gz": archive_payload,
+    }
+
+    requested_urls: list[str] = []
+
+    def fake_urlopen(url: str, *, timeout: int) -> io.BytesIO:
+        requested_urls.append(url)
+        assert timeout == 120
+        return io.BytesIO(release_assets[url.rsplit("/", 1)[-1]])
 
+    monkeypatch.setattr(release_artifacts.urllib.request, "urlopen", fake_urlopen)
+
+    release_artifacts.hydrate_and_verify(repo_root=tmp_path, manifest_path=manifest_path)
+    assert requested_urls == [
+        "https://github.com/stevesolun/ctx/releases/download/v1.0.21/wiki-graph-runtime.tar.gz",
+        "https://github.com/stevesolun/ctx/releases/download/v1.0.21/wiki-graph.tar.gz",
+    ]
+    assert (tmp_path / "graph" / "wiki-graph.tar.gz").read_bytes() == archive_payload
 
-def test_preflight_graph_lfs_pull_uses_per_command_filters(
+
+def test_preflight_fails_closed_on_existing_graph_artifact_tamper(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
     monkeypatch.setattr(ci_preflight, "REPO_ROOT", tmp_path)
-    monkeypatch.setattr(ci_preflight.shutil, "which", lambda _name: "/usr/bin/git")
-    artifact = tmp_path / "graph" / "wiki-graph.tar.gz"
-    artifact.parent.mkdir()
-    artifact.write_text(
-        f"version https://git-lfs.github.com/spec/v1\noid sha256:{'a' * 64}\nsize 1\n",
-        encoding="utf-8",
+    manifest_path = _write_release_artifact_manifest(tmp_path)
+    tracked = tmp_path / "graph" / "communities.json"
+    tracked.write_bytes(b"tampered")
+    monkeypatch.setattr(
+        release_artifacts.urllib.request,
+        "urlopen",
+        lambda *_args, **_kwargs: pytest.fail("tamper must fail before network access"),
     )
-    calls: list[list[str]] = []
-
-    class Result:
-        returncode = 0
-
-    def fake_run(argv: list[str], **_kwargs) -> Result:
-        calls.append(argv)
-        return Result()
-
-    verified: list[ci_preflight.LfsPointer] = []
-    monkeypatch.setattr(ci_preflight.subprocess, "run", fake_run)
-    monkeypatch.setattr(ci_preflight, "_verify_hydrated_lfs_pointer", verified.append)
-
-    assert ci_preflight.hydrate_graph_lfs_artifacts() == 0
-
-    assert len(calls) == 1
-    argv = calls[0]
-    lfs_index = argv.index("lfs")
-    assert argv[:lfs_index] == ["git", *ci_preflight.GIT_LFS_FILTER_CONFIG]
-    assert argv[lfs_index:] == [
-        "lfs",
-        "pull",
-        "--include",
-        "graph/wiki-graph.tar.gz",
-        "--exclude",
-        "",
-    ]
-    assert verified == [
-        ci_preflight.LfsPointer("graph/wiki-graph.tar.gz", "a" * 64, 1),
-    ]
+
+    with pytest.raises(ValueError, match="artifact mismatch"):
+        release_artifacts.hydrate_and_verify(repo_root=tmp_path, manifest_path=manifest_path)
+    assert tracked.read_bytes() == b"tampered"
+
+
+def test_release_artifact_manifest_rejects_unknown_fields(tmp_path: Path) -> None:
+    manifest_path = _write_release_artifact_manifest(tmp_path)
+    payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    payload["unexpected"] = True
+    manifest_path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="unknown manifest fields"):
+        release_artifacts.load_manifest(manifest_path)
 
 
 def test_preflight_no_test_policy_invocation_uses_current_dirty_file_set() -> None:
@@ -600,7 +688,7 @@ def test_preflight_runs_browser_and_similarity_when_classified() -> None:
     graph_resolver_script = next(
         step["run"]
         for step in graph_steps
-        if step.get("name") == "Resolve graph artifacts from release assets or targeted LFS"
+        if "graph_release_manifest.py hydrate" in str(step.get("run", ""))
     )
 
     assert "browser monitor security" in names
@@ -615,10 +703,8 @@ def test_preflight_runs_browser_and_similarity_when_classified() -> None:
     assert "similarity" in lane_names
     assert "browser" in lane_names
     assert "package" in lane_names
-    assert "release_asset_wait_seconds = 300" in graph_resolver_script
-    assert 'os.environ.get("GITHUB_EVENT_NAME") == "pull_request"' in graph_resolver_script
-    assert "release_asset_wait_seconds = 0" in graph_resolver_script
-    assert 'env.setdefault("GIT_LFS_CONCURRENTTRANSFERS", "1")' in graph_resolver_script
+    assert "--manifest graph/release-artifacts.json" in graph_resolver_script
+    assert "git lfs" not in graph_resolver_script.lower()
 
 
 def test_every_workflow_parses_under_the_strict_loader() -> None:

src/tests/test_ctx_ab_benchmark.py

@@ -2522,6 +2522,67 @@ def test_catalog_archive_validation_rejects_traversal(tmp_path: Path) -> None:
         benchmark.validate_catalog_archive(archive)
 
 
+def test_production_catalog_hydration_uses_the_strict_release_manifest(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "repo"
+    script = root / "scripts" / "graph_release_manifest.py"
+    manifest = root / "graph" / "release-artifacts.json"
+    archive = root / "graph" / "wiki-graph-runtime.tar.gz"
+    script.parent.mkdir(parents=True)
+    manifest.parent.mkdir(parents=True)
+    script.write_text("# resolver\n", encoding="utf-8")
+    manifest.write_text("{}\n", encoding="utf-8")
+    calls: list[tuple[list[str], Path]] = []
+
+    def fake_run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+        calls.append((command, kwargs["cwd"]))
+        archive.write_bytes(b"hydrated")
+        return subprocess.CompletedProcess(command, 0, stdout="", stderr="")
+
+    monkeypatch.setattr(benchmark.subprocess, "run", fake_run)
+
+    assert benchmark.hydrate_production_catalog_archive(root=root) == archive
+    assert calls == [
+        (
+            [
+                sys.executable,
+                str(script),
+                "hydrate",
+                "--repo-root",
+                str(root),
+                "--manifest",
+                str(manifest),
+                "--artifact",
+                "graph/wiki-graph-runtime.tar.gz",
+            ],
+            root,
+        )
+    ]
+
+
+def test_production_catalog_hydration_rejects_an_existing_tampered_archive(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "repo"
+    archive = root / "graph" / "wiki-graph-runtime.tar.gz"
+    archive.parent.mkdir(parents=True)
+    archive.write_bytes(b"tampered-unmanifested-catalog")
+    calls: list[list[str]] = []
+
+    def reject_manifest(command: list[str], **_kwargs: Any) -> subprocess.CompletedProcess[str]:
+        calls.append(command)
+        return subprocess.CompletedProcess(command, 1, stdout="", stderr="artifact mismatch")
+
+    monkeypatch.setattr(benchmark.subprocess, "run", reject_manifest)
+
+    with pytest.raises(RuntimeError, match="artifact mismatch"):
+        benchmark.hydrate_production_catalog_archive(root=root)
+    assert len(calls) == 1
+
+
 def _write_runtime_availability(
     path: Path,
     *,

src/tests/test_ctx_ab_holdout_prepare.py

@@ -602,6 +602,17 @@ def test_create_protocol_writes_authenticated_canonical_output(
         version="codex 1.2.3",
         provider_config_sha256=benchmark.codex_provider_config_sha256("openai"),
     )
+    hydrated: list[Path] = []
+
+    def hydrate_catalog(*, root: Path) -> Path:
+        hydrated.append(root)
+        return product_paths[1]
+
+    monkeypatch.setattr(
+        prepare.benchmark,
+        "hydrate_production_catalog_archive",
+        hydrate_catalog,
+    )
     monkeypatch.setattr(prepare, "_repository_state", lambda _root: state)
     monkeypatch.setattr(prepare, "_assert_repository_unchanged", lambda _state: None)
     monkeypatch.setattr(prepare, "_committed_v1_protocol", lambda _state: _v1())
@@ -633,6 +644,7 @@ def test_create_protocol_writes_authenticated_canonical_output(
     assert digest == _sha256(output.read_bytes())
     assert document["frozen_at"] == "2026-07-30T10:00:00Z"
     assert document["product_inputs"]["revision"] == REVISION
+    assert hydrated == [root]
     assert document["product_inputs"]["origin_url"] == ORIGIN_URL
     assert document["product_inputs"]["origin_main_revision"] == REVISION
     assert document["product_inputs"]["codex_binary_sha256"] == codex.sha256

src/tests/test_ctx_init.py

@@ -24,6 +24,7 @@ from ctx.adapters.claude_code.install.skill_install import install_skill
 from ctx.adapters.generic.ctx_core_tools import CtxCoreToolbox
 from ctx.adapters.generic.providers import ToolCall
 from ctx.core.graph.graph_packs import write_base_pack
+from ctx.core.graph import release_artifacts
 from ctx.core.graph.graph_store import validate_graph_store
 from ctx.core.install_policy_store import (
     has_persisted_install_policy as has_real_install_policy,
@@ -103,17 +104,6 @@ def _write_dashboard_index(path: Path, *, export_id: str = "test-export") -> Non
         conn.close()
 
 
-def _artifact_sha256_or_lfs_oid(path: Path, *, normalize_text: bool = False) -> str:
-    data = path.read_bytes()
-    if data.startswith(b"version https://git-lfs.github.com/spec/v1\n"):
-        for line in data.decode("utf-8").splitlines():
-            if line.startswith("oid sha256:"):
-                return line.removeprefix("oid sha256:")
-    if normalize_text:
-        data = data.replace(b"\r\n", b"\n")
-    return hashlib.sha256(data).hexdigest()
-
-
 def test_ensure_directories_creates_standard_tree(tmp_path: Path) -> None:
     created = ci.ensure_directories(tmp_path)
     # First call should create every standard subdir.
@@ -771,40 +761,34 @@ def test_download_graph_archive_verifies_sha256(
         )
     assert not bad_destination.exists()
 
+    bad_size_destination = tmp_path / "bad-size-wiki-graph.tar.gz"
+    with pytest.raises(ValueError, match="size mismatch"):
+        ci._download_graph_archive(
+            bad_size_destination,
+            url="https://example.invalid/wiki-graph.tar.gz",
+            expected_sha256=hashlib.sha256(payload).hexdigest(),
+            expected_size=len(payload) + 1,
+        )
+    assert not bad_size_destination.exists()
+
 
 def test_graph_download_checksums_match_shipped_artifacts() -> None:
     root = Path(__file__).resolve().parent.parent.parent
+    manifest = release_artifacts.load_manifest(root / "graph" / "release-artifacts.json")
     for mode, archive_name in ci._GRAPH_ARCHIVE_NAMES.items():
-        path = root / "graph" / archive_name
-        assert ci._GRAPH_ARCHIVE_SHA256[mode] == _artifact_sha256_or_lfs_oid(path)
-
-    overlay_path = root / "graph" / ci._GRAPH_ENTITY_OVERLAY_NAME
-    assert ci._GRAPH_ENTITY_OVERLAY_SHA256 == _artifact_sha256_or_lfs_oid(
-        overlay_path,
-        normalize_text=True,
-    )
-
+        artifact = manifest.artifact_for_path(f"graph/{archive_name}")
+        assert ci._GRAPH_ARCHIVE_SHA256[mode] == artifact.sha256
+        assert ci._GRAPH_ARCHIVE_SIZE[mode] == artifact.size
 
-def test_local_graph_archive_checksum_is_verified(tmp_path: Path) -> None:
-    archive = tmp_path / "wiki-graph-runtime.tar.gz"
-    archive.write_bytes(b"not the shipped runtime archive")
+    overlay = manifest.artifact_for_path(f"graph/{ci._GRAPH_ENTITY_OVERLAY_NAME}")
+    assert ci._GRAPH_ENTITY_OVERLAY_SHA256 == overlay.sha256
+    assert ci._GRAPH_ENTITY_OVERLAY_SIZE == overlay.size
 
-    with pytest.raises(ValueError, match="local graph archive checksum mismatch"):
-        ci._verify_local_graph_archive(archive, requested_install_mode="runtime")
 
-
-def test_lfs_pointer_graph_archive_is_ignored(
+def test_source_checkout_without_local_graph_archive_uses_release(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    graph_dir = tmp_path / "graph"
-    graph_dir.mkdir()
-    (graph_dir / "wiki-graph-runtime.tar.gz").write_text(
-        "version https://git-lfs.github.com/spec/v1\n"
-        "oid sha256:993fc08377fdb09edcff4414c59b10fc121189b4a161bf796e3f8f6600907bb1\n"
-        "size 122141091\n",
-        encoding="utf-8",
-    )
     cwd = tmp_path / "cwd"
     cwd.mkdir()
     monkeypatch.chdir(cwd)
@@ -813,6 +797,41 @@ def test_lfs_pointer_graph_archive_is_ignored(
     assert ci._find_local_graph_archive("runtime") is None
 
 
+def test_source_checkout_release_contract_comes_from_the_strict_manifest(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "repo"
+    graph_dir = root / "graph"
+    graph_dir.mkdir(parents=True)
+    source_manifest = Path(__file__).resolve().parents[2] / "graph" / "release-artifacts.json"
+    payload = json.loads(source_manifest.read_text(encoding="utf-8"))
+    payload["source_release_tag"] = "graph-artifacts-test-source"
+    (graph_dir / "release-artifacts.json").write_text(
+        json.dumps(payload),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(ci, "__file__", str(root / "src" / "ctx_init.py"))
+
+    contract = ci._source_graph_release_contract("runtime")
+    assert contract is not None
+    url, sha256, size = contract
+    runtime = release_artifacts.load_manifest(
+        graph_dir / "release-artifacts.json"
+    ).artifact_for_path("graph/wiki-graph-runtime.tar.gz")
+
+    assert url.endswith("/releases/download/graph-artifacts-test-source/wiki-graph-runtime.tar.gz")
+    assert (sha256, size) == (runtime.sha256, runtime.size)
+
+
+def test_local_graph_archive_checksum_is_verified(tmp_path: Path) -> None:
+    archive = tmp_path / "wiki-graph-runtime.tar.gz"
+    archive.write_bytes(b"not the shipped runtime archive")
+
+    with pytest.raises(ValueError, match="local graph archive checksum mismatch"):
+        ci._verify_local_graph_archive(archive, requested_install_mode="runtime")
+
+
 def test_custom_graph_url_requires_checksum_or_explicit_opt_out(
     tmp_path: Path,
     monkeypatch,

src/tests/test_graph_release_manifest.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import stat
+import subprocess
+import sys
+
+import pytest
+
+from ctx.core.graph import release_artifacts
+
+
+def _write_local_assets(root: Path) -> dict[str, bytes]:
+    payloads: dict[str, bytes] = {}
+    for index, (path, _asset_name, _hydrate) in enumerate(
+        release_artifacts.GRAPH_RELEASE_ARTIFACT_SPECS,
+        start=1,
+    ):
+        payload = f"artifact-{index}\n".encode()
+        destination = root / path
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(payload)
+        payloads[path] = payload
+    return payloads
+
+
+def test_refresh_writes_the_exact_five_asset_manifest_deterministically(tmp_path: Path) -> None:
+    payloads = _write_local_assets(tmp_path)
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+
+    assert (
+        release_artifacts.main(
+            [
+                "refresh",
+                "--repo-root",
+                str(tmp_path),
+                "--manifest",
+                str(manifest_path),
+                "--source-release-tag",
+                "v9.8.7",
+            ]
+        )
+        == 0
+    )
+    first = manifest_path.read_bytes()
+    assert (
+        release_artifacts.main(
+            [
+                "refresh",
+                "--repo-root",
+                str(tmp_path),
+                "--manifest",
+                str(manifest_path),
+                "--source-release-tag",
+                "v9.8.7",
+            ]
+        )
+        == 0
+    )
+    assert manifest_path.read_bytes() == first
+    assert stat.S_IMODE(manifest_path.stat().st_mode) == 0o600
+
+    manifest = release_artifacts.load_manifest(manifest_path)
+    assert manifest.repository == "stevesolun/ctx"
+    assert manifest.source_release_tag == "v9.8.7"
+    assert (
+        tuple(
+            (artifact.path, artifact.asset_name, artifact.hydrate)
+            for artifact in manifest.artifacts
+        )
+        == release_artifacts.GRAPH_RELEASE_ARTIFACT_SPECS
+    )
+    for artifact in manifest.artifacts:
+        assert artifact.size == len(payloads[artifact.path])
+
+
+def test_manifest_rejects_an_incomplete_artifact_roster(tmp_path: Path) -> None:
+    _write_local_assets(tmp_path)
+    manifest = release_artifacts.build_manifest(
+        repo_root=tmp_path,
+        repository="stevesolun/ctx",
+        source_release_tag="v1.0.21",
+    )
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    release_artifacts.write_manifest(manifest_path, manifest)
+    payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    payload["artifacts"].pop()
+    manifest_path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="exact graph release artifact roster"):
+        release_artifacts.load_manifest(manifest_path)
+
+
+def test_manifest_rejects_a_different_repository(tmp_path: Path) -> None:
+    _write_local_assets(tmp_path)
+    manifest = release_artifacts.build_manifest(
+        repo_root=tmp_path,
+        repository="stevesolun/ctx",
+        source_release_tag="v1.0.21",
+    )
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    release_artifacts.write_manifest(manifest_path, manifest)
+    payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    payload["repository"] = "attacker/fork"
+    manifest_path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="must be stevesolun/ctx"):
+        release_artifacts.load_manifest(manifest_path)
+
+
+def test_manifest_rejects_an_artifact_above_its_path_cap(tmp_path: Path) -> None:
+    _write_local_assets(tmp_path)
+    manifest = release_artifacts.build_manifest(
+        repo_root=tmp_path,
+        repository="stevesolun/ctx",
+        source_release_tag="v1.0.21",
+    )
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    release_artifacts.write_manifest(manifest_path, manifest)
+    payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    payload["artifacts"][-1]["size"] = 500_000_001
+    manifest_path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="size exceeds"):
+        release_artifacts.load_manifest(manifest_path)
+
+
+def test_refresh_rejects_a_local_artifact_above_its_path_cap(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_local_assets(tmp_path)
+    real_identity = release_artifacts.file_sha256_and_size
+
+    def oversized_full(path: Path) -> tuple[str, int]:
+        if path.name == "wiki-graph.tar.gz":
+            return "a" * 64, 500_000_001
+        return real_identity(path)
+
+    monkeypatch.setattr(release_artifacts, "file_sha256_and_size", oversized_full)
+
+    with pytest.raises(ValueError, match="exceeds the 500000000-byte cap"):
+        release_artifacts.build_manifest(
+            repo_root=tmp_path,
+            repository="stevesolun/ctx",
+            source_release_tag="v1.0.21",
+        )
+
+
+@pytest.mark.parametrize("kind", ["symlink", "directory", "oversize"])
+def test_manifest_input_must_be_a_small_regular_file(tmp_path: Path, kind: str) -> None:
+    manifest_path = tmp_path / "release-artifacts.json"
+    if kind == "symlink":
+        target = tmp_path / "target.json"
+        target.write_text("{}", encoding="utf-8")
+        manifest_path.symlink_to(target)
+        expected = "not a regular file"
+    elif kind == "directory":
+        manifest_path.mkdir()
+        expected = "not a regular file"
+    else:
+        manifest_path.write_bytes(b" " * (release_artifacts._MAX_MANIFEST_BYTES + 1))
+        expected = "exceeds"
+
+    with pytest.raises(ValueError, match=expected):
+        release_artifacts.load_manifest(manifest_path)
+
+
+def test_manifest_rejects_path_escape_before_accessing_assets(tmp_path: Path) -> None:
+    _write_local_assets(tmp_path)
+    manifest = release_artifacts.build_manifest(
+        repo_root=tmp_path,
+        repository="stevesolun/ctx",
+        source_release_tag="v1.0.21",
+    )
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    release_artifacts.write_manifest(manifest_path, manifest)
+    payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    payload["artifacts"][0]["path"] = "graph/../outside"
+    manifest_path.write_text(json.dumps(payload), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="safe graph/ path"):
+        release_artifacts.load_manifest(manifest_path)
+
+
+def test_validate_rejects_symlinked_local_artifact(tmp_path: Path) -> None:
+    _write_local_assets(tmp_path)
+    manifest = release_artifacts.build_manifest(
+        repo_root=tmp_path,
+        repository="stevesolun/ctx",
+        source_release_tag="v1.0.21",
+    )
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    release_artifacts.write_manifest(manifest_path, manifest)
+    tracked = tmp_path / "graph" / "communities.json"
+    target = tmp_path / "outside-communities.json"
+    tracked.replace(target)
+    try:
+        tracked.symlink_to(target)
+    except OSError as exc:
+        pytest.skip(f"file symlinks unavailable: {exc}")
+
+    with pytest.raises(ValueError, match="not a regular file"):
+        release_artifacts.validate_local_artifacts(
+            repo_root=tmp_path,
+            manifest_path=manifest_path,
+        )
+
+
+def test_selective_hydration_downloads_only_the_requested_manifest_artifact(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    payloads = _write_local_assets(tmp_path)
+    manifest = release_artifacts.build_manifest(
+        repo_root=tmp_path,
+        repository="stevesolun/ctx",
+        source_release_tag="v1.0.21",
+    )
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    release_artifacts.write_manifest(manifest_path, manifest)
+    runtime_path = "graph/wiki-graph-runtime.tar.gz"
+    full_path = "graph/wiki-graph.tar.gz"
+    (tmp_path / runtime_path).unlink()
+    (tmp_path / full_path).unlink()
+    downloaded: list[str] = []
+
+    def fake_download(
+        destination: Path,
+        *,
+        manifest: release_artifacts.GraphReleaseManifest,
+        artifact: release_artifacts.GraphReleaseArtifact,
+    ) -> None:
+        del manifest
+        downloaded.append(artifact.path)
+        destination.write_bytes(payloads[artifact.path])
+
+    monkeypatch.setattr(release_artifacts, "_download_artifact", fake_download)
+
+    release_artifacts.hydrate_and_verify(
+        repo_root=tmp_path,
+        manifest_path=manifest_path,
+        artifact_paths=[runtime_path],
+    )
+
+    assert downloaded == [runtime_path]
+    assert (tmp_path / runtime_path).read_bytes() == payloads[runtime_path]
+    assert not (tmp_path / full_path).exists()
+
+
+def test_cli_refresh_runs_with_the_stdlib_only(tmp_path: Path) -> None:
+    _write_local_assets(tmp_path)
+    manifest_path = tmp_path / "graph" / "release-artifacts.json"
+    script = Path(__file__).resolve().parents[2] / "scripts" / "graph_release_manifest.py"
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-S",
+            str(script),
+            "refresh",
+            "--repo-root",
+            str(tmp_path),
+            "--manifest",
+            str(manifest_path),
+            "--source-release-tag",
+            "v1.0.21",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert release_artifacts.load_manifest(manifest_path).source_release_tag == "v1.0.21"

src/tests/test_huggingface_sync.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import hashlib
+import json
 import sys
 import tarfile
 from pathlib import Path
@@ -16,15 +17,47 @@ if str(SCRIPTS_DIR) not in sys.path:
 import sync_huggingface  # noqa: E402
 
 
+RELEASE_ARTIFACT_SPECS = (
+    ("graph/communities.json", "communities.json", False),
+    ("graph/entity-overlays.jsonl", "entity-overlays.jsonl", False),
+    ("graph/skills-sh-catalog.json.gz", "skills-sh-catalog.json.gz", False),
+    ("graph/wiki-graph-runtime.tar.gz", "wiki-graph-runtime.tar.gz", True),
+    ("graph/wiki-graph.tar.gz", "wiki-graph.tar.gz", True),
+)
+
+
 def _required_hydrated_artifacts() -> tuple[Path, ...]:
     return tuple(sync_huggingface.HYDRATED_ARTIFACT_MIN_BYTES)
 
 
 def _write_small_hydrated_artifacts(repo: Path) -> None:
-    for rel in _required_hydrated_artifacts():
-        path = repo / rel
+    artifacts: list[dict[str, object]] = []
+    for path_name, asset_name, hydrate in RELEASE_ARTIFACT_SPECS:
+        rel = Path(path_name)
+        path = repo / path_name
         path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_bytes(b"\x1f\x8b" + rel.name.encode("utf-8"))
+        payload = b"\x1f\x8b" + rel.name.encode("utf-8")
+        path.write_bytes(payload)
+        artifacts.append(
+            {
+                "path": path_name,
+                "asset_name": asset_name,
+                "size": len(payload),
+                "sha256": hashlib.sha256(payload).hexdigest(),
+                "hydrate": hydrate,
+            }
+        )
+    (repo / "graph" / "release-artifacts.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "repository": "stevesolun/ctx",
+                "source_release_tag": "v-test",
+                "artifacts": artifacts,
+            }
+        ),
+        encoding="utf-8",
+    )
 
 
 def _tiny_hydrated_min_bytes() -> dict[Path, int]:
@@ -162,15 +195,12 @@ def test_hf_sync_workflow_uses_secret_and_hardened_script() -> None:
 
     assert "HF_TOKEN: ${{ secrets.HF_TOKEN }}" in text
     assert "lfs: false" in text
-    assert "Resolving graph artifacts from release cache, or targeted Git LFS" in text
-    assert "searching release caches before targeted Git LFS" in text
-    assert '"git", "lfs", "pull", "--include", path_name' in text
-    assert "verify_hydrated_file(artifact, expected_oid, expected_size)" in text
-    assert 'tag_name.startswith("graph-artifacts-")' in text
-    assert "latest_tag" not in text
-    for artifact in _required_hydrated_artifacts():
-        assert artifact.as_posix() in text
-        assert f'hydrate_from_release("{artifact.as_posix()}"' in text
+    assert "Hydrate required graph artifacts from exact release manifest" in text
+    assert (
+        "python scripts/graph_release_manifest.py hydrate --manifest graph/release-artifacts.json"
+    ) in text
+    assert "git lfs" not in text.lower()
+    assert "GIT_LFS_" not in text
     assert "scripts/sync_huggingface.py" in text
     assert "--repo-type dataset" in text
     assert "--repo-type model" not in text
@@ -441,7 +471,7 @@ def test_hf_graph_validation_rejects_stale_exact_counts(tmp_path: Path, monkeypa
         raise AssertionError("expected stale graph artifact rejection")
 
 
-def test_hf_export_requires_hydrated_artifacts_to_match_lfs_pointer(
+def test_hf_export_requires_artifacts_to_match_release_manifest(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -451,27 +481,12 @@ def test_hf_export_requires_hydrated_artifacts_to_match_lfs_pointer(
     graph_dir.mkdir()
     _write_small_hydrated_artifacts(repo)
     artifact = graph_dir / "wiki-graph.tar.gz"
-    expected = b"\x1f\x8bcurrent-full-graph"
-    artifact.write_bytes(expected)
-    expected_oid = hashlib.sha256(expected).hexdigest()
-    pointer = (
-        "version https://git-lfs.github.com/spec/v1\n"
-        f"oid sha256:{expected_oid}\n"
-        f"size {len(expected)}\n"
-    )
 
     monkeypatch.setattr(
         sync_huggingface,
         "HYDRATED_ARTIFACT_MIN_BYTES",
         _tiny_hydrated_min_bytes(),
     )
-
-    def fake_git_bytes(_repo: Path, *_args: str) -> bytes:
-        if _args[-1] == "HEAD:graph/wiki-graph.tar.gz":
-            return pointer.encode("utf-8")
-        raise sync_huggingface.subprocess.CalledProcessError(1, list(_args))
-
-    monkeypatch.setattr(sync_huggingface, "_git_bytes", fake_git_bytes)
     monkeypatch.setattr(
         sync_huggingface,
         "_validate_graph_artifact_integrity",
@@ -481,15 +496,11 @@ def test_hf_export_requires_hydrated_artifacts_to_match_lfs_pointer(
     sync_huggingface._assert_hydrated_artifacts(repo)
 
     artifact.write_bytes(b"\x1f\x8bstale-full-graph")
-    try:
+    with pytest.raises(RuntimeError, match="release manifest"):
         sync_huggingface._assert_hydrated_artifacts(repo)
-    except RuntimeError as exc:
-        assert "does not match HEAD LFS pointer" in str(exc)
-    else:
-        raise AssertionError("expected stale LFS asset rejection")
 
 
-def test_hf_export_skips_lfs_pointer_check_for_binary_git_artifact(
+def test_hf_export_rejects_incomplete_release_manifest_identity(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -498,30 +509,50 @@ def test_hf_export_skips_lfs_pointer_check_for_binary_git_artifact(
     graph_dir = repo / "graph"
     graph_dir.mkdir()
     _write_small_hydrated_artifacts(repo)
-    artifact = graph_dir / "wiki-graph.tar.gz"
-    artifact.write_bytes(b"\x1f\x8bcurrent-full-graph")
-
-    def fake_git_bytes(_repo: Path, *_args: str) -> bytes:
-        if _args[-1] == "HEAD:graph/wiki-graph.tar.gz":
-            return b"\x1f\x8bcommitted-binary-graph"
-        raise sync_huggingface.subprocess.CalledProcessError(1, list(_args))
+    manifest_path = graph_dir / "release-artifacts.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["artifacts"].pop()
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
 
     monkeypatch.setattr(
         sync_huggingface,
         "HYDRATED_ARTIFACT_MIN_BYTES",
         _tiny_hydrated_min_bytes(),
     )
-    monkeypatch.setattr(sync_huggingface, "_git_bytes", fake_git_bytes)
     monkeypatch.setattr(
         sync_huggingface,
         "_validate_graph_artifact_integrity",
         lambda _repo: None,
     )
 
-    sync_huggingface._assert_hydrated_artifacts(repo)
+    with pytest.raises(RuntimeError, match="invalid graph release manifest"):
+        sync_huggingface._assert_hydrated_artifacts(repo)
 
 
-def test_hf_export_rejects_corrupt_large_graph_artifact(tmp_path: Path, monkeypatch) -> None:
+def test_hf_export_rejects_release_manifest_for_other_repository(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _write_small_hydrated_artifacts(repo)
+    manifest_path = repo / "graph" / "release-artifacts.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["repository"] = "other/ctx"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    monkeypatch.setattr(
+        sync_huggingface,
+        "HYDRATED_ARTIFACT_MIN_BYTES",
+        _tiny_hydrated_min_bytes(),
+    )
+
+    with pytest.raises(RuntimeError, match="manifest repository must"):
+        sync_huggingface._assert_hydrated_artifacts(repo)
+
+
+def test_hf_export_rejects_corrupt_graph_before_deep_validation(
+    tmp_path: Path, monkeypatch
+) -> None:
     repo = tmp_path / "repo"
     repo.mkdir()
     graph_dir = repo / "graph"
@@ -554,10 +585,6 @@ def test_hf_export_rejects_corrupt_large_graph_artifact(tmp_path: Path, monkeypa
         ),
     )
 
-    try:
+    with pytest.raises(RuntimeError, match="does not match graph release manifest") as exc_info:
         sync_huggingface._assert_hydrated_artifacts(repo)
-    except RuntimeError as exc:
-        assert "graph artifact integrity validation failed" in str(exc)
-        assert "wiki-graph.tar.gz" in str(exc)
-    else:
-        raise AssertionError("expected corrupt graph artifact rejection")
+    assert "wiki-graph.tar.gz" in str(exc_info.value)

src/tests/test_lfs_retirement.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+GRAPH_ARCHIVES = (
+    "graph/wiki-graph.tar.gz",
+    "graph/wiki-graph-runtime.tar.gz",
+)
+
+
+def test_graph_archives_are_release_assets_not_git_lfs_files() -> None:
+    manifest = json.loads(
+        (REPO_ROOT / "graph" / "release-artifacts.json").read_text(encoding="utf-8")
+    )
+
+    hydrated_paths = {
+        artifact["path"] for artifact in manifest["artifacts"] if artifact["hydrate"] is True
+    }
+    assert hydrated_paths == set(GRAPH_ARCHIVES)
+
+    attributes = (REPO_ROOT / ".gitattributes").read_text(encoding="utf-8")
+    assert "filter=lfs" not in attributes
+
+    if not (REPO_ROOT / ".git").exists():
+        return
+    tracked = subprocess.run(
+        ["git", "ls-files", "--error-unmatch", *GRAPH_ARCHIVES],
+        cwd=REPO_ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert tracked.returncode != 0