Sync ctx d2429c6

GitHub commit: d2429c6d8f11d1d68cacc61083c1eba4a9e7717c

.gitattributes

@@ -1,4 +1,2 @@
 graph/wiki-graph.tar.gz filter=lfs diff=lfs merge=lfs -text
-graph/viz-overview.png filter=lfs diff=lfs merge=lfs -text
-graph/viz-security.png filter=lfs diff=lfs merge=lfs -text
 graph/skills-sh-catalog.json.gz filter=lfs diff=lfs merge=lfs -text

.github/workflows/publish.yml

@@ -5,9 +5,9 @@ name: Publish to PyPI
 # no API token needed once the pending publisher is configured at
 # https://pypi.org/manage/account/publishing/.
 #
-# Also deployable on demand via workflow_dispatch. Manual PyPI publishes must
-# run from a version tag that matches pyproject.toml; branch dispatches are
-# allowed only for TestPyPI.
+# Also deployable on demand to TestPyPI via workflow_dispatch. Production
+# PyPI publishes must use a version tag push so graph release assets are
+# uploaded before the wheel is published.
 
 on:
   push:
@@ -66,6 +66,11 @@ jobs:
           ref_type = os.environ.get("GITHUB_REF_TYPE", "")
           ref_name = os.environ["GITHUB_REF_NAME"]
 
+          if event == "workflow_dispatch" and target_repository == "pypi":
+              raise SystemExit(
+                  "Manual PyPI publish is disabled; push a version tag so "
+                  "graph release assets are uploaded before publishing"
+              )
           if event == "workflow_dispatch" and target_repository == "testpypi":
               print(f"manual TestPyPI publish allowed from {ref_type}:{ref_name}")
               raise SystemExit(0)
@@ -417,7 +422,7 @@ jobs:
     needs:
       - build
       - release-assets
-    if: ${{ always() && needs.build.result == 'success' && (github.event_name == 'workflow_dispatch' || needs.release-assets.result == 'success') }}
+    if: ${{ always() && needs.build.result == 'success' && (needs.release-assets.result == 'success' || (github.event_name == 'workflow_dispatch' && github.event.inputs.repository == 'testpypi')) }}
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -433,7 +438,7 @@ jobs:
           path: dist/
 
       - name: Publish to PyPI
-        if: github.event_name == 'push' || github.event.inputs.repository == 'pypi'
+        if: github.event_name == 'push'
         uses: pypa/gh-action-pypi-publish@release/v1
 
       - name: Publish to TestPyPI

.github/workflows/test.yml

@@ -299,10 +299,90 @@ jobs:
 
       - name: Resolve graph LFS artifacts
         shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
         run: |
           set -euo pipefail
           git lfs install --local
-          git lfs pull --include="graph/wiki-graph.tar.gz,graph/skills-sh-catalog.json.gz" --exclude=""
+          if git lfs pull --include="graph/wiki-graph.tar.gz" --exclude=""; then
+            exit 0
+          fi
+          echo "Git LFS download failed; trying matching prior release asset."
+          python - <<'PY'
+          import hashlib
+          import json
+          import os
+          from pathlib import Path
+          import subprocess
+          import urllib.request
+
+          graph_tar = Path("graph/wiki-graph.tar.gz")
+          pointer = graph_tar.read_text(encoding="utf-8", errors="replace")
+          expected_oid = ""
+          expected_size = 0
+          for line in pointer.splitlines():
+              if line.startswith("oid sha256:"):
+                  expected_oid = line.split(":", 1)[1].strip()
+              elif line.startswith("size "):
+                  expected_size = int(line.split(" ", 1)[1].strip())
+          if not expected_oid:
+              if graph_tar.stat().st_size > 100_000_000:
+                  print(f"{graph_tar} is already hydrated")
+                  raise SystemExit(0)
+              raise SystemExit("graph/wiki-graph.tar.gz is neither hydrated nor an LFS pointer")
+
+          repo = os.environ["GITHUB_REPOSITORY"]
+          releases = json.loads(subprocess.check_output(
+              ["gh", "api", f"repos/{repo}/releases?per_page=50"],
+              text=True,
+          ))
+          candidates = []
+          for release in releases:
+              if release.get("draft") or release.get("prerelease"):
+                  continue
+              for asset in release.get("assets", []):
+                  if asset.get("name") != "wiki-graph.tar.gz":
+                      continue
+                  digest = str(asset.get("digest") or "")
+                  size = int(asset.get("size") or 0)
+                  if size != expected_size:
+                      continue
+                  if digest and digest != f"sha256:{expected_oid}":
+                      continue
+                  candidates.append((release.get("tag_name"), asset))
+
+          if not candidates:
+              raise SystemExit(
+                  "No previous release asset matches graph/wiki-graph.tar.gz "
+                  f"sha256:{expected_oid} size:{expected_size}"
+              )
+
+          source_tag, asset = candidates[0]
+          tmp = graph_tar.with_name("wiki-graph.tar.gz.download")
+          sha = hashlib.sha256()
+          total = 0
+          with urllib.request.urlopen(asset["browser_download_url"], timeout=300) as resp:  # noqa: S310
+              with tmp.open("wb") as fh:
+                  while True:
+                      chunk = resp.read(1024 * 1024)
+                      if not chunk:
+                          break
+                      sha.update(chunk)
+                      total += len(chunk)
+                      fh.write(chunk)
+          actual_oid = sha.hexdigest()
+          if actual_oid != expected_oid or total != expected_size:
+              tmp.unlink(missing_ok=True)
+              raise SystemExit(
+                  "Downloaded graph tar does not match LFS pointer: "
+                  f"sha256:{actual_oid} size:{total}"
+              )
+          tmp.replace(graph_tar)
+          print(
+              "Hydrated graph/wiki-graph.tar.gz from "
+              f"{source_tag} release asset sha256:{actual_oid} size:{total}"
+          )
+          PY
 
       - name: Validate shipped graph artifacts
         run: |

CHANGELOG.md

@@ -7,6 +7,24 @@ Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 - No unreleased changes yet.
 
