Sync ctx 711582e

GitHub commit: 711582e373fea0c43204213279f9ebd5c8937f26

.githooks/post-checkout

@@ -1,3 +1,3 @@
 #!/bin/sh
-command -v git-lfs >/dev/null 2>&1 || { echo >&2 "\nThis repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-checkout' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks').\n"; exit 2; }
+command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-checkout' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; }
 git lfs post-checkout "$@"

.githooks/post-commit

@@ -1,3 +1,3 @@
 #!/bin/sh
-command -v git-lfs >/dev/null 2>&1 || { echo >&2 "\nThis repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-commit' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks').\n"; exit 2; }
+command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-commit' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; }
 git lfs post-commit "$@"

.githooks/post-merge

@@ -1,3 +1,3 @@
 #!/bin/sh
-command -v git-lfs >/dev/null 2>&1 || { echo >&2 "\nThis repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-merge' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks').\n"; exit 2; }
+command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-merge' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; }
 git lfs post-merge "$@"

.githooks/pre-push

@@ -1,3 +1,3 @@
 #!/bin/sh
-command -v git-lfs >/dev/null 2>&1 || { echo >&2 "\nThis repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'pre-push' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks').\n"; exit 2; }
+command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'pre-push' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; }
 git lfs pre-push "$@"

.github/workflows/huggingface-sync.yml

@@ -67,7 +67,7 @@ jobs:
               for line in Path("changed-files.txt").read_text(encoding="utf-8").splitlines()
               if line.strip()
           ]
