Add files using upload-large-folder tool

src/__init__.py

@@ -1,3 +1,3 @@
 """ctx — skill and agent recommendation for Claude Code."""
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"

src/ctx/__init__.py

@@ -30,7 +30,7 @@ Package layout:
     ctx.utils      - low-level primitives (safe names, atomic IO)
 """
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"
 
 
 # Public library surface — anything listed here is safe for third-

src/tests/test_ci_classifier.py

@@ -45,7 +45,11 @@ def test_docs_tooling_changes_are_docs_only() -> None:
 
 
 def test_graph_artifacts_are_graph_only_not_docs_only() -> None:
-    flags = classify_paths(["graph/wiki-graph.tar.gz", "graph/communities.json"])
+    flags = classify_paths([
+        "graph/wiki-graph.tar.gz",
+        "graph/wiki-graph-runtime.tar.gz",
+        "graph/communities.json",
+    ])
 
     assert flags["docs_changed"] is False
     assert flags["docs_only"] is False
@@ -154,7 +158,8 @@ def test_graph_artifact_job_uses_release_asset_fallback_for_lfs_budget() -> None
     assert "Resolve graph LFS artifacts" in workflow
     assert "Git LFS download failed; trying matching prior release asset." in workflow
     assert "sha256:{expected_oid} size:{expected_size}" in workflow
-    assert "Hydrated graph/wiki-graph.tar.gz from" in workflow
+    assert "Hydrated {path_name} from" in workflow
+    assert "graph/wiki-graph-runtime.tar.gz" in workflow
     assert "python src/validate_graph_artifacts.py" in workflow
     assert "validating pointer metadata only" not in workflow
 

src/tests/test_ctx_init.py

@@ -309,7 +309,12 @@ def test_main_with_graph_flag_installs_prebuilt_graph(
     archive = _write_graph_archive(tmp_path)
     monkeypatch.setattr(ci, "_claude_dir", lambda: claude)
     monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(ci, "_find_local_graph_archive", lambda: archive, raising=False)
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+        raising=False,
+    )
     monkeypatch.setattr(
         ci,
         "_download_graph_archive",
@@ -335,6 +340,9 @@ def test_main_with_graph_flag_installs_prebuilt_graph(
     graph_json = claude / "skill-wiki" / "graphify-out" / "graph.json"
     graph_payload = json.loads(graph_json.read_text(encoding="utf-8"))
     assert graph_payload["graph"]["export_id"] == "test-export"
+    assert not (
+        claude / "skill-wiki" / "entities" / "skills" / "current.md"
+    ).exists()
     assert not any("ctx.core.wiki.wiki_graphify" in c for c in calls)
     assert not any(c == "wiki_graphify" for call in calls for c in call)
 
@@ -355,12 +363,67 @@ def test_graph_install_rejects_incomplete_archive(
         tf.add(graph_out / "graph.json", arcname="graphify-out/graph.json")
 
     claude = tmp_path / "home"
-    monkeypatch.setattr(ci, "_find_local_graph_archive", lambda: archive)
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+    )
 
     assert ci.build_graph(claude) == 1
     assert not (claude / "skill-wiki" / "graphify-out" / "graph.json").exists()
 
 
+def test_graph_install_validation_does_not_parse_full_graph_json(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "wiki"
+    graph_out = wiki / "graphify-out"
+    graph_out.mkdir(parents=True)
+    (wiki / "index.md").write_text("# Wiki\n", encoding="utf-8")
+    (graph_out / "graph.json").write_text(
+        json.dumps({"graph": {"export_id": "test-export"}, "nodes": [], "links": []}),
+        encoding="utf-8",
+    )
+    (graph_out / "graph-delta.json").write_text(
+        json.dumps({"export_id": "test-export", "nodes": [], "edges": []}),
+        encoding="utf-8",
+    )
+    (graph_out / "communities.json").write_text(
+        json.dumps({"export_id": "test-export", "total_communities": 0}),
+        encoding="utf-8",
+    )
+    (graph_out / "graph-report.md").write_text(
+        "# Graph Report\n\n> Export ID: test-export\n",
+        encoding="utf-8",
+    )
+    (graph_out / "graph-export-manifest.json").write_text(
+        json.dumps({
+            "version": 1,
+            "export_id": "test-export",
+            "artifacts": {
+                "graph": "graph.json",
+                "delta": "graph-delta.json",
+                "communities": "communities.json",
+                "report": "graph-report.md",
+            },
+        }),
+        encoding="utf-8",
+    )
+    external = wiki / "external-catalogs" / "skills-sh"
+    external.mkdir(parents=True)
+    (external / "catalog.json").write_text("{}", encoding="utf-8")
+
+    def guarded_read(path: Path) -> object:
+        if path.name == "graph.json":
+            raise AssertionError("install validation must not parse full graph.json")
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    monkeypatch.setattr(ci, "_read_json_file", guarded_read)
+
+    ci._validate_graph_install_tree(wiki)
+
+
 def test_graph_install_force_prunes_stale_generated_files(
     tmp_path: Path,
     monkeypatch,
@@ -370,9 +433,20 @@ def test_graph_install_force_prunes_stale_generated_files(
     stale = claude / "skill-wiki" / "entities" / "skills" / "stale.md"
     stale.parent.mkdir(parents=True)
     stale.write_text("# Stale\n", encoding="utf-8")
-    monkeypatch.setattr(ci, "_find_local_graph_archive", lambda: archive)
+    monkeypatch.setattr(ci, "_claude_dir", lambda: claude)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+    )
 
-    assert ci.build_graph(claude, force=True) == 0
+    assert ci.main([
+        "--graph",
+        "--graph-install-mode", "full",
+        "--force",
+        "--model-mode", "skip",
+    ]) == 0
     assert not stale.exists()
     assert (claude / "skill-wiki" / "entities" / "skills" / "current.md").is_file()
 
@@ -389,7 +463,11 @@ def test_graph_install_rejects_path_traversal_archive(
         tf.addfile(info, io.BytesIO(payload))
 
     claude = tmp_path / "home"
-    monkeypatch.setattr(ci, "_find_local_graph_archive", lambda: archive)
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+    )
 
     assert ci.build_graph(claude) == 1
     assert not (tmp_path / "evil.txt").exists()

src/tests/test_ctx_monitor.py

@@ -360,7 +360,11 @@ def test_artifact_status_reads_promotion_metadata(
     repo_graph = tmp_path / "repo-graph"
     repo_graph.mkdir()
     (repo_graph / "wiki-graph.tar.gz").write_bytes(b"tar")
-    (repo_graph / "skills-sh-catalog.json.gz").write_bytes(b"catalog")
+    runtime_catalog = (
+        fake_claude / "skill-wiki" / "external-catalogs" / "skills-sh" / "catalog.json"
+    )
+    runtime_catalog.parent.mkdir(parents=True)
+    runtime_catalog.write_text("{}", encoding="utf-8")
     monkeypatch.setattr(cm, "_repo_graph_dir", lambda: repo_graph)
     (graph_dir / "graph.json.promotion.json").write_text(
         json.dumps({
@@ -378,9 +382,7 @@ def test_artifact_status_reads_promotion_metadata(
     assert status["graph_json"]["exists"] is True
     assert status["graph_json"]["size"] == graph.stat().st_size
     assert status["wiki_graph_tar"]["path"] == str(repo_graph / "wiki-graph.tar.gz")
-    assert status["skills_sh_catalog"]["path"] == str(
-        repo_graph / "skills-sh-catalog.json.gz",
-    )
+    assert status["skills_sh_catalog"]["path"] == str(runtime_catalog)
     assert status["promotion_count"] == 1
     assert status["promotions"][0]["status"] == "promoted"
     assert status["promotions"][0]["current_sha256"] == "new"

src/tests/test_validate_graph_artifacts.py

@@ -11,6 +11,7 @@ import pytest
 import yaml  # type: ignore[import-untyped]
 
 from validate_graph_artifacts import (
+    DEFAULT_HARNESSES,
     GraphArtifactError,
     _safe_tar_name,
     _scan_graph_json,
@@ -51,6 +52,59 @@ def _write_catalog(graph_dir: Path, *, converted_path: str | None = None) -> Non
         json.dump(catalog, f)
 
 
+def _write_runtime_archive(
+    graph_dir: Path,
+    *,
+    graph: dict[str, Any],
+    include_delta: bool = True,
+    include_report: bool = True,
+    include_manifest: bool = True,
+    delta_export_id: str = "export-test",
+    communities_export_id: str = "export-test",
+    report_export_id: str = "export-test",
+    manifest_export_id: str = "export-test",
+) -> None:
+    with tarfile.open(graph_dir / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        if include_delta:
+            _add_text(
+                tf,
+                "graphify-out/graph-delta.json",
+                json.dumps({"export_id": delta_export_id, "nodes": [], "edges": []}),
+            )
+        _add_text(
+            tf,
+            "graphify-out/communities.json",
+            json.dumps({"export_id": communities_export_id, "total_communities": 1}),
+        )
+        if include_report:
+            _add_text(
+                tf,
+                "graphify-out/graph-report.md",
+                f"# Graph Report\n\n> Export ID: {report_export_id}\n",
+            )
+        if include_manifest:
+            _add_text(
+                tf,
+                "graphify-out/graph-export-manifest.json",
+                json.dumps({
+                    "version": 1,
+                    "export_id": manifest_export_id,
+                    "artifacts": {
+                        "graph": "graph.json",
+                        "delta": "graph-delta.json",
+                        "communities": "communities.json",
+                        "report": "graph-report.md",
+                    },
+                    "counts": {"nodes": 2, "edges": 1, "communities": 1},
+                }),
+            )
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        for slug in sorted(DEFAULT_HARNESSES):
+            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
+
+
 def _write_archive(
     graph_dir: Path,
     *,
@@ -150,6 +204,17 @@ def _write_archive(
             ]),
             encoding="utf-8",
         )
+    _write_runtime_archive(
+        graph_dir,
+        graph=graph,
+        include_delta=include_delta,
+        include_report=include_report,
+        include_manifest=include_manifest,
+        delta_export_id=delta_export_id,
+        communities_export_id=communities_export_id,
+        report_export_id=report_export_id,
+        manifest_export_id=manifest_export_id,
+    )
 
 
 def test_validate_graph_artifacts_checks_catalog_paths_and_deep_graph_stats(

src/validate_graph_artifacts.py

@@ -49,6 +49,15 @@ _PREVIEW_HTML_FILES = (
     "viz-python.html",
     "viz-security.html",
 )
+_GRAPH_RUNTIME_REQUIRED_NAMES = {
+    "index.md",
+    "graphify-out/graph.json",
+    "graphify-out/graph-delta.json",
+    "graphify-out/communities.json",
+    "graphify-out/graph-report.md",
+    "graphify-out/graph-export-manifest.json",
+    "external-catalogs/skills-sh/catalog.json",
+}
 
 
 class GraphArtifactError(RuntimeError):
@@ -236,11 +245,17 @@ def validate_graph_artifacts(
 ) -> GraphArtifactStats:
     graph_dir = Path(graph_dir)
     tarball = graph_dir / "wiki-graph.tar.gz"
+    runtime_tarball = graph_dir / "wiki-graph-runtime.tar.gz"
     catalog_path = graph_dir / "skills-sh-catalog.json.gz"
     communities_path = graph_dir / "communities.json"
-    for path in (tarball, catalog_path, communities_path):
+    for path in (tarball, runtime_tarball, catalog_path, communities_path):
         _require_real_file(path)
 
+    expected_harnesses = DEFAULT_HARNESSES if expected_harnesses is None else expected_harnesses
+    _validate_runtime_graph_archive(
+        runtime_tarball,
+        expected_harnesses=expected_harnesses,
+    )
     catalog = _load_gzip_json(catalog_path)
     _load_json(communities_path)
     skills = _catalog_skills(catalog)
@@ -269,7 +284,6 @@ def validate_graph_artifacts(
     graph_nodes = graph_edges = graph_semantic_edges = skills_sh_nodes = 0
     harness_nodes = 0
     skill_pages = agent_pages = mcp_pages = harness_pages = skills_sh_converted = 0
-    expected_harnesses = DEFAULT_HARNESSES if expected_harnesses is None else expected_harnesses
     export_ids: dict[str, str] = {}
     manifest: dict[str, Any] | None = None
 
@@ -341,15 +355,7 @@ def validate_graph_artifacts(
                             f"{member.name} has {lines} lines, above limit {limit}",
                         )
 
-    required_names = {
-        "index.md",
-        "graphify-out/graph.json",
-        "graphify-out/graph-delta.json",
-        "graphify-out/communities.json",
-        "graphify-out/graph-report.md",
-        "graphify-out/graph-export-manifest.json",
-        "external-catalogs/skills-sh/catalog.json",
-    }
+    required_names = _GRAPH_RUNTIME_REQUIRED_NAMES
     missing_required = sorted(required_names - names)
     if missing_required:
         raise GraphArtifactError(f"wiki graph archive is missing: {missing_required}")
@@ -440,6 +446,77 @@ def validate_graph_artifacts(
     return stats
 
 
+def _validate_runtime_graph_archive(
+    tarball: Path,
+    *,
+    expected_harnesses: set[str],
+) -> None:
+    names: set[str] = set()
+    export_ids: dict[str, str] = {}
+    manifest: dict[str, Any] | None = None
+    with tarfile.open(tarball, "r:gz") as tf:
+        for member in tf:
+            name = _safe_tar_name(member.name)
+            names.add(name)
+            if not (member.isfile() or member.isdir()):
+                raise GraphArtifactError(
+                    f"runtime archive member is not a regular file/dir: {member.name}",
+                )
+            if name.endswith(".original"):
+                raise GraphArtifactError(
+                    f"runtime archive contains raw backup member: {member.name}",
+                )
+            if name.endswith(".lock"):
+                raise GraphArtifactError(
+                    f"runtime archive contains lock member: {member.name}",
+                )
+            if member.isfile() and name == "graphify-out/graph.json":
+                f = tf.extractfile(member)
+                if f is None:
+                    raise GraphArtifactError("runtime graph.json could not be read")
+                _record_export_id(export_ids, name, _scan_graph_export_id(f))
+            elif member.isfile() and name == "graphify-out/graph-delta.json":
+                data = _read_tar_json(tf, member, name)
+                _record_export_id(export_ids, name, _export_id_from_json(data, name))
+            elif member.isfile() and name == "graphify-out/communities.json":
+                data = _read_tar_json(tf, member, name)
+                _record_export_id(export_ids, name, _export_id_from_json(data, name))
+            elif member.isfile() and name == "graphify-out/graph-export-manifest.json":
+                data = _read_tar_json(tf, member, name)
+                if not isinstance(data, dict):
+                    raise GraphArtifactError(f"{name} did not contain a JSON object")
+                manifest = data
+            elif member.isfile() and name == "graphify-out/graph-report.md":
+                f = tf.extractfile(member)
+                if f is None:
+                    raise GraphArtifactError(f"{member.name} could not be read")
+                _record_export_id(export_ids, name, _export_id_from_report(f.read()))
+
+    missing_required = sorted(_GRAPH_RUNTIME_REQUIRED_NAMES - names)
+    if missing_required:
+        raise GraphArtifactError(
+            f"runtime graph archive is missing: {missing_required}",
+        )
+    missing_harnesses = sorted(
+        f"entities/harnesses/{slug}.md"
+        for slug in expected_harnesses
+        if f"entities/harnesses/{slug}.md" not in names
+    )
+    if missing_harnesses:
+        raise GraphArtifactError(
+            f"runtime graph archive is missing harness pages: {missing_harnesses}",
+        )
+    manifest_export_id = _validate_graph_export_manifest(manifest, names)
+    _record_export_id(
+        export_ids,
+        "graphify-out/graph-export-manifest.json",
+        manifest_export_id,
+    )
+    if "graphify-out/graph.json" not in export_ids:
+        raise GraphArtifactError("runtime graph.json is missing export_id")
+    _validate_export_ids(export_ids, expected=manifest_export_id)
+
+
 def _validate_graph_previews(
     graph_dir: Path,
     *,