Sync ctx b62b78d (part 5)

GitHub commit: b62b78d704ec54b3ff43e333982eef713a33c8df

src/tests/test_release_graph_count_sync.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-import subprocess
 from urllib.parse import quote
 
 import yaml  # type: ignore[import-untyped]
 
 import update_repo_stats as urs
+from ctx.core.graph import release_artifacts
 from scripts.ci_preflight import GRAPH_VALIDATE_ARGS
 
 
@@ -51,21 +51,6 @@ def _workflow_job_steps(path: str, job_name: str) -> list[dict[str, object]]:
     return steps
 
 
-def _head_lfs_pointer(path: str) -> dict[str, int | str]:
-    pointer = subprocess.check_output(
-        ["git", "cat-file", "-p", f"HEAD:{path}"],
-        text=True,
-    )
-    values: dict[str, int | str] = {}
-    for line in pointer.splitlines():
-        if line.startswith("oid sha256:"):
-            values["sha256"] = line.split(":", 1)[1].strip()
-        elif line.startswith("size "):
-            values["size"] = int(line.split(" ", 1)[1].strip())
-    assert values.keys() == {"sha256", "size"}
-    return values
-
-
 def _graph_contract_counts() -> dict[str, int]:
     flags = _flag_values(GRAPH_VALIDATE_ARGS[1:])
     return {
@@ -115,12 +100,26 @@ def test_pr_graph_check_runs_repo_stats_after_artifact_validation() -> None:
     assert steps[stats_index]["run"] == "python src/update_repo_stats.py --check"
 
 
-def test_graph_release_metadata_matches_committed_lfs_pointers() -> None:
-    full = _head_lfs_pointer("graph/wiki-graph.tar.gz")
-    runtime = _head_lfs_pointer("graph/wiki-graph-runtime.tar.gz")
+def test_graph_release_metadata_matches_strict_release_manifest() -> None:
+    manifest_path = Path("graph/release-artifacts.json")
+    manifest = release_artifacts.load_manifest(manifest_path)
     stats = json.loads(Path("graph/wiki-graph-stats.json").read_text(encoding="utf-8"))
+    full = manifest.artifact_for_path("graph/wiki-graph.tar.gz")
 
-    assert stats["artifact"] == {"path": "graph/wiki-graph.tar.gz", **full}
+    assert manifest.repository == "stevesolun/ctx"
+    assert manifest.source_release_tag == "v1.0.21"
+    assert (
+        tuple(
+            (artifact.path, artifact.asset_name, artifact.hydrate)
+            for artifact in manifest.artifacts
+        )
+        == release_artifacts.GRAPH_RELEASE_ARTIFACT_SPECS
+    )
+    assert stats["artifact"] == {
+        "path": full.path,
+        "size": full.size,
+        "sha256": full.sha256,
+    }
 
     for workflow_path in (
         ".github/workflows/test.yml",
@@ -128,9 +127,9 @@ def test_graph_release_metadata_matches_committed_lfs_pointers() -> None:
         ".github/workflows/huggingface-sync.yml",
     ):
         workflow = Path(workflow_path).read_text(encoding="utf-8")
-        for pointer in (full, runtime):
-            assert f'"sha256": "{pointer["sha256"]}"' in workflow
-            assert f'"size": {pointer["size"]}' in workflow
+        assert "graph/release-artifacts.json" in workflow
+        assert "scripts/graph_release_manifest.py" in workflow
+        assert "git lfs" not in workflow.lower()
 
 
 def test_public_docs_and_readmes_expose_current_graph_counts() -> None:

src/tests/test_release_supply_chain.py

@@ -614,6 +614,7 @@ def test_attestation_covers_every_published_artifact_and_blocks_publish() -> Non
     assert graph_download["with"]["name"] == "graph-release-assets"
     assert graph_attest["if"] == "needs.build.outputs.graph_assets_available == 'true'"
     published_graph_paths = {
+        "release-artifacts.json",
         "wiki-graph.tar.gz",
         "wiki-graph-runtime.tar.gz",
         "skills-sh-catalog.json.gz",

src/tests/test_reproducible_dist.py

@@ -431,7 +431,7 @@ def test_git_tree_export_disables_lfs_smudging(
         "HEAD",
     ]
     assert isinstance(captured["env"], dict)
-    assert captured["env"]["GIT_LFS_SKIP_SMUDGE"] == "1"
+    assert "GIT_LFS_SKIP_SMUDGE" not in captured["env"]
 
 
 def test_dev_dependencies_include_no_isolation_build_backend() -> None:

src/tests/test_review_findings.py

@@ -25,6 +25,7 @@ import pack_full_wiki_tar  # noqa: E402
 import sync_huggingface  # noqa: E402
 import validate_graph_artifacts as vga  # noqa: E402
 from ctx import dashboard_entities  # noqa: E402
+from ctx.core.graph import release_artifacts  # noqa: E402
 from ctx.core.wiki import wiki_queue_worker  # noqa: E402
 from ctx.utils._secret_scan import find_inline_secret_arg  # noqa: E402
 
@@ -225,54 +226,47 @@ def test_graph_markdown_host_path_scan_covers_key_value_delimiters(payload: byte
 
 
 @pytest.mark.parametrize(
-    "workflow_path",
+    ("workflow_path", "expected_invocations"),
     [
-        ".github/workflows/huggingface-sync.yml",
-        ".github/workflows/publish.yml",
-        ".github/workflows/test.yml",
+        (".github/workflows/huggingface-sync.yml", 1),
+        (".github/workflows/publish.yml", 1),
+        (".github/workflows/test.yml", 3),
     ],
 )
-def test_graph_workflow_searches_release_cache_before_lfs_fallback(
+def test_graph_workflows_use_one_strict_release_manifest_resolver(
     workflow_path: str,
+    expected_invocations: int,
 ) -> None:
     workflow = (ROOT / workflow_path).read_text(encoding="utf-8")
-    resolve_script = workflow[workflow.index("def hydrate_from_release") :]
-
-    release_search = resolve_script.index("for release in load_releases():")
-    lfs_fallback = resolve_script.rindex(
-        "hydrate_from_lfs(path_name, expected_oid, expected_size, hydrated_min_size)"
+    resolver = (
+        "python scripts/graph_release_manifest.py hydrate --manifest graph/release-artifacts.json"
     )
 
-    assert release_search < lfs_fallback
-    assert (
-        "hydrate_from_lfs(path_name, expected_oid, expected_size, hydrated_min_size)"
-        not in resolve_script[:release_search]
-    )
-    assert 'if expected_oid != fallback["sha256"]' not in resolve_script
+    assert workflow.count(resolver) == expected_invocations
+    assert "git lfs" not in workflow.lower()
+    assert "GIT_LFS_" not in workflow
 
 
-def test_preflight_refuses_oversized_graph_lfs_pointer_before_pull(
-    monkeypatch: Any,
-    tmp_path: Path,
-    capsys: Any,
-) -> None:
-    monkeypatch.setattr(ci_preflight, "REPO_ROOT", tmp_path)
-    artifact = tmp_path / "graph" / "wiki-graph.tar.gz"
-    artifact.parent.mkdir()
-    max_size = ci_preflight.GRAPH_LFS_MAX_FALLBACK_SIZES["graph/wiki-graph.tar.gz"]
-    artifact.write_text(
-        f"version https://git-lfs.github.com/spec/v1\noid sha256:{'a' * 64}\nsize {max_size + 1}\n",
-        encoding="utf-8",
+def test_preflight_hydrates_strict_manifest_before_graph_validation() -> None:
+    checks, _notes = ci_preflight.select_checks(
+        base_ref="origin/main",
+        files=["graph/release-artifacts.json"],
+        profile="pr",
+        python="python",
+    )
+    names = [check.name for check in checks]
+    hydrate = next(check for check in checks if check.name == "hydrate graph release assets")
+
+    assert names.index("hydrate graph release assets") < names.index("graph artifact validation")
+    assert hydrate.argv == (
+        "python",
+        "scripts/graph_release_manifest.py",
+        "hydrate",
+        "--manifest",
+        "graph/release-artifacts.json",
+        "--repo-root",
+        ".",
     )
-    monkeypatch.setattr(ci_preflight.shutil, "which", lambda _name: "/usr/bin/git")
-
-    def fail_run(*_args: Any, **_kwargs: Any) -> None:
-        raise AssertionError("git lfs pull should not run")
-
-    monkeypatch.setattr(ci_preflight.subprocess, "run", fail_run)
-
-    assert ci_preflight.hydrate_graph_lfs_artifacts() == 1
-    assert "exceeds cap" in capsys.readouterr().err
 
 
 def test_hf_card_export_uploads_docs_and_changelog(
@@ -666,7 +660,7 @@ def test_entity_search_fallback_returns_wiki_relative_path(tmp_path: Path) -> No
     assert str(tmp_path) not in results[0]["path"]
 
 
-def test_lfs_pointer_probe_does_not_full_read_hydrated_artifact(
+def test_release_manifest_hash_probe_does_not_full_read_artifact(
     monkeypatch: Any,
     tmp_path: Path,
 ) -> None:
@@ -679,4 +673,7 @@ def test_lfs_pointer_probe_does_not_full_read_hydrated_artifact(
 
     monkeypatch.setattr(Path, "read_bytes", fail_read_bytes)
 
-    assert ci_preflight._read_lfs_pointer(artifact) is None
+    assert release_artifacts.file_sha256_and_size(artifact) == (
+        sha256(b"hydrated graph payload").hexdigest(),
+        len(b"hydrated graph payload"),
+    )

src/tests/test_update_repo_stats.py

@@ -11,6 +11,7 @@ import pytest
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
 import update_repo_stats as urs  # noqa: E402
+from ctx.core.graph import release_artifacts  # noqa: E402
 
 
 def _add_bytes(tf: tarfile.TarFile, name: str, body: bytes) -> None:
@@ -65,6 +66,27 @@ def _write_graph_stats_sidecar(
     )
 
 
+def _write_graph_release_manifest(root: Path, *, full_size: int) -> None:
+    artifacts = tuple(
+        release_artifacts.GraphReleaseArtifact(
+            path=path,
+            asset_name=asset_name,
+            size=full_size if path == "graph/wiki-graph.tar.gz" else 1,
+            sha256="a" * 64,
+            hydrate=hydrate,
+        )
+        for path, asset_name, hydrate in release_artifacts.GRAPH_RELEASE_ARTIFACT_SPECS
+    )
+    release_artifacts.write_manifest(
+        root / "graph" / "release-artifacts.json",
+        release_artifacts.GraphReleaseManifest(
+            repository="stevesolun/ctx",
+            source_release_tag="v1.0.21",
+            artifacts=artifacts,
+        ),
+    )
+
+
 def test_tarball_stats_only_trust_safe_regular_members(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -167,6 +189,28 @@ def test_graph_artifact_stats_sidecar_rejects_size_drift(
     assert urs._read_graph_artifact_stats() is None
 
 
+def test_graph_artifact_stats_use_manifest_when_archive_is_not_checked_in(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    _write_graph_stats_sidecar(
+        tmp_path,
+        {"nodes": 100, "edges": 200, "skills": 30},
+        file_size=4,
+        artifact_size=4,
+    )
+    _write_graph_release_manifest(tmp_path, full_size=4)
+    (tmp_path / "graph" / "wiki-graph.tar.gz").unlink()
+
+    stats = urs._read_graph_artifact_stats()
+
+    assert stats is not None
+    assert stats["nodes"] == 100
+    assert stats["edges"] == 200
+    assert stats["skills"] == 30
+
+
 def test_read_graph_stats_prefers_artifact_sidecar_without_tarball_scan(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -446,17 +490,7 @@ def test_published_inventory_prose_uses_exact_graph_counts(
 ) -> None:
     graph_dir = tmp_path / "graph"
     graph_dir.mkdir()
-    (graph_dir / "wiki-graph.tar.gz").write_text(
-        "\n".join(
-            (
-                "version https://git-lfs.github.com/spec/v1",
-                "oid sha256:" + ("a" * 64),
-                f"size {314 * 1024 * 1024}",
-                "",
-            )
-        ),
-        encoding="utf-8",
-    )
+    _write_graph_release_manifest(tmp_path, full_size=314 * 1024 * 1024)
     text = "\n".join(
         [
             "badge/Graph-79%2C958_nodes_/_1.8M_edges-red",

src/tests/test_validate_graph_artifacts.py

@@ -1697,20 +1697,20 @@ def test_validator_default_floors_match_preflight_contract() -> None:
     assert values["--min-semantic-edges"] == str(DEFAULT_MIN_SEMANTIC_EDGES)
 
 
-def test_graph_only_workflow_uses_release_cache_or_targeted_lfs() -> None:
+def test_graph_only_workflow_uses_exact_release_manifest_resolver() -> None:
     workflow = yaml.safe_load(Path(".github/workflows/test.yml").read_text(encoding="utf-8"))
     steps = workflow["jobs"]["graph-check"]["steps"]
     resolve_step = next(
         step
         for step in steps
-        if step.get("name") == "Resolve graph artifacts from release assets or targeted LFS"
+        if step.get("name") == "Resolve graph artifacts from exact release manifest"
     )
-    script = resolve_step["run"]
+    validate_step = next(
+        step for step in steps if step.get("name") == "Validate shipped graph artifacts"
+    )
+    names = [step.get("name") for step in steps]
 
-    assert "release_asset_wait_seconds = 300" in script
-    assert "while True:" in script
-    assert "Waiting for matching release asset" in script
-    assert "time.sleep(release_asset_poll_seconds)" in script
-    assert "Pointer for {path_name} is not in release cache" in script
-    assert '"git", "lfs", "pull", "--include", path_name' in script
-    assert "verify_hydrated_file(graph_tar, expected_oid, expected_size)" in script
+    assert resolve_step["run"].strip() == (
+        "python scripts/graph_release_manifest.py hydrate --manifest graph/release-artifacts.json"
+    )
+    assert names.index(resolve_step["name"]) < names.index(validate_step["name"])

src/tests/test_workflow_lfs_caps.py

@@ -3,45 +3,79 @@ from __future__ import annotations
 from pathlib import Path
 
 import pytest
+import yaml  # type: ignore[import-untyped]
 
 ROOT = Path(__file__).resolve().parents[2]
+WORKFLOW_STEPS = {
+    ".github/workflows/huggingface-sync.yml": (
+        "sync",
+        "Hydrate required graph artifacts from exact release manifest",
+        "Set up Python",
+    ),
+    ".github/workflows/publish.yml": (
+        "build",
+        "Resolve release graph artifacts from exact release manifest",
+        "Validate release graph artifacts",
+    ),
+    ".github/workflows/test.yml": (
+        "graph-check",
+        "Resolve graph artifacts from exact release manifest",
+        "Validate shipped graph artifacts",
+    ),
+}
+RESOLVER_COMMAND = (
+    "python scripts/graph_release_manifest.py hydrate --manifest graph/release-artifacts.json"
+)
 
 
-def _resolve_script(workflow_path: str) -> str:
-    workflow = (ROOT / workflow_path).read_text(encoding="utf-8")
-    start = workflow.index("def hydrate_from_lfs")
-    end = workflow.index("          PY", start)
-    return workflow[start:end]
-
-
-@pytest.mark.parametrize(
-    "workflow_path",
-    [
-        ".github/workflows/huggingface-sync.yml",
-        ".github/workflows/publish.yml",
-        ".github/workflows/test.yml",
-    ],
-)
-def test_targeted_lfs_fallback_checks_pointer_size_before_pull(workflow_path: str) -> None:
+def _workflow_steps(workflow_path: str) -> list[dict[str, object]]:
+    job_name, _, _ = WORKFLOW_STEPS[workflow_path]
+    workflow = yaml.safe_load((ROOT / workflow_path).read_text(encoding="utf-8"))
+    steps = workflow["jobs"][job_name]["steps"]
+    assert isinstance(steps, list)
+    return steps
+
+
+@pytest.mark.parametrize("workflow_path", WORKFLOW_STEPS)
+def test_graph_workflows_have_no_git_lfs_dependency(workflow_path: str) -> None:
     workflow = (ROOT / workflow_path).read_text(encoding="utf-8")
-    script = _resolve_script(workflow_path)
 
-    assert '"graph/wiki-graph.tar.gz": 350_000_000' in workflow
-    assert '"graph/wiki-graph-runtime.tar.gz": 150_000_000' in workflow
-    size_check = script.index("if expected_size > max_size:")
-    lfs_pull = script.index('["git", "lfs", "pull", "--include", path_name, "--exclude", ""]')
-    missing_cap_check = script.index("no size cap configured")
+    assert "git lfs" not in workflow.lower()
+    assert "GIT_LFS_" not in workflow
+    assert "git-lfs.github.com" not in workflow
+    assert "targeted LFS" not in workflow
+
 
-    assert "max_size = max_lfs_fallback_sizes.get(path_name)" in script
-    assert missing_cap_check < lfs_pull
-    assert "pointer size {expected_size} exceeds cap {max_size}" in script
-    assert size_check < lfs_pull
+@pytest.mark.parametrize("workflow_path", WORKFLOW_STEPS)
+def test_graph_workflows_use_shared_exact_manifest_resolver(workflow_path: str) -> None:
+    _, step_name, _ = WORKFLOW_STEPS[workflow_path]
+    steps = _workflow_steps(workflow_path)
+    step = next(item for item in steps if item.get("name") == step_name)
+    run = str(step["run"])
 
+    assert RESOLVER_COMMAND in run
+    assert run.count("scripts/graph_release_manifest.py") == 1
+    assert "--manifest graph/release-artifacts.json" in run
+    assert "git" not in run.lower()
 
-def test_huggingface_sync_catalog_lfs_fallback_has_explicit_cap() -> None:
-    workflow = (ROOT / ".github" / "workflows" / "huggingface-sync.yml").read_text(encoding="utf-8")
 
-    assert '"graph/skills-sh-catalog.json.gz": 15_000_000' in workflow
-    assert workflow.index('"graph/skills-sh-catalog.json.gz": 15_000_000') < workflow.index(
-        'hydrate_from_release("graph/skills-sh-catalog.json.gz", 1_000_000)'
+@pytest.mark.parametrize("workflow_path", WORKFLOW_STEPS)
+def test_graph_workflows_resolve_before_consuming_artifacts(workflow_path: str) -> None:
+    _, resolver_name, consumer_name = WORKFLOW_STEPS[workflow_path]
+    names = [str(step.get("name", "")) for step in _workflow_steps(workflow_path)]
+
+    assert names.index(resolver_name) < names.index(consumer_name)
+
+
+def test_huggingface_hydration_keeps_canonical_full_sync_guard() -> None:
+    steps = _workflow_steps(".github/workflows/huggingface-sync.yml")
+    step = next(
+        item
+        for item in steps
+        if item.get("name") == "Hydrate required graph artifacts from exact release manifest"
+    )
+
+    assert step["if"] == (
+        "${{ env.HF_TOKEN != '' && github.repository == 'stevesolun/ctx' "
+        "&& steps.scope.outputs.sync_mode == 'full' }}"
     )

src/update_repo_stats.py

@@ -6,9 +6,9 @@ Run by the pre-commit hook so README/docs badges and inline counts never drift
 from reality. Reads only committed files and a live pytest collection.
 
 Sources of truth:
-  - graph/wiki-graph.tar.gz              -> graph/report/entity counts
+  - graph/release-artifacts.json          -> exact release asset identities
+  - graph/wiki-graph-stats.json           -> graph/report/entity counts
   - scripts/ci_preflight.py GRAPH_VALIDATE_ARGS -> exact release fallback
-  - graph/wiki-graph-runtime.tar.gz      -> runtime graph/report counts
   - graph/communities.json               -> current community export
   - graph/skills-sh-catalog.json.gz      -> hydrated skill body counts
   - pytest --collect-only -q             -> test inventory count
@@ -134,6 +134,19 @@ def _int_from_json(value: object) -> int | None:
     return None
 
 
+def _release_manifest_artifact_identity(path: str) -> tuple[str, int] | None:
+    manifest_path = REPO_ROOT / "graph" / "release-artifacts.json"
+    if not manifest_path.exists():
+        return None
+    try:
+        from ctx.core.graph.release_artifacts import load_manifest
+
+        artifact = load_manifest(manifest_path).artifact_for_path(path)
+    except (ImportError, KeyError, ValueError):
+        return None
+    return artifact.sha256, artifact.size
+
+
 def _read_graph_artifact_stats() -> dict[str, int | None] | None:
     """Read the shipped graph stats sidecar after checking artifact identity.
 
@@ -145,7 +158,7 @@ def _read_graph_artifact_stats() -> dict[str, int | None] | None:
     sidecar = graph_dir / _GRAPH_STATS_SIDECAR
     tarball = graph_dir / "wiki-graph.tar.gz"
     promotion = graph_dir / "wiki-graph.tar.gz.promotion.json"
-    if not sidecar.exists() or not tarball.exists():
+    if not sidecar.exists():
         return None
     try:
         payload = json.loads(sidecar.read_text(encoding="utf-8"))
@@ -157,7 +170,15 @@ def _read_graph_artifact_stats() -> dict[str, int | None] | None:
         expected_sha = str(artifact.get("sha256") or "").strip().lower()
         if expected_size is None or len(expected_sha) != 64:
             return None
-        if tarball.stat().st_size != expected_size:
+        manifest_identity = _release_manifest_artifact_identity("graph/wiki-graph.tar.gz")
+        if manifest_identity is not None and manifest_identity != (expected_sha, expected_size):
+            return None
+        if tarball.exists():
+            if tarball.is_symlink() or not tarball.is_file():
+                return None
+            if tarball.stat().st_size != expected_size:
+                return None
+        elif manifest_identity is None:
             return None
         if promotion.exists():
             promotion_payload = json.loads(promotion.read_text(encoding="utf-8"))
@@ -490,14 +511,14 @@ def read_graph_stats() -> dict:
     Priority:
       1. ``graph/wiki-graph-stats.json`` — the checked sidecar for the
          shipped graph artifact. This keeps docs/About updates fast while
-         still tying counts to the promoted tarball hash and size.
-      2. ``graph/wiki-graph.tar.gz`` — the tarball that ships in
-         releases. Pinned and canonical, but slow to enumerate.
+         still tying counts to the release manifest's exact hash and size.
+      2. ``graph/wiki-graph.tar.gz`` — the release-manifest-pinned tarball
+         when it has been hydrated locally. Canonical but slow to enumerate.
       3. ``scripts/ci_preflight.py`` graph contract counts — fallback
-         when a source checkout has not downloaded the release tarball.
+         when a source checkout has not hydrated the release tarball.
       4. ``~/.claude/skill-wiki/graphify-out/graph.json`` — the user's
          live wiki. Used only when the tarball isn't present (e.g. a
-         bare clone without the release asset downloaded).
+         bare clone without the release asset hydrated).
 
     Without this priority the pre-commit hook can silently publish stale
     contract numbers or whatever the user last re-graphified instead of
@@ -754,29 +775,16 @@ def format_edges(n: int) -> str:
 
 
 def _full_wiki_tarball_mib() -> int | None:
-    """Return the shipped full wiki tarball MiB, following Git LFS pointers."""
+    """Return the full release wiki tarball size from its pinned manifest."""
+    identity = _release_manifest_artifact_identity("graph/wiki-graph.tar.gz")
+    if identity is not None:
+        return round(identity[1] / (1024 * 1024))
     tarball = REPO_ROOT / "graph" / "wiki-graph.tar.gz"
     if not tarball.exists():
         return None
-    size = _git_lfs_pointer_size(tarball)
-    if size is None:
-        size = tarball.stat().st_size
-    return round(size / (1024 * 1024))
-
-
-def _git_lfs_pointer_size(path: Path) -> int | None:
-    try:
-        if path.stat().st_size > 1024:
-            return None
-        text = path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return None
-    if not text.startswith("version https://git-lfs.github.com/spec/v1\n"):
-        return None
-    match = re.search(r"^size (\d+)$", text, re.MULTILINE)
-    if match is None:
+    if tarball.is_symlink() or not tarball.is_file():
         return None
-    return int(match.group(1))
+    return round(tarball.stat().st_size / (1024 * 1024))
 
 
 Replacement = tuple[re.Pattern[str], str]