+## [1.0.0] - 2026-05-10
+
+### Added
+
+- Promoted ctx to the first stable release with shipped graph/wiki
+  recommendations for skills, agents, MCP servers, and harnesses.
+- Captured structured custom-model harness requirements during `ctx-init`
+  and `ctx-harness-install --recommend`: runtime/OS, autonomy, allowed tools,
+  verification, privacy/network constraints, and ctx attachment mode.
+
+### Fixed
+
+- Made graph HTML previews export-aware and covered them in the graph artifact
+  validator, so stale preview pages cannot ship beside a newer graph export.
+- Removed stale static graph PNG previews from the repository.
+- Classified `graph/*.html` as graph artifacts in CI so docs/graph checks run
+  when shipped graph previews change.
+
 ## [0.7.18] - 2026-05-09
 
 ### Fixed
@@ -1424,6 +1442,7 @@ pass. Full test suite: **1316 passed, 2 skipped**.
 - 5 dead imports removed (`os`, `Mapping`, `timedelta` from
   `ctx_lifecycle`; `Path` from `intake_gate`, `intake_pipeline`).
 
+[1.0.0]: https://github.com/stevesolun/ctx/releases/tag/v1.0.0
 [0.5.1]: https://github.com/stevesolun/ctx/releases/tag/v0.5.1
 [0.5.0]: https://github.com/stevesolun/ctx/releases/tag/v0.5.0
 [0.5.0-rc1]: https://github.com/stevesolun/ctx/releases/tag/v0.5.0-rc1

README.md