-          card_only_prefixes = (".github/", "docs/", "src/tests/")
+          card_only_prefixes = ("docs/",)
           card_only_files = {"README.md", "CHANGELOG.md"}
           card_only = bool(files) and all(
               path in card_only_files or path.startswith(card_only_prefixes)
@@ -82,33 +82,35 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: |
           set -euo pipefail
-          echo "Resolving graph artifacts from matching release assets to avoid Git LFS bandwidth."
+          echo "Resolving graph artifacts from release cache, or targeted Git LFS for new pointers."
           python - <<'PY'
           import hashlib
           import json
           import os
           from pathlib import Path
           import subprocess
-          import time
           import urllib.request
 
           repo = os.environ["GITHUB_REPOSITORY"]
-          release_asset_wait_seconds = 300
-          release_asset_poll_seconds = 10
           expected_graph_assets = {
               "graph/wiki-graph.tar.gz": {
-                  "sha256": "d051d4f21208abe3e73975a9c30650150138d88919c27979d725be936a6ea10a",
-                  "size": 296113770,
+                  "sha256": "2ce8a945c17a7345df9d27d8f101319a9f963b0fc85d399f104630bc06a7c4a0",
+                  "size": 295151086,
               },
               "graph/wiki-graph-runtime.tar.gz": {
-                  "sha256": "993fc08377fdb09edcff4414c59b10fc121189b4a161bf796e3f8f6600907bb1",
-                  "size": 122141091,
+                  "sha256": "d4a39836aab5f558b546842580b2e20c523b9a9ab901ed681f84c09b5c4d6515",
+                  "size": 110283462,
               },
               "graph/skills-sh-catalog.json.gz": {
                   "sha256": "d1bb927e93d65ef86cdbc6d68c7f57511d64c8f13026e8193287a9c4ca6f5815",
                   "size": 10763626,
               },
           }
+          max_lfs_fallback_sizes = {
+              "graph/wiki-graph.tar.gz": 350_000_000,
+              "graph/wiki-graph-runtime.tar.gz": 150_000_000,
+              "graph/skills-sh-catalog.json.gz": 15_000_000,
+          }
 
           def load_releases() -> list[dict]:
               return json.loads(subprocess.check_output(
@@ -116,55 +118,116 @@ jobs:
                   text=True,
               ))
 
+          def read_lfs_pointer(artifact: Path) -> tuple[str, int] | None:
+              if not artifact.exists():
+                  return None
+              pointer = artifact.read_text(encoding="utf-8", errors="replace")
+              if not pointer.startswith("version https://git-lfs.github.com/spec/v1"):
+                  return None
+              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 expected_oid and expected_size:
+                  return expected_oid, expected_size
+              raise SystemExit(f"{artifact} has incomplete Git LFS pointer metadata")
+
+          def verify_hydrated_file(artifact: Path, expected_oid: str, expected_size: int) -> None:
+              sha = hashlib.sha256()
+              total = 0
+              with artifact.open("rb") as fh:
+                  while True:
+                      chunk = fh.read(1024 * 1024)
+                      if not chunk:
+                          break
+                      sha.update(chunk)
+                      total += len(chunk)
+              actual_oid = sha.hexdigest()
+              if actual_oid != expected_oid or total != expected_size:
+                  raise SystemExit(
+                      f"{artifact} does not match LFS pointer: "
+                      f"sha256:{actual_oid} size:{total}"
+                  )
+
+          def pointer_matches_static_release_cache(pointer: tuple[str, int], fallback: dict[str, object]) -> bool:
+              return pointer == (str(fallback["sha256"]), int(fallback["size"]))
+
+          def hydrate_from_lfs(path_name: str, expected_oid: str, expected_size: int, hydrated_min_size: int) -> None:
+              artifact = Path(path_name)
+              max_size = max_lfs_fallback_sizes.get(path_name)
+              if max_size is None:
+                  raise SystemExit(f"Refusing Git LFS fallback for {path_name}: no size cap configured")
+              if expected_size > max_size:
+                  raise SystemExit(
+                      f"Refusing Git LFS fallback for {path_name}: "
+                      f"pointer size {expected_size} exceeds cap {max_size}"
+                  )
+              print(f"Pointer for {path_name} is not in release cache; hydrating from targeted Git LFS.")
+              env = os.environ.copy()
+              env.setdefault("GIT_LFS_SKIP_SMUDGE", "1")
+              env.setdefault("GIT_LFS_ACTIVITYTIMEOUT", "600")
+              env.setdefault("GIT_LFS_DIALTIMEOUT", "120")
+              env.setdefault("GIT_LFS_TLSTIMEOUT", "120")
+              subprocess.check_call(
+                  ["git", "lfs", "pull", "--include", path_name, "--exclude", ""],
+                  env=env,
+              )
+              if not artifact.exists() or artifact.stat().st_size <= hydrated_min_size:
+                  raise SystemExit(f"Git LFS did not hydrate {path_name}")
+              verify_hydrated_file(artifact, expected_oid, expected_size)
+              print(f"Hydrated {path_name} from targeted Git LFS sha256:{expected_oid} size:{expected_size}")
+
           def hydrate_from_release(path_name: str, hydrated_min_size: int) -> None:
               artifact = Path(path_name)
               fallback = expected_graph_assets[path_name]
               expected_oid = fallback["sha256"]
               expected_size = int(fallback["size"])
-              if artifact.exists():
-                  pointer = artifact.read_text(encoding="utf-8", errors="replace")
-                  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 pointer.startswith("version https://git-lfs.github.com/spec/v1") and artifact.stat().st_size > hydrated_min_size:
-                      print(f"{artifact} is already hydrated")
-                      return
-
-              deadline = time.monotonic() + release_asset_wait_seconds
-              while True:
-                  candidates = []
-                  for release in load_releases():
-                      tag_name = str(release.get("tag_name") or "")
-                      is_graph_cache = tag_name.startswith("graph-artifacts-")
-                      if release.get("draft") or (
-                          release.get("prerelease") and not is_graph_cache
-                      ):
+              if artifact.exists() and artifact.stat().st_size > hydrated_min_size:
+                  print(f"{artifact} is already hydrated")
+                  return
+              pointer = read_lfs_pointer(artifact)
+              if pointer is not None:
+                  expected_oid, expected_size = pointer
+                  if not pointer_matches_static_release_cache(pointer, fallback):
+                      print(
+                          f"Pointer for {path_name} is newer than the static release cache; "
+                          "searching release caches before targeted Git LFS."
+                      )
+
+              candidates = []
+              for release in load_releases():
+                  tag_name = str(release.get("tag_name") or "")
+                  is_graph_cache = tag_name.startswith("graph-artifacts-")
+                  if release.get("draft") or (
+                      release.get("prerelease") and not is_graph_cache
+                  ):
+                      continue
+                  for asset in release.get("assets", []):
+                      if asset.get("name") != artifact.name:
+                          continue
+                      digest = str(asset.get("digest") or "")
+                      size = int(asset.get("size") or 0)
+                      if size != expected_size:
                           continue
-                      for asset in release.get("assets", []):
-                          if asset.get("name") != artifact.name:
-                              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((tag_name, asset))
-
-                  if candidates:
-                      break
-                  if time.monotonic() >= deadline:
+                      if digest and digest != f"sha256:{expected_oid}":
+                          continue
+                      candidates.append((tag_name, asset))
+
+              if not candidates:
+                  if pointer is None:
                       raise SystemExit(
                           f"No release asset matches {path_name} "
                           f"sha256:{expected_oid} size:{expected_size}"
                       )
                   print(
-                      f"Waiting for matching release asset {artifact.name} "
+                      f"No release asset matches {path_name} "
                       f"sha256:{expected_oid} size:{expected_size}"
                   )
-                  time.sleep(release_asset_poll_seconds)
+                  hydrate_from_lfs(path_name, expected_oid, expected_size, hydrated_min_size)
+                  return
 
               source_tag, asset = candidates[0]
               tmp = artifact.with_name(f"{artifact.name}.download")

.github/workflows/publish.yml

@@ -139,30 +139,31 @@ jobs:
           TAG_NAME: ${{ github.ref_name }}
         run: |
           set -euo pipefail
-          echo "Resolving graph artifacts from matching release assets to avoid Git LFS bandwidth."
+          echo "Resolving graph artifacts from release cache, or targeted Git LFS for new pointers."
           python - <<'PY'
           import hashlib
           import json
           import os
           from pathlib import Path
           import subprocess
-          import time
           import urllib.request
 
           repo = os.environ["GITHUB_REPOSITORY"]
           current_tag = os.environ.get("TAG_NAME", "")
-          release_asset_wait_seconds = 300
-          release_asset_poll_seconds = 10
           expected_graph_assets = {
               "graph/wiki-graph.tar.gz": {
-                  "sha256": "e487ec2109803e3c05cb2ca6906e8a0bae681f32a4fe79f3fb2f168fbea2c947",
-                  "size": 329276669,
+                  "sha256": "2ce8a945c17a7345df9d27d8f101319a9f963b0fc85d399f104630bc06a7c4a0",
+                  "size": 295151086,
               },
               "graph/wiki-graph-runtime.tar.gz": {
-                  "sha256": "993fc08377fdb09edcff4414c59b10fc121189b4a161bf796e3f8f6600907bb1",
-                  "size": 122141091,
+                  "sha256": "d4a39836aab5f558b546842580b2e20c523b9a9ab901ed681f84c09b5c4d6515",
+                  "size": 110283462,
               },
           }
+          max_lfs_fallback_sizes = {
+              "graph/wiki-graph.tar.gz": 350_000_000,
+              "graph/wiki-graph-runtime.tar.gz": 150_000_000,
+          }
 
           def load_releases() -> list[dict]:
               return json.loads(subprocess.check_output(
@@ -170,57 +171,113 @@ jobs:
                   text=True,
               ))
 
+          def read_lfs_pointer(graph_tar: Path) -> tuple[str, int] | None:
+              if not graph_tar.exists():
+                  return None
+              pointer = graph_tar.read_text(encoding="utf-8", errors="replace")
+              if not pointer.startswith("version https://git-lfs.github.com/spec/v1"):
+                  return None
+              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 expected_oid and expected_size:
+                  return expected_oid, expected_size
+              raise SystemExit(f"{graph_tar} has incomplete Git LFS pointer metadata")
+
+          def verify_hydrated_file(graph_tar: Path, expected_oid: str, expected_size: int) -> None:
+              sha = hashlib.sha256()
+              total = 0
+              with graph_tar.open("rb") as fh:
+                  while True:
+                      chunk = fh.read(1024 * 1024)
+                      if not chunk:
+                          break
+                      sha.update(chunk)
+                      total += len(chunk)
+              actual_oid = sha.hexdigest()
+              if actual_oid != expected_oid or total != expected_size:
+                  raise SystemExit(
+                      f"{graph_tar} does not match LFS pointer: "
+                      f"sha256:{actual_oid} size:{total}"
+                  )
+
+          def pointer_matches_static_release_cache(pointer: tuple[str, int], fallback: dict[str, object]) -> bool:
+              return pointer == (str(fallback["sha256"]), int(fallback["size"]))
+
+          def hydrate_from_lfs(path_name: str, expected_oid: str, expected_size: int, hydrated_min_size: int) -> None:
+              graph_tar = Path(path_name)
+              max_size = max_lfs_fallback_sizes.get(path_name)
+              if max_size is None:
+                  raise SystemExit(f"Refusing Git LFS fallback for {path_name}: no size cap configured")
+              if expected_size > max_size:
+                  raise SystemExit(
+                      f"Refusing Git LFS fallback for {path_name}: "
+                      f"pointer size {expected_size} exceeds cap {max_size}"
+                  )
+              print(f"Pointer for {path_name} is not in release cache; hydrating from targeted Git LFS.")
+              env = os.environ.copy()
+              env.setdefault("GIT_LFS_SKIP_SMUDGE", "1")
+              env.setdefault("GIT_LFS_ACTIVITYTIMEOUT", "600")
+              env.setdefault("GIT_LFS_DIALTIMEOUT", "120")
+              env.setdefault("GIT_LFS_TLSTIMEOUT", "120")
+              subprocess.check_call(
+                  ["git", "lfs", "pull", "--include", path_name, "--exclude", ""],
+                  env=env,
+              )
+              if not graph_tar.exists() or graph_tar.stat().st_size <= hydrated_min_size:
+                  raise SystemExit(f"Git LFS did not hydrate {path_name}")
+              verify_hydrated_file(graph_tar, expected_oid, expected_size)
+              print(f"Hydrated {path_name} from targeted Git LFS sha256:{expected_oid} size:{expected_size}")
+
           def hydrate_from_release(path_name: str, hydrated_min_size: int) -> None:
               graph_tar = Path(path_name)
               fallback = expected_graph_assets[path_name]
               expected_oid = fallback["sha256"]
               expected_size = int(fallback["size"])
-              if graph_tar.exists():
-                  pointer = graph_tar.read_text(encoding="utf-8", errors="replace")
-                  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 pointer.startswith("version https://git-lfs.github.com/spec/v1") and graph_tar.stat().st_size > hydrated_min_size:
-                      print(f"{graph_tar} is already hydrated")
-                      return
-
-              deadline = time.monotonic() + release_asset_wait_seconds
-              while True:
-                  candidates = []
-                  for release in load_releases():
-                      tag_name = str(release.get("tag_name") or "")
-                      is_graph_cache = tag_name.startswith("graph-artifacts-")
-                      if release.get("draft") or (
-                          release.get("prerelease") and not is_graph_cache
-                      ):
+              if graph_tar.exists() and graph_tar.stat().st_size > hydrated_min_size:
+                  print(f"{graph_tar} is already hydrated")
+                  return
+              pointer = read_lfs_pointer(graph_tar)
+              if pointer is not None:
+                  expected_oid, expected_size = pointer
+                  if not pointer_matches_static_release_cache(pointer, fallback):
+                      print(
+                          f"Pointer for {path_name} is newer than the static release cache; "
+                          "searching release caches before targeted Git LFS."
+                      )
+
+              candidates = []
+              for release in load_releases():
+                  tag_name = str(release.get("tag_name") or "")
+                  is_graph_cache = tag_name.startswith("graph-artifacts-")
+                  if release.get("draft") or (
+                      release.get("prerelease") and not is_graph_cache
+                  ):
+                      continue
+                  if tag_name == current_tag:
+                      continue
+                  for asset in release.get("assets", []):
+                      if asset.get("name") != graph_tar.name:
                           continue
-                      if tag_name == current_tag:
+                      digest = str(asset.get("digest") or "")
+                      size = int(asset.get("size") or 0)
+                      if size != expected_size:
                           continue
-                      for asset in release.get("assets", []):
-                          if asset.get("name") != graph_tar.name:
-                              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((tag_name, asset))
-
-                  if candidates:
-                      break
-                  if time.monotonic() >= deadline:
-                      raise SystemExit(
-                          f"No previous release asset matches {path_name} "
-                          f"sha256:{expected_oid} size:{expected_size}"
-                      )
+                      if digest and digest != f"sha256:{expected_oid}":
+                          continue
+                      candidates.append((tag_name, asset))
+
+              if not candidates:
                   print(
-                      f"Waiting for matching release asset {graph_tar.name} "
+                      f"No previous release asset matches {path_name} "
                       f"sha256:{expected_oid} size:{expected_size}"
                   )
-                  time.sleep(release_asset_poll_seconds)
+                  hydrate_from_lfs(path_name, expected_oid, expected_size, hydrated_min_size)
+                  return
 
               source_tag, asset = candidates[0]
               tmp = graph_tar.with_name(f"{graph_tar.name}.download")

.github/workflows/test.yml

@@ -344,13 +344,13 @@ jobs:
           python -m pip install --upgrade pip
           python -m pip install ".[dev]"
 
-      - name: Resolve graph artifacts from release assets
+      - name: Resolve graph artifacts from release assets or targeted LFS
         shell: bash
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
           set -euo pipefail
-          echo "Resolving graph artifacts from matching release assets to avoid Git LFS bandwidth."
+          echo "Resolving graph artifacts from release cache, or targeted Git LFS for new PR pointers."
           python - <<'PY'
           import hashlib
           import json
@@ -362,17 +362,23 @@ jobs:
 
           repo = os.environ["GITHUB_REPOSITORY"]
           release_asset_wait_seconds = 300
+          if os.environ.get("GITHUB_EVENT_NAME") == "pull_request":
+              release_asset_wait_seconds = 0
           release_asset_poll_seconds = 10
           expected_graph_assets = {
               "graph/wiki-graph.tar.gz": {
-                  "sha256": "e487ec2109803e3c05cb2ca6906e8a0bae681f32a4fe79f3fb2f168fbea2c947",
-                  "size": 329276669,
+                  "sha256": "2ce8a945c17a7345df9d27d8f101319a9f963b0fc85d399f104630bc06a7c4a0",
+                  "size": 295151086,
               },
               "graph/wiki-graph-runtime.tar.gz": {
-                  "sha256": "993fc08377fdb09edcff4414c59b10fc121189b4a161bf796e3f8f6600907bb1",
-                  "size": 122141091,
+                  "sha256": "d4a39836aab5f558b546842580b2e20c523b9a9ab901ed681f84c09b5c4d6515",
+                  "size": 110283462,
               },
           }
+          max_lfs_fallback_sizes = {
+              "graph/wiki-graph.tar.gz": 350_000_000,
+              "graph/wiki-graph-runtime.tar.gz": 150_000_000,
+          }
 
           def load_releases() -> list[dict]:
               return json.loads(subprocess.check_output(
@@ -380,21 +386,85 @@ jobs:
                   text=True,
               ))
 
+          def read_lfs_pointer(graph_tar: Path) -> tuple[str, int] | None:
+              if not graph_tar.exists():
+                  return None
+              pointer = graph_tar.read_text(encoding="utf-8", errors="replace")
+              if not pointer.startswith("version https://git-lfs.github.com/spec/v1"):
+                  return None
+              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 expected_oid and expected_size:
+                  return expected_oid, expected_size
+              raise SystemExit(f"{graph_tar} has incomplete Git LFS pointer metadata")
+
+          def verify_hydrated_file(graph_tar: Path, expected_oid: str, expected_size: int) -> None:
+              sha = hashlib.sha256()
+              total = 0
+              with graph_tar.open("rb") as fh:
+                  while True:
+                      chunk = fh.read(1024 * 1024)
+                      if not chunk:
+                          break
+                      sha.update(chunk)
+                      total += len(chunk)
+              actual_oid = sha.hexdigest()
+              if actual_oid != expected_oid or total != expected_size:
+                  raise SystemExit(
+                      f"{graph_tar} does not match LFS pointer: "
+                      f"sha256:{actual_oid} size:{total}"
+                  )
+
+          def pointer_matches_static_release_cache(pointer: tuple[str, int], fallback: dict[str, object]) -> bool:
+              return pointer == (str(fallback["sha256"]), int(fallback["size"]))
+
+          def hydrate_from_lfs(path_name: str, expected_oid: str, expected_size: int, hydrated_min_size: int) -> None:
+              graph_tar = Path(path_name)
+              max_size = max_lfs_fallback_sizes.get(path_name)
+              if max_size is None:
+                  raise SystemExit(f"Refusing Git LFS fallback for {path_name}: no size cap configured")
+              if expected_size > max_size:
+                  raise SystemExit(
+                      f"Refusing Git LFS fallback for {path_name}: "
+                      f"pointer size {expected_size} exceeds cap {max_size}"
+                  )
+              print(f"Pointer for {path_name} is not in release cache; hydrating from targeted Git LFS.")
+              env = os.environ.copy()
+              env.setdefault("GIT_LFS_SKIP_SMUDGE", "1")
+              env.setdefault("GIT_LFS_ACTIVITYTIMEOUT", "600")
+              env.setdefault("GIT_LFS_DIALTIMEOUT", "120")
+              env.setdefault("GIT_LFS_TLSTIMEOUT", "120")
+              env.setdefault("GIT_LFS_CONCURRENTTRANSFERS", "1")
+              subprocess.check_call(
+                  ["git", "lfs", "pull", "--include", path_name, "--exclude", ""],
+                  env=env,
+              )
+              if not graph_tar.exists() or graph_tar.stat().st_size <= hydrated_min_size:
+                  raise SystemExit(f"Git LFS did not hydrate {path_name}")
+              verify_hydrated_file(graph_tar, expected_oid, expected_size)
+              print(f"Hydrated {path_name} from targeted Git LFS sha256:{expected_oid} size:{expected_size}")
+
           def hydrate_from_release(path_name: str, hydrated_min_size: int) -> None:
               graph_tar = Path(path_name)
               fallback = expected_graph_assets[path_name]
               expected_oid = fallback["sha256"]
               expected_size = int(fallback["size"])
-              if graph_tar.exists():
-                  pointer = graph_tar.read_text(encoding="utf-8", errors="replace")
-                  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 pointer.startswith("version https://git-lfs.github.com/spec/v1") and graph_tar.stat().st_size > hydrated_min_size:
-                      print(f"{graph_tar} is already hydrated")
-                      return
+              if graph_tar.exists() and graph_tar.stat().st_size > hydrated_min_size:
+                  print(f"{graph_tar} is already hydrated")
+                  return
+              pointer = read_lfs_pointer(graph_tar)
+              if pointer is not None:
+                  expected_oid, expected_size = pointer
+                  if not pointer_matches_static_release_cache(pointer, fallback):
+                      print(
+                          f"Pointer for {path_name} is newer than the static release cache; "
+                          "searching release caches before targeted Git LFS."
+                      )
 
               deadline = time.monotonic() + release_asset_wait_seconds
               while True:
@@ -420,10 +490,12 @@ jobs:
                   if candidates:
                       break
                   if time.monotonic() >= deadline:
-                      raise SystemExit(
+                      print(
                           f"No previous release asset matches {path_name} "
                           f"sha256:{expected_oid} size:{expected_size}"
                       )
+                      hydrate_from_lfs(path_name, expected_oid, expected_size, hydrated_min_size)
+                      return
                   print(
                       f"Waiting for matching release asset {graph_tar.name} "
                       f"sha256:{expected_oid} size:{expected_size}"

.no-mistakes.yaml

@@ -0,0 +1,12 @@
+commands:
+  test: "scripts/no_mistakes_run.sh test"
+  lint: "scripts/no_mistakes_run.sh lint"
+  format: "scripts/no_mistakes_run.sh format"
+
+auto_fix:
+  rebase: 3
+  review: 0
+  test: 3
+  document: 3
+  lint: 3
+  ci: 3

CHANGELOG.md

@@ -20,12 +20,23 @@ Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   `src`, `hooks`, and `scripts`.
 - Made canonical Hugging Face sync fail when `HF_TOKEN` is missing while forks
   still skip safely without publishing.
+- Made `ctx-mcp-add` stream JSONL inputs, extended Hugging Face card-only sync
+  to upload README, changelog, and docs inputs, and let PR graph checks fall
+  back to targeted Git LFS hydration for new graph artifact pointers.
+- Tightened graph/wiki artifact packaging by omitting local generated markdown,
+  redacting host-user paths from packed markdown, and restricting queue-driven
+  artifact promotion to known sibling staged targets.
 
 ### Fixed
 
 - Redacted runtime lifecycle free-text fields before storing local events so
   evidence, commands, summaries, triggers, reasons, and statuses do not retain
   secrets or local filesystem paths.
+- Expanded MCP argv `$ENVVAR` placeholders only at child-process spawn time and
+  rejected sensitive placeholder expansion by default, with explicit trusted
+  opt-in for servers that cannot avoid argv credentials.
+- Validated backup `top_files` overrides as top-level filenames only and added
+  dry-run support to legacy `backup_mirror prune --keep`.
 - Hardened `ctx-mcp-enrich` checkpoint and frontmatter handling so malformed
   checkpoints reset cleanly, processed slugs clear stale failures, body keys are
   not rewritten, and non-positive flush cadences fail fast.
@@ -324,8 +335,8 @@ Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Added
 
 - Shipped `graph/wiki-graph-runtime.tar.gz` as the default graph install
-  artifact for `ctx-init --graph`; full markdown wiki expansion remains
-  available with `--graph-install-mode full`.
+  artifact for `ctx-init --graph`; full wiki install remains available with
+  `--graph-install-mode full`.
 
 ### Fixed
 

CONTRIBUTING.md

@@ -26,6 +26,27 @@ pytest -q -m integration           # embedding precision/recall tests
 pytest --cov=src -q                # with coverage report
 ```
 
+Before opening a PR, run the local fast gate on committed branch history:
+
+```bash
+scripts/no_mistakes_run.sh fast
+```
+
+This selects the same PR checks as CI, groups independent work into lanes, and
+runs those lanes in isolated temporary git worktrees so local CPU, graph, docs,
+package, and test checks can run in parallel. It is the fast front door; the
+serial preflight/no-mistakes gate remains the authoritative final check:
+
+```bash
+python scripts/ci_preflight.py --profile pr
+```
+
+The preflight uses the same changed-file classifier as CI. Its no-test policy
+treats source, workflows, `pyproject.toml`, `scripts/ci_*`, maintainer graph/sync
+scripts, and `.no-mistakes.yaml` as contract files; include focused
+`src/tests/...` coverage unless the diff is a proven version or stats-only
+release metadata update.
+
 ## Documentation changes
 
 Public docs surfaces are release-tracked in the canonical
@@ -67,9 +88,25 @@ ruff check --fix src hooks scripts
 Maintainer no-mistakes agents can use `scripts/no_mistakes_codex_env.sh` as
 the Codex wrapper for this repo. It prepends the verified project Python venv
 when present and owner-only, plus Codex-bundled resources, without installing
-or upgrading system packages. Set `CTX_NO_MISTAKES_PYTHON_BIN` to override the
-Python venv explicitly; `CTX_NO_MISTAKES_CODEX_RESOURCES` and
+or upgrading system packages. Candidate venvs are checked in this order:
+`CTX_NO_MISTAKES_PYTHON_BIN`, `$PWD/.venv/bin`, this repository's `.venv/bin`,
+then `/tmp/ctx-verify-venv/bin`; the first owner-only venv containing
+`pytest`, `ruff`, and `mypy` wins and is exposed as
+`CTX_NO_MISTAKES_PYTHON_BIN_RESOLVED`. `CTX_NO_MISTAKES_CODEX_RESOURCES` and
 `CTX_NO_MISTAKES_REAL_CODEX` override the Codex resource directory or binary.
+The repo disables review-stage no-mistakes auto-fixes (`auto_fix.review: 0`) so
+review findings stay human-approved; rebase, test, document, lint, and CI stages
+still allow three automated repair attempts.
+
+## Release publishing
+
+PyPI publishes must run from a version tag that matches `pyproject.toml`; manual
+PyPI workflow dispatch is disabled. The publish workflow resolves the full and
+runtime graph tarballs from matching GitHub release cache assets first. If a
+checked-out Git LFS pointer is newer than the cache, it performs a targeted
+`git lfs pull` for that artifact only, enforces the configured pointer size cap,
+verifies SHA-256 and byte size, then runs graph validation before building and
+publishing the package.
 
 ## Commit conventions
 

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-4480_inventory-brightgreen.svg)](https://github.com/stevesolun/ctx/actions/workflows/test.yml)
+[![Tests](https://img.shields.io/badge/Tests-4575_inventory-brightgreen.svg)](https://github.com/stevesolun/ctx/actions/workflows/test.yml)
 [![Graph](https://img.shields.io/badge/Graph-79%2C958_nodes_/_1%2C778%2C069_edges-red.svg)](https://stevesolun.github.io/ctx/knowledge-graph/)
 [![Skills](https://img.shields.io/badge/Skills-68%2C494-blue.svg)](https://stevesolun.github.io/ctx/catalog/?type=skill)
 [![Agents](https://img.shields.io/badge/Agents-467-purple.svg)](https://stevesolun.github.io/ctx/catalog/?type=agent)
@@ -90,7 +90,7 @@ Examples from that tracker:
 pip install claude-ctx
 ctx-init                    # terminal wizard: hooks, graph, model, harness goal
 ctx-init --graph --hooks --model-mode skip  # fast runtime graph + Claude Code hooks
-ctx-init --graph --graph-install-mode full  # expand the full markdown wiki locally
+ctx-init --graph --graph-install-mode full  # install the full packed wiki locally
 ctx-init --wizard           # force the same wizard from scripts/tests
 ctx-init --model-mode custom --model openai/gpt-5.5 --goal "build a CAD agent"
 ```
@@ -110,17 +110,17 @@ recommendations, and the 207 harness pages needed by
 ctx-init --graph
 ```
 
-The full LLM-wiki artifact remains available for local browsing, Obsidian, and
-expanded markdown pages:
+The full LLM-wiki artifact remains available for local browsing and Obsidian.
+High-fanout skill, agent, MCP, converted, and concept pages are stored in
+`wiki-packs/` instead of expanded as individual files:
 
 ```bash
 ctx-init --graph --graph-install-mode full
 ```
 
-The full `wiki-graph.tar.gz` includes the shipped skill index,
-68,494 skill entity pages under `entities/skills/`, 67,024 hydrated
-installable `SKILL.md` files under `converted/`,
-and 207 harness pages under
+The full `wiki-graph.tar.gz` includes the shipped skill index and a wiki-pack
+base containing 68,494 skill entity pages plus 67,024 hydrated installable
+`SKILL.md` files. Harness pages remain directly available under
 `entities/harnesses/`.
 
 > **Windows:** PowerShell's built-in `tar.exe` does not support
@@ -153,19 +153,31 @@ ctx-telemetry-export --dry-run --json       # inspect privacy-redacted telemetry
 ctx-monitor serve          # local dashboard: http://127.0.0.1:8765/
 ```
 
-Before pushing, run the local PR gate:
+Before pushing, run the two-tier local PR gate. Start with the fast committed-HEAD
+gate:
+
+```bash
+scripts/no_mistakes_run.sh fast
+```
+
+That runner selects the same checks as PR preflight, groups independent checks
+into isolated temporary worktree lanes, and runs them in parallel. Treat it as
+the fast front door; the serial preflight/no-mistakes path remains the
+authoritative final local gate:
 
 ```bash
 python scripts/ci_preflight.py --profile pr
 ```
 
-It uses the same changed-file classifier as GitHub Actions, then runs the
+Preflight uses the same changed-file classifier as GitHub Actions, then runs the
 matching local checks: stats, ruff format/check, mypy, pip check, unit
 coverage, canaries, package build, twine, docs, graph validation, browser, and
 similarity gates as needed. For docs changes, that docs gate runs the public
-docs tracker checks before the strict MkDocs build. Use `--profile full` before
-release work to force the source/package gates even for docs-only or graph-only
-changes.
+docs tracker checks before the strict MkDocs build. When graph artifacts are
+changed and still checked out as Git LFS pointers, preflight hydrates only the
+required tarballs, checks the pointer SHA-256 and size caps, then validates the
+artifacts. Use `--profile full` before release work to force the
+source/package gates even for docs-only or graph-only changes.
 
 The **`ctx-monitor`** dashboard shows currently loaded skills, agents, MCP servers, installed harness records, selectable recommendations (`/recommend`), and generic-harness validation/escalation plus tool-selection/token-usage state (`/runtime`). It provides load/unload buttons where ctx owns the live action, a graph view (`/graph?slug=...`), the LLM-wiki entity browser (`/wiki/<slug>`), a filterable skills grid, a session timeline, audit/runtime log views, and a live SSE event stream. Installed harness records appear in `/loaded`; harness pages appear in `/wiki` and `/graph`. Harness install/update/uninstall actions stay in `ctx-harness-install`.
 

docs/backup-hook-install.md

@@ -80,7 +80,9 @@ See `src/backup_config.py` and the `backup` section of
 
 - **top_files** — `settings.json`, `skill-manifest.json`,
   `pending-skills.json`, `CLAUDE.md`, `AGENTS.md`, `user-profile.json`,
-  `skill-system-config.json`, `skill-registry.json`.
+  `skill-system-config.json`, `skill-registry.json`. User overrides must be
+  top-level filenames only: no path separators, absolute paths, drive letters,
+  UNC paths, `.` entries, or `..` traversal.
 - **trees** — `agents/`, `skills/`.
 - **memory** — `projects/*/memory/**` when `memory_glob` is true.
 - **always excluded** — `.credentials.json`, `claude.json`, token
@@ -88,7 +90,10 @@ See `src/backup_config.py` and the `backup` section of
 
 To override per user, drop a partial config at
 `~/.claude/backup-config.json`. Fields you omit fall back to the repo
-default. Example:
+default. Invalid `top_files` entries are ignored with a `[backup-config]`
+stderr warning; if every supplied `top_files` entry is invalid, the effective
+config falls back to the defaults instead of disabling top-level backups.
+Example:
 
 ```json
 {
@@ -204,12 +209,14 @@ python -m backup_mirror prune --policy --dry-run --json
 python -m backup_mirror prune --policy
 
 # Legacy mode (still works): keep only the N newest.
+python -m backup_mirror prune --keep 20 --dry-run
 python -m backup_mirror prune --keep 20
 ```
 
 The policy output tells you which snapshots were kept by `keep_latest`
 versus `keep_daily`, so a surprising retention decision is easy to
-audit.
+audit. Legacy `--keep` dry-runs print the snapshot IDs that would be removed
+without deleting their directories.
 
 ## Troubleshooting
 

docs/dashboard.md

@@ -255,8 +255,8 @@ per-process monitor token injected into the rendered page.
 | `GET /api/kpi.json` | `DashboardSummary` passthrough — `{total, by_subject, grade_counts, lifecycle_counts, category_breakdown, hard_floor_counts, low_quality_candidates, archived, generated_at}`. Returns `{total: 0, detail: "no sidecars yet"}` when the quality directory is empty |
 | `GET /api/runtime.json` | Runtime lifecycle summary: source path, validation count, failed/error count, open-escalation count, latest validation, recent validations, open escalations, session IDs, `tool_selection`, `token_usage`, `token_usage_history`, and `recent_tool_usage`. |
 | `GET /api/config.json` | Effective/default/user config payload used by the Config tab. |
-| `GET /api/entities/search.json?q=<text>&type=<entity>&limit=80` | Wiki entity search results for Manage, Config, and entity picker flows. |
-| `GET /api/entity/<slug>.json?type=<entity>` | Frontmatter and Markdown body for one wiki entity from the same merged pack/local source as `/wiki/<slug>`. |
+| `GET /api/entities/search.json?q=<text>&type=<entity>&limit=80` | Wiki entity search results for Manage, Config, and entity picker flows, with wiki-relative `path` values. |
+| `GET /api/entity/<slug>.json?type=<entity>` | Frontmatter, wiki-relative `path`, and Markdown body for one wiki entity from the same merged pack/local source as `/wiki/<slug>`. |
 | `GET /api/events.stream` | Server-sent events tail of `~/.claude/ctx-audit.jsonl` |
 
 ### Mutation endpoints

docs/entity-onboarding.md

@@ -81,6 +81,11 @@ The durable wiki worker drains `entity-upsert`, `graph-export`,
 `skill-index-refresh`, `tar-refresh`, and `artifact-promotion` jobs. Use
 `ctx-wiki-worker --wiki ~/.claude/skill-wiki --limit 1` for a controlled
 single-job drain, or omit `--limit` to drain the ready queue.
+Artifact-promotion jobs must target known `<wiki>/graphify-out/` graph outputs
+or allowlisted repo `graph/` release artifacts, and their staged path must be
+the target sibling named `<target>.staged`. The worker rejects staged/target
+symlinks and selects the JSON/JSONL/gzip/tar validator from the target file
+type before promotion.
 
 For a manual attach dry-run against an existing vector index:
 
@@ -191,6 +196,7 @@ ctx-agent-add --agent-path ./code-reviewer.md --name code-reviewer
 ctx-agent-add --agent-path ./code-reviewer.md --name code-reviewer --update-existing
 
 ctx-mcp-add --from-json ./github-mcp.json
+ctx-mcp-fetch --source pulsemcp --limit 50 | ctx-mcp-add --from-stdin
 ctx-mcp-add --from-json ./github-mcp.json --update-existing
 
 ctx-harness-add --from-json ./text-to-cad-harness.json
@@ -302,10 +308,21 @@ ctx-mcp-add --from-json ./github-mcp.json
 ```
 
 MCP pages live under `entities/mcp-servers/<shard>/<slug>.md`. The add command
-detects existing pages by slug and, when possible, canonical GitHub URL. If a
-match exists, ctx prints the update review and skips replacement unless
+accepts a single JSON object with `--from-json` or streams JSONL records from
+`--from-jsonl`/`--from-stdin` without preloading the whole batch. It detects
+existing pages by slug and, when possible, canonical GitHub URL. If a match
+exists, ctx prints the update review and skips replacement unless
 `--update-existing` is passed.
 
+Runtime install is separate from catalog add. Use
+`ctx-mcp-install <slug> --dry-run` to inspect the Claude MCP command without
+mutating local state. If the server is already installed, dry-run reports
+`skipped-existing` and does not reconcile `skill-manifest.json`; run without
+`--dry-run` to refresh the manifest record, or add `--force` when you need to
+reinstall the Claude MCP entry. Inline secret-looking arguments are rejected; use
+environment variables, secret-file/path flags, or `--cmd-json` placeholders
+instead of literal tokens.
+
 ## Add a Harness
 
 Use this when a repo provides the runtime around a model rather than just a

docs/harness/attaching-to-hosts.md

@@ -141,6 +141,12 @@ Example config:
 Parent secrets are not inherited unless you set `inherit_env: true`; prefer
 explicit `env` keys for servers that need credentials. `${tmp_path}` expands
 to a pytest temporary directory so filesystem probes can avoid real user data.
+For lower-level `McpServerConfig` users, `args` are literal by default. Set
+`expand_argv_env=True` to expand `$ENVVAR` and `${ENVVAR}` placeholders from the
+final child environment immediately before spawn. Sensitive placeholders are
+rejected unless `allow_argv_secret_expansion=True` is also set for trusted local
+servers that cannot avoid argv credentials; prefer `credential_env` or explicit
+`env` for servers that read secrets from the environment.
 
 ---
 
@@ -224,6 +230,17 @@ system prompt overrides, session resume, JSON output, ...).
 If the console script is unavailable, use the package entrypoint instead:
 `python -m ctx run ...`.
 
+Explicit `--mcp name:<command>` specs are split into argv without a shell.
+Secret-looking inline arguments are rejected so tokens do not land in session
+metadata. Pass credentials with `--mcp-env name:ENVVAR` only to servers that
+read secrets from their child environment, or configure the server to read a
+secret file/path argument instead. Sensitive `$ENVVAR` and `${ENVVAR}` argv
+placeholders are rejected by default because resolving them would expose the
+secret in the child process argv. Secret indirection flags such as
+`--token-file`, `--api-key-path`, `--credential-env`, and
+`--client-secret-var` are accepted only when their values look like paths,
+placeholders, or environment variable names rather than literal secrets.
+
 Planning and review modes are opt-in flags on `ctx run`. Use `--planner` to
 produce a structured spec before generation, `--evaluator` to grade and revise
 the result, and `--contract` with both `--planner` and `--evaluator` to refine

docs/huggingface-publish.md

@@ -21,13 +21,20 @@ by git.
 
 Every push to `main` runs `.github/workflows/huggingface-sync.yml`. The job
 checks out source without spending Git LFS bandwidth, hydrates the required
-graph artifacts from the latest GitHub release assets, installs the sync
-dependencies, and calls `scripts/sync_huggingface.py`. It publishes only when
-the repository secret `HF_TOKEN` is configured. On the canonical
+graph artifacts from matching GitHub release cache assets, and falls back to a
+targeted `git lfs pull` only when a pointer is newer than the cache and within
+the configured size cap. It then installs the sync dependencies and calls
+`scripts/sync_huggingface.py`. It publishes only when the repository secret
+`HF_TOKEN` is configured. On the canonical
 `stevesolun/ctx` repository, a missing token is a hard failure so main cannot
 silently drift from the dataset repo. On forks, a missing token still exits
 successfully with a notice because forks are not trusted publishing sources.
 
+When only repo-card inputs changed (`README.md`, `CHANGELOG.md`, or files under
+`docs/`), the workflow uses card-only upload mode. Source, test, workflow, graph,
+or packaging changes always run the full dataset sync so tracked files cannot
+drift behind GitHub.
+
 The sync script is still the contract: it exports the tracked git snapshot,
 adds Hugging Face repo-card metadata, validates README/docs stats, verifies the
 graph artifacts are hydrated rather than LFS pointers, and refuses to publish
@@ -41,10 +48,10 @@ uploaded `README.md`, and refuses to publish if the full wiki tarball, runtime
 wiki tarball, or compressed skill index is missing, too small, or still a Git
 LFS pointer.
 
-The script prefers Hugging Face's resumable large-folder uploader when the
-remote already has no stale paths. If the remote contains files that are not in
-the current git snapshot, the script falls back to a single clean replacement
-commit so deleted local files cannot survive remotely.
+Full sync uploads the exported tree with `delete_patterns="*"`, so files removed
+from the current git snapshot are removed remotely in the same commit.
+Card-only sync exports only `README.md`, `CHANGELOG.md`, and tracked `docs/**`
+inputs, then replaces just those remote paths.
 
 Do not paste the token into a command line. Prompt for it, set it only for the
 current process, and clear it after the upload.
@@ -65,6 +72,12 @@ try {
 }
 ```
 
+For a README/changelog/docs-only refresh:
+
+```powershell
+python scripts/sync_huggingface.py --repo . --repo-id Stevesolun/ctx --repo-type dataset --card-only
+```
+
 ## Verify
 
 ```powershell

docs/index.md

@@ -39,7 +39,7 @@ with persistent memory that gets smarter every session.
     source checkouts use `graph/wiki-graph-runtime.tar.gz`, while pip installs
     download the matching GitHub release asset. Use
     `ctx-init --graph --graph-install-mode full` when you want the full
-    markdown LLM-wiki expanded locally.
+    packed LLM-wiki installed locally.
 
     Custom-model users can run
     `ctx-init --model-mode custom --model <provider/model> --goal "<task>"`
@@ -48,13 +48,21 @@ with persistent memory that gets smarter every session.
 !!! tip "Before pushing"
 
     ```bash
+    scripts/no_mistakes_run.sh fast
     python scripts/ci_preflight.py --profile pr
     ```
 
-    The preflight uses the same changed-file classifier as GitHub Actions and
+    `scripts/no_mistakes_run.sh fast` is the fast front door: it selects the
+    same PR checks, splits independent work into isolated temporary worktree
+    lanes, and runs them in parallel against committed branch history. The
+    serial preflight/no-mistakes path remains the authoritative final local
+    gate. Preflight uses the same changed-file classifier as GitHub Actions and
     runs the matching local gates before you open a PR: stats, ruff
     format/check, mypy, pip check, unit coverage, canaries, package build,
     twine, docs, graph validation, browser, and similarity checks as needed.
+    When graph artifacts are still Git LFS pointers, preflight hydrates only
+    the required tarballs, verifies their pointer SHA-256 and size caps, then
+    validates the artifacts.
     Use `--profile full` before release work to force the source/package gates
     even for docs-only or graph-only changes. Docs changes run public docs
     tracker checks before the strict MkDocs build, including bug-smoke,
@@ -223,15 +231,15 @@ ones are flagged. New ones self-ingest.
 
     ---
 
-    Current main is **v1.0.20** — MIT, CI-matrixed (Ubuntu 3.12 plus Windows/macOS 3.11/3.12),
-    4,480 test inventory. Adds enterprise OpenTelemetry-ready telemetry and
+    Current main is **v1.0.21** — MIT, CI-matrixed (Ubuntu 3.12 plus Windows/macOS 3.11/3.12),
+    4,575 test inventory. Adds enterprise OpenTelemetry-ready telemetry and
     ships console scripts including `ctx-init`,
     `ctx-monitor` (local dashboard with graph + wiki + load/unload for
     skills, agents, and MCP servers, plus Harness Setup for user-owned LLMs),
     `ctx-incremental-attach`, `ctx-incremental-shadow`, `ctx-dedup-check`
     (pre-ship near-duplicate gate), and
     `ctx-tag-backfill` (entity hygiene), plus a fast runtime graph artifact
-    and the full ~282 MiB wiki tarball with **79,958 nodes / 1,778,069 edges / 52 Louvain communities**.
+    and the full ~281 MiB wiki tarball with **79,958 nodes / 1,778,069 edges / 52 Louvain communities**.
 
     [:octicons-arrow-right-24: CHANGELOG](https://github.com/stevesolun/ctx/blob/main/CHANGELOG.md) ·
     [Repository](https://github.com/stevesolun/ctx)

docs/knowledge-graph.md

@@ -16,12 +16,13 @@ Authoritative numbers from the shipped tarball. The curated-core snapshot
 is **12,934 nodes** (1,470 curated skills + 467 agents + 10,790 MCP servers + 207 harnesses). Harness pages under `entities/harnesses/` are ingested into
 local rebuilds and the separate harness recommendation path. The
 tarball also carries **68,494 skill pages**; **67,024**
-skill bodies are hydrated as installable `SKILL.md` files under
-`converted/`; the **28,612** entries over the configured line
-limit were converted to gated micro-skill orchestrators. Full original bodies
-are used during graph rebuilds for semantic similarity, but
-`SKILL.md.original` backups, transient `.lock` files, and `.ctx/` queue state
-are omitted from the shipped tarball.
+skill bodies are hydrated as installable `SKILL.md` files in the wiki-pack
+base under `converted/`; the **28,612** entries over the configured line limit
+were converted to gated micro-skill orchestrators. Full original bodies are
+used during graph rebuilds for semantic similarity, but
+`SKILL.md.original` backups, transient `.lock` files, `.ctx/` queue state,
+local generated markdown catalogs, and host-user paths are omitted from the
+shipped tarball.
 
 | | Count |
 |---|---:|
@@ -51,17 +52,18 @@ the harness pages used by `ctx-harness-install`:
 ctx-init --graph
 ```
 
-To expand every shipped skill/agent/MCP entity page, harness page,
-skill page, concept page, converted micro-skill pipeline,
-and Obsidian vault metadata, request the full wiki artifact explicitly:
+To install the full shipped wiki, including the wiki-pack base for
+skill/agent/MCP entity pages, skill pages, concept pages, converted
+micro-skill pipelines, direct harness pages, and Obsidian vault metadata,
+request the full wiki artifact explicitly:
 
 ```bash
 ctx-init --graph --graph-install-mode full
 ```
 
 Manual extraction is still supported for offline/source installs. Extract the
-full tarball into your `~/.claude/skill-wiki/` when you want local markdown
-wiki browsing:
+full tarball into your `~/.claude/skill-wiki/` when you want local wiki
+browsing through ctx's merged pack/local view:
 
 ```bash
 mkdir -p ~/.claude/skill-wiki
@@ -416,9 +418,22 @@ Graphify exports stage and validate each generated artifact before atomic
 promotion. `graph.json`, `graph-delta.json`, `communities.json`,
 `graph-report.md`, and `graph-export-manifest.json` each get a sibling
 `*.promotion.json` file with candidate, current, and `last_good` hashes plus
-rollback metadata. The manifest is promoted last, so a crash between artifact
-promotion and manifest promotion is detected as an incomplete export and the
-next run rebuilds instead of trusting mixed graph files.
+rollback metadata. Queue-driven promotion accepts only graphify artifacts named
+`graph.json`, `graph-delta.json`, `communities.json`, `graph-report.md`, or
+`graph-export-manifest.json` under `<wiki>/graphify-out/`, plus the release
+artifacts allowlisted under repo `graph/`, and always from sibling
+`<target>.staged` files. Staged and target symlinks are rejected. Validators are
+selected from the target suffix: JSON, JSONL, gzip JSON, gzip JSONL, full wiki
+tar, and runtime graph tar each get the matching structural check before
+promotion. The manifest is promoted last, so a crash between artifact promotion
+and manifest promotion is detected as an incomplete export and the next run
+rebuilds instead of trusting mixed graph files.
+
+Artifact validation also treats privacy and fanout as release contracts: archive
+JSON, graph-pack node/edge metadata, markdown members, and merged wiki-pack
+markdown must not contain host-user paths; markdown members are capped at
+10 MiB; local generated markdown such as `catalog.md`, `converted-index.md`,
+`log.md`, and `versions-catalog.md` must stay out of the full archive.
 
 ## Current artifact record
 

docs/qa/dashboard-user-story-status.csv

@@ -37,9 +37,9 @@ DASH-API-006,Dashboard API,Sidecars API,/api/sidecars.json,src/ctx/monitor/api/r
 DASH-API-007,Dashboard API,Runtime API,/api/runtime.json,src/ctx/monitor/api/readonly.py and src/ctx/monitor/services/runtime.py,As a dashboard client I can fetch runtime lifecycle diagnostics,API returns validation escalation selection token usage and recent usage metadata without raw evidence strings or secrets,ctx-monitor running,GET /api/runtime.json and scan for secret-like fields plus raw evidence strings,Retested Pass,PASS: focused runtime monitor test asserts recent_tool_usage exposes evidence_present/evidence_length and not the raw evidence value.,,,,,2026-07-02,
 DASH-API-008,Dashboard API,SkillSpector API,/api/skillspector.json,src/ctx/monitor/api/readonly.py,As a dashboard client I can fetch SkillSpector findings,API returns audit records filtered by severity and query,ctx-monitor running,GET /api/skillspector.json?severity=HIGH&q=prompt,Tested Pass,PASS: /api/skillspector.json?severity=HIGH&q=prompt returned HTTP 200 JSON with summary filters and records keys.,,,,,2026-06-25,
 DASH-API-009,Dashboard API,Config API,/api/config.json,src/ctx/monitor/api/readonly.py,As a dashboard client I can fetch effective config,API returns defaults overrides required metadata and no secrets,ctx-monitor running,GET /api/config.json and validate required fields,Tested Pass,PASS: /api/config.json returned HTTP 200 JSON with defaults user effective and path keys.,,,,,2026-06-25,
-DASH-API-010,Dashboard API,Entity Search API,/api/entities/search.json,src/ctx/monitor/api/readonly.py,As a dashboard client I can search entities for autocomplete,API returns typed entity suggestions for search terms and rejects unsafe queries cleanly,ctx-monitor running,GET /api/entities/search.json?q=github&type=skill,Tested Pass,PASS: /api/entities/search.json?q=github&type=skill&limit=5 returned HTTP 200 JSON with results and total keys.,,,,,2026-06-25,
+DASH-API-010,Dashboard API,Entity Search API,/api/entities/search.json,src/ctx/monitor/api/readonly.py,As a dashboard client I can search entities for autocomplete,API returns typed entity suggestions with wiki-relative paths for search terms and rejects unsafe queries cleanly,ctx-monitor running,GET /api/entities/search.json?q=github&type=skill,Tested Pass,PASS: /api/entities/search.json?q=github&type=skill&limit=5 returned HTTP 200 JSON with results and total keys.,,,,,2026-06-25,
 DASH-API-011,Dashboard API,Events Stream API,/api/events.stream,src/ctx/monitor/api/readonly.py,As a dashboard client I can stream live events,API opens a server-sent event stream and sends data or a clear heartbeat without hanging page load,ctx-monitor running,GET /api/events.stream with timeout and validate SSE framing,Retested Pass,FAIL: /api/events.stream timed out without returning bytes within 10 seconds.,DASH-UX-001,SSE stream did not send an initial heartbeat or ready comment.,Fixed by flushing an immediate : connected SSE comment.,PASS: /api/events.stream returned HTTP 200 and : connected within 1.1s after dashboard restart.,2026-06-25,
-DASH-API-012,Dashboard API,Entity Detail API,/api/entity/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch typed entity detail,API returns full entity detail for safe slugs and safe 404 for unknown or unsafe slugs,ctx-monitor running,GET /api/entity/github.json?type=mcp-server and invalid slug,Tested Pass,PASS: /api/entity/github.json?type=mcp-server returned HTTP 200 JSON with slug type path frontmatter and body keys.,,,,,2026-06-25,
+DASH-API-012,Dashboard API,Entity Detail API,/api/entity/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch typed entity detail,API returns full entity detail with wiki-relative paths for safe slugs and safe 404 for unknown or unsafe slugs,ctx-monitor running,GET /api/entity/github.json?type=mcp-server and invalid slug,Tested Pass,PASS: /api/entity/github.json?type=mcp-server returned HTTP 200 JSON with slug type path frontmatter and body keys.,,,,,2026-06-25,
 DASH-API-013,Dashboard API,Skill Detail API,/api/skill/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch legacy skill detail,API returns sidecar skill JSON or JSON detail 404 for missing/unsafe slugs without leaking paths,ctx-monitor running,GET /api/skill/github.json and /api/skill/missing-sidecar.json,Retested Pass,PASS: /api/skill/github.json?type=skill returned HTTP 200 JSON sidecar payload and focused monitor tests covered JSON detail 404 for a missing sidecar.,AUDIT-025,Missing sidecar API responses used an HTML 404 body.,Fixed,PASS: .venv/bin/python -m pytest src/tests/test_ctx_monitor.py::test_skill_sidecar_api_missing_sidecar_returns_json_404 src/tests/test_ctx_monitor.py::test_skill_sidecar_api_reads_typed_sidecar -q -> 2 passed.,2026-07-05,
 DASH-API-014,Dashboard API,Graph Neighborhood API,/api/graph/<slug>.json,src/ctx/monitor/services/graph.py,As a dashboard client I can fetch graph neighborhoods quickly,API resolves slug and type to bounded nodes edges suggestions and readable relationship data,ctx-monitor running with graph artifact,GET /api/graph/github.json?type=skill&limit=20 and validate JSON shape plus latency,Tested Pass,PASS: /api/graph/github.json?type=skill&limit=20 returned HTTP 200 JSON with nodes edges center resolved suggestions schema layout and insights keys.,,,,,2026-06-25,
 DASH-POST-001,Dashboard Mutation,Load API,/api/load,src/ctx/monitor/api/mutations.py,As a dashboard user I can load an entity safely,POST validates mutation token entity type and slug before mutating active load state,ctx-monitor running with mutation token and fixture,POST /api/load against temp fixture and verify response plus state,Tested Pass,PASS: focused pytest covered /api/load token and fixture-backed load mutation behavior.,,,,,2026-06-25,

docs/qa/feature-user-story-status.csv

@@ -1,5 +1,5 @@
 feature_id,surface,feature,entrypoint_or_route,source_evidence,user_story,expected_behavior,setup_preconditions,test_command_or_steps,status,first_test_result,error_id,error_summary,fix_status,retest_result,last_verified_at,notes
-CLI-001,CLI,Generic model run harness,ctx; python -m ctx,pyproject.toml project.scripts and src/ctx/__main__.py,As a user I can run or resume a model-agnostic ctx session,ctx and python -m ctx expose the same run/resume/sessions harness with configured provider tools budgets transcript ordering privacy-safe failure telemetry and persisted initial trace metadata,Provider credentials or dry-run/local test provider available,ctx --help; python -m ctx --help; focused run/resume smoke,Retested Pass,PASS: test_harness_cli_run.py focused suite reports 73 passed; test_package_scaffold.py covers python -m ctx --help.,AUDIT-018,Early ctx run/resume failures could exit without complete telemetry or trace correlation.,Fixed,PASS: .venv/bin/pytest src/tests/test_harness_cli_run.py -q --tb=short -> 73 passed.,2026-07-05,Updated for CLI failure telemetry and trace metadata.
+CLI-001,CLI,Generic model run harness,ctx; python -m ctx,pyproject.toml project.scripts and src/ctx/__main__.py,As a user I can run or resume a model-agnostic ctx session,ctx and python -m ctx expose the same run/resume/sessions harness with configured provider tools secret-safe MCP attachment token budgets transcript ordering privacy-safe failure telemetry and persisted initial trace metadata,Provider credentials or dry-run/local test provider available,ctx --help; python -m ctx --help; focused run/resume smoke,Retested Pass,PASS: test_harness_cli_run.py focused suite reports 73 passed; test_package_scaffold.py covers python -m ctx --help.,AUDIT-018,Early ctx run/resume failures could exit without complete telemetry or trace correlation.,Fixed,PASS: .venv/bin/pytest src/tests/test_harness_cli_run.py -q --tb=short -> 73 passed.,2026-07-05,Updated for CLI failure telemetry trace metadata and inline MCP secret rejection.
 CLI-002,CLI,Repository recommendation,ctx-recommend,pyproject.toml project.scripts,As a user I can ask ctx for current repo recommendations,ctx returns capped relevant skill agent MCP recommendations from the shared graph engine,Graph installed and target repo available,ctx-recommend --help then sample repo recommendation,Tested Pass,recommend CLI/golden subset: 24 passed for ctx-recommend and shared recommendation surfaces.,,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
 CLI-003,CLI,Initial setup,ctx-init,pyproject.toml project.scripts,As a new user I can install hooks graph and model mode from one command,ctx-init installs requested pieces idempotently and reports failures with non-zero exit,Writable user config directory,ctx-init --model-mode skip --graph,Retested Pass,"PASS: temp USERPROFILE ctx-init --model-mode skip --knowledge-mode skip created .claude config/toolboxes and exited 0. PASS: temp USERPROFILE ctx-init --graph --graph-install-mode runtime --model-mode skip installed graph.json and harness page in 129.2s.",CTX-AZ-006,Full graph install exceeded the 10-minute Windows smoke budget before packed wiki artifacts: native-tar full install completed in 759.0s and cleanup took 171.7s.,Packed full artifact now ships wiki-packs and omits expanded non-root markdown fanout; ctx-init checksum updated.,PASS: temp USERPROFILE ctx-init --graph --graph-install-mode full --model-mode skip --knowledge-mode skip exited 0 in 409.7s with graph-store.sqlite3 wiki-packs harness pages and no expanded skills/agents/MCP/converted/concepts markdown.,2026-06-23,Runtime path remains usable; full path now installs packed markdown wiki under the smoke budget while keeping harness pages direct.
 CLI-004,CLI,Claude hook install,ctx-install-hooks,pyproject.toml project.scripts,As a Claude Code user I can install ctx hooks,Hooks are installed idempotently and point to existing modules,Claude config path writable,ctx-install-hooks --help then temp-home smoke,Tested Pass,inject hooks/ctx-init hook subset: 24 passed for hook install and failure handling.,,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
@@ -14,8 +14,8 @@ CLI-012,CLI,Agent add,ctx-agent-add,pyproject.toml project.scripts,As a user I c
 CLI-013,CLI,Agent install,ctx-agent-install,pyproject.toml project.scripts,As a Claude Code user I can install an agent,Agent installs safely and appears in manifest/load surface,Temp Claude home,ctx-agent-install --help,Tested Pass,"install/unload batch: 187 passed, including agent install behavior.",,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
 CLI-014,CLI,Agent unload,ctx-agent-unload,pyproject.toml project.scripts,As a user I can unload stale agents,Agent active state is removed safely and recommendation can suggest replacements,Temp installed agent,ctx-agent-unload --help,Tested Pass,install/unload batch plus monitor 3-type coverage: 187 passed for install/unload core behavior.,,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
 CLI-015,CLI,Agent mirror,ctx-agent-mirror,pyproject.toml project.scripts,As a user I can mirror agents into wiki,Mirror emits normalized wiki pages with source metadata,Temp agent source,ctx-agent-mirror --help,Tested Pass,Temp CLI smoke passed: ctx-agent-mirror mirrored agent body into converted-agents and cleaned temp files.,,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
-CLI-016,CLI,MCP add,ctx-mcp-add,pyproject.toml project.scripts,As a user I can add or update an MCP server,MCP record is validated enriched written atomically and linked in graph,Temp MCP JSON/URL and wiki path,ctx-mcp-add --dry-run with fixture,Retested Pass,Failed in isolated A-Z flow: Windows UTF-8 BOM input was rejected by markdown/JSON parsing; some rejected batch CLIs could still exit 0.,CTX-AZ-004,"Entity onboarding was not Windows-BOM-safe across skill/agent/MCP/harness inputs, and failed batches needed non-zero exits.",Fixed,MCP add accepted BOM-prefixed JSON and wrote sharded wiki entity in temp CLI flow; stdin BOM regression is covered by pytest. Focused pytest regressions passed.,2026-06-23,Regression coverage added for BOM inputs and MCP rejected-batch exit.
-CLI-017,CLI,MCP install,ctx-mcp-install,pyproject.toml project.scripts,As a Claude Code user I can install an MCP server,MCP config is updated safely and secrets are not echoed or persisted inline,Temp Claude config,ctx-mcp-install --help then dry/temp smoke,Tested Pass,"install/unload batch: 187 passed, including MCP install behavior.",,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
+CLI-016,CLI,MCP add,ctx-mcp-add,pyproject.toml project.scripts,As a user I can add or update an MCP server,MCP record is validated enriched written atomically linked in graph and JSONL/stdin batches stream without preloading,Temp MCP JSON/URL and wiki path,ctx-mcp-add --dry-run with fixture,Retested Pass,Failed in isolated A-Z flow: Windows UTF-8 BOM input was rejected by markdown/JSON parsing; some rejected batch CLIs could still exit 0.,CTX-AZ-004,"Entity onboarding was not Windows-BOM-safe across skill/agent/MCP/harness inputs, and failed batches needed non-zero exits.",Fixed,MCP add accepted BOM-prefixed JSON and wrote sharded wiki entity in temp CLI flow; stdin BOM regression is covered by pytest. Focused pytest regressions passed.,2026-06-23,Regression coverage added for BOM inputs MCP rejected-batch exit and streaming JSONL input.
+CLI-017,CLI,MCP install,ctx-mcp-install,pyproject.toml project.scripts,As a Claude Code user I can install an MCP server,MCP config is updated safely dry-run does not mutate manifest state and secrets are not echoed or persisted inline,Temp Claude config,ctx-mcp-install --help then dry/temp smoke,Tested Pass,"install/unload batch: 187 passed, including MCP install behavior.",,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke including installed dry-run manifest safety.
 CLI-018,CLI,MCP uninstall,ctx-mcp-uninstall,pyproject.toml project.scripts,As a user I can uninstall an MCP server,MCP config entry is removed without damaging other servers,Temp Claude config,ctx-mcp-uninstall --help,Tested Pass,"install/unload batch: 187 passed, including MCP uninstall behavior.",,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
 CLI-019,CLI,MCP fetch,ctx-mcp-fetch,pyproject.toml project.scripts,As a maintainer I can fetch MCP catalog data,Fetch produces normalized records with source provenance and retry-safe output,Network available or fixture mode,ctx-mcp-fetch --help,Tested Pass,"MCP fetch/ingest/server batch: 77 passed, 1 skipped.",,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
 CLI-020,CLI,MCP ingest,ctx-mcp-ingest,pyproject.toml project.scripts,As a maintainer I can ingest MCP catalog data,"Ingest deduplicates and normalizes records, streams --from-jsonl one record per line without preloading, reports --status without creating a missing wiki path, records malformed JSONL or non-object JSON as current-run failures with a nonzero dry-run exit, and resets corrupt scalar/nested checkpoint member shapes fresh.",Fixture catalog,ctx-mcp-ingest --help; pytest src/tests/test_mcp_ingest.py -q,Retested Pass,PASS: focused MCP ingest regressions cover malformed JSONL/non-object current-run failures corrupt checkpoint scalar/nested member resets JSONL streaming and read-only status.,AUDIT-016; AUDIT-022; AUDIT-023,Malformed JSONL/non-object inputs were warned or skipped corrupt checkpoint member shapes could poison checkpoint recovery JSONL replay preloaded files and --status created missing wiki paths.,Fixed,PASS: .venv/bin/python -m pytest src/tests/test_mcp_ingest.py -q --tb=short -> 32 passed.,2026-07-05,Updated for malformed input checkpoint JSONL streaming and read-only status regressions.
@@ -43,7 +43,7 @@ CLI-041,CLI,SkillSpector remediation,ctx-skillspector-remediation,pyproject.toml
 CLI-042,Dashboard,Monitor server,ctx-monitor,pyproject.toml project.scripts,As a user I can launch the local dashboard,Dashboard starts on local host serves all nav pages and does not expose LAN mode unauthenticated,Graph runtime installed,ctx-monitor serve --host 127.0.0.1 --port 8765,Tested Pass,Started ctx-monitor on 127.0.0.1:8765; HTTP dashboard responded after restart.,,,,,2026-06-23,Dashboard route sweep; no mutation performed.
 CLI-043,CLI,Telemetry export,ctx-telemetry-export,pyproject.toml project.scripts and docs/telemetry.md,As an enterprise operator I can export local ctx telemetry to configured sinks,Export reads local event and metric spools applies checkpoints and supports local JSONL or OTLP sinks with host allow-listing,Telemetry spool and optional exporter config,ctx-telemetry-export --dry-run --json,Tested Pass,enterprise telemetry focused tests covered exporter configuration checkpointing local JSONL and OTLP payload paths.,,,,,2026-06-29,Validated in telemetry release gate without requiring external collector credentials.
 CLI-044,CLI,Telemetry retention,ctx-telemetry-retention,pyproject.toml project.scripts and docs/telemetry.md,As an enterprise operator I can preview and enforce telemetry retention,Retention plans and enforces TTL cleanup for local telemetry signals while recording status without leaking payloads,Telemetry config and local spool paths,ctx-telemetry-retention plan --signal all --json,Tested Pass,enterprise telemetry focused tests covered retention planning enforcement status output and privacy salt behavior.,,,,,2026-06-29,Validated as local-only enterprise privacy default with exporters separately configurable.
-CLI-045,CLI,Backup mirror CLI,"python -m backup_mirror create, snapshot-if-changed, verify, restore, watchdog, prune","src/backup_mirror.py, src/backup_watchdog.py, docs/backup-hook-install.md",As a Claude Code user I can snapshot verify restore watch and prune tracked config backups from documented commands,Backup mirror commands create SHA-gated snapshots verify before restore run watchdog polling safely and prune by retention policy without leaking credentials,Temp Claude home fixture available,"python -m pytest src/tests/test_backup_mirror.py src/tests/test_backup_retention.py src/tests/test_backup_watchdog.py -q",Tested Pass,"test_backup_mirror.py, test_backup_retention.py, and test_backup_watchdog.py cover create snapshot-if-changed verify restore watchdog and prune CLI paths.",,,,,2026-06-29,Added so the public backup install page's documented python -m backup_mirror commands are tracked as first-class behavior.
+CLI-045,CLI,Backup mirror CLI,"python -m backup_mirror create, snapshot-if-changed, verify, restore, watchdog, prune","src/backup_mirror.py, src/backup_watchdog.py, docs/backup-hook-install.md",As a Claude Code user I can snapshot verify restore watch and prune tracked config backups from documented commands,Backup mirror commands create SHA-gated snapshots verify before restore run watchdog polling safely prune by retention policy or legacy keep with dry-run and validate top_files filenames without leaking credentials,Temp Claude home fixture available,"python -m pytest src/tests/test_backup_mirror.py src/tests/test_backup_retention.py src/tests/test_backup_watchdog.py -q",Tested Pass,"test_backup_mirror.py, test_backup_retention.py, and test_backup_watchdog.py cover create snapshot-if-changed verify restore watchdog and prune CLI paths.",,,,,2026-06-29,Added so the public backup install page's documented python -m backup_mirror commands are tracked as first-class behavior including top_files filename validation and keep-prune dry-run safety.
 CLI-046,CLI,Generic harness planner evaluator and contract modes,"ctx run --planner, ctx run --evaluator, ctx run --contract","src/ctx/cli/run.py, src/tests/test_harness_planner.py, src/tests/test_harness_evaluator.py, src/tests/test_harness_contract.py",As a model-agnostic harness user I can run planning evaluation and contract review modes,ctx.cli.run exposes --planner --evaluator and --contract modes while preserving session and runtime semantics,Provider fixture or local test provider available,"python -m pytest src/tests/test_harness_planner.py src/tests/test_harness_evaluator.py src/tests/test_harness_contract.py -q",Tested Pass,harness planner evaluator and contract tests cover CLI parser runtime dispatch and persisted outputs.,,,,,2026-06-29,Split from broad CLI-001 so deep ctx.cli.run modes are explicit.
 CLI-047,CLI,Resume MCP restoration safety,ctx resume --restore-session-mcp and credential_env,src/ctx/cli/run.py and src/tests/test_harness_cli_run.py,As a returning harness user I can resume without restoring executable MCP metadata unless I opt in,ctx resume skips recorded MCP command and env metadata by default restores credential_env only with explicit --restore-session-mcp and emits previous trace correlation when available,Recorded session fixture,python -m pytest src/tests/test_harness_cli_run.py -q,Retested Pass,PASS: test_harness_cli_run.py covers default skip restore opt-in credential_env behavior failed resume telemetry and previous_trace_id correlation.,AUDIT-018,Early ctx resume failures and resumed sessions lacked reliable previous trace correlation telemetry.,Fixed,PASS: .venv/bin/pytest src/tests/test_harness_cli_run.py -q --tb=short -> 73 passed.,2026-07-05,Tracks resume security and trace correlation semantics inside broad CLI-001.
 CLI-048,CLI,Harness update and uninstall controls,ctx-harness-install --update and ctx-harness-install --uninstall,src/harness_install.py and src/tests/test_harness_install.py,As a harness user I can dry-run update or uninstall an installed harness safely,Update and uninstall flows detect installed harness state show planned changes and avoid destructive surprises,Installed harness fixture,python -m pytest src/tests/test_harness_install.py -q,Tested Pass,test_harness_install.py covers update dry-run uninstall safety and missing-record behavior.,,,,,2026-06-29,Split from CLI-026 so install recommend update and uninstall semantics are separately tracked.
@@ -53,7 +53,7 @@ HOOK-002,Hooks,Quality Stop runtime hook,hooks/quality_on_session_end.py,hooks/q
 PYAPI-001,Python API,Public Python API,ctx.api and ctx top-level re-exports,src/ctx/api.py and src/ctx/__init__.py,As a harness author I can import ctx from Python without depending on internal modules,recommend_bundle recommend_related graph_query wiki_search wiki_get list_all_entities default_wiki_dir and CtxCoreToolbox keep stable signatures safe defaults and top-level re-exports,Runtime wiki or synthetic fixture available,pytest src/tests/test_public_api.py -q,Tested Pass,test_public_api.py covers __all__ exports top-level re-exports signatures happy paths empty paths and telemetry privacy payloads.,,,,,2026-07-02,Added during canonical feature inventory gap pass and updated when related recommendations became public API.
 MCP-001,MCP/Core Tools,Read/query tool catalog,"ctx__recommend_bundle, ctx__recommend_related, ctx__graph_query, ctx__wiki_search, ctx__wiki_get",src/ctx/adapters/generic/ctx_core_tools.py and src/ctx/mcp_server/server.py,As an MCP or generic harness client I can call ctx read tools consistently,Read tools return recommendations related suggestions graph neighborhoods wiki search and wiki entity payloads through both generic toolbox and MCP stdio surfaces,Synthetic graph/wiki fixture available,pytest src/tests/test_harness_ctx_core.py src/tests/test_mcp_server.py -q,Tested Pass,test_harness_ctx_core.py and test_mcp_server.py pin the read tool names schemas dispatch success paths and JSON-RPC tools/list exposure.,,,,,2026-07-02,Canonical tracker row for the first-class ctx-core read tools; ctx__recommend_related adds partial-selection suggestions.
 MCP-002,MCP/Core Tools,Lifecycle and session tool catalog,"ctx__observe_dev_event, ctx__load_entity, ctx__mark_entity_used, ctx__record_validation, ctx__record_escalation, ctx__unload_entity, ctx__session_end, ctx__session_state",src/ctx/adapters/generic/ctx_core_tools.py and ctx.runtime_lifecycle.record,As an MCP or generic harness client I can record runtime lifecycle evidence,Lifecycle tools append privacy-safe runtime events with redacted free text enforce bound session IDs hash telemetry identifiers expose local session state with caller-facing slugs and keep token-usage metrics on the lifecycle event trace/span,Temp runtime lifecycle directory available,pytest src/tests/test_harness_ctx_core.py src/tests/test_mcp_server.py -q,Retested Pass,"PASS: test_harness_ctx_core covers lifecycle append order, free-text and security-scan redaction, bound session enforcement, telemetry hashing, lifecycle usage metric span correlation, and test_mcp_server.py covers lifecycle tools/call round-trip.",AUDIT-017,Lifecycle token-usage metrics were emitted before the lifecycle telemetry span.,Fixed,PASS: .venv/bin/pytest src/tests/test_harness_ctx_core.py -q --tb=short -> 74 passed.,2026-07-05,Canonical tracker row for lifecycle/session tools exposed in the MCP/core toolbox catalog.
-MCP-003,MCP Router,Trusted third-party MCP attachment,McpClient and McpRouter,src/ctx/adapters/generic/tools/mcp_router.py,As a generic harness user I can attach trusted third-party MCP servers safely,Router starts MCP subprocesses with isolated environment namespaces tools handles timeouts redacts secrets emits client-side external tool telemetry and propagates W3C traceparent metadata to MCP servers,Fake MCP server fixture available,pytest src/tests/test_mcp_router.py src/tests/test_enterprise_telemetry.py -q,Retested Pass,"PASS: test_mcp_router.py and test_enterprise_telemetry.py cover client start/stop, external-call telemetry, _meta.traceparent injection, session hash correlation, server span parenting, and stderr redaction.",AUDIT-019,External MCP calls lacked client-side telemetry and spawned MCP server spans did not inherit the caller trace.,Fixed,PASS: .venv/bin/pytest src/tests/test_mcp_router.py src/tests/test_enterprise_telemetry.py -q --tb=short -> 115 passed.,2026-07-05,Added because third-party MCP attachment is user-facing host functionality not just internal plumbing.
+MCP-003,MCP Router,Trusted third-party MCP attachment,McpClient and McpRouter,src/ctx/adapters/generic/tools/mcp_router.py,As a generic harness user I can attach trusted third-party MCP servers safely,Router starts MCP subprocesses with isolated environment namespaces tools handles timeouts expands nonsecret env placeholders blocks sensitive argv placeholder expansion by default supports trusted opt-in redacts literal credential env values and stderr emits client-side external tool telemetry and propagates W3C traceparent metadata to MCP servers,Fake MCP server fixture available,pytest src/tests/test_mcp_router.py src/tests/test_enterprise_telemetry.py -q,Retested Pass,"PASS: test_mcp_router.py and test_enterprise_telemetry.py cover client start/stop, external-call telemetry, _meta.traceparent injection, session hash correlation, server span parenting, env placeholder safety, and literal/general stderr redaction.",AUDIT-019,External MCP calls lacked client-side telemetry and spawned MCP server spans did not inherit the caller trace.,Fixed,PASS: .venv/bin/pytest src/tests/test_mcp_router.py src/tests/test_enterprise_telemetry.py -q --tb=short -> 115 passed.,2026-07-05,Added because third-party MCP attachment is user-facing host functionality not just internal plumbing and updated for argv secret placeholder policy.
 MCP-004,MCP/Core Tools,Response format negotiation,output_format and _response_format,src/ctx/adapters/generic/ctx_core_tools.py,As a tool caller I can request JSON or GCF output from read tools,Read tool schemas expose optional output_format and _response_format aliases and fall back to JSON errors when GCF codec is unavailable,Generic toolbox fixture available,pytest src/tests/test_harness_ctx_core.py -q,Tested Pass,test_harness_ctx_core.py covers optional schema fields JSON default GCF opt-in public alias and codec-missing fallback.,,,,,2026-06-29,Tracks a schema-visible behavior exposed to MCP/tool clients.
 DASH-001,Dashboard,Home page,/,src/ctx/monitor/routes.py,As a user I can land on a useful dashboard home,Home shows current counts and high-value entry points without stale numbers,Monitor running,GET /,Tested Pass,GET / returned 200 in 1506ms after restart.,,,,,2026-06-23,Dashboard route sweep; no mutation performed.
 DASH-002,Dashboard,Loaded page,/loaded,src/ctx/monitor/routes.py,As a user I can see loaded entities,Loaded page lists active skills agents MCPs and supports load state clarity,Monitor running,GET /loaded,Tested Pass,GET /loaded returned 200 in 79ms after restart.,,,,,2026-06-23,Dashboard route sweep; no mutation performed.
@@ -81,8 +81,8 @@ API-003,Dashboard API,Status API,/api/status.json,src/ctx/monitor/routes.py,As a
 API-004,Dashboard API,KPI API,/api/kpi.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch KPI JSON,Endpoint returns bounded KPI payload quickly,Monitor running,GET /api/kpi.json,Tested Pass,GET /api/kpi.json returned 200 in 105ms after restart.,,,,,2026-06-23,Dashboard route sweep; no mutation performed.
 API-005,Dashboard API,Grades API,/api/grades.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch grades JSON,Endpoint returns score and grade payload with explanations,Monitor running,GET /api/grades.json,Retested Pass,Initial dashboard sweep: GET /api/grades.json returned 200 but took 16833ms for a tiny payload.,CTX-AZ-005,Grades API ignored cached KPI grade_counts and rescanned all quality sidecars on demand.,Fixed,"After routing through cached KPI summary, GET /api/grades.json returned 200 in 92ms after restart.",2026-06-23,Fallback full sidecar scan remains for missing KPI summary.
 API-006,Dashboard API,Runtime API,/api/runtime.json,src/ctx/monitor/api/readonly.py and src/ctx/monitor/services/runtime.py,As a dashboard client I can fetch runtime JSON,Endpoint returns lifecycle selection token usage and recent usage metadata without raw evidence strings,Monitor running,GET /api/runtime.json and scan for raw evidence strings,Retested Pass,PASS: runtime lifecycle test asserts private evidence text is absent from recent_tool_usage.,,,,,2026-07-02,Retested in the tool-selection/token-history canonical loop.
-API-007,Dashboard API,Entity search API,/api/entities/search.json,src/ctx/monitor/routes.py,As a dashboard client I can search entities,Endpoint supports live query type filters and useful fuzzy results,Monitor running,GET /api/entities/search.json?q=review&type=agent,Tested Pass,PASS: endpoint returned 200 in 28ms with agent review results,,,,,2026-06-23,
-API-008,Dashboard API,Entity detail API,/api/entity/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch entity details,Endpoint returns canonical entity docs frontmatter and graph sidecar,Monitor running,GET /api/entity/github.json?type=mcp-server,Tested Pass,GET /api/entity/github.json?type=mcp-server returned 200 in 27ms after restart.,,,,,2026-06-23,Dashboard route sweep; no mutation performed.
+API-007,Dashboard API,Entity search API,/api/entities/search.json,src/ctx/monitor/routes.py,As a dashboard client I can search entities,Endpoint supports live query type filters useful fuzzy results and wiki-relative result paths,Monitor running,GET /api/entities/search.json?q=review&type=agent,Tested Pass,PASS: endpoint returned 200 in 28ms with agent review results,,,,,2026-06-23,
+API-008,Dashboard API,Entity detail API,/api/entity/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch entity details,Endpoint returns canonical entity docs frontmatter wiki-relative path and graph sidecar without host filesystem roots,Monitor running,GET /api/entity/github.json?type=mcp-server,Tested Pass,GET /api/entity/github.json?type=mcp-server returned 200 in 27ms after restart.,,,,,2026-06-23,Dashboard route sweep; no mutation performed; entity paths are wiki-relative.
 API-009,Dashboard API,Graph neighborhood API,/api/graph/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch a graph neighborhood,Endpoint returns bounded nodes edges scores and reasons fast after runtime install,Monitor running,GET /api/graph/github.json?type=skill&limit=20,Tested Pass,PASS: endpoint returned 200 in 2295ms with nodes/edges JSON,,,,,2026-06-23,
 API-010,Dashboard API,Load/unload APIs,/api/load and /api/unload,src/ctx/monitor/routes.py,As a dashboard user I can load/unload entities,POST validates input changes active state and rejects unsafe requests,Monitor running and temp state,POST /api/load then /api/unload,Tested Pass,"Focused pytest passed: perform_load rejects invalid slugs, load security scan surfaces output, perform_unload rejects invalid slugs.",,,,,2026-06-23,"Validated through isolated monitor mutation tests, not live local catalog mutation."
 API-011,Dashboard API,Entity upsert/delete APIs,/api/entity/upsert and /api/entity/delete,src/ctx/monitor/routes.py,As a dashboard user I can manually add edit or delete entities,POST validates type slug content and queues graph/wiki updates safely,Monitor running and temp wiki,POST fixture upsert/delete,Tested Pass,Focused pytest passed: entity upsert writes wiki page and queues graph refresh; existing-page confirmation and delete behavior covered.,,,,,2026-06-23,"Validated through isolated monitor mutation tests, not live local catalog mutation."
@@ -90,7 +90,7 @@ API-012,Dashboard API,Config read API,/api/config.json,src/ctx/monitor/routes.py
 API-013,Dashboard API,Sidecars API,/api/sidecars.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch paginated sidecar cards,Endpoint supports query type grade floor and limit filters without full unbounded scans,Monitor running with sidecar fixtures,GET /api/sidecars.json?q=review&type=agent&grade=A&hide_floor=1&limit=1,Tested Pass,Focused monitor API test returned filtered sidecar JSON with total limit filters and caps.,,,,,2026-06-23,Added during route inventory coverage audit.
 API-014,Dashboard API,SkillSpector API,/api/skillspector.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch SkillSpector findings,Endpoint returns filtered audit summary and records for dashboard remediation views,Monitor running with skillspector audit fixture,GET /api/skillspector.json?severity=HIGH&q=prompt,Tested Pass,Focused monitor API test returned HIGH prompt-injection SkillSpector record JSON.,,,,,2026-06-23,Added during route inventory coverage audit.
 API-015,Dashboard API,Sidecar detail API,/api/skill/<slug>.json,src/ctx/monitor/routes.py,As a dashboard client I can fetch one sidecar JSON,Endpoint returns typed sidecar details or a JSON detail 404 for missing/unsafe slugs,Monitor running with typed sidecar fixture,GET /api/skill/filesystem.json?type=mcp-server and /api/skill/missing-sidecar.json,Retested Pass,Focused monitor API tests returned typed MCP sidecar JSON and JSON detail 404 for a missing sidecar.,AUDIT-025,Missing sidecar API responses used an HTML 404 body.,Fixed,PASS: .venv/bin/python -m pytest src/tests/test_ctx_monitor.py::test_skill_sidecar_api_missing_sidecar_returns_json_404 src/tests/test_ctx_monitor.py::test_skill_sidecar_api_reads_typed_sidecar -q -> 2 passed.,2026-07-05,Updated for JSON API missing-sidecar 404 behavior.
-GRAPH-001,Graph/Wiki,Full graph artifact validation,src/validate_graph_artifacts.py,pyproject and scripts/ci_preflight.py,As a maintainer I can validate shipped graph artifacts,Validation deep-checks tar members counts no originals no locks exact release counts and line thresholds,Repo graph artifacts present,python src/validate_graph_artifacts.py --deep ...,Tested Pass,PASS: exact counts validated nodes 79958 edges 1778069 semantic 1088763 pages skills 68494 agents 467 MCPs 10790 harnesses 207,,,,,2026-06-23,
+GRAPH-001,Graph/Wiki,Full graph artifact validation,src/validate_graph_artifacts.py,pyproject and scripts/ci_preflight.py,As a maintainer I can validate shipped graph artifacts,Validation deep-checks tar members counts no originals no locks no host-user paths exact release counts and line thresholds,Repo graph artifacts present,python src/validate_graph_artifacts.py --deep ...,Tested Pass,PASS: exact counts validated nodes 79958 edges 1778069 semantic 1088763 pages skills 68494 agents 467 MCPs 10790 harnesses 207,,,,,2026-06-23,
 GRAPH-002,Graph/Wiki,Published stats sync,src/update_repo_stats.py,pyproject and src/update_repo_stats.py,As a maintainer I can keep README docs and About counts in sync,Stats come from shipped graph artifacts and checks fail when docs drift,Repo graph artifacts present,python src/update_repo_stats.py --check,Tested Pass,PASS: README/docs stats are up to date; test_release_graph_count_sync 3 passed,,,,,2026-06-23,
 GRAPH-003,Graph/Wiki,Graph pack manifest,ctx core graph_packs/pack_validation,src/ctx/core/graph and wiki modules,As a maintainer I can use base and overlay graph packs,Packs have manifest export IDs parent IDs checksums tombstones and merged reads,Graph pack fixtures,pytest graph pack tests,Tested Pass,graph packs/store/incremental batch: 59 passed and graph pack manifest tests passed.,,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
 GRAPH-004,Graph/Wiki,SQLite operational graph store,ctx-graph-store,src/ctx/core/graph/graph_store.py,As a dashboard user I get fast search/neighborhoods,Store builds from graphify-out validates freshness and accelerates reads,Runtime graph installed,ctx-graph-store build/search/neighborhood fixture,Tested Pass,"graph packs/store/incremental batch: 59 passed, including SQLite graph store tests.",,,,,2026-06-23,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.
@@ -129,7 +129,7 @@ DOC-NAV-026,Docs,Skill-quality install page,docs/skill-quality-install.md,mkdocs
 DIST-001,Distribution,GitHub About metadata,GitHub repository About,src/update_repo_stats.py,As a GitHub visitor I can understand ctx positioning and current counts from the repo About,About says ctx is a recommendation layer not a marketplace and uses shipped graph counts,GitHub CLI authenticated,python src/update_repo_stats.py --check-github-about,Retested Pass,PASS: GitHub About description is up to date on main 16c96b1.,,,,,2026-06-29,Revalidated after inventory wording merge with python src/update_repo_stats.py --check-github-about.
 DIST-002,Distribution,Main CI test workflow,.github/workflows/test.yml,.github/workflows/test.yml,As a contributor I can trust the required main test workflow,Main push runs static gates unit-linux canaries package smoke browser security and required CI aggregate,GitHub Actions available,gh run view 28340695216,Retested Pass,PASS: main Tests workflow run 28340695216 for 16c96b1 completed successfully and CI required job 83954824744 passed.,,,,,2026-06-29,"Matrix pytest static gates unit-linux browser monitor security telemetry enterprise gate package smoke clean-host similarity and A-Z canary all passed."
 DIST-003,Distribution,Docs deploy workflow,.github/workflows/docs.yml,.github/workflows/docs.yml,As a docs visitor I get the current public docs after main updates,Docs workflow builds strict MkDocs and deploys GitHub Pages without stale generated content,GitHub Pages enabled,gh run view 28340695222 and curl public docs URLs,Retested Pass,PASS: Deploy docs to GitHub Pages run 28340695222 for 16c96b1 succeeded and public docs home telemetry dashboard and knowledge-graph URLs returned HTTP 200.,,,,,2026-07-05,"Public docs reflect post-merge main with current 4,473 test inventory after PR #239."
-DIST-004,Distribution,Hugging Face sync workflow,.github/workflows/huggingface-sync.yml,.github/workflows/huggingface-sync.yml and scripts/sync_huggingface.py,As a Hugging Face visitor I get the same tracked repo and graph artifacts as GitHub,Workflow hydrates graph artifacts by matching LFS sha/size release assets before publishing and refuses stale README/docs stats,Valid write-scoped HF_TOKEN configured in GitHub secrets,GitHub Actions Sync Hugging Face workflow on main,Blocked/Human Decision,FAIL: main Sync Hugging Face workflow run 28340695227 for 16c96b1 failed after README/docs stats and graph artifact hydration passed; upload to https://huggingface.co/api/datasets/Stevesolun/ctx/preupload/main returned 401 Unauthorized / Invalid username or password.,CTX-CICD-001,Post-exposure HF_TOKEN rotation remains open after successful sync proof,"Replace and revoke the token that was exposed during incident handling, update GitHub HF_TOKEN, then rerun the Sync Hugging Face workflow.","PASS: workflow_dispatch Sync Hugging Face run 28362276544 proved the replacement secret could publish the dataset at that time; current repo stats are enforced separately by update_repo_stats.py and PR #239 refreshed GitHub docs to 4,473 inventory.",2026-07-05,"Successful run proved the replacement secret worked, but the exposed credential still requires another rotation before this row can pass."
+DIST-004,Distribution,Hugging Face sync workflow,.github/workflows/huggingface-sync.yml,.github/workflows/huggingface-sync.yml and scripts/sync_huggingface.py,As a Hugging Face visitor I get the same tracked repo and graph artifacts as GitHub,Workflow hydrates graph artifacts from matching release assets or size-capped targeted LFS for full publishes while refusing stale README/docs stats and limiting card-only sync to README/CHANGELOG/docs inputs,Valid write-scoped HF_TOKEN configured in GitHub secrets,GitHub Actions Sync Hugging Face workflow on main,Blocked/Human Decision,FAIL: main Sync Hugging Face workflow run 28340695227 for 16c96b1 failed after README/docs stats and graph artifact hydration passed; upload to https://huggingface.co/api/datasets/Stevesolun/ctx/preupload/main returned 401 Unauthorized / Invalid username or password.,CTX-CICD-001,Post-exposure HF_TOKEN rotation remains open after successful sync proof,"Replace and revoke the token that was exposed during incident handling, update GitHub HF_TOKEN, then rerun the Sync Hugging Face workflow.","PASS: workflow_dispatch Sync Hugging Face run 28362276544 proved the replacement secret could publish the dataset at that time; current repo stats are enforced separately by update_repo_stats.py and PR #239 refreshed GitHub docs to 4,473 inventory.",2026-07-05,"Successful run proved the replacement secret worked, but the exposed credential still requires another rotation before this row can pass; workflow classifier now full-syncs source test and workflow changes."
 DIST-005,Distribution,Clean host contract workflow,.github/workflows/clean-host-contract.yml,.github/workflows/clean-host-contract.yml,As a new installer I can verify ctx works on a clean host,Workflow installs the package in a clean environment and runs the clean-host smoke contract,GitHub Actions available,gh run view 28340695216,Retested Pass,PASS: Clean host contract job 83954561453 passed inside main Tests run 28340695216 for 16c96b1.,,,,,2026-06-29,Revalidated through the current required main workflow after the inventory wording merge.
 DIST-006,Distribution,PyPI publish workflow,.github/workflows/publish.yml,.github/workflows/publish.yml,As a PyPI user I can install the tagged release with matching graph artifacts,Tag publish builds the wheel validates graph artifacts uploads release assets and publishes the package,Published release tag and clean temporary PyPI install environment,Inspect publish workflow run plus release/PyPI metadata; install claude-ctx from PyPI and load ctx-telemetry-export; run local full graph/dashboard smoke,Retested Pass,"PASS: v1.0.20 Publish to PyPI workflow run 28371022076 succeeded for 2bfce9275b34ecabda1742180607020fab3f8b0c; release assets include wiki-graph.tar.gz, wiki-graph-runtime.tar.gz, skills-sh-catalog.json.gz, communities.json, and entity-overlays.jsonl with SHA-256 digests; PyPI exposes claude-ctx 1.0.20 wheel and sdist; clean temp venv installed claude-ctx==1.0.20 and loaded ctx-telemetry-export.",,,,,2026-06-29,"Release v1.0.20 is published on GitHub and PyPI; full local ctx-init --graph --graph-install-mode full populated the LLM-wiki, and dashboard smoke passed all graph/wiki/entity routes."
 DIST-007,Distribution,Parallel pytest experiment workflow,.github/workflows/xdist-experiment.yml,.github/workflows/xdist-experiment.yml,As a maintainer I can benchmark pytest-xdist safely before adopting it,Workflow runs only when explicitly dispatched and does not affect required checks until proven stable,GitHub Actions available,Manual workflow_dispatch run for xdist experiment,Tested Pass,GitHub Actions run 28133264595 passed on ubuntu-latest windows-latest and macos-latest with Python 3.12.,,,,,2026-06-24,Dispatched manually on main; optional experiment remains out of required checks.
@@ -139,16 +139,16 @@ SEC-002,Distribution,No-mistakes development gate,no-mistakes axi run,imported-s
 MAINT-001,Maintainer,Backup snapshot audit,scripts/audit_backup.py,scripts/audit_backup.py,As a maintainer I can inspect backup snapshots for missing expected files,Script summarizes backup contents while accepting --help without snapshot access and flags missing graph/wiki/report artifacts without mutating the repo,Backup fixture available,python scripts/audit_backup.py --help; run script against representative backup fixture,Retested Pass,PASS: --help printed usage without touching snapshot files; temp backup fixture with BOM manifest printed entries and OK coverage; focused pytest passed.,CTX-AZ-008; CTX-QA-034,Backup audit previously rejected UTF-8 BOM manifests and treated --help as a snapshot path,Fixed by utf-8-sig manifest reads and snapshot-free help parsing in PR #210,PASS: /tmp/ctx-verify-venv/bin/python scripts/audit_backup.py --help; focused pytest 62 passed 1 skipped; no-mistakes run 01KWFXQTHJ83VNZ9ZJGMTAJPWC checks-passed.,2026-07-02,Read-only reporting; --help is snapshot-free and does not repair backup gaps.
 MAINT-002,Maintainer,Dashboard graph index builder,scripts/build_dashboard_graph_index.py,scripts/build_dashboard_graph_index.py,As a dashboard user I get fast graph search and neighborhoods,Script builds the dashboard SQLite/index artifacts from graph exports for fast monitor reads,Graph fixture available,Run script against small graph fixture and query resulting index,Retested Pass,FAIL: BOM-prefixed graph.json from PowerShell Set-Content -Encoding UTF8 raised JSONDecodeError.,CTX-AZ-008,Dashboard graph index builder read graph JSON with utf-8 and rejected common Windows BOM input,Fixed by reading graph JSON with utf-8-sig,PASS: temp graph fixture built SQLite index with 2 nodes and neighbor mcp-server:github; regression pytest passed.,2026-06-23,
 MAINT-003,Maintainer,CI change classifier,scripts/ci_classifier.py,scripts/ci_classifier.py and .github/workflows/test.yml,As a contributor I get the right CI gates for the files I changed,Classifier marks docs graph source package browser and similarity changes conservatively,CI classifier tests available,python -m pytest src/tests/test_ci_classifier.py -q,Tested Pass,CI classifier suite covers path classes and workflow contract behavior.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
-MAINT-004,Maintainer,No-test policy gate,scripts/ci_no_test_policy.py,scripts/ci_no_test_policy.py and .github/workflows/test.yml,As a reviewer I can reject risky code or workflow changes without test updates,Policy fails contract changes that omit matching tests while only allowing metadata-only releases when diff hunks prove version or stats-only edits,CI policy tests available,python -m pytest src/tests/test_ci_classifier.py src/tests/test_ci_preflight.py -q,Tested Pass,CI policy and preflight suites cover contract files release metadata exceptions and rejection when diff context is missing.,,,,,2026-07-05,Validated after preflight started passing real per-file diffs to the policy helper.
+MAINT-004,Maintainer,No-test policy gate,scripts/ci_no_test_policy.py,scripts/ci_no_test_policy.py and .github/workflows/test.yml,As a reviewer I can reject risky code or workflow changes without test updates,Policy fails contract changes including release sync and graph artifact maintainer scripts that omit matching tests while only allowing metadata-only releases when diff hunks prove version or stats-only edits,CI policy tests available,python -m pytest src/tests/test_ci_classifier.py src/tests/test_ci_preflight.py -q,Tested Pass,CI policy and preflight suites cover contract files release metadata exceptions and rejection when diff context is missing.,,,,,2026-07-05,Validated after preflight started passing real per-file diffs to the policy helper and after maintainer script contract coverage expanded.
 MAINT-005,Maintainer,Required CI aggregate,scripts/ci_required.py,scripts/ci_required.py and .github/workflows/test.yml,As a branch maintainer I can trust the required CI summary,Aggregate rejects failed missing or wrongly skipped required jobs and allows documented conditional skips,CI required tests available,python -m pytest src/tests/test_ci_classifier.py -q,Tested Pass,CI classifier suite covers required job dependency success failure and conditional skip cases.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
-MAINT-006,Maintainer,CI preflight gate,scripts/ci_preflight.py,scripts/ci_preflight.py and scripts/ci_classifier.py,As a contributor I can run the same preflight logic locally that CI uses,"Preflight classifies changes then emits source static gates (ruff format/check, ruff lint, mypy, pip check), public docs tracker including bug-smoke, feature, dashboard, and toolbox coverage, strict build, graph, browser, package, and similarity gates required",Repo checkout with git available,Run scripts/ci_preflight.py against representative changed files,Tested Pass,"select_checks and workflow parity coverage confirm the public docs tracker includes bug-smoke, feature, dashboard, and toolbox checks before strict MkDocs build.",,,,,2026-07-05,Validated through the preflight selection seam and workflow parity test without launching expensive full preflight.
+MAINT-006,Maintainer,CI preflight gate,scripts/ci_preflight.py,scripts/ci_preflight.py scripts/ci_classifier.py and scripts/local_fast_gate.py,As a contributor I can run the same preflight logic locally that CI uses,"Preflight classifies changes then emits source static gates (ruff format/check, ruff lint, mypy, pip check), public docs tracker including bug-smoke, feature, dashboard, and toolbox coverage, strict build, graph, browser, package, and similarity gates required; local-fast groups those same checks into isolated parallel worktree lanes before the serial gate",Repo checkout with git available,Run scripts/ci_preflight.py against representative changed files; run scripts/no_mistakes_run.sh fast before PR validation,Tested Pass,"select_checks and workflow parity coverage confirm the public docs tracker includes bug-smoke, feature, dashboard, and toolbox checks before strict MkDocs build; local_fast_gate grouping coverage confirms graph hydration stays with graph validation and source changes split across independent lanes.",,,,,2026-07-06,Validated through focused preflight tests and the first real local-fast run which exposed missing tracker coverage before the final serial gate.
 MAINT-007,Maintainer,Clean host contract script,scripts/clean_host_contract.py,scripts/clean_host_contract.py and .github/workflows/clean-host-contract.yml,As a new installer I can smoke ctx on a clean host,Script builds a clean venv installs ctx and runs init scan harness and monitor checks,Network and clean temp venv available,GitHub clean-host contract or local script smoke,Tested Pass,Clean host contract job passed inside PR #195 required checks.,,,,,2026-06-23,Workflow evidence covers the script path.
 MAINT-008,Maintainer,Dashboard smoke script,scripts/dashboard_smoke.py,scripts/dashboard_smoke.py,As a maintainer I can smoke a running monitor before release,Script probes an already running ctx-monitor base URL and checks key pages/APIs with optional warmup,Monitor running or fake HTTP fixture available,python -m pytest src/tests/test_dashboard_smoke.py -q,Tested Pass,Dashboard smoke test suite covers route probing warmup and failure reporting for a supplied base URL.,,,,,2026-06-29,Corrected wording from starts-or-probes to probes-running-monitor; ctx-monitor startup is tracked separately by CLI-042.
 MAINT-009,Maintainer,Graph artifact guard,scripts/graph_artifact_guard.py,scripts/graph_artifact_guard.py,As a maintainer I can prevent huge graph artifacts from bloating local Git state,Guard parks unparks and prunes graph artifacts safely without deleting unrelated files,Graph artifact fixture available,python -m pytest src/tests/test_graph_artifact_guard.py -q,Tested Pass,Graph artifact guard suite covers park unpark prune and explicit git prune safety.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
 MAINT-010,Maintainer,Overlay wiki entities,scripts/overlay_wiki_entities.py,scripts/overlay_wiki_entities.py,As a graph maintainer I can apply curated entity overlays to the wiki artifact,Script overlays entity pages and rebuilds dashboard index without corrupting packed wiki structure,Overlay fixture available,python -m pytest src/tests/test_overlay_wiki_entities.py -q,Tested Pass,Overlay wiki entities tests cover page generation replacements and CLI help.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
-MAINT-011,Maintainer,Full wiki tar repacker,scripts/pack_full_wiki_tar.py,scripts/pack_full_wiki_tar.py,As a maintainer I can ship a packed full LLM-wiki artifact without huge expanded fanout,Repacker moves high-fanout pages into wiki packs omits raw originals and is idempotent,Wiki tar fixture available,python -m pytest src/tests/test_pack_full_wiki_tar.py -q,Tested Pass,Pack full wiki tar tests cover packed wiki output original omission and idempotent repack.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
+MAINT-011,Maintainer,Full wiki tar repacker,scripts/pack_full_wiki_tar.py,scripts/pack_full_wiki_tar.py,As a maintainer I can ship a packed full LLM-wiki artifact without huge expanded fanout,Repacker moves high-fanout pages into wiki packs omits raw originals local generated markdown and host-user paths and is idempotent,Wiki tar fixture available,python -m pytest src/tests/test_pack_full_wiki_tar.py -q,Tested Pass,Pack full wiki tar tests cover packed wiki output original omission and idempotent repack.,,,,,2026-06-23,Validated by focused pytest in this tracker slice including local generated markdown omission and host path redaction.
 MAINT-012,Maintainer,SkillSpector wiki pruner,scripts/prune_skillspector_wiki.py,scripts/prune_skillspector_wiki.py,As a maintainer I can prune low-value SkillSpector wiki noise before shipping,Script builds pruned artifacts in dry-run/apply modes while preserving required catalog metadata,Prune fixture available,python -m pytest src/tests/test_prune_skillspector_wiki.py -q,Tested Pass,Prune SkillSpector wiki tests cover dry-run apply and artifact rewrite behavior.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
-MAINT-013,Maintainer,Hugging Face sync script,scripts/sync_huggingface.py,scripts/sync_huggingface.py and .github/workflows/huggingface-sync.yml,As a Hugging Face visitor I get a clean repo-card snapshot without ignored local artifacts,Script exports tracked files adds repo-card metadata validates graph artifacts and removes stale remote files,HF token or fake API available,python -m pytest src/tests/test_huggingface_sync.py -q,Tested Pass,Hugging Face sync tests cover metadata wrapping stale remote cleanup and hardened workflow contract.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
+MAINT-013,Maintainer,Hugging Face sync script,scripts/sync_huggingface.py,scripts/sync_huggingface.py and .github/workflows/huggingface-sync.yml,As a Hugging Face visitor I get a clean repo-card snapshot without ignored local artifacts,Script exports tracked files adds repo-card metadata validates graph artifacts removes stale remote files and limits card-only uploads to README/CHANGELOG/docs inputs,HF token or fake API available,python -m pytest src/tests/test_huggingface_sync.py -q,Tested Pass,Hugging Face sync tests cover metadata wrapping stale remote cleanup and hardened workflow contract.,,,,,2026-06-23,Validated by focused pytest in this tracker slice including full sync selection for source test and workflow changes.
 MAINT-014,Maintainer,Similarity threshold tuner,scripts/tune_similarity_thresholds.py,scripts/tune_similarity_thresholds.py,As a graph maintainer I can calibrate similarity thresholds against fixtures,Tuner prints help without loading the embedding model and sweeps threshold settings with precision/recall/F1 output without mutating graph artifacts,Similarity fixture corpus available,python scripts/tune_similarity_thresholds.py --help; run tuner against fixture corpus,Retested Pass,"PASS: --help printed usage without loading the embedder; focused pytest passed; tuner prints precision, recall, F1, and confusion counts.",CTX-QA-035,Similarity tuner --help previously loaded the embedding backend and could fail before usage output,Fixed by model-free help handling and F1 metric reporting in PR #210,PASS: /tmp/ctx-verify-venv/bin/python scripts/tune_similarity_thresholds.py --help; focused pytest 62 passed 1 skipped; GitHub Similarity precision/recall passed.,2026-07-02,Full sweep still depends on embedding backend availability; --help stays model-free and CI covers fixture precision/recall/F1.
 PUBLIC-001,Docs,Public catalog search JavaScript,docs/assets/javascripts/catalog.js,docs/assets/javascripts/catalog.js and docs/catalog.md,As a GitHub Pages visitor I can filter catalog tiles without a local dashboard,JavaScript wires input and checkbox filters and updates visible catalog cards/counts client-side,Docs assets available,python -m pytest src/tests/test_docs_catalog_page.py -q,Tested Pass,Docs catalog page tests verify script inclusion input listener and public non-local links.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.
 PUBLIC-002,Docs,Public repo stats refresh JavaScript,docs/assets/javascripts/repo-stats-refresh.js,docs/assets/javascripts/repo-stats-refresh.js and mkdocs.yml,As a docs visitor I see current repo stats when GitHub allows client refresh,JavaScript is included by MkDocs and degrades safely when live repo stats cannot be fetched,Docs assets available,python -m pytest src/tests/test_docs_repo_stats.py -q,Tested Pass,Docs repo stats tests verify MkDocs includes the script and the script has the expected refresh behavior.,,,,,2026-06-23,Validated by focused pytest in this tracker slice.

graph/README.md

@@ -26,7 +26,7 @@ The runtime recommendation paths use this graph in these ways:
 | File | Contents |
 |---|---|
 | `wiki-graph-runtime.tar.gz` | Fast install artifact used by default `ctx-init --graph`: `graphify-out/*`, the skill index, 207 harness pages, wiki index files, and Obsidian metadata needed for recommendations and harness dry-runs without expanding every entity page |
-| `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, skill indexes, SkillSpector stamps, and Obsidian metadata |
+| `wiki-graph.tar.gz` | Full LLM-wiki: direct harness/root pages, wiki-packed skill/agent/MCP/converted/concept pages, `graphify-out/graph.json`, `graph-delta.json`, export manifest, communities, skill indexes, SkillSpector stamps, and Obsidian metadata |
 | `skillspector-audit.jsonl.gz` | Compact per-skill audit records produced by a ctx-run static `--no-llm` pass with [NVIDIA SkillSpector](https://github.com/NVIDIA/SkillSpector). This is not NVIDIA endorsement or certification. The same gzip is embedded in `wiki-graph.tar.gz` as `security/skillspector-audit.jsonl.gz`. |
 | Skill catalog gzip | Compressed skill index for the 67,024 body-backed skill entries shipped in the wiki |
 | `communities.json` | Current Louvain community export |
@@ -50,7 +50,7 @@ right path for recommendations and first-time installs because it avoids
 expanding hundreds of thousands of markdown files while still shipping the
 harness pages needed by `ctx-harness-install --dry-run`. Use
 `ctx-init --graph --graph-install-mode full` or manual full extraction when you
-want local wiki browsing, Obsidian, or the converted skill body tree.
+want local wiki browsing, Obsidian, or wiki-packed converted skill bodies.
 
 ## Modular Pack Model
 
@@ -78,26 +78,33 @@ store refresh path.
 
 ## What Is Inside `wiki-graph.tar.gz`
 
-- `entities/skills/` - all skill entity pages
-- `entities/agents/` - agent entity pages
-- `entities/mcp-servers/<shard>/` - sharded MCP server entity pages
+- `entities/skills/` - directory placeholder; skill pages are packed under `wiki-packs/`
+- `entities/agents/` - directory placeholder; agent pages are packed under `wiki-packs/`
+- `entities/mcp-servers/<shard>/` - sharded MCP server pages packed under `wiki-packs/`
 - `entities/harnesses/` - harness entity pages
-- `converted/` - installable skill bodies
-- `converted-agents/` - mirrored agent bodies
-- `concepts/` - community concept pages
+- `converted/` - non-markdown conversion metadata; installable skill bodies are packed under `wiki-packs/`
+- `converted-agents/` - mirrored agent pages packed under `wiki-packs/`
+- `concepts/` - community concept pages packed under `wiki-packs/`
 - `external-catalogs/` - machine-readable skill index, summary, and coverage metadata
 - `security/skillspector-audit.jsonl.gz` - per-skill SkillSpector audit records
 - `graphify-out/graph.json` - NetworkX node-link graph
 - `graphify-out/graph-delta.json` - delta export for the latest graph generation
 - `graphify-out/graph-export-manifest.json` - export manifest tying graph, delta, communities, and report to one generation
 - `graphify-out/communities.json` - community export
-- `SCHEMA.md`, `index.md`, `log.md`, `catalog.md` - wiki contract and indexes
+- `wiki-packs/base-<export-id>/` - packed high-fanout wiki pages for skills, agents, MCP servers, converted bodies, and concepts
+- `SCHEMA.md`, `index.md` - wiki contract and root index
 - `.obsidian/` - vault metadata for local graph browsing
 
-`SKILL.md.original` backups, transient `.lock` files, and `.ctx/` queue state
-are not shipped. Local micro-skill conversion may keep `.original` files for
-traceability, but the packaged tarball excludes them so users do not ingest raw
-long bodies after conversion.
+`SKILL.md.original` backups, transient `.lock` files, `.ctx/` queue state, and
+local generated markdown catalogs such as `catalog.md`, `converted-index.md`,
+`log.md`, and `versions-catalog.md` are not shipped. Local micro-skill
+conversion may keep `.original` files for traceability, but the packaged
+tarball excludes them so users do not ingest raw long bodies after conversion.
+Markdown payloads are also scrubbed of host-user paths during repack. The
+artifact validator rejects host-user paths in archive JSON, graph-pack node/edge
+metadata, markdown members, and merged wiki-pack markdown; markdown members are
+capped at 10 MiB, and local generated markdown catalogs must not appear outside
+the packed root/index contract.
 
 ## Extract
 
@@ -152,6 +159,11 @@ python src/validate_graph_artifacts.py --deep \
   --expected-harness-pages 207
 ```
 
+PR graph checks hydrate tarball pointers from matching GitHub release assets
+first. If a PR points at a new Git LFS object that is not in the release cache,
+CI performs a targeted `git lfs pull` for that artifact and verifies its
+pointer SHA-256 and size before validation.
+
 Manual sanity checks:
 
 ```bash
@@ -297,8 +309,9 @@ python src/import_skills_sh_catalog.py \
 
 For a full local wiki repack from an existing artifact, use the packed-page
 repacker. It writes `wiki-packs/base-<export-id>/`, removes expanded
-skill/agent/MCP entity pages from the tar member list, and leaves harness pages
-directly available for fast runtime setup:
+skill/agent/MCP entity pages and local generated markdown catalogs from the tar
+member list, redacts host-user paths in markdown payloads, and leaves harness
+pages directly available for fast runtime setup:
 
 ```bash
 python scripts/pack_full_wiki_tar.py \
@@ -332,13 +345,30 @@ python -c "from pathlib import Path; from ctx.core.wiki.artifact_promotion impor
 The repack command above is for Git Bash/MSYS. In Linux/macOS shells omit
 `--force-local`; in PowerShell use `tar -czf` without `--force-local`.
 
-Both flows validate candidates before atomic promotion. Each promoted artifact
+Both flows validate candidates before atomic promotion. Queue-driven artifact
+promotion accepts only `graph.json`, `graph-delta.json`, `communities.json`,
+`graph-report.md`, and `graph-export-manifest.json` under
+`<wiki>/graphify-out/`, or the allowlisted release artifacts under repo
+`graph/`: `wiki-graph.tar.gz`, `wiki-graph-runtime.tar.gz`,
+`wiki-graph-stats.json`, `skills-sh-catalog.json.gz`,
+`skillspector-audit.jsonl.gz`, `entity-overlays.jsonl`, `communities.json`,
+`dedup-report.{json,md}`, and `tag-backfill.{json,md}`. The staged file must be
+the target sibling named `<target>.staged`, and staged/target symlinks are
+rejected. The worker chooses validators from the target type: JSON, JSONL, gzip
+JSON, gzip JSONL, full wiki tar, and runtime graph tar. Each promoted artifact
 gets a sibling `*.promotion.json` file with current, candidate, and `last_good`
 hashes for review or rollback. The graph, delta, communities, report, and
 export manifest are shipped together and carry the same export ID so validation
 can reject mixed or partially refreshed graph generations. Raw `.original`
-backups, transient `.lock` files, and `.ctx/` queue state must not appear in
-the shipped tarball.
+backups, transient `.lock` files, `.ctx/` queue state, local generated markdown
+catalogs, and host-user paths must not appear in the shipped tarball.
+
+Version-tag PyPI publishes use the same graph artifact contract. The publish
+workflow resolves the full and runtime tarballs from previous release or graph
+cache assets first; if a checked-out LFS pointer is newer than the cache, it
+hydrates only that artifact with a size-capped `git lfs pull`, verifies the
+pointer SHA-256 and byte size, validates graph artifacts, uploads release
+assets, then publishes the package.
 
 ## Implementation Notes
 

graph/wiki-graph-runtime.tar.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:993fc08377fdb09edcff4414c59b10fc121189b4a161bf796e3f8f6600907bb1
-size 122141091
+oid sha256:d4a39836aab5f558b546842580b2e20c523b9a9ab901ed681f84c09b5c4d6515
+size 110283462

graph/wiki-graph-stats.json

@@ -2,8 +2,8 @@
   "schema_version": 1,
   "artifact": {
     "path": "graph/wiki-graph.tar.gz",
-    "size": 296113770,
-    "sha256": "d051d4f21208abe3e73975a9c30650150138d88919c27979d725be936a6ea10a"
+    "size": 295151086,
+    "sha256": "2ce8a945c17a7345df9d27d8f101319a9f963b0fc85d399f104630bc06a7c4a0"
   },
   "source": "validated graph artifact release contract",
   "counts": {

graph/wiki-graph.tar.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d051d4f21208abe3e73975a9c30650150138d88919c27979d725be936a6ea10a
-size 296113770
+oid sha256:2ce8a945c17a7345df9d27d8f101319a9f963b0fc85d399f104630bc06a7c4a0
+size 295151086