Sync ctx 711582e (part 2)

GitHub commit: 711582e373fea0c43204213279f9ebd5c8937f26

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-ctx"
-version = "1.0.20"
+version = "1.0.21"
 description = "Not an Amazon-style catalog: a recommendation layer for loading the right skills, agents, MCPs, and harnesses at the right development moment"
 authors = [{ name = "Steve Solun" }]
 license = "MIT"

qa/bug_smoke_status.csv

@@ -25,3 +25,13 @@ AUDIT-023,CLI UX,MCP ingest,--status creates wiki path,src/mcp_ingest.py; src/te
 AUDIT-024,Security,Dashboard docs,entity-encoded active URL attributes,src/ctx/dashboard_docs.py; src/tests/test_security_hardening.py,Dashboard audit found entity-encoded active schemes survived docs sanitization in URL-bearing attributes.,High,Docs HTML sanitization should neutralize active URL schemes after entity decoding and control-character stripping.,parallel dashboard audit + focused pytest,Retested Pass,Entity-encoded javascript and data HTML schemes survived in href src xlink:href or formaction before fix.,Docs sanitization missed encoded active URL schemes in URL-bearing attributes.,Render sanitized docs HTML with entity-encoded active schemes in href src xlink:href and formaction before the fix.,Decode and normalize URL-bearing attribute values before active-scheme checks and cover the four attributes.,Fixed,.venv/bin/python -m pytest src/tests/test_security_hardening.py -q --tb=short,PASS: security hardening suite reported 41 passed with encoded active URL regressions.,2026-07-05,Codex,Reviewed by worker tests + local static audit,Ponytail: sanitize URL-bearing attributes only; preserve safe tabbed-input behavior.,Closed; continue repo-wide discovery.
 AUDIT-025,API Correctness,Monitor readonly API,HTML 404 for missing skill sidecar,src/ctx/monitor/api/readonly.py; src/tests/test_ctx_monitor.py,Dashboard audit found /api/skill/<slug>.json returned an HTML 404 body when the sidecar was missing.,Medium,JSON API routes should return JSON error payloads for missing resources.,parallel dashboard audit + focused pytest,Retested Pass,Missing skill sidecar API response had text/html content before fix.,Readonly skill API returned HTML for a JSON endpoint failure.,GET /api/skill/missing-sidecar.json before the fix and inspect status content type and body.,Return a JSON detail payload with 404 status for missing sidecars and add monitor regression coverage.,Fixed,.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,PASS: focused monitor API sidecar tests reported 2 passed.,2026-07-05,Codex,Reviewed by worker tests + local static audit,Ponytail: route-local JSON error only; no dispatcher refactor.,Closed; continue repo-wide discovery.
 AUDIT-026,Privacy,Core wiki tool,absolute wiki path in model-facing output,src/ctx/adapters/generic/ctx_core_tools.py; src/tests/test_harness_ctx_core.py,Runtime audit found ctx__wiki_get returned absolute wiki filesystem paths in success and missing-page outputs.,High,Model-facing wiki fetch results should expose wiki-relative paths or candidate labels without host absolute paths.,parallel runtime audit + focused pytest,Retested Pass,ctx__wiki_get success path and looked_in candidates included host absolute wiki paths before fix.,Wiki fetch tool leaked local filesystem layout into persisted tool results.,Call ctx__wiki_get for an existing page or missing slug under a temp wiki before the fix and inspect JSON output.,Return wiki-relative entity paths for success and missing candidates and assert temp absolute paths are absent.,Fixed,.venv/bin/python -m pytest src/tests/test_harness_ctx_core.py::TestWikiGet -q,PASS: TestWikiGet reported 6 passed with absolute-path privacy regressions.,2026-07-05,Codex,Reviewed by worker tests + local static audit,Ponytail: replace host paths with existing wiki-relative entity paths only.,Closed; continue repo-wide discovery.
+AUDIT-027,CLI Reliability,MCP add,JSONL batch preload,src/mcp_add.py; src/tests/test_mcp_add.py,Local static probe found ctx-mcp-add --from-jsonl read the whole JSONL file and stored all records before processing.,Medium,ctx-mcp-add --from-jsonl and --from-stdin should process records as a stream instead of preloading large catalogs.,manual static scan + focused pytest,Retested Pass,JSONL input used read_text().splitlines() and raw_records collected all records before batch processing.,Large MCP add catalogs could use unnecessary memory and delay first-record processing.,Monkeypatch Path.read_text to fail and run ctx-mcp-add --from-jsonl before the fix.,Stream JSONL/stdin records through the existing batch processor and use unknown-total progress for streaming inputs.,Fixed,.venv/bin/python -m pytest src/tests/test_mcp_add.py::TestAddMcpCliInput -q --tb=short,PASS: MCP add CLI input tests reported 4 passed including JSONL streaming regression.,2026-07-06,Codex,Reviewed by local tests + static audit,Ponytail: preserve existing add semantics; only replace input buffering with streaming iteration.,Closed; continue repo-wide discovery.
+AUDIT-028,CLI UX,MCP install,installed dry-run manifest reconciliation,src/ctx/adapters/claude_code/install/mcp_install.py; src/tests/test_mcp_install.py,Hegel runtime audit found dry-run already-installed branch called record_install before dry-run guard.,Medium,ctx-mcp-install dry-run should not mutate manifest state.,parallel runtime audit + focused pytest,Retested Pass,Already-installed dry-run recorded a manifest load entry before fix.,Dry-run install changed local manifest for an already installed MCP.,Call install_mcp on installed entity with dry_run=True and inspect manifest load before fix.,Skip manifest reconciliation when dry_run is true while preserving normal already-installed reconciliation.,Fixed,.venv/bin/python -m pytest src/tests/test_mcp_install.py -q --tb=short,PASS: test_mcp_install.py reported 113 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by local tests + static audit,Ponytail: guard only dry-run reconciliation path; non-dry-run manifest repair remains.,Closed; continue repo-wide discovery.
+AUDIT-029,Privacy,Monitor API,entity detail absolute path,src/ctx/monitor/services/wiki.py; src/tests/test_ctx_monitor.py,Turing monitor audit found /api/entity/<slug>.json returned absolute wiki filesystem paths.,Medium,Monitor entity detail JSON should expose wiki-relative paths and no host root.,parallel monitor audit + focused pytest,Retested Pass,Entity detail payload path contained the temp wiki absolute path before fix.,Monitor API leaked local wiki filesystem layout to JSON clients.,GET /api/entity/python-patterns.json under a temp wiki and inspect detail path before fix.,Return wiki_relative_path for entity_detail and assert the host path is absent.,Fixed,.venv/bin/python -m pytest src/tests/test_ctx_monitor.py::test_entity_search_and_detail_apis_support_edit_flow -q --tb=short,PASS: focused monitor API test passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by local tests + static audit,Ponytail: change only the API path field to the existing wiki-relative helper.,Closed; continue repo-wide discovery.
+AUDIT-030,CI Gate,Hugging Face sync,card-only classifier stale tracked files,.github/workflows/huggingface-sync.yml; src/tests/test_huggingface_sync.py,Lagrange CI audit found src/tests and .github changes routed to --card-only uploads.,High,Hugging Face sync should only use card-only mode for docs or explicit card files and should fully sync source test and workflow changes.,parallel CI audit + focused pytest,Retested Pass,src/tests and .github workflow edits selected card-only mode before fix.,HF dataset sync could leave tracked repository files stale while updating only README metadata.,Classify changed files under src/tests and .github before fix and inspect SYNC_MODE.,Limit card_only_prefixes to docs plus explicit card files and add workflow regression assertions.,Fixed,.venv/bin/python -m pytest src/tests/test_huggingface_sync.py src/tests/test_ci_classifier.py -q --tb=short,PASS: Hugging Face and CI classifier suites reported 80 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: tighten classifier tuple only; existing README and docs card-only behavior remains.,Closed; continue repo-wide discovery.
+AUDIT-031,CI Gate,No-test policy,maintainer script contract coverage,scripts/ci_no_test_policy.py; src/tests/test_ci_classifier.py,Lagrange CI audit found release sync and artifact maintainer scripts were not contract files for no-test policy.,High,Changes to release sync or artifact maintainer scripts should require matching tests.,parallel CI audit + focused pytest,Retested Pass,scripts/sync_huggingface.py and graph artifact scripts passed no-test policy without tests before fix.,Release and artifact script changes could bypass test-change requirements.,Evaluate no-test policy with scripts/sync_huggingface.py and graph artifact scripts before fix.,Add named maintainer scripts to contract file set and cover them in classifier tests.,Fixed,.venv/bin/python -m pytest src/tests/test_huggingface_sync.py src/tests/test_ci_classifier.py -q --tb=short,PASS: Hugging Face and CI classifier suites reported 80 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: explicit allowlist extension only; normal release metadata exemptions unchanged.,Closed; continue repo-wide discovery.
+AUDIT-032,Privacy,Graph artifacts,host paths in public wiki archives,graph/wiki-graph.tar.gz; graph/wiki-graph-runtime.tar.gz; scripts/pack_full_wiki_tar.py; src/validate_graph_artifacts.py,Turing graph audit found shipped wiki archives contained C:\\Users and /Users host paths in log and packed markdown pages.,High,Public graph and runtime wiki archives should omit generated local catalogs and redact host-user paths from markdown payloads.,parallel graph audit + artifact validator,Retested Pass,Top-level log and catalog pages plus packed converted references contained host paths before fix.,Published graph artifacts leaked local filesystem paths.,Scan wiki graph tarballs and wiki-pack pages for C:\\Users C:/Users or /Users before fix.,Omit generated local markdown catalogs redact host-user paths during repack and enforce strict archive markdown validation.,Fixed,.venv/bin/python src/validate_graph_artifacts.py --graph-dir graph,PASS: graph artifact validator passed and direct wiki-pack scans found no C:\\Users C:/Users or /Users signatures.,2026-07-06,Codex,Reviewed by worker + local artifact validation,Ponytail: sanitize public archive payloads at pack time and keep validator strict.,Closed; continue repo-wide discovery.
+AUDIT-033,CLI Safety,Backup prune,legacy keep dry-run deletion,src/backup_mirror.py; src/tests/test_backup_mirror.py,Hegel runtime audit found prune --keep N --dry-run deleted snapshots in the legacy branch.,High,backup prune --keep N --dry-run should report planned removals without deleting snapshots.,parallel runtime audit + focused pytest,Retested Pass,Legacy keep dry-run called prune_snapshots and removed old snapshot directories before fix.,Dry-run backup pruning could delete snapshots.,Run backup_mirror prune --keep 1 --dry-run on three temp snapshots and inspect remaining snapshots before fix.,Thread dry_run through legacy prune_snapshots and print would-remove messages.,Fixed,.venv/bin/python -m pytest src/tests/test_backup_config.py src/tests/test_backup_mirror.py src/tests/test_harness_cli_run.py -q --tb=short,PASS: runtime safety focused suite reported 154 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: preserve keep-prune semantics and only bypass deletion in dry-run.,Closed; continue repo-wide discovery.
+AUDIT-034,Security,Backup config,unsafe top_files entries,src/backup_config.py; src/tests/test_backup_config.py,Hegel runtime audit found top_files accepted traversal absolute drive and UNC paths.,High,backup top_files should be top-level filenames only and should never escape the configured home root.,parallel runtime audit + focused pytest,Retested Pass,top_files accepted ../../.ssh/id_rsa and absolute paths before fix.,Backup mirror configuration could include files outside the intended top-level home scope.,Load backup config with traversal absolute drive and UNC top_files values before fix.,Validate top_files as non-empty top-level filenames before ALWAYS_EXCLUDE filtering.,Fixed,.venv/bin/python -m pytest src/tests/test_backup_config.py src/tests/test_backup_mirror.py src/tests/test_harness_cli_run.py -q --tb=short,PASS: runtime safety focused suite reported 154 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: validate configured filenames only; existing exclude filtering remains.,Closed; continue repo-wide discovery.
+AUDIT-035,Security,ctx run MCP inline specs,inline secret argv persistence,src/ctx/cli/run.py; src/tests/test_harness_cli_run.py,Hegel runtime audit found --mcp specs accepted token-looking argv that could be persisted in session metadata.,High,ctx run --mcp inline commands should reject secret-looking argv and direct users to --mcp-env.,parallel runtime audit + focused pytest,Retested Pass,Inline MCP command args accepted --token and ghp_ values before fix.,MCP secrets could be embedded in command args and session metadata.,Parse an --mcp spec containing --token or ghp_ before fix and inspect parsed args.,Use existing secret scanner in _parse_mcp_spec and fail with --mcp-env guidance.,Fixed,.venv/bin/python -m pytest src/tests/test_backup_config.py src/tests/test_backup_mirror.py src/tests/test_harness_cli_run.py -q --tb=short,PASS: runtime safety focused suite reported 154 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: block inline secret-looking args only; --mcp-env remains the supported credential path.,Closed; continue repo-wide discovery.
+AUDIT-036,Security,Wiki queue artifact promotion,arbitrary target_path overwrite,src/ctx/core/wiki/wiki_queue_worker.py; src/tests/test_wiki_queue_worker.py,Turing graph audit found queued artifact promotion trusted payload target_path and could replace arbitrary files.,High,Queued artifact promotion should only promote known graph and wiki artifact targets from sibling staged files.,parallel graph audit + focused pytest,Retested Pass,ARTIFACT_PROMOTION_JOB payload could promote /tmp/staged to /tmp/outside before fix.,Queue worker could overwrite files outside allowed graph artifact locations.,Enqueue artifact promotion with outside target_path and inspect overwritten outside file before fix.,Resolve paths validate exact allowed target names and require staged_path to equal target sibling .staged before promotion.,Fixed,.venv/bin/python -m pytest src/tests/test_wiki_queue_worker.py src/tests/test_wiki_queue.py src/tests/test_wiki_queue_producers.py src/tests/test_artifact_promotion.py -q --tb=short,PASS: wiki queue and artifact promotion suites reported 50 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: restrict promotion boundary only; known graph and wiki artifact promotions still work.,Closed; continue repo-wide discovery.