@@ -18,7 +18,7 @@ tags:
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/Python-3.11+-green.svg)](https://python.org)
 [![PyPI](https://img.shields.io/pypi/v/claude-ctx.svg)](https://pypi.org/project/claude-ctx/)
-[![Tests](https://img.shields.io/badge/Tests-3698_collected-brightgreen.svg)](#)
+[![Tests](https://img.shields.io/badge/Tests-3706_collected-brightgreen.svg)](#)
 [![Graph](https://img.shields.io/badge/Graph-102%2C696_nodes_/_2.9M_edges-red.svg)](graph/)
 [![Docs](https://img.shields.io/badge/docs-MkDocs_Material-blue.svg)](https://stevesolun.github.io/ctx/)
 

docs/index.md

@@ -185,8 +185,8 @@ ones are flagged. New ones self-ingest.
 
     ---
 
-    **v0.7.x** — MIT, CI-matrixed (Ubuntu + Windows × Python 3.11/3.12),
-    3,698 tests collected. Ships console scripts including `ctx-init`,
+    **v1.0.0** — MIT, CI-matrixed (Ubuntu + Windows × Python 3.11/3.12),
+    3,706 tests collected. Ships console scripts including `ctx-init`,
     `ctx-monitor` (local dashboard with graph + wiki + load/unload for
     skills, agents, and MCP servers, plus harness wiki/graph browsing),
     `ctx-dedup-check` (pre-ship near-duplicate gate), and

docs/knowledge-graph.md

@@ -261,6 +261,7 @@ next run rebuilds instead of trusting mixed graph files.
 | 2026-05-04 v0.7.3 artifact refresh | **2,960,215** | Hydrated one recoverable Skills.sh command-injection-testing body, raising hydrated Skills.sh `SKILL.md` files to 89,463; generated micro-skill markdown now defangs high-risk command-injection payloads before packaging. Graph topology unchanged. |
 | 2026-05-04 body-backed Skills.sh prune | **2,900,834** | Removed 1,383 Skills.sh records that had no packaged `SKILL.md` body and no parseable Skills.sh prose body. Remaining Skills.sh catalog entries, graph nodes, entity pages, and converted `SKILL.md` bodies are all **89,463**. |
 | 2026-05-05 artifact hygiene refresh | **2,900,834** | Repacked `graph/wiki-graph.tar.gz` to remove transient `.lock` files from the shipped LLM-wiki. Topology unchanged; current tar members: **598,135**. |
+| 2026-05-10 v1.0.0 release prep | **2,900,834** | Refreshed shipped HTML previews from the current export, validated their export IDs in CI, and removed stale PNG previews. Topology unchanged. |
 
 The full audit history lives in `CHANGELOG.md`. The current build is
 fully reproducible from the wiki content.

graph/README.md

@@ -26,12 +26,17 @@ The runtime recommendation paths use this graph in two ways:
 | `wiki-graph.tar.gz` | Full LLM-wiki: entity pages, converted skill bodies, mirrored agent bodies, concept pages, `graphify-out/graph.json`, `graph-delta.json`, export manifest, communities, external catalogs, and Obsidian metadata |
 | `skills-sh-catalog.json.gz` | Compressed Skills.sh catalog for the 89,463 body-backed entries shipped in the wiki |
 | `communities.json` | Current Louvain community export |
-| `viz-overview.html` / `.png` | Plotly overview of the graph |
+| `viz-overview.html` | Plotly overview of the graph |
 | `viz-python.html` | Python-focused graph view |
-| `viz-security.html` / `.png` | Security-focused graph view |
+| `viz-security.html` | Security-focused graph view |
 | `viz-ai-agents.html` | AI-agent-focused graph view |
 | `sample-top60.html` | Interactive top-degree sample |
 
+Preview HTML files are generated from the shipped `graphify-out/graph.json`
+and embed the graph export ID in `<meta name="ctx-graph-export-id">`. Static
+PNG snapshots are intentionally not shipped because they can drift from the
+current tarball without an executable freshness check.
+
 ## What Is Inside `wiki-graph.tar.gz`
 
 - `entities/skills/` - all skill entity pages, including `skills-sh-*` pages

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-ctx"
-version = "0.7.18"
+version = "1.0.0"
 description = "Skill and agent recommendation system for Claude Code — knowledge graph, wiki, and intake quality gates"
 authors = [{ name = "Steve Solun" }]
 license = "MIT"

scripts/ci_classifier.py

@@ -33,6 +33,7 @@ GRAPH_ARTIFACT_PATTERNS = (
     "graph/communities.json",
     "graph/skills-sh-catalog.json.gz",
     "graph/wiki-graph.tar.gz",
+    "graph/*.html",
 )
 BROWSER_PATTERNS = (
     ".github/workflows/test.yml",

src/__init__.py

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

src/ctx/__init__.py

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

src/ctx_init.py

@@ -585,6 +585,24 @@ _PROVIDER_KEY_ENV: dict[str, str] = {
     "ollama": "",
 }
 
+_HARNESS_REQUIREMENT_FIELDS = (
+    ("runtime", "harness_runtime"),
+    ("autonomy", "harness_autonomy"),
+    ("tools", "harness_tools"),
+    ("verification", "harness_verify"),
+    ("privacy", "harness_privacy"),
+    ("attach_mode", "harness_attach_mode"),
+)
+
+_HARNESS_REQUIREMENT_FLAGS = {
+    "runtime": "--harness-runtime",
+    "autonomy": "--harness-autonomy",
+    "tools": "--harness-tools",
+    "verification": "--harness-verify",
+    "privacy": "--harness-privacy",
+    "attach_mode": "--harness-attach-mode",
+}
+
 
 def _model_provider_prefix(model: str) -> str:
     return model.split("/", 1)[0] if "/" in model else model
@@ -1156,6 +1174,72 @@ def _prompt_knowledge_mode(default: str = "shipped") -> str:
         print("  Please choose shipped, local, enriched, or skip.")
 
 
+def _harness_requirements_from_args(args: argparse.Namespace) -> dict[str, str]:
+    requirements: dict[str, str] = {}
+    for key, attr in _HARNESS_REQUIREMENT_FIELDS:
+        value = str(getattr(args, attr, "") or "").strip()
+        if value:
+            requirements[key] = value
+    return requirements
+
+
+def _harness_requirements_text(requirements: dict[str, str]) -> str:
+    return " ".join(
+        value for _key, value in requirements.items()
+        if value.strip()
+    )
+
+
+def _harness_plan_command(
+    *,
+    goal: str,
+    model_provider: str | None,
+    model: str | None,
+    harness_requirements: dict[str, str],
+) -> str:
+    parts = [
+        "ctx-harness-install --recommend",
+        f"--goal {json.dumps(goal or model or 'custom model work')}",
+    ]
+    if model_provider:
+        parts.append(f"--model-provider {json.dumps(model_provider)}")
+    if model:
+        parts.append(f"--model {json.dumps(model)}")
+    for key, _attr in _HARNESS_REQUIREMENT_FIELDS:
+        value = harness_requirements.get(key)
+        if value:
+            parts.append(f"{_HARNESS_REQUIREMENT_FLAGS[key]} {json.dumps(value)}")
+    parts.append("--plan-on-no-fit")
+    return " ".join(parts)
+
+
+def _prompt_harness_requirements(args: argparse.Namespace) -> None:
+    args.harness_runtime = _prompt_text(
+        "Runtime / OS target for the harness",
+        default=getattr(args, "harness_runtime", None),
+    )
+    args.harness_autonomy = _prompt_text(
+        "Autonomy level, e.g. supervised or autonomous",
+        default=getattr(args, "harness_autonomy", None) or "supervised",
+    )
+    args.harness_tools = _prompt_text(
+        "Allowed tools/access, e.g. filesystem shell browser",
+        default=getattr(args, "harness_tools", None),
+    )
+    args.harness_verify = _prompt_text(
+        "Verification commands or gates, e.g. pytest ruff",
+        default=getattr(args, "harness_verify", None),
+    )
+    args.harness_privacy = _prompt_text(
+        "Privacy/network constraints",
+        default=getattr(args, "harness_privacy", None),
+    )
+    args.harness_attach_mode = _prompt_text(
+        "How ctx should attach, e.g. mcp, cli, or api",
+        default=getattr(args, "harness_attach_mode", None) or "mcp",
+    )
+
+
 def _stdio_is_interactive() -> bool:
     return bool(
         getattr(sys.stdin, "isatty", lambda: False)()
@@ -1221,6 +1305,7 @@ def run_wizard(args: argparse.Namespace) -> None:
         default=args.goal,
     )
     if args.model_mode == "custom":
+        _prompt_harness_requirements(args)
         args.validate_model = _prompt_yes_no(
             "Validate the model with one tiny provider call now?",
             default=args.validate_model,
@@ -1246,6 +1331,9 @@ def run_model_onboarding(args: argparse.Namespace, claude: Path) -> int:
         _model_provider_prefix(args.model) if args.model else None
     )
     api_key_env = _resolve_api_key_env(args.api_key_env, args.model, provider)
+    harness_requirements = (
+        _harness_requirements_from_args(args) if mode == "custom" else {}
+    )
     profile: dict[str, Any] = {
         "mode": mode,
         "provider": provider,
@@ -1255,6 +1343,8 @@ def run_model_onboarding(args: argparse.Namespace, claude: Path) -> int:
         "goal": goal,
         "knowledge_mode": getattr(args, "knowledge_mode", "shipped"),
     }
+    if harness_requirements:
+        profile["harness_requirements"] = harness_requirements
     written = write_model_profile(claude, profile, force=args.force)
     if written:
         print(f"  [ok] wrote {written.name}")
@@ -1277,7 +1367,13 @@ def run_model_onboarding(args: argparse.Namespace, claude: Path) -> int:
         return rc
 
     recommendation_query = " ".join(
-        part for part in [goal, provider or "", args.model or "", "harness"]
+        part for part in [
+            goal,
+            _harness_requirements_text(harness_requirements),
+            provider or "",
+            args.model or "",
+            "harness",
+        ]
         if part
     )
     harnesses = recommend_harnesses(
@@ -1294,11 +1390,12 @@ def run_model_onboarding(args: argparse.Namespace, claude: Path) -> int:
             print(f"         install: ctx-harness-install {name} --dry-run")
     elif goal or mode == "custom":
         print("  [info] no harness recommendations matched yet")
-        print(
-            "       build plan: ctx-harness-install --recommend "
-            f"--goal {json.dumps(goal or args.model or 'custom model work')} "
-            f"--model {json.dumps(args.model or '')} --plan-on-no-fit"
-        )
+        print("       build plan: " + _harness_plan_command(
+            goal=goal,
+            model_provider=provider,
+            model=args.model,
+            harness_requirements=harness_requirements,
+        ))
     return rc
 
 
@@ -1363,6 +1460,30 @@ def main(argv: list[str] | None = None) -> int:
         "--goal",
         help="What the user wants to build; used for harness recommendations",
     )
+    parser.add_argument(
+        "--harness-runtime",
+        help="Runtime/OS target for custom-model harness recommendations",
+    )
+    parser.add_argument(
+        "--harness-autonomy",
+        help="Desired harness autonomy level, e.g. supervised or autonomous",
+    )
+    parser.add_argument(
+        "--harness-tools",
+        help="Allowed harness tools/access, e.g. filesystem shell browser",
+    )
+    parser.add_argument(
+        "--harness-verify",
+        help="Verification commands or gates the harness should run",
+    )
+    parser.add_argument(
+        "--harness-privacy",
+        help="Privacy, network, or data-access constraints for the harness",
+    )
+    parser.add_argument(
+        "--harness-attach-mode",
+        help="Preferred ctx attachment mode, e.g. mcp, cli, or api",
+    )
     parser.add_argument(
         "--validate-model",
         action="store_true",

src/harness_install.py

@@ -809,11 +809,18 @@ def recommend_harnesses_for_cli(
     model_provider: str | None,
     model: str | None,
     top_k: int,
+    harness_requirements: dict[str, str] | None = None,
 ) -> list[dict[str, Any]]:
-    from ctx_init import recommend_harnesses  # noqa: PLC0415
+    from ctx_init import _harness_requirements_text, recommend_harnesses  # noqa: PLC0415
 
     query = " ".join(
-        part for part in [goal, model_provider or "", model or "", "harness"] if part
+        part for part in [
+            goal,
+            _harness_requirements_text(harness_requirements or {}),
+            model_provider or "",
+            model or "",
+            "harness",
+        ] if part
     )
     return recommend_harnesses(
         query,
@@ -828,11 +835,13 @@ def render_no_fit_harness_plan(
     goal: str,
     model_provider: str | None,
     model: str | None,
+    harness_requirements: dict[str, str] | None = None,
 ) -> str:
     """Render a build handoff when no catalog harness fits the user's setup."""
     provider = model_provider or _provider_from_model_slug(model) or "unknown provider"
     model_name = model or "unspecified model"
     goal_text = goal.strip() or "unspecified development goal"
+    requirement_lines = _format_harness_requirement_lines(harness_requirements or {})
     return "\n".join([
         "# Custom Harness PRD",
         "",
@@ -845,6 +854,7 @@ def render_no_fit_harness_plan(
         f"- Model provider: {provider}",
         f"- Model: {model_name}",
         "- Target operating systems: Windows, macOS, and Linux unless narrowed by the user",
+        *requirement_lines,
         "",
         "## Required Interview Before Building",
         "",
@@ -895,12 +905,31 @@ def _provider_from_model_slug(model: str | None) -> str | None:
     return provider or None
 
 
+def _format_harness_requirement_lines(
+    requirements: dict[str, str],
+) -> list[str]:
+    labels = {
+        "runtime": "Runtime / OS",
+        "autonomy": "Autonomy",
+        "tools": "Allowed tools/access",
+        "verification": "Verification",
+        "privacy": "Privacy/network",
+        "attach_mode": "Preferred ctx attachment",
+    }
+    return [
+        f"- {label}: {requirements[key]}"
+        for key, label in labels.items()
+        if requirements.get(key)
+    ]
+
+
 def write_no_fit_harness_plan(
     path: Path,
     *,
     goal: str,
     model_provider: str | None,
     model: str | None,
+    harness_requirements: dict[str, str] | None = None,
 ) -> Path:
     target = path.expanduser()
     reject_symlink_path(target)
@@ -910,6 +939,7 @@ def write_no_fit_harness_plan(
             goal=goal,
             model_provider=model_provider,
             model=model,
+            harness_requirements=harness_requirements,
         ),
     )
     return target
@@ -956,6 +986,12 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--goal", help="What you want to build or automate")
     parser.add_argument("--model-provider", help="Model provider prefix, e.g. openai or ollama")
     parser.add_argument("--model", help="Model slug, e.g. openrouter/openai/gpt-5.5")
+    parser.add_argument("--harness-runtime", help="Runtime/OS target for harness fit")
+    parser.add_argument("--harness-autonomy", help="Desired autonomy level")
+    parser.add_argument("--harness-tools", help="Allowed tools/access for the harness")
+    parser.add_argument("--harness-verify", help="Verification commands or gates")
+    parser.add_argument("--harness-privacy", help="Privacy, network, or data constraints")
+    parser.add_argument("--harness-attach-mode", help="Preferred ctx attachment mode")
     parser.add_argument("--top-k", type=int, default=5, help="Maximum recommendations to print")
     parser.add_argument(
         "--plan-on-no-fit",
@@ -1021,11 +1057,15 @@ def main(argv: list[str] | None = None) -> int:
         if not goal.strip():
             print("Error: --recommend requires --goal or a free-text query", file=sys.stderr)
             return 2
+        from ctx_init import _harness_requirements_from_args  # noqa: PLC0415
+
+        harness_requirements = _harness_requirements_from_args(args)
         results = recommend_harnesses_for_cli(
             goal=goal,
             model_provider=args.model_provider,
             model=args.model,
             top_k=max(1, min(int(args.top_k), 5)),
+            harness_requirements=harness_requirements,
         )
         print_recommendations(results)
         if not results and args.plan_on_no_fit:
@@ -1035,6 +1075,7 @@ def main(argv: list[str] | None = None) -> int:
                     goal=goal,
                     model_provider=args.model_provider,
                     model=args.model,
+                    harness_requirements=harness_requirements,
                 )
                 print(f"Custom harness plan: {path}")
             else:
@@ -1043,6 +1084,7 @@ def main(argv: list[str] | None = None) -> int:
                     goal=goal,
                     model_provider=args.model_provider,
                     model=args.model,
+                    harness_requirements=harness_requirements,
                 ), end="")
         elif not results:
             print("Use --plan-on-no-fit to generate a custom harness PRD.")

src/tests/test_ci_classifier.py

@@ -56,6 +56,16 @@ def test_graph_artifacts_are_graph_only_not_docs_only() -> None:
     assert flags["source_changed"] is False
 
 
+def test_graph_preview_html_is_graph_artifact() -> None:
+    flags = classify_paths(["graph/viz-overview.html"])
+
+    assert flags["docs_changed"] is False
+    assert flags["docs_only"] is False
+    assert flags["graph_artifact_changed"] is True
+    assert flags["graph_changed"] is True
+    assert flags["graph_only"] is True
+
+
 def test_graph_readme_is_docs_not_graph_artifact() -> None:
     flags = classify_paths(["graph/README.md"])
 
@@ -138,12 +148,14 @@ def test_ci_workflows_default_to_read_only_token_permissions() -> None:
         assert "\npermissions:\n  contents: read\n" in workflow
 
 
-def test_graph_artifact_job_fails_closed_without_lfs_hydration() -> None:
+def test_graph_artifact_job_uses_release_asset_fallback_for_lfs_budget() -> None:
     workflow = Path(".github/workflows/test.yml").read_text(encoding="utf-8")
 
     assert "Resolve graph LFS artifacts" in workflow
-    assert "graph/wiki-graph.tar.gz,graph/skills-sh-catalog.json.gz" in workflow
-    assert "Validate graph artifact pointer when LFS unavailable" not 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 "python src/validate_graph_artifacts.py" in workflow
     assert "validating pointer metadata only" not in workflow
 
 
@@ -177,12 +189,20 @@ def test_publish_workflow_validates_and_uploads_graph_assets() -> None:
     assert "gh release upload" in workflow
     assert '--repo "$GITHUB_REPOSITORY"' in workflow
     assert "needs.release-assets.result == 'success'" in workflow
+    assert "github.event_name == 'workflow_dispatch' || needs.release-assets.result == 'success'" not in workflow
     assert "continue-on-error: true" not in workflow
     assert "needs.release-assets.result == 'skipped'" not in workflow
     assert "PyPI publish will continue without release asset upload" not in workflow
     assert "graph_assets_available" in workflow
 
 
+def test_changelog_defines_current_release_link() -> None:
+    changelog = Path("CHANGELOG.md").read_text(encoding="utf-8")
+
+    assert "## [1.0.0] - 2026-05-10" in changelog
+    assert "[1.0.0]: https://github.com/stevesolun/ctx/releases/tag/v1.0.0" in changelog
+
+
 def test_pre_commit_refreshes_all_repo_stats_outputs() -> None:
     hook = Path(".githooks/pre-commit").read_text(encoding="utf-8")
 

src/tests/test_ctx_init.py

@@ -140,6 +140,12 @@ def test_main_auto_wizard_in_terminal_configures_custom_model(
         "",                   # api key env default: OPENAI_API_KEY
         "",                   # base URL
         "build CAD artifacts",
+        "windows python",      # runtime / OS
+        "supervised",          # autonomy
+        "filesystem shell",    # allowed tools
+        "pytest ruff",         # verification
+        "private repo",        # privacy / network
+        "mcp",                 # attach mode
         "n",                  # validate model
     ])
     monkeypatch.setattr(builtins, "input", lambda _prompt: next(answers))
@@ -168,6 +174,14 @@ def test_main_auto_wizard_in_terminal_configures_custom_model(
     assert profile["api_key_env"] == "OPENAI_API_KEY"
     assert profile["goal"] == "build CAD artifacts"
     assert profile["knowledge_mode"] == "enriched"
+    assert profile["harness_requirements"] == {
+        "runtime": "windows python",
+        "autonomy": "supervised",
+        "tools": "filesystem shell",
+        "verification": "pytest ruff",
+        "privacy": "private repo",
+        "attach_mode": "mcp",
+    }
     user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
     assert user_config["knowledge"]["mode"] == "enriched"
 
@@ -450,6 +464,60 @@ def test_main_custom_model_writes_profile_and_recommends_harness(
     assert "text-to-cad" in capsys.readouterr().out
 
 
+def test_main_custom_model_records_structured_harness_requirements(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    recommendation_calls: list[dict[str, object]] = []
+
+    def fake_recommend(
+        goal: str,
+        top_k: int = 5,
+        model_provider: str | None = None,
+        model: str | None = None,
+    ) -> list[dict[str, object]]:
+        recommendation_calls.append({
+            "goal": goal,
+            "top_k": top_k,
+            "model_provider": model_provider,
+            "model": model,
+        })
+        return []
+
+    monkeypatch.setattr(ci, "recommend_harnesses", fake_recommend)
+
+    rc = ci.main([
+        "--model-mode", "custom",
+        "--model", "openai/gpt-5.5",
+        "--goal", "build a code agent",
+        "--harness-runtime", "windows python",
+        "--harness-autonomy", "supervised",
+        "--harness-tools", "filesystem shell browser",
+        "--harness-verify", "pytest ruff",
+        "--harness-privacy", "private repo no secrets",
+        "--harness-attach-mode", "mcp",
+    ])
+
+    assert rc == 0
+    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
+    assert profile["harness_requirements"] == {
+        "runtime": "windows python",
+        "autonomy": "supervised",
+        "tools": "filesystem shell browser",
+        "verification": "pytest ruff",
+        "privacy": "private repo no secrets",
+        "attach_mode": "mcp",
+    }
+    query = str(recommendation_calls[0]["goal"])
+    assert "windows python" in query
+    assert "filesystem shell browser" in query
+    assert "pytest ruff" in query
+    assert "private repo no secrets" in query
+    assert "mcp" in query
+
+
 def test_main_custom_model_no_fit_points_to_harness_plan(
     tmp_path: Path,
     monkeypatch,
@@ -462,13 +530,25 @@ def test_main_custom_model_no_fit_points_to_harness_plan(
     rc = ci.main([
         "--model-mode", "custom",
         "--model", "ollama/llama3.1",
+        "--model-provider", "ollama",
         "--goal", "private local CAD workflow",
+        "--harness-runtime", "linux server",
+        "--harness-tools", "filesystem shell",
+        "--harness-verify", "pytest",
+        "--harness-privacy", "offline source code",
+        "--harness-attach-mode", "mcp",
     ])
 
     assert rc == 0
     output = capsys.readouterr().out
     assert "no harness recommendations matched yet" in output
     assert "ctx-harness-install --recommend" in output
+    assert "--model-provider \"ollama\"" in output
+    assert "--harness-runtime \"linux server\"" in output
+    assert "--harness-tools \"filesystem shell\"" in output
+    assert "--harness-verify \"pytest\"" in output
+    assert "--harness-privacy \"offline source code\"" in output
+    assert "--harness-attach-mode \"mcp\"" in output
     assert "--plan-on-no-fit" in output
 
 

src/tests/test_harness_install.py

@@ -764,6 +764,93 @@ def test_recommend_mode_prints_install_handoff(
     assert "ctx-harness-install text-to-cad --dry-run" in output
 
 
+def test_recommend_mode_passes_structured_harness_requirements(
+    monkeypatch: Any,
+) -> None:
+    calls: list[dict[str, object]] = []
+
+    def fake_recommend(**kwargs: Any) -> list[dict[str, object]]:
+        calls.append(kwargs)
+        return []
+
+    monkeypatch.setattr(harness_install, "recommend_harnesses_for_cli", fake_recommend)
+
+    rc = harness_install.main([
+        "--recommend",
+        "--goal",
+        "build a code agent",
+        "--model",
+        "openai/gpt-5.5",
+        "--harness-runtime",
+        "windows python",
+        "--harness-autonomy",
+        "supervised",
+        "--harness-tools",
+        "filesystem shell browser",
+        "--harness-verify",
+        "pytest ruff",
+        "--harness-privacy",
+        "private repo no secrets",
+        "--harness-attach-mode",
+        "mcp",
+    ])
+
+    assert rc == 0
+    assert calls[0]["harness_requirements"] == {
+        "runtime": "windows python",
+        "autonomy": "supervised",
+        "tools": "filesystem shell browser",
+        "verification": "pytest ruff",
+        "privacy": "private repo no secrets",
+        "attach_mode": "mcp",
+    }
+
+
+def test_recommend_cli_query_includes_structured_harness_requirements(
+    monkeypatch: Any,
+) -> None:
+    import ctx_init
+
+    calls: list[dict[str, object]] = []
+
+    def fake_recommend(
+        goal: str,
+        top_k: int = 5,
+        model_provider: str | None = None,
+        model: str | None = None,
+    ) -> list[dict[str, object]]:
+        calls.append({
+            "goal": goal,
+            "top_k": top_k,
+            "model_provider": model_provider,
+            "model": model,
+        })
+        return []
+
+    monkeypatch.setattr(ctx_init, "recommend_harnesses", fake_recommend)
+
+    harness_install.recommend_harnesses_for_cli(
+        goal="build a code agent",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+        top_k=5,
+        harness_requirements={
+            "runtime": "windows python",
+            "tools": "filesystem shell browser",
+            "verification": "pytest ruff",
+            "privacy": "private repo no secrets",
+            "attach_mode": "mcp",
+        },
+    )
+
+    query = str(calls[0]["goal"])
+    assert "windows python" in query
+    assert "filesystem shell browser" in query
+    assert "pytest ruff" in query
+    assert "private repo no secrets" in query
+    assert "mcp" in query
+
+
 def test_recommend_no_fit_prints_custom_harness_plan(
     monkeypatch: Any,
     capsys: Any,
@@ -778,6 +865,14 @@ def test_recommend_no_fit_prints_custom_harness_plan(
         "ollama",
         "--model",
         "ollama/llama3.1",
+        "--harness-runtime",
+        "linux server",
+        "--harness-tools",
+        "filesystem shell",
+        "--harness-verify",
+        "pytest",
+        "--harness-privacy",
+        "offline source code",
         "--plan-on-no-fit",
     ])
 
@@ -788,6 +883,10 @@ def test_recommend_no_fit_prints_custom_harness_plan(
     assert "ctx-mcp-server" in output
     assert "ctx.recommend_bundle" in output
     assert "Windows, macOS, and Linux" in output
+    assert "Runtime / OS: linux server" in output
+    assert "Allowed tools/access: filesystem shell" in output
+    assert "Verification: pytest" in output
+    assert "Privacy/network: offline source code" in output
 
 
 def test_recommend_no_fit_writes_custom_harness_plan(

src/tests/test_validate_graph_artifacts.py

@@ -17,6 +17,14 @@ from validate_graph_artifacts import (
     validate_graph_artifacts,
 )
 
+_PREVIEW_HTML_FILES = (
+    "sample-top60.html",
+    "viz-ai-agents.html",
+    "viz-overview.html",
+    "viz-python.html",
+    "viz-security.html",
+)
+
 
 def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
     payload = text.encode("utf-8")
@@ -125,6 +133,23 @@ def _write_archive(
             _add_text(tf, "./converted/skills-sh-example-skill/SKILL.md.original", "# Raw\n")
         if include_lock:
             _add_text(tf, "./index.md.lock", "")
+    for preview in _PREVIEW_HTML_FILES:
+        (graph_dir / preview).write_text(
+            "\n".join([
+                "<!DOCTYPE html>",
+                "<html><head>",
+                f'<meta name="ctx-graph-export-id" content="{manifest_export_id}">',
+                "</head><body>",
+                "const CTX_GRAPH_METADATA = "
+                + json.dumps({
+                    "export_id": manifest_export_id,
+                    "source_graph_nodes": 2,
+                    "source_graph_edges": 1,
+                }),
+                "</body></html>",
+            ]),
+            encoding="utf-8",
+        )
 
 
 def test_validate_graph_artifacts_checks_catalog_paths_and_deep_graph_stats(
@@ -212,6 +237,35 @@ def test_validate_graph_artifacts_rejects_mixed_export_generation(
         )
 
 
+def test_validate_graph_artifacts_rejects_stale_preview_html(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text(
+        json.dumps({"total_communities": 1}),
+        encoding="utf-8",
+    )
+    _write_archive(tmp_path)
+    (tmp_path / "viz-overview.html").write_text(
+        '<meta name="ctx-graph-export-id" content="old-export">',
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="stale graph preview"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
 @pytest.mark.parametrize(
     ("archive_kwargs", "missing_name"),
     [

src/tests/test_wiki_visualize.py

@@ -13,6 +13,7 @@ and assert that the payload never appears in an executable form.
 
 from __future__ import annotations
 
+import json
 import sys
 from pathlib import Path
 
@@ -118,3 +119,52 @@ def test_visualizer_renders_mcp_and_harness_type_filters():
     assert 'data-type="harness"' in html
     assert '"mcp-server": "#06b6d4"' in html
     assert '"harness": "#22c55e"' in html
+
+
+def test_visualizer_can_load_explicit_graph_and_communities(tmp_path):
+    import wiki_visualize as wv
+
+    graph_path = tmp_path / "graph.json"
+    communities_path = tmp_path / "communities.json"
+    graph_path.write_text(json.dumps({
+        "directed": False,
+        "multigraph": False,
+        "graph": {"export_id": "ctx-graph-test-2-1"},
+        "nodes": [
+            {"id": "skill:a", "label": "alpha", "type": "skill", "tags": ["python"]},
+            {"id": "harness:b", "label": "beta", "type": "harness", "tags": ["agent"]},
+        ],
+        "edges": [{"source": "skill:a", "target": "harness:b", "weight": 0.9}],
+    }), encoding="utf-8")
+    communities_path.write_text(json.dumps({
+        "communities": {"7": {"members": ["skill:a", "harness:b"]}},
+    }), encoding="utf-8")
+
+    G = wv.load_graph(graph_path)
+    communities = wv.load_communities(communities_path)
+
+    assert G.graph["export_id"] == "ctx-graph-test-2-1"
+    assert G.number_of_nodes() == 2
+    assert communities["communities"]["7"]["members"] == ["skill:a", "harness:b"]
+
+
+def test_visualizer_embeds_export_metadata_for_preview_freshness():
+    import wiki_visualize as wv
+
+    G = nx.Graph(export_id="ctx-graph-test-2-1")
+    G.add_node("skill:a", label="alpha", type="skill", tags=["python"])
+    G.add_node("harness:b", label="beta", type="harness", tags=["agent"])
+    G.add_edge("skill:a", "harness:b", weight=0.9)
+    pos = {"skill:a": (0.0, 0.0), "harness:b": (1.0, 1.0)}
+
+    html = wv.build_html_with_filters(
+        G,
+        pos,
+        title="Knowledge Graph",
+        metadata={"export_id": "ctx-graph-test-2-1", "nodes": 2, "edges": 1},
+    )
+
+    assert '<meta name="ctx-graph-export-id" content="ctx-graph-test-2-1">' in html
+    assert '"export_id": "ctx-graph-test-2-1"' in html
+    assert '"nodes": 2' in html
+    assert '"edges": 1' in html

src/validate_graph_artifacts.py

@@ -34,10 +34,21 @@ _SOURCE_SKILLS_SH_RE = re.compile(rb'"source_catalog"\s*:\s*"skills\.sh"')
 _HARNESS_TYPE_RE = re.compile(rb'"type"\s*:\s*"harness"')
 _GRAPH_KEY_RE = re.compile(rb'"graph"\s*:\s*\{')
 _REPORT_EXPORT_ID_RE = re.compile(r"^>\s*Export ID:\s*(\S+)\s*$", re.MULTILINE)
+_PREVIEW_EXPORT_ID_RE = re.compile(
+    r'<meta\s+name=["\']ctx-graph-export-id["\']\s+content=["\']([^"\']+)["\']',
+    re.IGNORECASE,
+)
 _SEMANTIC_SIM_RE = re.compile(
     rb'"semantic_sim"\s*:\s*(-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)',
 )
 _WINDOWS_DRIVE_RE = re.compile(r"^[A-Za-z]:")
+_PREVIEW_HTML_FILES = (
+    "sample-top60.html",
+    "viz-ai-agents.html",
+    "viz-overview.html",
+    "viz-python.html",
+    "viz-security.html",
+)
 
 
 class GraphArtifactError(RuntimeError):
@@ -351,6 +362,7 @@ def validate_graph_artifacts(
     if "graphify-out/graph.json" not in export_ids:
         raise GraphArtifactError("graphify-out/graph.json is missing export_id")
     _validate_export_ids(export_ids, expected=manifest_export_id)
+    _validate_graph_previews(graph_dir, export_id=manifest_export_id, manifest=manifest)
     missing_pages = sorted(required_skill_pages - names)
     if missing_pages:
         raise GraphArtifactError(f"missing Skills.sh entity pages: {missing_pages[:5]}")
@@ -428,6 +440,43 @@ def validate_graph_artifacts(
     return stats
 
 
+def _validate_graph_previews(
+    graph_dir: Path,
+    *,
+    export_id: str,
+    manifest: dict[str, Any] | None,
+) -> None:
+    counts = manifest.get("counts") if isinstance(manifest, dict) else None
+    source_nodes = counts.get("nodes") if isinstance(counts, dict) else None
+    source_edges = counts.get("edges") if isinstance(counts, dict) else None
+    for filename in _PREVIEW_HTML_FILES:
+        path = graph_dir / filename
+        if not path.is_file() or path.stat().st_size == 0:
+            raise GraphArtifactError(f"missing graph preview: {filename}")
+        text = path.read_text(encoding="utf-8", errors="replace")
+        match = _PREVIEW_EXPORT_ID_RE.search(text)
+        actual_export = match.group(1).strip() if match else ""
+        if actual_export != export_id:
+            raise GraphArtifactError(
+                f"stale graph preview {filename}: expected export_id {export_id}, "
+                f"got {actual_export or 'missing'}",
+            )
+        if isinstance(source_nodes, int) and not re.search(
+            rf'"source_graph_nodes"\s*:\s*{source_nodes}\b',
+            text,
+        ):
+            raise GraphArtifactError(
+                f"stale graph preview {filename}: missing source_graph_nodes {source_nodes}",
+            )
+        if isinstance(source_edges, int) and not re.search(
+            rf'"source_graph_edges"\s*:\s*{source_edges}\b',
+            text,
+        ):
+            raise GraphArtifactError(
+                f"stale graph preview {filename}: missing source_graph_edges {source_edges}",
+            )
+
+
 def _read_tar_json(tf: tarfile.TarFile, member: tarfile.TarInfo, name: str) -> Any:
     f = tf.extractfile(member)
     if f is None:

src/wiki_visualize.py

@@ -72,12 +72,13 @@ COMMUNITY_COLORS = [
 ]
 
 
-def load_graph() -> nx.Graph:
+def load_graph(path: Path | str | None = None) -> nx.Graph:
     """Load the knowledge graph."""
-    if not GRAPH_PATH.exists():
-        print(f"Error: {GRAPH_PATH} not found. Run wiki_graphify.py first.", file=sys.stderr)
+    graph_path = Path(path) if path is not None else GRAPH_PATH
+    if not graph_path.exists():
+        print(f"Error: {graph_path} not found. Run wiki_graphify.py first.", file=sys.stderr)
         sys.exit(1)
-    with open(GRAPH_PATH, encoding="utf-8") as f:
+    with open(graph_path, encoding="utf-8") as f:
         data = json.load(f)
     # Auto-detect NetworkX 2.x "links" vs 3.x "edges" schema — graph.json
     # was written with the legacy key on build machines that had the old
@@ -86,11 +87,12 @@ def load_graph() -> nx.Graph:
     return node_link_graph(data, edges=edges_key)
 
 
-def load_communities() -> dict:
+def load_communities(path: Path | str | None = None) -> dict:
     """Load community assignments."""
-    if not COMMUNITIES_PATH.exists():
+    communities_path = Path(path) if path is not None else COMMUNITIES_PATH
+    if not communities_path.exists():
         return {}
-    with open(COMMUNITIES_PATH, encoding="utf-8") as f:
+    with open(communities_path, encoding="utf-8") as f:
         return json.load(f)
 
 
@@ -101,6 +103,7 @@ def extract_subgraph(
     hops: int = 1,
     min_weight: float = 0.0,
     community_id: int | None = None,
+    communities: dict | None = None,
     tag_filter: str | None = None,
     top_n: int | None = None,
 ) -> nx.Graph:
@@ -131,8 +134,8 @@ def extract_subgraph(
             frontier = next_frontier
 
     elif community_id is not None:
-        communities = load_communities()
-        comm_data = communities.get("communities", {}).get(str(community_id))
+        community_data = communities if communities is not None else load_communities()
+        comm_data = community_data.get("communities", {}).get(str(community_id))
         if not comm_data:
             print(f"Error: community {community_id} not found", file=sys.stderr)
             return nx.Graph()
@@ -177,11 +180,23 @@ def compute_layout(G: nx.Graph) -> dict[str, tuple[float, float]]:
     return nx.spring_layout(G, k=2.0 / math.sqrt(max(G.number_of_nodes(), 1)), iterations=50, seed=42)
 
 
-def build_html_with_filters(G: nx.Graph, pos: dict, title: str = "Knowledge Graph") -> str:
+def build_html_with_filters(
+    G: nx.Graph,
+    pos: dict,
+    title: str = "Knowledge Graph",
+    *,
+    communities: dict | None = None,
+    metadata: dict | None = None,
+) -> str:
     """Build a self-contained HTML page with sidebar filter controls."""
     # Prepare node data as JSON for the JS frontend
     nodes_data = []
-    communities = load_communities()
+    communities = communities if communities is not None else load_communities()
+    metadata = dict(metadata or {})
+    if "export_id" not in metadata and G.graph.get("export_id"):
+        metadata["export_id"] = G.graph.get("export_id")
+    metadata.setdefault("nodes", G.number_of_nodes())
+    metadata.setdefault("edges", G.number_of_edges())
     node_community: dict[str, int] = {}
     for cid, comm_data in communities.get("communities", {}).items():
         for member in comm_data.get("members", []):
@@ -217,10 +232,16 @@ def build_html_with_filters(G: nx.Graph, pos: dict, title: str = "Knowledge Grap
 
     top_tags = sorted(tag_counts.items(), key=lambda x: -x[1])[:25]
     safe_title = html.escape(title)
+    export_id = str(metadata.get("export_id") or "")
+    export_meta = (
+        f'<meta name="ctx-graph-export-id" content="{html.escape(export_id, quote=True)}">'
+        if export_id else ""
+    )
 
     return f"""<!DOCTYPE html>
 <html><head><meta charset="utf-8">
 <title>{safe_title}</title>
+{export_meta}
 <!-- Pinned to an explicit version (not -latest) so served content can't change
      silently. A real SRI hash would be better but must be generated from the
      published release — see https://cdn.plot.ly/ for hashes. -->
@@ -288,6 +309,7 @@ def build_html_with_filters(G: nx.Graph, pos: dict, title: str = "Knowledge Grap
 const NODES = {_safe_json_for_script(nodes_data)};
 const EDGES = {_safe_json_for_script(edges_data)};
 const TYPE_COLORS = {_safe_json_for_script(TYPE_COLORS)};
+const CTX_GRAPH_METADATA = {_safe_json_for_script(metadata)};
 const COMM_COLORS = ["#ef4444","#f97316","#eab308","#22c55e","#06b6d4","#3b82f6","#8b5cf6","#ec4899","#14b8a6","#f43f5e","#84cc16","#0ea5e9","#a855f7","#e11d48","#10b981"];
 
 function esc(s) {{ return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,'&#39;'); }}
@@ -668,9 +690,16 @@ def main() -> None:
     parser.add_argument("--top", type=int, help="Show only the top-N most connected nodes")
     parser.add_argument("--output", help="Save to HTML file instead of opening browser")
     parser.add_argument("--stats", action="store_true", help="Print graph stats and exit")
+    parser.add_argument("--graph-json", type=Path, help="Load this graph.json instead of ~/.claude")
+    parser.add_argument(
+        "--communities-json",
+        type=Path,
+        help="Load this communities.json instead of ~/.claude",
+    )
     args = parser.parse_args()
 
-    G = load_graph()
+    G = load_graph(args.graph_json)
+    communities = load_communities(args.communities_json)
 
     if args.stats:
         print(f"Full graph: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")
@@ -681,7 +710,6 @@ def main() -> None:
         print("\nTop 10 by connections:")
         for n in top:
             print(f"  {G.nodes[n].get('label', n)} ({G.degree(n)} connections)")
-        communities = load_communities()
         print(f"\nCommunities: {len(communities.get('communities', {}))}")
         return
 
@@ -699,6 +727,7 @@ def main() -> None:
         hops=args.hops,
         min_weight=args.min_weight,
         community_id=args.community,
+        communities=communities,
         tag_filter=args.tag,
         top_n=args.top,
     )
@@ -724,7 +753,19 @@ def main() -> None:
     # Layout + render with embedded filter sidebar
     pos = compute_layout(sub)
     output_path = args.output or "graph-view.html"
-    html = build_html_with_filters(sub, pos, title=title)
+    html = build_html_with_filters(
+        sub,
+        pos,
+        title=title,
+        communities=communities,
+        metadata={
+            "export_id": G.graph.get("export_id"),
+            "source_graph_nodes": G.number_of_nodes(),
+            "source_graph_edges": G.number_of_edges(),
+            "view_nodes": sub.number_of_nodes(),
+            "view_edges": sub.number_of_edges(),
+        },
+    )
     Path(output_path).write_text(html, encoding="utf-8")
     print(f"Saved to {output_path}")