scripts/ci_no_test_policy.py

@@ -20,6 +20,15 @@ RELEASE_GENERATED_STATS_FILES = {
     "docs/index.md",
     "docs/knowledge-graph.md",
 }
+MAINTAINER_SCRIPT_CONTRACT_FILES = {
+    "scripts/clean_host_contract.py",
+    "scripts/graph_artifact_guard.py",
+    "scripts/pack_full_wiki_tar.py",
+    "scripts/sync_huggingface.py",
+}
+GATE_CONFIG_CONTRACT_FILES = {
+    ".no-mistakes.yaml",
+}
 VERSION_LINE_RE = re.compile(r'version = "\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?"')
 INIT_VERSION_LINE_RE = re.compile(r'__version__ = "\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?"')
 TEST_COUNT_STATS_RE = re.compile(
@@ -55,7 +64,8 @@ def is_contract_file(path: str) -> bool:
     return (
         (path.startswith("src/") and path.endswith((".py", ".json")))
         or path.startswith("scripts/ci_")
-        or path == "scripts/clean_host_contract.py"
+        or path in MAINTAINER_SCRIPT_CONTRACT_FILES
+        or path in GATE_CONFIG_CONTRACT_FILES
         or path == "pyproject.toml"
         or (path.startswith(".github/workflows/") and path.endswith((".yml", ".yaml")))
     ) and not path.startswith("src/tests/")

scripts/ci_preflight.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import argparse
 from dataclasses import dataclass
+import hashlib
 import os
 from pathlib import Path
 import shutil
@@ -71,6 +72,26 @@ GRAPH_VALIDATE_ARGS = (
     "--max-stage-lines",
     "40",
 )
+GRAPH_LFS_ARTIFACTS = (
+    "graph/wiki-graph.tar.gz",
+    "graph/wiki-graph-runtime.tar.gz",
+)
+GRAPH_LFS_MAX_FALLBACK_SIZES = {
+    "graph/wiki-graph.tar.gz": 350_000_000,
+    "graph/wiki-graph-runtime.tar.gz": 150_000_000,
+}
+LFS_POINTER_PREFIX = "version https://git-lfs.github.com/spec/v1"
+LFS_POINTER_MAX_BYTES = 4096
+GIT_LFS_FILTER_CONFIG = (
+    "-c",
+    "filter.lfs.process=git-lfs filter-process",
+    "-c",
+    "filter.lfs.smudge=git-lfs smudge -- %f",
+    "-c",
+    "filter.lfs.clean=git-lfs clean -- %f",
+    "-c",
+    "filter.lfs.required=true",
+)
 
 
 @dataclass(frozen=True)
@@ -80,6 +101,13 @@ class Check:
     env: dict[str, str] | None = None
 
 
+@dataclass(frozen=True)
+class LfsPointer:
+    path: str
+    sha256: str
+    size: int
+
+
 def _run_git(args: list[str], *, allow_failure: bool = False) -> list[str]:
     proc = subprocess.run(
         ["git", *args],
@@ -137,6 +165,122 @@ def _diffs_for_files(base_ref: str, files: list[str]) -> dict[str, str]:
     return diffs
 
 
+def _read_lfs_pointer(path: Path) -> LfsPointer | None:
+    if not path.exists():
+        return None
+    prefix_bytes = LFS_POINTER_PREFIX.encode("utf-8")
+    with path.open("rb") as fh:
+        prefix = fh.read(len(prefix_bytes))
+        if prefix != prefix_bytes:
+            return None
+        pointer_bytes = prefix + fh.read(LFS_POINTER_MAX_BYTES - len(prefix_bytes))
+    expected_oid = ""
+    expected_size = 0
+    pointer = pointer_bytes.decode("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 expected_oid and expected_size:
+        return LfsPointer(path.relative_to(REPO_ROOT).as_posix(), expected_oid, expected_size)
+    raise RuntimeError(f"{path.relative_to(REPO_ROOT)} has incomplete Git LFS pointer metadata")
+
+
+def _file_sha256_and_size(path: Path) -> tuple[str, int]:
+    sha = hashlib.sha256()
+    total = 0
+    with path.open("rb") as fh:
+        while True:
+            chunk = fh.read(1024 * 1024)
+            if not chunk:
+                break
+            sha.update(chunk)
+            total += len(chunk)
+    return sha.hexdigest(), total
+
+
+def _verify_hydrated_lfs_pointer(pointer: LfsPointer) -> None:
+    path = REPO_ROOT / pointer.path
+    if _read_lfs_pointer(path) is not None:
+        raise RuntimeError(f"{pointer.path} is still a Git LFS pointer after hydration")
+    actual_sha256, actual_size = _file_sha256_and_size(path)
+    if actual_sha256 != pointer.sha256 or actual_size != pointer.size:
+        raise RuntimeError(
+            f"{pointer.path} does not match its Git LFS pointer: "
+            f"sha256:{actual_sha256} size:{actual_size}"
+        )
+
+
+def hydrate_graph_lfs_artifacts() -> int:
+    pointers = [
+        pointer
+        for relpath in GRAPH_LFS_ARTIFACTS
+        if (pointer := _read_lfs_pointer(REPO_ROOT / relpath)) is not None
+    ]
+    if not pointers:
+        print("Graph LFS artifacts are already hydrated.")
+        return 0
+
+    if not shutil.which("git"):
+        print("git is required to hydrate graph LFS artifacts", file=sys.stderr)
+        return 127
+
+    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")
+    for pointer in pointers:
+        max_size = GRAPH_LFS_MAX_FALLBACK_SIZES[pointer.path]
+        if pointer.size > max_size:
+            print(
+                f"Refusing Git LFS fallback for {pointer.path}: "
+                f"pointer size {pointer.size} exceeds cap {max_size}",
+                file=sys.stderr,
+            )
+            return 1
+        print(f"Hydrating {pointer.path} from Git LFS sha256:{pointer.sha256} size:{pointer.size}")
+        proc = subprocess.run(
+            [
+                "git",
+                *GIT_LFS_FILTER_CONFIG,
+                "lfs",
+                "pull",
+                "--include",
+                pointer.path,
+                "--exclude",
+                "",
+            ],
+            cwd=REPO_ROOT,
+            check=False,
+            env=env,
+        )
+        if proc.returncode != 0:
+            print(f"git lfs pull failed for {pointer.path}", file=sys.stderr)
+            return proc.returncode
+        try:
+            _verify_hydrated_lfs_pointer(pointer)
+        except RuntimeError as exc:
+            print(str(exc), file=sys.stderr)
+            return 1
+    return 0
+
+
+def _run_whitespace_check(base_ref: str) -> int:
+    base = _diff_base(base_ref)
+    commands = (
+        ["diff", "--check", base, "HEAD"],
+        ["diff", "--cached", "--check"],
+        ["diff", "--check"],
+    )
+    for args in commands:
+        proc = subprocess.run(["git", *args], check=False)
+        if proc.returncode != 0:
+            return proc.returncode
+    return 0
+
+
 def select_checks(
     *,
     base_ref: str,
@@ -146,7 +290,7 @@ def select_checks(
 ) -> tuple[list[Check], list[str]]:
     flags = classify_paths(files)
     checks: list[Check] = [
-        Check("whitespace", ("git", "diff", "--check")),
+        Check("whitespace", (python, __file__, "--base", base_ref, "--internal-whitespace")),
         Check("repo stats", (python, "src/update_repo_stats.py", "--check")),
     ]
     notes = [
@@ -256,6 +400,9 @@ def select_checks(
         )
 
     if flags["graph_artifact_changed"]:
+        checks.append(
+            Check("hydrate graph LFS", (python, __file__, "--internal-hydrate-graph-lfs"))
+        )
         checks.append(Check("graph artifact validation", (python, *GRAPH_VALIDATE_ARGS)))
 
     if source_required and flags["similarity_changed"]:
@@ -396,11 +543,26 @@ def main(argv: list[str] | None = None) -> int:
         action="store_true",
         help=argparse.SUPPRESS,
     )
+    parser.add_argument(
+        "--internal-hydrate-graph-lfs",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--internal-whitespace",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
     args = parser.parse_args(argv)
 
     if not shutil.which("git"):
         raise SystemExit("git is required for ci_preflight")
 
+    if args.internal_hydrate_graph_lfs:
+        return hydrate_graph_lfs_artifacts()
+    if args.internal_whitespace:
+        return _run_whitespace_check(args.base)
+
     files = changed_files(args.base)
     if args.internal_no_test_policy:
         return _run_no_test_policy_for_files(files, base_ref=args.base)

scripts/local_fast_gate.py

@@ -0,0 +1,254 @@
+"""Run PR preflight checks in isolated parallel local lanes.
+
+The regular CI preflight stays the serial source of truth. This runner is a
+fast local front door: it selects the same checks, groups independent work into
+lanes, and runs each lane in a temporary git worktree so caches, graph hydration,
+and package builds do not contend with each other.
+"""
+
+from __future__ import annotations
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import as_completed
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from scripts.ci_preflight import Check  # noqa: E402
+from scripts.ci_preflight import changed_files  # noqa: E402
+from scripts.ci_preflight import select_checks  # noqa: E402
+
+LANE_ORDER = ("cheap", "static", "unit", "docs", "graph", "feature", "package", "misc")
+CHECK_LANES = {
+    "whitespace": "cheap",
+    "repo stats": "cheap",
+    "no-test policy": "cheap",
+    "ruff format": "static",
+    "ruff": "static",
+    "mypy": "static",
+    "pip check": "static",
+    "unit-linux equivalent": "unit",
+    "A-Z canary": "unit",
+    "contract compatibility local": "unit",
+    "clean host contract": "unit",
+    "public docs tracker": "docs",
+    "docs strict build": "docs",
+    "hydrate graph LFS": "graph",
+    "graph artifact validation": "graph",
+    "telemetry enterprise": "feature",
+    "similarity precision/recall": "feature",
+    "browser monitor security": "feature",
+    "clean preflight dist": "package",
+    "build wheel": "package",
+    "twine check": "package",
+}
+
+
+@dataclass(frozen=True)
+class Lane:
+    name: str
+    checks: tuple[Check, ...]
+
+
+@dataclass(frozen=True)
+class LaneResult:
+    name: str
+    returncode: int
+    elapsed: float
+    worktree: Path | None = None
+
+
+def _lane_name(check: Check) -> str:
+    return CHECK_LANES.get(check.name, "misc")
+
+
+def group_checks(checks: list[Check]) -> list[Lane]:
+    grouped: dict[str, list[Check]] = {lane: [] for lane in LANE_ORDER}
+    for check in checks:
+        grouped[_lane_name(check)].append(_worktree_safe_check(check))
+    return [Lane(name, tuple(grouped[name])) for name in LANE_ORDER if grouped[name]]
+
+
+def _worktree_safe_check(check: Check) -> Check:
+    ci_preflight = (REPO_ROOT / "scripts" / "ci_preflight.py").resolve()
+    argv = tuple(
+        "scripts/ci_preflight.py" if _same_path_arg(arg, ci_preflight) else arg
+        for arg in check.argv
+    )
+    return Check(check.name, argv, check.env)
+
+
+def _same_path_arg(arg: str, expected: Path) -> bool:
+    try:
+        return Path(arg).resolve() == expected
+    except OSError:
+        return False
+
+
+def _git_stdout(args: list[str]) -> str:
+    return subprocess.check_output(["git", *args], cwd=REPO_ROOT, text=True)
+
+
+def _is_worktree_dirty() -> bool:
+    return bool(_git_stdout(["status", "--porcelain"]).strip())
+
+
+def _create_worktree(lane: str) -> Path:
+    parent = Path(tempfile.mkdtemp(prefix="ctx-local-fast-"))
+    worktree = parent / lane
+    env = os.environ.copy()
+    env.setdefault("GIT_LFS_SKIP_SMUDGE", "1")
+    subprocess.check_call(
+        ["git", "worktree", "add", "--detach", str(worktree), "HEAD"],
+        cwd=REPO_ROOT,
+        env=env,
+        stdout=subprocess.DEVNULL,
+    )
+    return worktree
+
+
+def _remove_worktree(worktree: Path) -> None:
+    subprocess.run(
+        ["git", "worktree", "remove", "--force", str(worktree)],
+        cwd=REPO_ROOT,
+        check=False,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    shutil.rmtree(worktree.parent, ignore_errors=True)
+
+
+def _run_check(check: Check, *, cwd: Path, index: int, total: int, lane: str) -> int:
+    print(
+        f"[{lane} {index}/{total}] {check.name}: {' '.join(check.argv)}",
+        flush=True,
+    )
+    env = os.environ.copy()
+    env.setdefault("PYTHONDONTWRITEBYTECODE", "1")
+    env.setdefault("PIP_DISABLE_PIP_VERSION_CHECK", "1")
+    env.setdefault("GIT_LFS_SKIP_SMUDGE", "1")
+    if check.env:
+        env.update(check.env)
+    proc = subprocess.run(check.argv, cwd=cwd, check=False, env=env)
+    if proc.returncode != 0:
+        print(f"[{lane} fail] {check.name} exited {proc.returncode}", file=sys.stderr)
+    return proc.returncode
+
+
+def run_lane(lane: Lane, *, keep_worktrees: bool) -> LaneResult:
+    start = time.monotonic()
+    worktree = _create_worktree(lane.name)
+    try:
+        for index, check in enumerate(lane.checks, start=1):
+            returncode = _run_check(
+                check,
+                cwd=worktree,
+                index=index,
+                total=len(lane.checks),
+                lane=lane.name,
+            )
+            if returncode != 0:
+                return LaneResult(lane.name, returncode, time.monotonic() - start, worktree)
+        return LaneResult(lane.name, 0, time.monotonic() - start, worktree)
+    finally:
+        if not keep_worktrees:
+            _remove_worktree(worktree)
+
+
+def run_lanes(
+    lanes: list[Lane],
+    *,
+    jobs: int,
+    keep_worktrees: bool = False,
+) -> int:
+    if not lanes:
+        print("No local-fast lanes selected.")
+        return 0
+    worker_count = max(1, min(jobs, len(lanes)))
+    print(f"Running {len(lanes)} local-fast lanes with {worker_count} workers.")
+    failures: list[LaneResult] = []
+    with ThreadPoolExecutor(max_workers=worker_count) as executor:
+        futures = {
+            executor.submit(run_lane, lane, keep_worktrees=keep_worktrees): lane for lane in lanes
+        }
+        for future in as_completed(futures):
+            result = future.result()
+            status = "pass" if result.returncode == 0 else "fail"
+            print(f"[{status}] {result.name} lane in {result.elapsed:.1f}s")
+            if result.returncode != 0:
+                failures.append(result)
+
+    if failures:
+        for failure in failures:
+            print(
+                f"[fail] {failure.name} lane exited {failure.returncode}",
+                file=sys.stderr,
+            )
+        return 1
+    return 0
+
+
+def print_dry_run(lanes: list[Lane]) -> None:
+    for lane in lanes:
+        print(f"[lane] {lane.name}")
+        for check in lane.checks:
+            print(f"  - {check.name}: {' '.join(check.argv)}")
+
+
+def _default_jobs() -> int:
+    cpu_count = os.cpu_count() or 2
+    return max(1, min(cpu_count, len(LANE_ORDER)))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base", default="origin/main")
+    parser.add_argument("--profile", choices=("pr", "full"), default="pr")
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--jobs", type=int, default=_default_jobs())
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--keep-worktrees", action="store_true")
+    parser.add_argument(
+        "--allow-dirty",
+        action="store_true",
+        help="allow a dirty worktree; uncommitted changes still are not run in temp worktrees",
+    )
+    args = parser.parse_args(argv)
+
+    if not shutil.which("git"):
+        raise SystemExit("git is required for local_fast_gate")
+    if not args.dry_run and not args.allow_dirty and _is_worktree_dirty():
+        raise SystemExit(
+            "local-fast runs committed HEAD in temp worktrees; commit or stash changes first "
+            "(or pass --allow-dirty if you only need a committed-HEAD gate)."
+        )
+
+    files = changed_files(args.base)
+    checks, notes = select_checks(
+        base_ref=args.base,
+        files=files,
+        profile=args.profile,
+        python=args.python,
+    )
+    lanes = group_checks(checks)
+    for note in notes:
+        print(f"[note] {note}")
+    print("[note] local-fast runs selected committed-HEAD checks in isolated temp worktrees.")
+    if args.dry_run:
+        print_dry_run(lanes)
+        return 0
+    return run_lanes(lanes, jobs=args.jobs, keep_worktrees=args.keep_worktrees)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/no_mistakes_codex_env.sh

@@ -3,8 +3,11 @@ set -euo pipefail
 
 # no-mistakes agents run in a stripped-down environment. Keep ctx validation fast
 # by exposing the verified project Python toolchain and Codex-bundled ripgrep.
-default_ctx_python_bin="/tmp/ctx-verify-venv/bin"
-ctx_python_bin="${CTX_NO_MISTAKES_PYTHON_BIN:-${default_ctx_python_bin}}"
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
+repo_root="$(cd -- "${script_dir}/.." && pwd -P)"
+pwd_ctx_python_bin="${PWD}/.venv/bin"
+repo_ctx_python_bin="${repo_root}/.venv/bin"
+fallback_ctx_python_bin="/tmp/ctx-verify-venv/bin"
 codex_resources="${CTX_NO_MISTAKES_CODEX_RESOURCES:-/Applications/Codex.app/Contents/Resources}"
 real_codex="${CTX_NO_MISTAKES_REAL_CODEX:-${codex_resources}/codex}"
 
@@ -13,19 +16,43 @@ is_trusted_python_bin() {
   local venv_dir="${bin_dir%/bin}"
 
   [[ -d "${bin_dir}" && -x "${bin_dir}/python" ]] || return 1
+  [[ -f "${venv_dir}/pyvenv.cfg" ]] || return 1
   [[ -O "${venv_dir}" && -O "${bin_dir}" ]] || return 1
   [[ -z "$(find "${venv_dir}" "${bin_dir}" -prune -perm -022 -print -quit)" ]]
 }
 
-trusted_ctx_python_bin=""
+has_validation_tools() {
+  local bin_dir="$1"
+
+  PYTHONDONTWRITEBYTECODE=1 "${bin_dir}/python" - <<'PY' >/dev/null 2>&1
+import importlib.util
+
+missing = [
+    module
+    for module in ("pytest", "ruff", "mypy")
+    if importlib.util.find_spec(module) is None
+]
+raise SystemExit(1 if missing else 0)
+PY
+}
+
+candidate_python_bins=()
 if [[ -n "${CTX_NO_MISTAKES_PYTHON_BIN:-}" ]]; then
-  trusted_ctx_python_bin="${ctx_python_bin}"
-elif is_trusted_python_bin "${ctx_python_bin}"; then
-  trusted_ctx_python_bin="${ctx_python_bin}"
+  candidate_python_bins+=("${CTX_NO_MISTAKES_PYTHON_BIN}")
 fi
+candidate_python_bins+=("${pwd_ctx_python_bin}" "${repo_ctx_python_bin}" "${fallback_ctx_python_bin}")
+
+trusted_ctx_python_bin=""
+for candidate_python_bin in "${candidate_python_bins[@]}"; do
+  if is_trusted_python_bin "${candidate_python_bin}" && has_validation_tools "${candidate_python_bin}"; then
+    trusted_ctx_python_bin="${candidate_python_bin}"
+    break
+  fi
+done
 
 if [[ -n "${trusted_ctx_python_bin}" ]]; then
   export PATH="${trusted_ctx_python_bin}:${codex_resources}:${PATH}"
+  export CTX_NO_MISTAKES_PYTHON_BIN_RESOLVED="${trusted_ctx_python_bin}"
   if [[ -x "${trusted_ctx_python_bin}/python" ]]; then
     export VIRTUAL_ENV="${VIRTUAL_ENV:-${trusted_ctx_python_bin%/bin}}"
   fi

scripts/no_mistakes_run.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
+repo_root="$(cd -- "${script_dir}/.." && pwd -P)"
+action="${1:-}"
+
+is_trusted_python_bin() {
+  local bin_dir="$1"
+  local venv_dir="${bin_dir%/bin}"
+
+  [[ -d "${bin_dir}" && -x "${bin_dir}/python" ]] || return 1
+  [[ -f "${venv_dir}/pyvenv.cfg" ]] || return 1
+  [[ -O "${venv_dir}" && -O "${bin_dir}" ]] || return 1
+  [[ -z "$(find "${venv_dir}" "${bin_dir}" -prune -perm -022 -print -quit)" ]]
+}
+
+has_validation_tools() {
+  local bin_dir="$1"
+
+  PYTHONDONTWRITEBYTECODE=1 "${bin_dir}/python" - <<'PY' >/dev/null 2>&1
+import importlib.util
+
+missing = [
+    module
+    for module in ("pytest", "ruff", "mypy")
+    if importlib.util.find_spec(module) is None
+]
+raise SystemExit(1 if missing else 0)
+PY
+}
+
+append_agent_wrapper_venv() {
+  local config_path="${HOME:-}/.no-mistakes/config.yaml"
+  local wrapper_path
+  local wrapper_root
+
+  [[ -f "${config_path}" ]] || return 0
+  wrapper_path="$(awk '/^[[:space:]]+codex:[[:space:]]/ {print $2; exit}' "${config_path}")"
+  [[ -n "${wrapper_path}" && -f "${wrapper_path}" ]] || return 0
+  wrapper_root="$(cd -- "$(dirname -- "${wrapper_path}")/.." && pwd -P)"
+  candidate_python_bins+=("${wrapper_root}/.venv/bin")
+}
+
+candidate_python_bins=()
+if [[ -n "${CTX_NO_MISTAKES_PYTHON_BIN:-}" ]]; then
+  candidate_python_bins+=("${CTX_NO_MISTAKES_PYTHON_BIN}")
+fi
+candidate_python_bins+=("${PWD}/.venv/bin" "${repo_root}/.venv/bin")
+append_agent_wrapper_venv
+candidate_python_bins+=("/tmp/ctx-verify-venv/bin")
+
+trusted_ctx_python_bin=""
+for candidate_python_bin in "${candidate_python_bins[@]}"; do
+  if is_trusted_python_bin "${candidate_python_bin}" && has_validation_tools "${candidate_python_bin}"; then
+    trusted_ctx_python_bin="${candidate_python_bin}"
+    break
+  fi
+done
+
+if [[ -z "${trusted_ctx_python_bin}" ]]; then
+  echo "No trusted ctx validation Python found with pytest, ruff, and mypy." >&2
+  exit 127
+fi
+
+export PATH="${trusted_ctx_python_bin}:${PATH}"
+export VIRTUAL_ENV="${trusted_ctx_python_bin%/bin}"
+export CTX_NO_MISTAKES_PYTHON_BIN_RESOLVED="${trusted_ctx_python_bin}"
+export PYTHONDONTWRITEBYTECODE="${PYTHONDONTWRITEBYTECODE:-1}"
+export PIP_DISABLE_PIP_VERSION_CHECK="${PIP_DISABLE_PIP_VERSION_CHECK:-1}"
+
+case "${action}" in
+  fast)
+    exec python scripts/local_fast_gate.py --profile pr "${@:2}"
+    ;;
+  test)
+    exec python scripts/ci_preflight.py --profile pr
+    ;;
+  lint)
+    python -m ruff check .
+    python -m ruff format --check src hooks scripts
+    exec python -m mypy src
+    ;;
+  format)
+    exec python -m ruff format src hooks scripts
+    ;;
+  *)
+    echo "Usage: scripts/no_mistakes_run.sh {fast|test|lint|format}" >&2
+    exit 64
+    ;;
+esac

scripts/pack_full_wiki_tar.py

@@ -13,8 +13,51 @@ from pathlib import Path, PurePosixPath
 from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack
 
 _WINDOWS_DRIVE_RE = re.compile(r"^[A-Za-z]:")
+_PATH_CHAR = r"[^`\"'<>|\s\r\n)]"
+_PATH_TOKEN = rf"{_PATH_CHAR}+"
+_PATH_TERMINAL_WORD = r"[A-Z0-9][^`\"'<>|/\\\s\r\n)]*"
+_PATH_LOWER_PROSE_WORDS = (
+    r"(?:a|an|and|are|as|at|by|for|from|in|is|of|on|or|the|to|was|were|with|without)"
+)
+_PATH_LOWER_TERMINAL_WORD = (
+    rf"(?!(?:{_PATH_LOWER_PROSE_WORDS})(?=$|[\s),.;:!?]))"
+    r"[a-z][^`\"'<>|/\\\s\r\n),.;:!?]*"
+)
+_PATH_TERMINAL_END = r"(?=$|[\r\n`\"'),.;:!?>\]])"
+_PATH_SPACED_COMPONENT = (
+    rf"(?: {_PATH_CHAR}*[\\/]{_PATH_CHAR}*| {_PATH_CHAR}*\.{_PATH_CHAR}+"
+    rf"|(?: {_PATH_TERMINAL_WORD})+"
+    rf"|(?: {_PATH_LOWER_TERMINAL_WORD}){{1,2}}{_PATH_TERMINAL_END})"
+)
+_PATH_BOUNDARY = r"(?:^|(?<=[`\"'(<\[\s=,:]))"
+_QUOTED_PATH_BOUNDARY = r"(?<=[`\"'(<\[])"
+_QUOTED_PATH_TOKEN = r"[^`\"'<>|\r\n)]+"
+_QUOTED_PATH_END = r"(?=[`\"')>\]])"
+_QUOTED_WINDOWS_USER_PATH_RE = re.compile(
+    rf"(?i){_QUOTED_PATH_BOUNDARY}[A-Z]:[\\/]+Users[\\/]+{_QUOTED_PATH_TOKEN}{_QUOTED_PATH_END}"
+)
+_QUOTED_POSIX_USER_PATH_RE = re.compile(
+    rf"{_QUOTED_PATH_BOUNDARY}(?:(?i:file:///)|/)(?:Users|home)/"
+    rf"{_QUOTED_PATH_TOKEN}{_QUOTED_PATH_END}"
+)
+_WINDOWS_USER_PATH_RE = re.compile(
+    rf"(?i)\b[A-Z]:[\\/]+Users[\\/]+{_PATH_TOKEN}(?:{_PATH_SPACED_COMPONENT})*"
+)
+_POSIX_USER_PATH_RE = re.compile(
+    rf"{_PATH_BOUNDARY}(?:(?i:file:///)|/)(?:Users|home)/{_PATH_TOKEN}"
+    rf"(?:{_PATH_SPACED_COMPONENT})*"
+)
+_POSIX_USER_PATH_PREFIX_RE = re.compile(rf"{_PATH_BOUNDARY}(?:(?i:file:///)|/)(?:Users|home)/")
 _GRAPH_MANIFEST = "graphify-out/graph-export-manifest.json"
 _REQUIRED_EXPANDED_MARKDOWN = frozenset({"graphify-out/graph-report.md"})
+_LOCAL_GENERATED_MARKDOWN = frozenset(
+    {
+        "catalog.md",
+        "converted-index.md",
+        "log.md",
+        "versions-catalog.md",
+    }
+)
 
 
 @dataclass(frozen=True)
@@ -60,7 +103,13 @@ def repack_full_wiki_tar(source: Path, target: Path | None = None) -> RepackStat
         if not export_id:
             raise ValueError(f"{source} is missing graph export id")
         if existing_pack_root.exists():
-            pages.update(load_merged_wiki_pages(existing_pack_root))
+            pages.update(
+                {
+                    name: _normalise_page_text(text)
+                    for name, text in load_merged_wiki_pages(existing_pack_root).items()
+                    if _should_pack_markdown_page(name)
+                }
+            )
 
         pack_root = tmp_root / "wiki-packs"
         write_wiki_base_pack(
@@ -112,8 +161,19 @@ def _rewrite_tar_with_pack(
                     if extracted is None:
                         raise ValueError(f"archive file is unreadable: {member.name}")
                     with extracted:
-                        member.name = name
-                        dst.addfile(member, extracted)
+                        if name.endswith(".md"):
+                            text = _normalise_page_text(
+                                extracted.read().decode("utf-8", errors="replace")
+                            )
+                            _add_text(dst, name=name, text=text)
+                        elif _should_redact_text_member(name):
+                            text = _redact_host_user_paths(
+                                extracted.read().decode("utf-8", errors="replace")
+                            )
+                            _add_text(dst, name=name, text=text)
+                        else:
+                            member.name = name
+                            dst.addfile(member, extracted)
                     written_names.add(name)
                 elif member.isdir():
                     member.name = name
@@ -122,9 +182,9 @@ def _rewrite_tar_with_pack(
                 else:
                     raise ValueError(f"unsupported archive member: {member.name}")
             for name in sorted(_REQUIRED_EXPANDED_MARKDOWN - written_names):
-                text = pages.get(name)
-                if text is not None:
-                    _add_text(dst, name=name, text=text)
+                required_text = pages.get(name)
+                if required_text is not None:
+                    _add_text(dst, name=name, text=required_text)
             for path in sorted(pack_root.rglob("*")):
                 if path.is_file():
                     dst.add(path, arcname=path.relative_to(pack_root.parent).as_posix())
@@ -175,7 +235,17 @@ def _validate_pack_payload(pack_root: Path, expected_pages: dict[str, str]) -> N
 
 
 def _normalise_page_text(text: str) -> str:
-    return text if text.strip() else "<!-- empty markdown page -->\n"
+    if not text.strip():
+        return "<!-- empty markdown page -->\n"
+    return _redact_host_user_paths(text)
+
+
+def _redact_host_user_paths(text: str) -> str:
+    redacted = _QUOTED_WINDOWS_USER_PATH_RE.sub("<host-user-path>", text)
+    redacted = _QUOTED_POSIX_USER_PATH_RE.sub("<host-user-path>", redacted)
+    redacted = _WINDOWS_USER_PATH_RE.sub("<host-user-path>", redacted)
+    redacted = _POSIX_USER_PATH_RE.sub("<host-user-path>", redacted)
+    return _POSIX_USER_PATH_PREFIX_RE.sub("<host-user-path>", redacted)
 
 
 def _safe_tar_name(raw_name: str) -> str:
@@ -212,11 +282,15 @@ def _is_high_fanout_entity_page(name: str) -> bool:
 
 
 def _should_pack_markdown_page(name: str) -> bool:
-    return name.endswith(".md") and not name.startswith("wiki-packs/")
+    return (
+        name.endswith(".md")
+        and name not in _LOCAL_GENERATED_MARKDOWN
+        and not name.startswith("wiki-packs/")
+    )
 
 
 def _should_skip_expanded_markdown_member(name: str) -> bool:
-    return (
+    return name in _LOCAL_GENERATED_MARKDOWN or (
         name.endswith(".md")
         and name not in _REQUIRED_EXPANDED_MARKDOWN
         and "/" in name
@@ -224,6 +298,14 @@ def _should_skip_expanded_markdown_member(name: str) -> bool:
     )
 
 
+def _should_redact_text_member(name: str) -> bool:
+    return (
+        name.startswith("graphify-out/")
+        and not name.startswith("graphify-out/packs/")
+        and name.endswith((".json", ".jsonl"))
+    )
+
+
 def _add_text(tf: tarfile.TarFile, *, name: str, text: str) -> None:
     payload = text.encode("utf-8")
     info = tarfile.TarInfo(name)

scripts/sync_huggingface.py

@@ -40,6 +40,8 @@ HYDRATED_ARTIFACT_MIN_BYTES = {
     Path("graph/wiki-graph-runtime.tar.gz"): 10_000_000,
     Path("graph/skills-sh-catalog.json.gz"): 1_000_000,
 }
+CARD_ONLY_DELETE_PATTERNS = ("README.md", "CHANGELOG.md", "docs/**")
+_CARD_ONLY_FILES = frozenset({Path("README.md"), Path("CHANGELOG.md")})
 GRAPH_VALIDATOR_INT_FLAGS = {
     "--min-nodes": "min_nodes",
     "--min-edges": "min_edges",
@@ -231,21 +233,35 @@ def _export_tracked_tree(repo: Path, export_dir: Path) -> None:
     repo_root = repo.resolve()
     export_root = export_dir.resolve()
     for rel in _iter_tracked_files(repo):
-        source = (repo_root / rel).resolve()
-        if source != repo_root and not source.is_relative_to(repo_root):
-            raise ValueError(f"unsafe source path: {rel}")
-        if source.is_symlink():
-            raise ValueError(f"refusing to follow symlink during HF sync: {rel}")
-        if not source.is_file():
-            continue
-        target = (export_root / rel).resolve()
-        if target != export_root and not target.is_relative_to(export_root):
-            raise ValueError(f"unsafe export path: {rel}")
-        target.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(source, target)
+        _copy_export_file(repo_root, export_root, rel)
     _copy_hydrated_artifacts(repo_root, export_root)
 
 
+def _export_card_inputs(repo: Path, export_dir: Path) -> None:
+    repo_root = repo.resolve()
+    export_root = export_dir.resolve()
+    for rel in _iter_tracked_files(repo):
+        if rel in _CARD_ONLY_FILES or (rel.parts and rel.parts[0] == "docs"):
+            _copy_export_file(repo_root, export_root, rel)
+    _patch_export_readme(export_dir)
+
+
+def _copy_export_file(repo_root: Path, export_root: Path, rel: Path) -> None:
+    raw_source = repo_root / rel
+    if raw_source.is_symlink():
+        raise ValueError(f"refusing to follow symlink during HF sync: {rel}")
+    source = raw_source.resolve()
+    if source != repo_root and not source.is_relative_to(repo_root):
+        raise ValueError(f"unsafe source path: {rel}")
+    if not source.is_file():
+        return
+    target = (export_root / rel).resolve()
+    if target != export_root and not target.is_relative_to(export_root):
+        raise ValueError(f"unsafe export path: {rel}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, target)
+
+
 def _copy_hydrated_artifacts(repo_root: Path, export_root: Path) -> None:
     """Copy required graph artifacts even when they are intentionally untracked."""
     for rel in HYDRATED_ARTIFACT_MIN_BYTES:
@@ -342,6 +358,25 @@ def _upload_readme_card(
         shutil.rmtree(workspace, ignore_errors=True)
 
 
+def _upload_card_inputs(
+    *,
+    api: Any,
+    export_dir: Path,
+    repo_id: str,
+    repo_type: str,
+    head: str,
+) -> str:
+    info = api.upload_folder(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        folder_path=str(export_dir),
+        commit_message=f"Sync ctx card {head[:7]}",
+        commit_description=f"GitHub commit: {head}",
+        delete_patterns=list(CARD_ONLY_DELETE_PATTERNS),
+    )
+    return str(getattr(info, "commit_url", info))
+
+
 def sync_to_huggingface(
     *,
     repo: Path,
@@ -379,19 +414,27 @@ def sync_card_to_huggingface(
     repo_type: str,
     token: str,
 ) -> str:
-    """Upload only the Hugging Face repo card README."""
+    """Upload only Hugging Face repo-card inputs."""
     from huggingface_hub import HfApi
 
     head = _git(repo, "rev-parse", "HEAD")
-    api = HfApi(token=token)
-    _ensure_hf_repo_exists(api=api, repo_id=repo_id, repo_type=repo_type)
-    return _upload_readme_card(
-        api=api,
-        repo=repo,
-        repo_id=repo_id,
-        repo_type=repo_type,
-        head=head,
-    )
+    _assert_repo_stats_current(repo)
+    workspace = Path(tempfile.mkdtemp(prefix="ctx-hf-card-"))
+    export_dir = workspace / "export"
+    try:
+        export_dir.mkdir()
+        _export_card_inputs(repo, export_dir)
+        api = HfApi(token=token)
+        _ensure_hf_repo_exists(api=api, repo_id=repo_id, repo_type=repo_type)
+        return _upload_card_inputs(
+            api=api,
+            export_dir=export_dir,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            head=head,
+        )
+    finally:
+        shutil.rmtree(workspace, ignore_errors=True)
 
 
 def main() -> None:
@@ -412,7 +455,7 @@ def main() -> None:
     parser.add_argument(
         "--card-only",
         action="store_true",
-        help="Only refresh README.md repo-card metadata without uploading artifacts",
+        help="Only refresh repo-card inputs without uploading artifacts",
     )
     args = parser.parse_args()
     token = os.environ.get("HF_TOKEN")

src/__init__.py

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

src/backup_config.py

@@ -41,6 +41,27 @@ ALWAYS_EXCLUDE: frozenset[str] = frozenset(
 _ALLOWED_SCOPES: frozenset[str] = frozenset({"full", "incremental", "hybrid"})
 
 
+def _validate_top_file(value: str) -> str:
+    """Validate a top-level file name from backup.top_files."""
+    value = value.strip()
+    if not value:
+        raise ValueError("top_files[] must be a non-empty filename")
+    parts = value.replace("\\", "/").split("/")
+    if any(part == ".." for part in parts):
+        raise ValueError(f"top_files[]: {value!r} contains '..' path traversal")
+    if value == ".":
+        raise ValueError("top_files[]: '.' is not a filename")
+    if value.startswith(("//", "\\\\")):
+        raise ValueError(f"top_files[]: {value!r} is a UNC path")
+    if len(value) >= 2 and value[1] == ":":
+        raise ValueError(f"top_files[]: {value!r} contains a drive letter")
+    if value.startswith(("/", "\\")):
+        raise ValueError(f"top_files[]: {value!r} is absolute")
+    if "/" in value or "\\" in value:
+        raise ValueError(f"top_files[]: {value!r} contains a path separator")
+    return value
+
+
 # ── Schema ──────────────────────────────────────────────────────────────────
 
 
@@ -81,6 +102,7 @@ class BackupConfig:
     # Phase 2 implements incremental/hybrid. Phase 1 only honours "full".
     scope: str = "full"
     max_file_bytes: int = 5 * 1024 * 1024  # 5 MB
+    # Top-level filenames under ~/.claude only; paths and traversal are rejected.
     top_files: tuple[str, ...] = (
         "settings.json",
         "skill-manifest.json",
@@ -115,11 +137,10 @@ class BackupConfig:
             raise ValueError(f"retention.keep_daily must be >= 0, got {self.retention.keep_daily}")
         if "{timestamp}" not in self.name_format:
             raise ValueError(f"name_format must contain '{{timestamp}}', got {self.name_format!r}")
+        validated_top = tuple(_validate_top_file(str(name)) for name in self.top_files)
         # Silently drop ALWAYS_EXCLUDE names from top_files. frozen
         # dataclass requires object.__setattr__ for the rewrite.
-        filtered_top = tuple(
-            name for name in self.top_files if Path(name).name not in ALWAYS_EXCLUDE
-        )
+        filtered_top = tuple(name for name in validated_top if name not in ALWAYS_EXCLUDE)
         if filtered_top != self.top_files:
             object.__setattr__(self, "top_files", filtered_top)
 
@@ -198,6 +219,41 @@ def _coerce_trees(raw: Any, default: tuple[BackupTree, ...]) -> tuple[BackupTree
     return tuple(out)
 
 
+def _coerce_user_top_files(raw: Any) -> tuple[str, ...] | None:
+    if raw is None:
+        return None
+    if not isinstance(raw, list):
+        _warn_ignored_config("top_files override must be a list")
+        return None
+    out: list[str] = []
+    for entry in raw:
+        try:
+            out.append(_validate_top_file(str(entry)))
+        except ValueError as exc:
+            _warn_ignored_config(f"ignoring top_files entry: {exc}")
+    return tuple(out)
+
+
+def _sanitize_user_override(raw: dict[str, Any]) -> dict[str, Any]:
+    sanitized = dict(raw)
+    if "top_files" in sanitized:
+        raw_top_files = sanitized["top_files"]
+        top_files = _coerce_user_top_files(raw_top_files)
+        if top_files is None:
+            sanitized.pop("top_files", None)
+        elif not top_files and raw_top_files:
+            sanitized.pop("top_files", None)
+        else:
+            sanitized["top_files"] = list(top_files)
+    return sanitized
+
+
+def _warn_ignored_config(message: str) -> None:
+    import sys as _sys
+
+    print(f"[backup-config] {message}", file=_sys.stderr)
+
+
 def _coerce_retention(raw: Any) -> BackupRetention:
     if not isinstance(raw, dict):
         return BackupRetention()
@@ -266,14 +322,14 @@ def from_ctx_config() -> BackupConfig:
     except Exception:
         base_raw = {}
 
-    merged: dict[str, Any] = dict(base_raw) if isinstance(base_raw, dict) else {}
+    merged: dict[str, Any] = _sanitize_user_override(base_raw) if isinstance(base_raw, dict) else {}
 
     user_override = Path(os.path.expanduser("~/.claude/backup-config.json"))
     if user_override.is_file():
         try:
             user_raw = json.loads(user_override.read_text(encoding="utf-8"))
             if isinstance(user_raw, dict):
-                _deep_merge(merged, user_raw)
+                _deep_merge(merged, _sanitize_user_override(user_raw))
         except (OSError, json.JSONDecodeError):
             pass
 

src/backup_mirror.py

@@ -33,8 +33,9 @@ Commands:
         Restore the snapshot over the live tree. Without --dry-run this
         overwrites live files; with --dry-run it prints what would change.
 
-    python src/backup_mirror.py prune --keep <N>
-        Delete all but the N newest snapshots. Legacy mode.
+    python src/backup_mirror.py prune --keep <N> [--dry-run]
+        Delete all but the N newest snapshots. Legacy mode. With
+        ``--dry-run`` it prints what would be removed without deleting.
 
     python src/backup_mirror.py prune --policy [--dry-run] [--json]
         Apply the configured retention policy (keep_latest + keep_daily).
@@ -645,27 +646,47 @@ def _delete_snapshot_dirs(
     backups_dir) or any path that fails the containment check.
     """
     removed: list[str] = []
-    for snap in snaps_to_remove:
+    for snap in _safe_prune_snapshots(snaps_to_remove, backups_dir):
         snap_path = Path(snap.path)
-        if snap_path.is_symlink() or not _contained(snap_path, backups_dir):
-            continue
         shutil.rmtree(snap_path, ignore_errors=True)
         removed.append(snap.snapshot_id)
     return removed
 
 
-def prune_snapshots(keep: int, backups_dir: Path | None = None) -> tuple[str, ...]:
+def _safe_prune_snapshots(
+    snaps_to_remove: Iterable[SnapshotInfo],
+    backups_dir: Path,
+) -> list[SnapshotInfo]:
+    safe: list[SnapshotInfo] = []
+    for snap in snaps_to_remove:
+        snap_path = Path(snap.path)
+        if snap_path.is_symlink() or not _contained(snap_path, backups_dir):
+            continue
+        safe.append(snap)
+    return safe
+
+
+def prune_snapshots(
+    keep: int,
+    backups_dir: Path | None = None,
+    *,
+    dry_run: bool = False,
+) -> tuple[str, ...]:
     """Legacy prune: keep only the ``keep`` newest snapshots.
 
     Retained for backward compatibility. New callers should prefer
     :func:`prune_by_policy`, which honours both ``keep_latest`` and
-    ``keep_daily`` from the active :class:`BackupRetention`.
+    ``keep_daily`` from the active :class:`BackupRetention`. When
+    ``dry_run`` is true, return the snapshot IDs that would be removed without
+    deleting their directories.
     """
     if keep < 0:
         raise ValueError(f"keep must be >= 0, got {keep}")
     backups_dir = backups_dir if backups_dir is not None else BACKUPS_DIR
     snaps = list_snapshots(backups_dir)
     to_remove = snaps[keep:]
+    if dry_run:
+        return tuple(s.snapshot_id for s in _safe_prune_snapshots(to_remove, backups_dir))
     return tuple(_delete_snapshot_dirs(to_remove, backups_dir))
 
 
@@ -702,11 +723,18 @@ def prune_by_policy(
     snaps = list_snapshots(backups_dir)
     plan = plan_prune(snaps, policy, now=now)
 
-    if dry_run:
-        return plan
-
     by_id = {s.snapshot_id: s for s in snaps}
     to_remove = [by_id[i] for i in plan.delete if i in by_id]
+    if dry_run:
+        safe_delete = {snap.snapshot_id for snap in _safe_prune_snapshots(to_remove, backups_dir)}
+        pruned_delete = tuple(i for i in plan.delete if i in safe_delete)
+        return RetentionPlan(
+            keep=plan.keep,
+            delete=pruned_delete,
+            protected_by_latest=plan.protected_by_latest,
+            protected_by_daily=plan.protected_by_daily,
+        )
+
     removed = _delete_snapshot_dirs(to_remove, backups_dir)
     # Any snapshot in plan.delete that we refused to touch (symlink or
     # containment failure) stays on disk — surface that honestly by
@@ -916,10 +944,11 @@ def cmd_prune(args: argparse.Namespace) -> int:
     if args.keep is None:
         print("prune requires either --policy or --keep N", file=sys.stderr)
         return 2
-    removed = prune_snapshots(args.keep)
+    removed = prune_snapshots(args.keep, dry_run=args.dry_run)
     for r in removed:
-        print(f"removed {r}")
-    print(f"kept {args.keep} newest snapshot(s); removed {len(removed)}.")
+        print(f"{'would remove' if args.dry_run else 'removed'} {r}")
+    action = "would remove" if args.dry_run else "removed"
+    print(f"kept {args.keep} newest snapshot(s); {action} {len(removed)}.")
     return 0
 
 

src/ctx/__init__.py

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

src/ctx/adapters/claude_code/install/mcp_install.py

@@ -446,12 +446,13 @@ def install_mcp(
         install_cmd = _safe_manifest_command(fm.get("install_cmd"))
         if install_cmd:
             skipped_extra["command"] = install_cmd
-        record_install(
-            slug,
-            entity_type="mcp-server",
-            source="ctx-mcp-install",
-            extra=skipped_extra,
-        )
+        if not dry_run:
+            record_install(
+                slug,
+                entity_type="mcp-server",
+                source="ctx-mcp-install",
+                extra=skipped_extra,
+            )
         return InstallResult(
             slug=slug,
             status="skipped-existing",

src/ctx/adapters/generic/tools/mcp_router.py

@@ -47,7 +47,7 @@ import threading
 import time
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Any, Iterator
+from typing import Any, Iterable, Iterator
 
 from ctx.adapters.generic.providers.base import ToolDefinition
 from ctx.telemetry import (
@@ -57,6 +57,7 @@ from ctx.telemetry import (
     telemetry_span,
     traceparent_from_span,
 )
+from ctx.utils._secret_scan import find_inline_secret_arg, secret_key_like
 
 _logger = logging.getLogger(__name__)
 
@@ -88,13 +89,18 @@ _ENV_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 _RESERVED_SERVER_NAMES = frozenset({"ctx"})
 _SENSITIVE_ASSIGNMENT_RE = re.compile(
     r"(?i)\b([A-Z0-9_-]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|"
-    r"CREDENTIAL|AUTHORIZATION)[A-Z0-9_-]*)\s*([:=])\s*([^\s]+)"
+    r"PASSWD|PRIVATE[_-]?KEY|CREDENTIAL|ACCESS[_-]?KEY|"
+    r"CLIENT[_-]?SECRET|AUTHORIZATION|BEARER)[A-Z0-9_-]*)\s*([:=])\s*([^\s]+)"
 )
 _BEARER_RE = re.compile(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]{8,}")
 _TOKEN_VALUE_RE = re.compile(
     r"\b(?:ghp|gho|ghu|ghs|ghr|github_pat|hf|sk|xox[baprs])"
     r"[_-]?[A-Za-z0-9_./+=-]{8,}\b"
 )
+_ENV_PLACEHOLDER_RE = re.compile(
+    r"\$(?:\{(?P<braced>[A-Za-z_][A-Za-z0-9_]*)\}|(?P<bare>[A-Za-z_][A-Za-z0-9_]*))"
+)
+_MIN_LITERAL_SECRET_LENGTH = 4
 
 
 def _duration_ms(started: float) -> float:
@@ -187,14 +193,25 @@ def _validate_env_name(name: str) -> None:
         raise ValueError(f"invalid MCP credential env var name: {name!r}")
 
 
-def _redact_sensitive_text(text: str) -> str:
+def _redact_sensitive_text(text: str, literal_values: Iterable[str] = ()) -> str:
     """Remove likely credential values from diagnostics before retention."""
     text = _BEARER_RE.sub("Bearer [REDACTED]", text)
     text = _SENSITIVE_ASSIGNMENT_RE.sub(
         lambda match: f"{match.group(1)}{match.group(2)}[REDACTED]",
         text,
     )
-    return _TOKEN_VALUE_RE.sub("[REDACTED]", text)
+    text = _TOKEN_VALUE_RE.sub("[REDACTED]", text)
+    for value in sorted(
+        {
+            value
+            for value in literal_values
+            if len(value) >= _MIN_LITERAL_SECRET_LENGTH and "[REDACTED]" not in value
+        },
+        key=len,
+        reverse=True,
+    ):
+        text = text.replace(value, "[REDACTED]")
+    return text
 
 
 def _child_env_for_config(config: "McpServerConfig") -> dict[str, str]:
@@ -206,6 +223,65 @@ def _child_env_for_config(config: "McpServerConfig") -> dict[str, str]:
     return env
 
 
+def _stderr_redaction_values(config: "McpServerConfig", env: dict[str, str]) -> tuple[str, ...]:
+    credential_keys = {key.upper() for key in config.credential_env}
+    values = []
+    for key, value in env.items():
+        if key.upper() in credential_keys or secret_key_like(key):
+            values.append(value)
+    return tuple(dict.fromkeys(values))
+
+
+def _env_placeholder_names(value: str) -> tuple[str, ...]:
+    names: list[str] = []
+    for match in _ENV_PLACEHOLDER_RE.finditer(value):
+        name = match.group("braced") or match.group("bare")
+        if name is not None:
+            names.append(name)
+    return tuple(names)
+
+
+def _is_sensitive_env_reference(config: "McpServerConfig", name: str) -> bool:
+    credential_keys = {key.upper() for key in config.credential_env}
+    return name.upper() in credential_keys or secret_key_like(name)
+
+
+def _expand_env_placeholders(value: str, env: dict[str, str]) -> str:
+    def replace_match(match: re.Match[str]) -> str:
+        name = match.group("braced") or match.group("bare")
+        if name is None:
+            return match.group(0)
+        return env.get(name, match.group(0))
+
+    return _ENV_PLACEHOLDER_RE.sub(replace_match, value)
+
+
+def _expand_config_args(config: "McpServerConfig", env: dict[str, str]) -> tuple[str, ...]:
+    if not config.expand_argv_env:
+        return config.args
+    if not config.allow_argv_secret_expansion:
+        for arg in config.args:
+            for name in _env_placeholder_names(arg):
+                if name in env and _is_sensitive_env_reference(config, name):
+                    raise ValueError(
+                        f"MCP server {config.name!r} argv references sensitive env var "
+                        f"{name!r}; pass secrets through the child environment or set "
+                        "allow_argv_secret_expansion=True only for trusted local servers"
+                    )
+    expanded = tuple(_expand_env_placeholders(arg, env) for arg in config.args)
+    if not config.allow_argv_secret_expansion:
+        secret_arg = find_inline_secret_arg(list(expanded))
+        bearer_arg = next((arg for arg in expanded if _BEARER_RE.search(arg)), None)
+        if secret_arg is not None or bearer_arg is not None:
+            marker = secret_arg if secret_arg is not None else "Bearer"
+            raise ValueError(
+                f"MCP server {config.name!r} argv expands an env var into secret-looking "
+                f"argument {marker!r}; pass secrets through the child environment or set "
+                "allow_argv_secret_expansion=True only for trusted local servers"
+            )
+    return expanded
+
+
 def _popen_process_group_kwargs() -> dict[str, Any]:
     if os.name == "nt":
         return {"creationflags": getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)}
@@ -282,6 +358,12 @@ class McpServerConfig:
     so there is no shell interpolation — a server config cannot inject
     shell metacharacters into the spawn call.
 
+    ``args`` are literal by default. Set ``expand_argv_env=True`` to expand
+    ``$ENVVAR`` or ``${ENVVAR}`` placeholders from the final child environment
+    immediately before spawn. Sensitive env vars are not expanded into argv
+    unless ``allow_argv_secret_expansion`` is explicitly enabled for a trusted
+    local server.
+
     ``env`` is the explicit child overlay. Parent secrets are not
     inherited by default; only a small process-basics allowlist
     (PATH, temp/home, locale, Windows runtime vars) is passed through.
@@ -299,6 +381,8 @@ class McpServerConfig:
     startup_timeout: float = 10.0
     request_timeout: float = 30.0
     inherit_env: bool = False
+    allow_argv_secret_expansion: bool = False
+    expand_argv_env: bool = False
 
     def __post_init__(self) -> None:
         _validate_server_name(self.name)
@@ -337,6 +421,7 @@ class McpClient:
         # thread so a chatty server doesn't block the pipe.
         self._stderr_lines: list[str] = []
         self._stderr_thread: threading.Thread | None = None
+        self._stderr_redaction_values: tuple[str, ...] = ()
 
     # ── lifecycle ──────────────────────────────────────────────────────────
 
@@ -347,11 +432,13 @@ class McpClient:
 
         self._stdout_frames = queue.Queue()
         env = _child_env_for_config(self._config)
+        self._stderr_redaction_values = _stderr_redaction_values(self._config, env)
 
         command = _resolve_executable(self._config.command, env)
+        args = _expand_config_args(self._config, env)
         try:
             self._proc = subprocess.Popen(
-                [command, *self._config.args],
+                [command, *args],
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
@@ -360,6 +447,7 @@ class McpClient:
                 **_popen_process_group_kwargs(),
             )
         except OSError as exc:
+            self._stderr_redaction_values = ()
             raise McpServerError(
                 f"{self._config.name}: failed to start MCP command {self._config.command!r}: {exc}"
             ) from exc
@@ -367,7 +455,11 @@ class McpClient:
 
         # Drain stderr in the background so a verbose server can't fill
         # the OS pipe buffer and deadlock us.
-        self._stderr_thread = threading.Thread(target=self._drain_stderr, daemon=True)
+        self._stderr_thread = threading.Thread(
+            target=self._drain_stderr,
+            args=(self._stderr_redaction_values,),
+            daemon=True,
+        )
         self._stderr_thread.start()
         self._stdout_thread = threading.Thread(target=self._drain_stdout, daemon=True)
         self._stdout_thread.start()
@@ -395,6 +487,7 @@ class McpClient:
         proc = self._proc
         self._proc = None
         if proc is None:
+            self._stderr_redaction_values = ()
             return
         try:
             # Close stdin to signal the server to exit cleanly.
@@ -424,6 +517,7 @@ class McpClient:
                 thread.join(timeout=0.2)
         self._stdout_thread = None
         self._stderr_thread = None
+        self._stderr_redaction_values = ()
 
     def __enter__(self) -> "McpClient":
         self.start()
@@ -649,7 +743,7 @@ class McpClient:
         finally:
             self._stdout_frames.put(None)
 
-    def _drain_stderr(self) -> None:
+    def _drain_stderr(self, redaction_values: tuple[str, ...]) -> None:
         """Consume stderr in the background; keep the last ~200 lines."""
         proc = self._proc
         if proc is None or proc.stderr is None:
@@ -659,7 +753,7 @@ class McpClient:
                 line = raw.decode("utf-8", errors="replace").rstrip()
                 if not line:
                     continue
-                self._stderr_lines.append(_redact_sensitive_text(line))
+                self._stderr_lines.append(_redact_sensitive_text(line, redaction_values))
                 # Cap memory usage on a chatty server.
                 if len(self._stderr_lines) > 200:
                     del self._stderr_lines[:-200]

src/ctx/cli/run.py

@@ -55,6 +55,7 @@ from ctx.adapters.generic.state import (
 )
 from ctx.adapters.generic.tools import McpRouter, McpServerConfig
 from ctx.telemetry import record_event, record_exception, telemetry_span
+from ctx.utils._secret_scan import find_inline_secret_arg
 
 
 _logger = logging.getLogger(__name__)
@@ -253,7 +254,9 @@ def _parse_mcp_spec(spec: str) -> McpServerConfig:
       name:<shell-invocation>
         Example: filesystem:npx -y @modelcontextprotocol/server-filesystem /data
         The part before the colon is the name; the part after is the
-        command + args (split on whitespace, no shell).
+        command + args (split on whitespace, no shell). Secret-looking
+        inline args are rejected; pass credentials through the child
+        environment with --mcp-env.
 
       name (bare)
         Names that match a known preset get a default invocation.
@@ -279,6 +282,13 @@ def _parse_mcp_spec(spec: str) -> McpServerConfig:
             raise SystemExit(f"malformed --mcp spec: {spec!r}: {exc}") from exc
         if not parts:
             raise SystemExit(f"malformed --mcp spec: {spec!r}")
+        secret_arg = find_inline_secret_arg(parts)
+        if secret_arg is not None:
+            raise SystemExit(
+                f"--mcp inline command for server {name!r} contains secret-looking "
+                f"argv {secret_arg!r}; use --mcp-env {name}:ENVVAR and configure "
+                "the server to read that environment variable instead"
+            )
         if name == "filesystem" and len(parts) == 1:
             filesystem_preset = _MCP_PRESETS["filesystem"]
             return McpServerConfig(
@@ -760,7 +770,8 @@ def _build_parser() -> argparse.ArgumentParser:
         metavar="NAME[:COMMAND]",
         help=(
             "Attach an MCP server. Repeatable. Forms: "
-            "'filesystem' (preset) or 'name:npx -y ...' (explicit)."
+            "'filesystem' (preset) or 'name:npx -y ...' (explicit; "
+            "secret-looking argv rejected)."
         ),
     )
     r.add_argument(

src/ctx/core/wiki/wiki_queue_worker.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import socket
 import subprocess
@@ -21,7 +22,12 @@ from ctx.core.graph.graph_packs import (
 )
 from ctx.core.graph.graph_store import ensure_graph_store
 from ctx.core.graph.incremental_attach import attach_entity
-from ctx.core.wiki.artifact_promotion import promote_staged_artifact
+from ctx.core.wiki.artifact_promotion import (
+    ArtifactValidator,
+    promote_staged_artifact,
+    validate_gzip_json_artifact,
+    validate_json_artifact,
+)
 from ctx.core.wiki import wiki_queue
 from ctx.core.wiki.pack_compaction import (
     compact_active_pack_sets,
@@ -41,6 +47,30 @@ _ENTITY_SUBJECT_TYPES = {
 }
 _DEFAULT_ATTACH_MIN_FINAL_WEIGHT = 0.03
 _VECTOR_INDEX_META_NAME = "vector-index.meta.json"
+_WIKI_GRAPH_PROMOTION_TARGET_NAMES = frozenset(
+    {
+        "communities.json",
+        "graph-delta.json",
+        "graph-export-manifest.json",
+        "graph-report.md",
+        "graph.json",
+    }
+)
+_REPO_GRAPH_PROMOTION_TARGET_NAMES = frozenset(
+    {
+        "communities.json",
+        "dedup-report.json",
+        "dedup-report.md",
+        "entity-overlays.jsonl",
+        "skills-sh-catalog.json.gz",
+        "skillspector-audit.jsonl.gz",
+        "tag-backfill.json",
+        "tag-backfill.md",
+        "wiki-graph-runtime.tar.gz",
+        "wiki-graph-stats.json",
+        "wiki-graph.tar.gz",
+    }
+)
 MaintenanceHandler = Callable[[Path, dict[str, Any]], str]
 
 
@@ -556,21 +586,266 @@ def _handle_tar_refresh(_wiki_path: Path, payload: dict[str, Any]) -> str:
     return "tar refresh completed"
 
 
-def _handle_artifact_promotion(_wiki_path: Path, payload: dict[str, Any]) -> str:
-    staged = Path(_required_payload_string(payload, "staged_path"))
-    target = Path(_required_payload_string(payload, "target_path"))
+def _handle_artifact_promotion(wiki_path: Path, payload: dict[str, Any]) -> str:
+    staged, target = _resolve_artifact_promotion_paths(
+        wiki_path,
+        _required_payload_string(payload, "staged_path"),
+        _required_payload_string(payload, "target_path"),
+    )
     validator = payload.get("validator")
-    validate = None
-    if validator == "wiki-tar":
-        from import_skills_sh_catalog import _validate_wiki_tarball_candidate  # noqa: PLC0415
-
-        validate = _validate_wiki_tarball_candidate
-    elif validator not in (None, "", "none"):
+    if validator not in (None, "", "none", "wiki-tar"):
         raise ValueError(f"unsupported artifact validator: {validator}")
+    validate = _artifact_validator_for_target(target)
     result = promote_staged_artifact(staged, target, validate=validate)
     return f"promoted artifact to {result.target}"
 
 
+def _artifact_validator_for_target(target: Path) -> ArtifactValidator | None:
+    name = target.name
+    if name == "wiki-graph.tar.gz":
+        from import_skills_sh_catalog import _validate_wiki_tarball_candidate  # noqa: PLC0415
+
+        return _validate_wiki_tarball_candidate
+    if name == "wiki-graph-runtime.tar.gz":
+        return _validate_runtime_graph_tar_gz_artifact
+    if name.endswith(".jsonl.gz"):
+        return _validate_gzip_jsonl_artifact
+    if name.endswith(".json.gz"):
+        return validate_gzip_json_artifact
+    if name.endswith(".jsonl"):
+        return _validate_jsonl_artifact
+    if name == "graph.json":
+        return _validate_graph_json_artifact
+    if name == "graph-delta.json":
+        return _validate_graph_delta_json_artifact
+    if name == "communities.json":
+        return _validate_communities_json_artifact
+    if name == "graph-export-manifest.json":
+        return _validate_graph_export_manifest_artifact
+    if name.endswith(".json"):
+        return validate_json_artifact
+    return None
+
+
+def _validate_tar_gz_artifact(path: Path) -> None:
+    import tarfile
+
+    try:
+        with tarfile.open(path, "r:gz"):
+            pass
+    except tarfile.TarError as exc:
+        raise ValueError(f"invalid tar.gz artifact: {path}") from exc
+
+
+def _validate_runtime_graph_tar_gz_artifact(path: Path) -> None:
+    import tarfile
+
+    from validate_graph_artifacts import (  # noqa: PLC0415
+        GraphArtifactError,
+        validate_runtime_graph_archive,
+    )
+
+    _validate_tar_gz_artifact(path)
+    try:
+        validate_runtime_graph_archive(path)
+    except (GraphArtifactError, OSError, tarfile.TarError) as exc:
+        raise ValueError(f"invalid runtime graph artifact: {path}: {exc}") from exc
+
+
+def _validate_jsonl_artifact(path: Path) -> None:
+    try:
+        with path.open("rt", encoding="utf-8") as fh:
+            for line in fh:
+                if line.strip():
+                    json.loads(line)
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"invalid JSONL artifact: {path}") from exc
+
+
+def _validate_gzip_jsonl_artifact(path: Path) -> None:
+    import gzip
+
+    try:
+        with gzip.open(path, "rt", encoding="utf-8") as fh:
+            for line in fh:
+                if line.strip():
+                    json.loads(line)
+    except (OSError, EOFError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"invalid gzip JSONL artifact: {path}") from exc
+
+
+def _read_json_object_artifact(path: Path) -> dict[str, Any]:
+    try:
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"invalid JSON artifact: {path}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"invalid JSON artifact: {path} must contain an object")
+    return data
+
+
+def _validate_graph_json_artifact(path: Path) -> None:
+    data = _read_json_object_artifact(path)
+    if not isinstance(data.get("nodes"), list):
+        raise ValueError(f"invalid graph.json artifact: {path} missing nodes list")
+    if not isinstance(data.get("edges"), list):
+        raise ValueError(f"invalid graph.json artifact: {path} missing edges list")
+    if not isinstance(data.get("graph"), dict):
+        raise ValueError(f"invalid graph.json artifact: {path} missing graph object")
+
+
+def _validate_graph_delta_json_artifact(path: Path) -> None:
+    data = _read_json_object_artifact(path)
+    if data.get("version") != 1:
+        raise ValueError(f"invalid graph-delta.json artifact: {path} version must be 1")
+    if not isinstance(data.get("full_rebuild"), bool):
+        raise ValueError(f"invalid graph-delta.json artifact: {path} missing full_rebuild bool")
+    if not isinstance(data.get("export_id"), str) or not data["export_id"].strip():
+        raise ValueError(f"invalid graph-delta.json artifact: {path} missing export_id")
+    if data["full_rebuild"]:
+        for key in ("node_count", "edge_count"):
+            if isinstance(data.get(key), bool) or not isinstance(data.get(key), int):
+                raise ValueError(f"invalid graph-delta.json artifact: {path} missing {key} int")
+    else:
+        if not isinstance(data.get("nodes"), list):
+            raise ValueError(f"invalid graph-delta.json artifact: {path} missing nodes list")
+        if not isinstance(data.get("edges"), list):
+            raise ValueError(f"invalid graph-delta.json artifact: {path} missing edges list")
+
+
+def _validate_communities_json_artifact(path: Path) -> None:
+    data = _read_json_object_artifact(path)
+    if not isinstance(data.get("export_id"), str) or not data["export_id"].strip():
+        raise ValueError(f"invalid communities.json artifact: {path} missing export_id")
+    if not isinstance(data.get("communities"), dict):
+        raise ValueError(f"invalid communities.json artifact: {path} missing communities object")
+    if isinstance(data.get("total_communities"), bool) or not isinstance(
+        data.get("total_communities"), int
+    ):
+        raise ValueError(f"invalid communities.json artifact: {path} missing total_communities int")
+
+
+def _validate_graph_export_manifest_artifact(path: Path) -> None:
+    data = _read_json_object_artifact(path)
+    if data.get("version") != 1:
+        raise ValueError(f"invalid graph-export-manifest artifact: {path} version must be 1")
+    if not isinstance(data.get("export_id"), str) or not data["export_id"].strip():
+        raise ValueError(f"invalid graph-export-manifest artifact: {path} missing export_id")
+    artifacts = data.get("artifacts")
+    if not isinstance(artifacts, dict):
+        raise ValueError(f"invalid graph-export-manifest artifact: {path} missing artifacts object")
+    expected_artifacts = {
+        "delta": "graph-delta.json",
+        "communities": "communities.json",
+        "report": "graph-report.md",
+    }
+    if set(artifacts) != {"graph", *expected_artifacts}:
+        raise ValueError(f"invalid graph-export-manifest artifact: {path} invalid artifacts map")
+    if artifacts.get("graph") not in {"graph.json", "packs"}:
+        raise ValueError(f"invalid graph-export-manifest artifact: {path} invalid graph artifact")
+    for key, expected in expected_artifacts.items():
+        if artifacts.get(key) != expected:
+            raise ValueError(
+                f"invalid graph-export-manifest artifact: {path} invalid artifacts map"
+            )
+    counts = data.get("counts")
+    if not isinstance(counts, dict):
+        raise ValueError(f"invalid graph-export-manifest artifact: {path} missing counts object")
+    for key in ("nodes", "edges", "communities"):
+        if isinstance(counts.get(key), bool) or not isinstance(counts.get(key), int):
+            raise ValueError(f"invalid graph-export-manifest artifact: {path} missing {key} count")
+
+
+def _resolve_artifact_promotion_paths(
+    wiki_path: Path,
+    raw_staged_path: str,
+    raw_target_path: str,
+) -> tuple[Path, Path]:
+    wiki_root = Path(wiki_path).expanduser().resolve()
+    repo_root = _source_root()
+    target = _resolve_artifact_target_path(raw_target_path, wiki_root, repo_root)
+    staged = _resolve_staged_artifact_path(raw_staged_path, target, wiki_root, repo_root)
+    expected_staged = target.with_name(f"{target.name}.staged")
+    if staged != expected_staged:
+        raise ValueError(
+            f"artifact promotion staged_path must be the target sibling {expected_staged}"
+        )
+    reject_symlink_path(staged)
+    reject_symlink_path(target)
+    return staged, target
+
+
+def _resolve_artifact_target_path(
+    raw_target_path: str,
+    wiki_root: Path,
+    repo_root: Path | None,
+) -> Path:
+    bases = (wiki_root,) if repo_root is None else (wiki_root, repo_root)
+    for base in bases:
+        target = _resolve_payload_path(raw_target_path, base)
+        if _is_allowed_artifact_target(target, wiki_root, repo_root):
+            return target
+    target = _resolve_payload_path(raw_target_path, wiki_root)
+    raise ValueError(f"artifact promotion target_path is not an allowed artifact target: {target}")
+
+
+def _resolve_staged_artifact_path(
+    raw_staged_path: str,
+    target: Path,
+    wiki_root: Path,
+    repo_root: Path | None,
+) -> Path:
+    path = Path(raw_staged_path).expanduser()
+    if path.is_absolute():
+        return path.resolve()
+    expected_staged = target.with_name(f"{target.name}.staged")
+    bases = (
+        (target.parent, wiki_root) if repo_root is None else (target.parent, wiki_root, repo_root)
+    )
+    for base in bases:
+        staged = (base / path).resolve()
+        if staged == expected_staged:
+            return staged
+    return (wiki_root / path).resolve()
+
+
+def _resolve_payload_path(raw_path: str, base: Path) -> Path:
+    path = Path(raw_path).expanduser()
+    if path.is_absolute():
+        return path.resolve()
+    return (base / path).resolve()
+
+
+def _is_allowed_artifact_target(target: Path, wiki_root: Path, repo_root: Path | None) -> bool:
+    if target.parent == wiki_root / "graphify-out":
+        return target.name in _WIKI_GRAPH_PROMOTION_TARGET_NAMES
+    if repo_root is not None and target.parent == repo_root / "graph":
+        return target.name in _REPO_GRAPH_PROMOTION_TARGET_NAMES
+    return False
+
+
+def _source_root() -> Path | None:
+    source = Path(__file__).resolve()
+    for parent in source.parents:
+        if _is_ctx_source_root(parent, source):
+            return parent
+    return None
+
+
+def _is_ctx_source_root(parent: Path, source: Path) -> bool:
+    pyproject = parent / "pyproject.toml"
+    repo_source = parent / "src" / "ctx" / "core" / "wiki" / "wiki_queue_worker.py"
+    if not pyproject.is_file() or not repo_source.is_file():
+        return False
+    try:
+        return (
+            'name = "claude-ctx"' in pyproject.read_text(encoding="utf-8")
+            and repo_source.resolve() == source
+        )
+    except OSError:
+        return False
+
+
 def _handle_pack_compaction(wiki_path: Path, payload: dict[str, Any]) -> str:
     threshold = _optional_payload_int(
         payload,

src/ctx/dashboard_entities.py

@@ -24,6 +24,7 @@ class EntityCrudDeps:
     wiki_entity_target_path: Callable[[str, str], Path]
     wiki_entity_path: Callable[[str, str | None], Path | None]
     iter_wiki_entity_paths: Callable[[str | None], list[tuple[str, str, Path]]]
+    wiki_relative_path: Callable[[Path], str | None]
     read_manifest: Callable[[], dict[str, Any]]
     perform_unload: Callable[[str, str], tuple[bool, str]]
     queue_entity_refresh: Callable[[str, str, Path, str, str], None]
@@ -270,12 +271,14 @@ def search_wiki_entities(
         if isinstance(detail, dict):
             frontmatter = detail.get("frontmatter")
             body = str(detail.get("body") or "")[:4096]
+            relpath = str(detail.get("path") or "")
         else:
             try:
                 head = path.read_text(encoding="utf-8", errors="replace")[:4096]
             except OSError:
                 continue
             frontmatter, body = deps.parse_frontmatter(head)
+            relpath = deps.wiki_relative_path(path) or ""
         if not isinstance(frontmatter, dict):
             frontmatter = {}
         tags = deps.frontmatter_tags(frontmatter.get("tags", ""))
@@ -297,7 +300,7 @@ def search_wiki_entities(
                 "title": title,
                 "description": description,
                 "tags": tags[:12],
-                "path": str(path),
+                "path": relpath,
                 "href": deps.entity_wiki_href(slug, current_type),
             }
         )

src/ctx/monitor/compat.py

@@ -237,6 +237,7 @@ _iter_wiki_entity_paths = _wiki_call(_wiki_service.iter_entity_paths)
 _wiki_entity_detail = _wiki_call(_wiki_service.entity_detail)
 _wiki_pack_entity_from_relpath = _wiki_service.pack_entity_from_relpath
 _read_wiki_entity_text = _wiki_call(_wiki_service.read_entity_text)
+_wiki_relative_path = _wiki_call(_wiki_service.wiki_relative_path)
 
 
 def _search_wiki_entities(
@@ -311,6 +312,7 @@ def _entity_crud_deps() -> dashboard_entities.EntityCrudDeps:
         wiki_entity_target_path=_wiki_entity_target_path,
         wiki_entity_path=_wiki_entity_path,
         iter_wiki_entity_paths=_iter_wiki_entity_paths,
+        wiki_relative_path=_wiki_relative_path,
         read_manifest=_read_manifest,
         perform_unload=_perform_unload,
         queue_entity_refresh=lambda entity_type, slug, entity_path, content, action: (

src/ctx/monitor/services/wiki.py

@@ -214,7 +214,7 @@ def entity_detail(
     return {
         "slug": slug,
         "type": detected_type,
-        "path": str(path),
+        "path": wiki_relative_path(wiki_dir, path) or "",
         "frontmatter": frontmatter,
         "body": body,
     }