Add files using upload-large-folder tool

src/__init__.py

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

src/ctx/__init__.py

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

src/ctx/adapters/generic/ctx_core_tools.py

@@ -135,6 +135,20 @@ class CtxCoreToolbox:
                             "minimum": 1,
                             "maximum": 5,
                         },
+                        "model_provider": {
+                            "type": "string",
+                            "description": (
+                                "Optional custom/local model provider, used only "
+                                "for companion harness recommendations."
+                            ),
+                        },
+                        "model": {
+                            "type": "string",
+                            "description": (
+                                "Optional model slug, used only for companion "
+                                "harness recommendations."
+                            ),
+                        },
                     },
                     "required": ["query"],
                 },
@@ -256,6 +270,10 @@ class CtxCoreToolbox:
             return self._dispatch_lifecycle(args, "load_entity")
         if local_name == "mark_entity_used":
             return self._dispatch_lifecycle(args, "mark_entity_used")
+        if local_name == "record_validation":
+            return self._dispatch_lifecycle(args, "record_validation")
+        if local_name == "record_escalation":
+            return self._dispatch_lifecycle(args, "record_escalation")
         if local_name == "unload_entity":
             return self._dispatch_lifecycle(args, "unload_entity")
         if local_name == "session_end":
@@ -331,7 +349,24 @@ class CtxCoreToolbox:
             }
             for r in raw
         ]
-        return json.dumps({"query": query, "tags": tags, "results": results})
+        model_provider = _optional_str(args.get("model_provider"))
+        model = _optional_str(args.get("model"))
+        companion_harnesses = (
+            _recommend_companion_harnesses(
+                query,
+                top_k=top_k,
+                model_provider=model_provider,
+                model=model,
+            )
+            if model_provider or model
+            else []
+        )
+        return json.dumps({
+            "query": query,
+            "tags": tags,
+            "results": results,
+            "companion_harnesses": companion_harnesses,
+        })
 
     def _dispatch_graph_query(self, args: dict[str, Any]) -> str:
         seeds_raw = args.get("seeds") or []
@@ -465,6 +500,28 @@ class CtxCoreToolbox:
                     slug=str(args.get("slug") or ""),
                     reason=str(args.get("reason") or "") or None,
                 )
+            elif name == "record_validation":
+                result = self._lifecycle.record_validation(
+                    session_id=str(args.get("session_id") or ""),
+                    check_name=str(args.get("check_name") or ""),
+                    status=str(args.get("status") or ""),
+                    command=str(args.get("command") or "") or None,
+                    summary=str(args.get("summary") or "") or None,
+                    entity_type=str(args.get("entity_type") or "") or None,
+                    slug=str(args.get("slug") or "") or None,
+                    payload=_dict_arg(args.get("payload")),
+                )
+            elif name == "record_escalation":
+                result = self._lifecycle.record_escalation(
+                    session_id=str(args.get("session_id") or ""),
+                    trigger=str(args.get("trigger") or ""),
+                    reason=str(args.get("reason") or ""),
+                    severity=str(args.get("severity") or "") or None,
+                    status=str(args.get("status") or "") or None,
+                    entity_type=str(args.get("entity_type") or "") or None,
+                    slug=str(args.get("slug") or "") or None,
+                    payload=_dict_arg(args.get("payload")),
+                )
             elif name == "session_end":
                 result = self._lifecycle.end_session(
                     session_id=str(args.get("session_id") or ""),
@@ -569,6 +626,48 @@ def _query_to_tags(query: str) -> list[str]:
     return query_to_tags(query)
 
 
+def _optional_str(raw: Any) -> str | None:
+    if not isinstance(raw, str):
+        return None
+    value = raw.strip()
+    return value or None
+
+
+def _recommend_companion_harnesses(
+    query: str,
+    *,
+    top_k: int,
+    model_provider: str | None,
+    model: str | None,
+) -> list[dict[str, Any]]:
+    try:
+        from ctx_init import recommend_harnesses  # noqa: PLC0415
+
+        raw = recommend_harnesses(
+            query,
+            top_k=top_k,
+            model_provider=model_provider,
+            model=model,
+        )
+    except Exception as exc:  # noqa: BLE001
+        _logger.warning("ctx harness companion recommendation failed: %s", exc)
+        return []
+    return [
+        {
+            "name": row.get("name"),
+            "type": "harness",
+            "fit_score": row.get("fit_score"),
+            "normalized_score": row.get("normalized_score"),
+            "matching_tags": row.get("matching_tags", []),
+            "provider_match": row.get("provider_match"),
+            "detail_url": row.get("detail_url"),
+            "install_command": row.get("install_command"),
+        }
+        for row in raw
+        if row.get("name")
+    ]
+
+
 def _lifecycle_tool_definitions() -> list[ToolDefinition]:
     entity_enum = list(RECOMMENDABLE_ENTITY_TYPES)
     session = {
@@ -635,6 +734,63 @@ def _lifecycle_tool_definitions() -> list[ToolDefinition]:
                 "required": ["session_id", "entity_type", "slug"],
             },
         ),
+        ToolDefinition(
+            name=f"{_NAMESPACE}record_validation",
+            description=(
+                "Record a harness validation check result outside the chat "
+                "transcript so state can be inspected and replayed."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "session_id": session,
+                    "check_name": {
+                        "type": "string",
+                        "description": "Stable name of the check that ran.",
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": ["passed", "failed", "skipped", "error"],
+                    },
+                    "command": {"type": "string"},
+                    "summary": {"type": "string"},
+                    "entity_type": entity_type,
+                    "slug": slug,
+                    "payload": {"type": "object"},
+                },
+                "required": ["session_id", "check_name", "status"],
+            },
+        ),
+        ToolDefinition(
+            name=f"{_NAMESPACE}record_escalation",
+            description=(
+                "Record that a predefined escalation condition was reached "
+                "so the host can ask the user instead of hiding state in chat."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "session_id": session,
+                    "trigger": {
+                        "type": "string",
+                        "description": "Stable escalation trigger name.",
+                    },
+                    "reason": {"type": "string"},
+                    "severity": {
+                        "type": "string",
+                        "enum": ["info", "warning", "blocking"],
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": ["open", "resolved", "ignored"],
+                    },
+                    "entity_type": entity_type,
+                    "slug": slug,
+                    "payload": {"type": "object"},
+                },
+                "required": ["session_id", "trigger", "reason"],
+            },
+        ),
         ToolDefinition(
             name=f"{_NAMESPACE}unload_entity",
             description=(
@@ -669,8 +825,9 @@ def _lifecycle_tool_definitions() -> list[ToolDefinition]:
             name=f"{_NAMESPACE}session_state",
             description=(
                 "Read the current lifecycle state for a session, including "
-                "loaded entities, used entities, and unload candidates that "
-                "were loaded but have no usage evidence."
+                "loaded entities, used entities, validation checks, "
+                "escalations, and unload candidates that were loaded but "
+                "have no usage evidence."
             ),
             parameters={
                 "type": "object",

src/ctx/adapters/generic/runtime_lifecycle.py

@@ -17,6 +17,8 @@ from ctx.utils._fs_utils import reject_symlink_path
 
 _SESSION_RE = re.compile(r"^[A-Za-z0-9_.:-]{1,128}$")
 _ENTITY_TYPES = set(RECOMMENDABLE_ENTITY_TYPES)
+_VALIDATION_STATUSES = {"passed", "failed", "skipped", "error"}
+_ESCALATION_STATUSES = {"open", "resolved", "ignored"}
 
 
 @dataclass(frozen=True)
@@ -91,6 +93,54 @@ class RuntimeLifecycleStore:
             reason=reason,
         )
 
+    def record_validation(
+        self,
+        *,
+        session_id: str,
+        check_name: str,
+        status: str,
+        command: str | None = None,
+        summary: str | None = None,
+        entity_type: str | None = None,
+        slug: str | None = None,
+        payload: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return self._record(
+            action="validation",
+            session_id=session_id,
+            check_name=_validate_nonempty(check_name, "check_name"),
+            status=_validate_choice(status, _VALIDATION_STATUSES, "status"),
+            command=command,
+            summary=summary,
+            entity_type=entity_type,
+            slug=slug,
+            payload=payload or {},
+        )
+
+    def record_escalation(
+        self,
+        *,
+        session_id: str,
+        trigger: str,
+        reason: str,
+        severity: str | None = None,
+        status: str | None = None,
+        entity_type: str | None = None,
+        slug: str | None = None,
+        payload: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return self._record(
+            action="escalation",
+            session_id=session_id,
+            trigger=_validate_nonempty(trigger, "trigger"),
+            reason=_validate_nonempty(reason, "reason"),
+            severity=severity or "blocking",
+            status=_validate_choice(status or "open", _ESCALATION_STATUSES, "status"),
+            entity_type=entity_type,
+            slug=slug,
+            payload=payload or {},
+        )
+
     def end_session(
         self,
         *,
@@ -114,14 +164,27 @@ class RuntimeLifecycleStore:
         session_id = _validate_session_id(session_id)
         loaded: dict[tuple[str, str], dict[str, Any]] = {}
         unloaded: list[dict[str, Any]] = []
+        validations: list[dict[str, Any]] = []
+        escalations: list[dict[str, Any]] = []
         min_age = max(0.0, float(min_unused_seconds))
         now = time.time()
+        latest_dev_event_epoch: float | None = None
 
         for event in self._events_for_session(session_id):
+            action = event.get("action")
+            if action == "dev_event":
+                latest_dev_event_epoch = float(event.get("created_at_epoch") or 0)
+                continue
+            if action == "validation":
+                validations.append(_validation_state(event))
+                continue
+            if action == "escalation":
+                escalations.append(_escalation_state(event))
+                continue
             key = (str(event.get("entity_type") or ""), str(event.get("slug") or ""))
             if not key[0] or not key[1]:
                 continue
-            if event.get("action") == "load_requested":
+            if action == "load_requested":
                 loaded[key] = {
                     "entity_type": key[0],
                     "slug": key[1],
@@ -132,14 +195,15 @@ class RuntimeLifecycleStore:
                     "use_count": 0,
                     "last_used_at": None,
                     "evidence": [],
+                    "dev_event_epoch": latest_dev_event_epoch,
                 }
-            elif event.get("action") == "used" and key in loaded:
+            elif action == "used" and key in loaded:
                 loaded[key]["used"] = True
                 loaded[key]["use_count"] = int(loaded[key]["use_count"]) + 1
                 loaded[key]["last_used_at"] = event.get("created_at")
                 if event.get("evidence"):
                     loaded[key]["evidence"].append(event["evidence"])
-            elif event.get("action") == "unload_requested":
+            elif action == "unload_requested":
                 current = loaded.pop(key, None)
                 unloaded.append({
                     "entity_type": key[0],
@@ -154,6 +218,7 @@ class RuntimeLifecycleStore:
         unload_candidates = [
             entry for entry in loaded_entries
             if not entry["used"]
+            and _loaded_before_latest_dev_event(entry, latest_dev_event_epoch)
             and (min_age == 0 or now - float(entry.get("loaded_at_epoch") or 0) >= min_age)
         ]
         return {
@@ -163,6 +228,14 @@ class RuntimeLifecycleStore:
             "used": [entry for entry in loaded_entries if entry["used"]],
             "unload_candidates": unload_candidates,
             "unloaded": unloaded,
+            "validations": validations,
+            "escalations": escalations,
+            "latest_validation_status": (
+                str(validations[-1]["status"]) if validations else None
+            ),
+            "open_escalations": [
+                event for event in escalations if event["status"] == "open"
+            ],
         }
 
     def _record(self, **event: Any) -> dict[str, Any]:
@@ -228,3 +301,53 @@ def _validate_slug(raw: str) -> str:
     value = raw.strip()
     validate_skill_name(value)
     return value
+
+
+def _validate_nonempty(raw: str, field: str) -> str:
+    value = raw.strip()
+    if not value:
+        raise ValueError(f"{field} must be non-empty")
+    return value
+
+
+def _validate_choice(raw: str, allowed: set[str], field: str) -> str:
+    value = raw.strip().lower()
+    if value not in allowed:
+        raise ValueError(f"{field} must be one of {', '.join(sorted(allowed))}")
+    return value
+
+
+def _validation_state(event: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "check_name": event.get("check_name"),
+        "status": event.get("status"),
+        "command": event.get("command"),
+        "summary": event.get("summary"),
+        "entity_type": event.get("entity_type"),
+        "slug": event.get("slug"),
+        "payload": event.get("payload") or {},
+    }
+
+
+def _escalation_state(event: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "trigger": event.get("trigger"),
+        "reason": event.get("reason"),
+        "severity": event.get("severity"),
+        "status": event.get("status"),
+        "entity_type": event.get("entity_type"),
+        "slug": event.get("slug"),
+        "payload": event.get("payload") or {},
+    }
+
+
+def _loaded_before_latest_dev_event(
+    entry: dict[str, Any],
+    latest_dev_event_epoch: float | None,
+) -> bool:
+    if latest_dev_event_epoch is None:
+        return True
+    loaded_window = entry.get("dev_event_epoch")
+    if loaded_window is None:
+        return True
+    return float(loaded_window) < latest_dev_event_epoch

src/ctx/cli/run.py

@@ -55,6 +55,7 @@ from ctx.adapters.generic.tools import McpRouter, McpServerConfig
 
 _logger = logging.getLogger(__name__)
 _CTX_SESSION_MARKER = "ctx runtime session id:"
+_MODEL_PROFILE_NAME = "ctx-model-profile.json"
 
 
 # ── Provider key-env defaults ───────────────────────────────────────────────
@@ -92,6 +93,53 @@ def _resolve_api_key_env(
     return key if key else None
 
 
+def _claude_dir() -> Path:
+    return Path(os.path.expanduser("~/.claude"))
+
+
+def _load_model_profile() -> dict[str, Any]:
+    path = _claude_dir() / _MODEL_PROFILE_NAME
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return {}
+    except (OSError, json.JSONDecodeError) as exc:
+        _logger.warning("ctx model profile could not be loaded: %s", exc)
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _profile_str(profile: dict[str, Any], key: str) -> str | None:
+    value = profile.get(key)
+    if not isinstance(value, str):
+        return None
+    value = value.strip()
+    return value or None
+
+
+def _apply_model_profile_defaults(args: argparse.Namespace) -> str | None:
+    """Apply ctx-init's saved model profile to `ctx run` args."""
+    profile = _load_model_profile()
+    profile_model = _profile_str(profile, "model")
+    if not args.model and profile_model:
+        args.model = profile_model
+    if not args.model:
+        return (
+            "error: --model is required unless "
+            f"{_claude_dir() / _MODEL_PROFILE_NAME} contains a model"
+        )
+    if profile_model != args.model:
+        return None
+
+    if args.provider is None:
+        args.provider = _profile_str(profile, "provider")
+    if args.api_key_env is None and isinstance(profile.get("api_key_env"), str):
+        args.api_key_env = profile["api_key_env"]
+    if args.base_url is None:
+        args.base_url = _profile_str(profile, "base_url")
+    return None
+
+
 # ── MCP spec parsing ───────────────────────────────────────────────────────
 
 
@@ -413,11 +461,11 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     r.add_argument(
         "--model",
-        required=True,
         help=(
             "Model slug in LiteLLM form, e.g. "
             "'openrouter/anthropic/claude-opus-4.7', "
-            "'ollama/llama3.1:70b', 'openai/gpt-5.5'."
+            "'ollama/llama3.1:70b', 'openai/gpt-5.5'. "
+            "Default: ~/.claude/ctx-model-profile.json when configured."
         ),
     )
     r.add_argument(
@@ -649,6 +697,11 @@ def _build_parser() -> argparse.ArgumentParser:
 
 
 def _cmd_run(args: argparse.Namespace) -> int:
+    profile_error = _apply_model_profile_defaults(args)
+    if profile_error:
+        print(profile_error, file=sys.stderr)
+        return 2
+
     sdir = Path(args.sessions_dir) if args.sessions_dir else default_sessions_dir()
 
     api_key_env = _resolve_api_key_env(args.api_key_env, args.model, args.provider)

src/ctx/config.json

@@ -72,12 +72,13 @@
   },
 
   "graph": {
-    "_comment": "Knowledge-graph edge weighting for wiki_graphify. Base edges between entity pages (skill ↔ agent ↔ mcp-server ↔ harness, any combination) come from semantic similarity, explicit tags, slug tokens, source overlap, or direct wikilinks. Semantic/tag/token weights must sum to 1.0. Edge boosts then add explainable rank signals (direct links, source overlap, Adamic-Adar, type affinity, usage, quality) without creating edges by themselves. Override any key in your user config (~/.claude/skill-system-config.json).",
+    "_comment": "Knowledge-graph edge weighting for wiki_graphify. Base edges between entity pages (skill ↔ agent ↔ mcp-server ↔ harness, any combination) come from semantic similarity, explicit tags, slug tokens, source overlap, or direct wikilinks. Semantic/tag/token weights must sum to 1.0. min_edge_weight drops weak final blended edges after scoring; default 0.03 is the calibrated shipped graph floor. Edge boosts then add explainable rank signals (direct links, source overlap, Adamic-Adar, type affinity, usage, quality) without creating edges by themselves. Override any key in your user config (~/.claude/skill-system-config.json).",
     "edge_weights": {
       "semantic":    0.70,
       "tags":        0.15,
       "slug_tokens": 0.15
     },
+    "min_edge_weight": 0.03,
     "semantic": {
       "_comment": "Semantic edge construction uses two thresholds so you can tune display strictness WITHOUT paying to rebuild the graph. build_floor is the low bar for inclusion (all pairs at or above this survive to graph.json); min_cosine is the query/display filter that consumers (resolve, visualize, recommend) apply at read time. build_floor must be <= min_cosine. Rebuilding is only required when you change top_k, build_floor, or the entity body text that drives the cached embeddings — min_cosine alone is rebuild-free.",
       "top_k": 20,

src/ctx/core/wiki/artifact_promotion.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import gzip
 import hashlib
 import json
 import os
@@ -71,6 +72,7 @@ def promote_staged_artifact(
     started_at = _timestamp(now)
     previous = _snapshot(target)
     candidate = _snapshot(staged)
+    rollback = _rollback_record(target, previous)
     pending_record = {
         "schema_version": 1,
         "status": "staged",
@@ -78,6 +80,8 @@ def promote_staged_artifact(
         "started_at": started_at,
         "previous": previous,
         "candidate": candidate,
+        "last_good": previous,
+        "rollback": rollback,
     }
     atomic_write_json(metadata, pending_record, indent=2)
 
@@ -104,6 +108,37 @@ def _default_metadata_path(target: Path) -> Path:
     return target.with_name(f"{target.name}.promotion.json")
 
 
+def validate_json_artifact(path: Path, *, required_keys: tuple[str, ...] = ()) -> None:
+    """Raise if *path* is not a readable JSON object artifact."""
+    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")
+    missing = [key for key in required_keys if key not in data]
+    if missing:
+        raise ValueError(f"invalid JSON artifact: {path} missing keys {missing}")
+
+
+def validate_gzip_json_artifact(
+    path: Path,
+    *,
+    required_keys: tuple[str, ...] = (),
+) -> None:
+    """Raise if *path* is not a readable gzip-compressed JSON object artifact."""
+    try:
+        with gzip.open(path, "rt", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except (OSError, EOFError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"invalid gzip JSON artifact: {path}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"invalid gzip JSON artifact: {path} must contain an object")
+    missing = [key for key in required_keys if key not in data]
+    if missing:
+        raise ValueError(f"invalid gzip JSON artifact: {path} missing keys {missing}")
+
+
 def _recover_completed_promotion(
     *,
     target: Path,
@@ -139,6 +174,8 @@ def _recover_completed_promotion(
         "status": "promoted",
         "promoted_at": _timestamp(),
         "current": current,
+        "last_good": record.get("last_good", previous),
+        "rollback": record.get("rollback", _rollback_record(target, previous)),
     }
     atomic_write_json(metadata, promoted_record, indent=2)
     return ArtifactPromotionResult(
@@ -171,6 +208,16 @@ def _snapshot(path: Path) -> dict[str, Any]:
     }
 
 
+def _rollback_record(target: Path, previous: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "available": bool(previous.get("exists")),
+        "target": str(target),
+        "sha256": previous.get("sha256"),
+        "size": previous.get("size"),
+        "mtime_ns": previous.get("mtime_ns"),
+    }
+
+
 def _sha256_file(path: Path) -> str:
     digest = hashlib.sha256()
     with path.open("rb") as f:

src/ctx/core/wiki/wiki_graphify.py

@@ -33,6 +33,11 @@ from ctx.core.entity_types import (
     entity_wikilink,
     mcp_shard,
 )
+from ctx.core.wiki.artifact_promotion import (
+    ArtifactValidator,
+    promote_staged_artifact,
+    validate_json_artifact,
+)
 from ctx.core.wiki.wiki_utils import parse_frontmatter as _parse_fm
 from ctx.utils._fs_utils import safe_atomic_write_text
 
@@ -632,7 +637,7 @@ def build_graph(
             "quality": w_quality * quality,
         }
         final = min(sum(components.values()), 1.0)
-        if final <= 0.0:
+        if final <= 0.0 or final < _cfg.graph_edge_min_weight:
             # Useless edge — only happens when every signal dropped to
             # zero or landed below its floor. Skip materialisation.
             continue
@@ -757,6 +762,7 @@ def build_graph(
     # edges were never materialised).
     G.graph["semantic_build_floor"] = round(_cfg.graph_semantic_build_floor, 4)
     G.graph["semantic_min_cosine_default"] = round(_cfg.graph_semantic_min_cosine, 4)
+    G.graph["min_edge_weight"] = round(_cfg.graph_edge_min_weight, 4)
 
     print(f"Graph: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")
     print(
@@ -1505,10 +1511,13 @@ def export_graph(
         graph_meta["export_id"] = export_id
     else:
         graph_data["graph"] = {"export_id": export_id}
-    safe_atomic_write_text(
-        GRAPH_OUT / "graph.json",
+    _stage_and_promote_graph_artifact(
+        "graph.json",
         json.dumps(graph_data, indent=2, default=str),
-        encoding="utf-8",
+        validate=lambda path: validate_json_artifact(
+            path,
+            required_keys=("nodes", "edges", "graph"),
+        ),
     )
 
     # No binary sidecar. An earlier revision wrote ``graph.pickle`` next
@@ -1524,10 +1533,13 @@ def export_graph(
     # stat a single file to detect changes.
     delta = _build_delta(G, delta_nodes or set())
     delta["export_id"] = export_id
-    safe_atomic_write_text(
-        GRAPH_OUT / "graph-delta.json",
+    _stage_and_promote_graph_artifact(
+        "graph-delta.json",
         json.dumps(delta, indent=2, default=str),
-        encoding="utf-8",
+        validate=lambda path: validate_json_artifact(
+            path,
+            required_keys=("version", "full_rebuild", "export_id"),
+        ),
     )
 
     # Community labels
@@ -1535,8 +1547,8 @@ def export_graph(
     for cid, members in communities.items():
         labels[cid] = label_community(G, members)
 
-    safe_atomic_write_text(
-        GRAPH_OUT / "communities.json",
+    _stage_and_promote_graph_artifact(
+        "communities.json",
         json.dumps({
             "export_id": export_id,
             "communities": {str(cid): {"label": labels[cid], "members": members}
@@ -1544,7 +1556,10 @@ def export_graph(
             "total_communities": len(communities),
             "generated": TODAY,
         }, indent=2),
-        encoding="utf-8",
+        validate=lambda path: validate_json_artifact(
+            path,
+            required_keys=("export_id", "communities", "total_communities"),
+        ),
     )
 
     # God nodes (highest degree)
@@ -1567,13 +1582,12 @@ def export_graph(
     for cid, members in sorted(communities.items(), key=lambda x: -len(x[1])):
         report_lines.append(f"- **{labels[cid]}** — {len(members)} members")
 
-    safe_atomic_write_text(
-        GRAPH_OUT / "graph-report.md",
+    _stage_and_promote_graph_artifact(
+        "graph-report.md",
         "\n".join(report_lines),
-        encoding="utf-8",
     )
-    safe_atomic_write_text(
-        GRAPH_OUT / GRAPH_EXPORT_MANIFEST,
+    _stage_and_promote_graph_artifact(
+        GRAPH_EXPORT_MANIFEST,
         json.dumps({
             "version": 1,
             "export_id": export_id,
@@ -1590,11 +1604,26 @@ def export_graph(
                 "communities": len(communities),
             },
         }, indent=2),
-        encoding="utf-8",
+        validate=lambda path: validate_json_artifact(
+            path,
+            required_keys=("version", "export_id", "artifacts", "counts"),
+        ),
     )
     print(f"Graph exported to {GRAPH_OUT}/")
 
 
+def _stage_and_promote_graph_artifact(
+    name: str,
+    text: str,
+    *,
+    validate: ArtifactValidator | None = None,
+) -> None:
+    target = GRAPH_OUT / name
+    staged = target.with_name(f"{target.name}.staged")
+    safe_atomic_write_text(staged, text, encoding="utf-8")
+    promote_staged_artifact(staged, target, validate=validate)
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description="Build knowledge graph from wiki entities")
     parser.add_argument(

src/ctx/core/wiki/wiki_queue.py

@@ -7,13 +7,14 @@ future processor leases jobs with explicit worker IDs.
 
 from __future__ import annotations
 
+from contextlib import contextmanager
 import json
 import sqlite3
 import time
 from hashlib import sha256
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterable
+from typing import Any, Iterable, Iterator
 
 from ctx.utils._fs_utils import reject_symlink_path
 
@@ -21,6 +22,9 @@ STATUS_PENDING = "pending"
 STATUS_RUNNING = "running"
 STATUS_SUCCEEDED = "succeeded"
 STATUS_FAILED = "failed"
+STATUS_CANCELLED = "cancelled"
+TERMINAL_STATUSES = (STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELLED)
+ACTIVE_STATUSES = (STATUS_PENDING, STATUS_RUNNING)
 
 ENTITY_UPSERT_JOB = "entity-upsert"
 GRAPH_EXPORT_JOB = "graph-export"
@@ -81,6 +85,10 @@ class QueueJob:
     updated_at: float
 
 
+class QueueStorageError(RuntimeError):
+    """Raised when the durable queue DB cannot be opened or initialized."""
+
+
 def init_queue(db_path: Path) -> None:
     """Create the queue database and enable SQLite WAL mode."""
     with _connect(db_path) as conn:
@@ -160,6 +168,7 @@ def enqueue_maintenance_job(
         content_hash=content_hash,
         max_attempts=max_attempts,
         available_at=available_at,
+        reuse_terminal=False,
         now=now,
     )
 
@@ -173,6 +182,7 @@ def enqueue(
     content_hash: str | None = None,
     max_attempts: int = 3,
     available_at: float | None = None,
+    reuse_terminal: bool = True,
     now: float | None = None,
 ) -> QueueJob:
     """Insert a pending job or return the existing job for an idempotency key."""
@@ -186,14 +196,24 @@ def enqueue(
     with _connect(db_path) as conn:
         conn.execute("BEGIN IMMEDIATE")
         try:
+            if idempotency_key and not reuse_terminal and content_hash:
+                row = _select_active_duplicate(conn, kind, content_hash)
+                if row is not None:
+                    conn.execute("COMMIT")
+                    return _row_to_job(row)
             if idempotency_key:
                 row = conn.execute(
                     "SELECT * FROM wiki_queue_jobs WHERE idempotency_key = ?",
                     (idempotency_key,),
                 ).fetchone()
                 if row is not None:
-                    conn.execute("COMMIT")
-                    return _row_to_job(row)
+                    existing = _row_to_job(row)
+                    if reuse_terminal or existing.status not in TERMINAL_STATUSES:
+                        conn.execute("COMMIT")
+                        return existing
+                    idempotency_key = (
+                        f"{idempotency_key}:run:{timestamp:.6f}:{time.monotonic_ns()}"
+                    )
             cur = conn.execute(
                 """
                 INSERT INTO wiki_queue_jobs (
@@ -234,8 +254,7 @@ def lease_next(
     now: float | None = None,
 ) -> QueueJob | None:
     """Lease the oldest available pending job, recovering expired leases first."""
-    if not worker_id.strip():
-        raise ValueError("worker_id must be non-empty")
+    claimed_worker_id = _validate_worker_id(worker_id)
     if lease_seconds <= 0:
         raise ValueError(f"lease_seconds must be > 0 (got {lease_seconds})")
     timestamp = _now(now)
@@ -264,7 +283,7 @@ def lease_next(
                 """,
                 (
                     STATUS_RUNNING,
-                    worker_id,
+                    claimed_worker_id,
                     timestamp + float(lease_seconds),
                     timestamp,
                     job_id,
@@ -278,13 +297,21 @@ def lease_next(
             raise
 
 
-def mark_succeeded(db_path: Path, job_id: int, *, now: float | None = None) -> QueueJob:
+def mark_succeeded(
+    db_path: Path,
+    job_id: int,
+    *,
+    worker_id: str | None = None,
+    now: float | None = None,
+) -> QueueJob:
     """Mark a leased job as succeeded and clear lease metadata."""
     timestamp = _now(now)
+    expected_worker_id = _validate_worker_id(worker_id) if worker_id is not None else None
     with _connect(db_path) as conn:
         conn.execute("BEGIN IMMEDIATE")
         try:
-            _select_job(conn, job_id)
+            current = _row_to_job(_select_job(conn, job_id))
+            _assert_job_leased_by_worker(current, expected_worker_id)
             conn.execute(
                 """
                 UPDATE wiki_queue_jobs
@@ -309,6 +336,7 @@ def mark_failed(
     db_path: Path,
     job_id: int,
     *,
+    worker_id: str | None = None,
     error: str,
     retry: bool,
     delay_seconds: float = 0.0,
@@ -317,10 +345,12 @@ def mark_failed(
     """Record a job failure, retrying if allowed and attempts remain."""
     timestamp = _now(now)
     delay = max(0.0, float(delay_seconds))
+    expected_worker_id = _validate_worker_id(worker_id) if worker_id is not None else None
     with _connect(db_path) as conn:
         conn.execute("BEGIN IMMEDIATE")
         try:
             current = _row_to_job(_select_job(conn, job_id))
+            _assert_job_leased_by_worker(current, expected_worker_id)
             should_retry = retry and current.attempts < current.max_attempts
             status = STATUS_PENDING if should_retry else STATUS_FAILED
             available_at = timestamp + delay if should_retry else current.available_at
@@ -345,6 +375,69 @@ def mark_failed(
             raise
 
 
+def cancel_job(
+    db_path: Path,
+    job_id: int,
+    *,
+    worker_id: str | None = None,
+    reason: str | None = None,
+    now: float | None = None,
+) -> QueueJob:
+    """Cancel a pending/running job and clear any active lease.
+
+    Cancellation is idempotent for an already-cancelled job. Succeeded and
+    failed jobs remain immutable terminal records.
+    """
+    timestamp = _now(now)
+    expected_worker_id = _validate_worker_id(worker_id) if worker_id is not None else None
+    detail = reason.strip() if isinstance(reason, str) and reason.strip() else None
+    with _connect(db_path) as conn:
+        conn.execute("BEGIN IMMEDIATE")
+        try:
+            current = _row_to_job(_select_job(conn, job_id))
+            if current.status == STATUS_CANCELLED:
+                conn.execute("COMMIT")
+                return current
+            if current.status in (STATUS_SUCCEEDED, STATUS_FAILED):
+                raise RuntimeError(
+                    f"queue job {current.id} is already terminal: {current.status}"
+                )
+            if current.status == STATUS_RUNNING and expected_worker_id is not None:
+                _assert_job_leased_by_worker(current, expected_worker_id)
+            conn.execute(
+                """
+                UPDATE wiki_queue_jobs
+                   SET status = ?,
+                       worker_id = NULL,
+                       leased_until = NULL,
+                       last_error = ?,
+                       updated_at = ?
+                 WHERE id = ?
+                """,
+                (STATUS_CANCELLED, detail, timestamp, int(job_id)),
+            )
+            row = _select_job(conn, job_id)
+            conn.execute("COMMIT")
+            return _row_to_job(row)
+        except Exception:
+            conn.execute("ROLLBACK")
+            raise
+
+
+def recover_expired_leases(db_path: Path, *, now: float | None = None) -> dict[str, int]:
+    """Recover expired running jobs without leasing a new job."""
+    timestamp = _now(now)
+    with _connect(db_path) as conn:
+        conn.execute("BEGIN IMMEDIATE")
+        try:
+            recovered = _recover_expired_leases(conn, timestamp)
+            conn.execute("COMMIT")
+            return recovered
+        except Exception:
+            conn.execute("ROLLBACK")
+            raise
+
+
 def get_job(db_path: Path, job_id: int) -> QueueJob:
     """Return one queue job by ID."""
     with _connect(db_path) as conn:
@@ -372,23 +465,82 @@ def list_jobs(
     return [_row_to_job(row) for row in rows]
 
 
-def _connect(db_path: Path) -> sqlite3.Connection:
+def count_jobs_by_status(db_path: Path) -> dict[str, int]:
+    """Return queue job counts grouped by status."""
+    with _connect(db_path) as conn:
+        rows = conn.execute(
+            """
+            SELECT status, COUNT(*) AS count
+              FROM wiki_queue_jobs
+             GROUP BY status
+            """,
+        ).fetchall()
+    return {str(row["status"]): int(row["count"]) for row in rows}
+
+
+def list_recent_jobs(
+    db_path: Path,
+    *,
+    limit: int = 20,
+    statuses: Iterable[str] | None = None,
+) -> list[QueueJob]:
+    """List the newest queue jobs, bounded in SQLite."""
+    bounded_limit = max(0, int(limit))
+    if bounded_limit == 0:
+        return []
+    status_filter = tuple(statuses or ())
+    with _connect(db_path) as conn:
+        if status_filter:
+            placeholders = ",".join("?" for _ in status_filter)
+            rows = conn.execute(
+                f"""
+                SELECT * FROM wiki_queue_jobs
+                 WHERE status IN ({placeholders})
+                 ORDER BY id DESC
+                 LIMIT ?
+                """,
+                (*status_filter, bounded_limit),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                """
+                SELECT * FROM wiki_queue_jobs
+                 ORDER BY id DESC
+                 LIMIT ?
+                """,
+                (bounded_limit,),
+            ).fetchall()
+    return [_row_to_job(row) for row in rows]
+
+
+@contextmanager
+def _connect(db_path: Path) -> Iterator[sqlite3.Connection]:
     path = Path(db_path)
     reject_symlink_path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
     reject_symlink_path(path)
-    conn = sqlite3.connect(path, timeout=30.0, isolation_level=None)
-    conn.row_factory = sqlite3.Row
-    conn.execute("PRAGMA busy_timeout = 30000")
-    conn.execute("PRAGMA journal_mode = WAL")
-    conn.execute("PRAGMA synchronous = NORMAL")
-    conn.execute("PRAGMA foreign_keys = ON")
-    conn.executescript(_SCHEMA)
-    return conn
-
-
-def _recover_expired_leases(conn: sqlite3.Connection, now: float) -> None:
-    conn.execute(
+    conn: sqlite3.Connection | None = None
+    try:
+        conn = sqlite3.connect(path, timeout=30.0, isolation_level=None)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA busy_timeout = 30000")
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA synchronous = NORMAL")
+        conn.execute("PRAGMA foreign_keys = ON")
+        conn.executescript(_SCHEMA)
+    except sqlite3.DatabaseError as exc:
+        if conn is not None:
+            conn.close()
+        raise QueueStorageError(f"queue database is not readable: {path}") from exc
+    try:
+        yield conn
+    finally:
+        if conn is not None:
+            conn.close()
+
+
+def _recover_expired_leases(conn: sqlite3.Connection, now: float) -> dict[str, int]:
+    requeued = conn.execute(
         """
         UPDATE wiki_queue_jobs
            SET status = ?,
@@ -402,20 +554,28 @@ def _recover_expired_leases(conn: sqlite3.Connection, now: float) -> None:
         """,
         (STATUS_PENDING, now, STATUS_RUNNING, now),
     )
-    conn.execute(
+    failed = conn.execute(
         """
         UPDATE wiki_queue_jobs
            SET status = ?,
                worker_id = NULL,
                leased_until = NULL,
+               last_error = ?,
                updated_at = ?
          WHERE status = ?
            AND leased_until IS NOT NULL
            AND leased_until <= ?
            AND attempts >= max_attempts
         """,
-        (STATUS_FAILED, now, STATUS_RUNNING, now),
+        (
+            STATUS_FAILED,
+            "lease expired; max attempts exhausted",
+            now,
+            STATUS_RUNNING,
+            now,
+        ),
     )
+    return {"requeued": int(requeued.rowcount or 0), "failed": int(failed.rowcount or 0)}
 
 
 def _select_next_ready(
@@ -450,6 +610,24 @@ def _select_next_ready(
     ).fetchone()
 
 
+def _select_active_duplicate(
+    conn: sqlite3.Connection,
+    kind: str,
+    content_hash: str,
+) -> sqlite3.Row | None:
+    return conn.execute(
+        """
+        SELECT * FROM wiki_queue_jobs
+         WHERE kind = ?
+           AND content_hash = ?
+           AND status IN (?, ?)
+         ORDER BY id DESC
+         LIMIT 1
+        """,
+        (kind, content_hash, *ACTIVE_STATUSES),
+    ).fetchone()
+
+
 def _select_job(conn: sqlite3.Connection, job_id: int) -> sqlite3.Row:
     row = conn.execute(
         "SELECT * FROM wiki_queue_jobs WHERE id = ?",
@@ -503,11 +681,33 @@ def _validate_kind(kind: str) -> None:
         raise ValueError("kind must be a non-empty string")
 
 
+def _validate_worker_id(worker_id: str) -> str:
+    if not isinstance(worker_id, str) or not worker_id.strip():
+        raise ValueError("worker_id must be non-empty")
+    return worker_id.strip()
+
+
 def _validate_maintenance_kind(kind: str) -> None:
     _validate_kind(kind)
     if kind not in MAINTENANCE_JOB_KINDS:
         raise ValueError(f"unsupported maintenance job kind: {kind}")
 
 
+def _assert_job_leased_by_worker(job: QueueJob, worker_id: str | None) -> None:
+    if job.status != STATUS_RUNNING:
+        actual = job.worker_id or "<none>"
+        target = worker_id or actual
+        raise RuntimeError(
+            f"queue job {job.id} is not leased by worker {target} "
+            f"(status={job.status}, worker_id={actual})"
+        )
+    if worker_id is not None and job.worker_id != worker_id:
+        actual = job.worker_id or "<none>"
+        raise RuntimeError(
+            f"queue job {job.id} is not leased by worker {worker_id} "
+            f"(status={job.status}, worker_id={actual})"
+        )
+
+
 def _now(now: float | None) -> float:
     return time.time() if now is None else float(now)

src/ctx/core/wiki/wiki_queue_worker.py

@@ -61,6 +61,7 @@ def process_next(
         failed = wiki_queue.mark_failed(
             db_path,
             job.id,
+            worker_id=worker_id,
             error=str(exc),
             retry=True,
             delay_seconds=retry_delay_seconds,
@@ -73,7 +74,7 @@ def process_next(
             message=str(failed.last_error or exc),
         )
 
-    succeeded = wiki_queue.mark_succeeded(db_path, job.id, now=now)
+    succeeded = wiki_queue.mark_succeeded(db_path, job.id, worker_id=worker_id, now=now)
     return ProcessResult(
         job_id=succeeded.id,
         kind=succeeded.kind,
@@ -136,6 +137,12 @@ def _process_entity_upsert(wiki_path: Path, payload: dict[str, Any]) -> str:
         )
 
     update_index(str(wiki_path), [slug], subject_type=subject_type)
+    wiki_queue.enqueue_maintenance_job(
+        wiki_path,
+        kind=wiki_queue.GRAPH_EXPORT_JOB,
+        payload={"graph_only": True, "incremental": True},
+        source="entity-upsert",
+    )
     return f"refreshed {subject_type} index for {slug}"
 
 

src/tests/test_artifact_promotion.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import gzip
 import json
 from datetime import datetime, timezone
 from pathlib import Path
@@ -34,6 +35,9 @@ def test_promote_staged_artifact_validates_replaces_and_records_metadata(
     assert metadata["previous"]["size"] == 4
     assert metadata["candidate"]["size"] == 4
     assert metadata["current"]["sha256"] == metadata["candidate"]["sha256"]
+    assert metadata["last_good"] == metadata["previous"]
+    assert metadata["rollback"]["available"] is True
+    assert metadata["rollback"]["sha256"] == metadata["previous"]["sha256"]
 
 
 def test_promote_staged_artifact_validation_failure_preserves_target(
@@ -58,6 +62,21 @@ def test_promote_staged_artifact_validation_failure_preserves_target(
     assert staged.exists()
     assert not target.with_name("artifact.txt.promotion.json").exists()
 
+    malformed_json = tmp_path / "broken.json"
+    malformed_json.write_text("{", encoding="utf-8")
+    with pytest.raises(ValueError, match="invalid JSON artifact"):
+        artifact_promotion.validate_json_artifact(malformed_json)
+
+    truncated_gzip = tmp_path / "broken.json.gz"
+    truncated_gzip.write_bytes(b"\x1f\x8b")
+    with pytest.raises(ValueError, match="invalid gzip JSON artifact"):
+        artifact_promotion.validate_gzip_json_artifact(truncated_gzip)
+
+    valid_gzip = tmp_path / "catalog.json.gz"
+    with gzip.open(valid_gzip, "wt", encoding="utf-8") as fh:
+        json.dump({"skills": []}, fh)
+    artifact_promotion.validate_gzip_json_artifact(valid_gzip, required_keys=("skills",))
+
 
 def test_promote_staged_artifact_replace_failure_preserves_target_and_last_good(
     tmp_path: Path,
@@ -83,6 +102,8 @@ def test_promote_staged_artifact_replace_failure_preserves_target_and_last_good(
     assert staged.exists()
     assert metadata["status"] == "staged"
     assert metadata["previous"]["sha256"] != metadata["candidate"]["sha256"]
+    assert metadata["last_good"] == metadata["previous"]
+    assert metadata["rollback"]["available"] is True
 
 
 def test_promote_staged_artifact_recovers_after_post_replace_crash(

src/tests/test_ci_classifier.py

@@ -24,7 +24,9 @@ def test_docs_only_classification() -> None:
     assert flags == {
         "browser_changed": False,
         "ci_changed": False,
+        "docs_changed": True,
         "docs_only": True,
+        "graph_artifact_changed": False,
         "graph_changed": True,
         "graph_only": False,
         "package_changed": False,
@@ -37,6 +39,7 @@ def test_docs_tooling_changes_are_docs_only() -> None:
     flags = classify_paths(["mkdocs.yml", "requirements-docs.txt"])
 
     assert flags["docs_only"] is True
+    assert flags["docs_changed"] is True
     assert flags["graph_only"] is False
     assert flags["source_changed"] is False
 
@@ -44,21 +47,48 @@ def test_docs_tooling_changes_are_docs_only() -> None:
 def test_graph_artifacts_are_graph_only_not_docs_only() -> None:
     flags = classify_paths(["graph/wiki-graph.tar.gz", "graph/communities.json"])
 
+    assert flags["docs_changed"] is False
     assert flags["docs_only"] is False
+    assert flags["graph_artifact_changed"] is True
     assert flags["graph_changed"] is True
     assert flags["graph_only"] is True
     assert flags["similarity_changed"] is False
     assert flags["source_changed"] is False
 
 
+def test_graph_readme_is_docs_not_graph_artifact() -> None:
+    flags = classify_paths(["graph/README.md"])
+
+    assert flags["docs_changed"] is True
+    assert flags["docs_only"] is True
+    assert flags["graph_artifact_changed"] is False
+    assert flags["graph_changed"] is True
+    assert flags["graph_only"] is True
+
+
 def test_mixed_graph_and_source_change_is_not_graph_only() -> None:
     flags = classify_paths(["graph/wiki-graph.tar.gz", "src/ctx/adapters/generic/loop.py"])
 
+    assert flags["graph_artifact_changed"] is True
     assert flags["graph_changed"] is True
     assert flags["graph_only"] is False
     assert flags["source_changed"] is True
 
 
+def test_mixed_source_docs_and_graph_artifact_requests_specific_gates() -> None:
+    flags = classify_paths([
+        "src/ctx/core/wiki/wiki_graphify.py",
+        "docs/knowledge-graph.md",
+        "graph/wiki-graph.tar.gz",
+    ])
+
+    assert flags["docs_changed"] is True
+    assert flags["docs_only"] is False
+    assert flags["graph_artifact_changed"] is True
+    assert flags["graph_only"] is False
+    assert flags["source_changed"] is True
+
+
 def test_source_change_marks_source_and_package() -> None:
     flags = classify_paths(["src/ctx/adapters/generic/loop.py"])
 
@@ -75,6 +105,7 @@ def test_workflow_change_fails_open_for_future_gates() -> None:
     assert flags["package_changed"] is True
     assert flags["similarity_changed"] is True
     assert flags["source_changed"] is True
+    assert flags["docs_changed"] is False
     assert flags["docs_only"] is False
 
 
@@ -94,6 +125,14 @@ def test_ci_workflows_default_to_read_only_token_permissions() -> None:
         assert "\npermissions:\n  contents: read\n" in workflow
 
 
+def test_graph_artifact_job_has_lfs_budget_fallback() -> None:
+    workflow = Path(".github/workflows/test.yml").read_text(encoding="utf-8")
+
+    assert "Resolve graph LFS artifacts" in workflow
+    assert "Git LFS artifact download failed; validating pointer metadata only." in workflow
+    assert "Validate graph artifact pointer when LFS unavailable" in workflow
+
+
 def test_publish_oidc_permission_is_limited_to_publish_job() -> None:
     workflow = Path(".github/workflows/publish.yml").read_text(encoding="utf-8")
     header = workflow.split("\njobs:\n", maxsplit=1)[0]
@@ -184,9 +223,23 @@ def test_main_writes_github_outputs(tmp_path: Path, monkeypatch) -> None:
     written = output.read_text(encoding="utf-8").splitlines()
     assert "package_changed=true" in written
     assert "source_changed=true" in written
+    assert "docs_changed=false" in written
     assert "docs_only=false" in written
 
 
+def test_main_handles_utf8_bom_changed_files(tmp_path: Path, monkeypatch) -> None:
+    changed = tmp_path / "changed-files.txt"
+    output = tmp_path / "github-output.txt"
+    changed.write_text("\ufeffgraph/wiki-graph.tar.gz\n", encoding="utf-8")
+    monkeypatch.setenv("GITHUB_OUTPUT", str(output))
+
+    assert main([str(changed)]) == 0
+
+    written = output.read_text(encoding="utf-8").splitlines()
+    assert "graph_artifact_changed=true" in written
+    assert "graph_only=true" in written
+
+
 def test_ci_required_allows_pr_policy_skip_on_push_only() -> None:
     needs = _required_needs(**{"no-test-no-merge": {"result": "skipped"}})
 
@@ -227,7 +280,12 @@ def test_ci_required_allows_heavy_jobs_to_skip_on_docs_only_pr() -> None:
     needs = _required_needs(
         classify={
             "result": "success",
-            "outputs": {"browser_changed": "false", "docs_only": "true"},
+            "outputs": {
+                "browser_changed": "false",
+                "docs_changed": "true",
+                "docs_only": "true",
+                "graph_artifact_changed": "false",
+            },
         },
         **{
             "graph-check": {"result": "skipped"},
@@ -250,7 +308,10 @@ def test_ci_required_allows_heavy_jobs_to_skip_on_docs_only_pr() -> None:
 
 def test_ci_required_rejects_missing_docs_check_on_docs_only_pr() -> None:
     needs = _required_needs(
-        classify={"result": "success", "outputs": {"docs_only": "true"}},
+        classify={
+            "result": "success",
+            "outputs": {"docs_changed": "true", "docs_only": "true"},
+        },
         **{"docs-check": {"result": "skipped"}},
     )
 
@@ -265,7 +326,9 @@ def test_ci_required_allows_heavy_jobs_to_skip_on_graph_only_pr() -> None:
             "result": "success",
             "outputs": {
                 "browser_changed": "false",
+                "docs_changed": "false",
                 "docs_only": "false",
+                "graph_artifact_changed": "true",
                 "graph_only": "true",
             },
         },
@@ -290,7 +353,10 @@ def test_ci_required_allows_heavy_jobs_to_skip_on_graph_only_pr() -> None:
 
 def test_ci_required_rejects_missing_graph_check_on_graph_only_pr() -> None:
     needs = _required_needs(
-        classify={"result": "success", "outputs": {"graph_only": "true"}},
+        classify={
+            "result": "success",
+            "outputs": {"graph_artifact_changed": "true", "graph_only": "true"},
+        },
         **{"graph-check": {"result": "skipped"}},
     )
 
@@ -315,7 +381,11 @@ def test_ci_required_rejects_missing_similarity_gate_on_source_pr() -> None:
     needs = _required_needs(
         classify={
             "result": "success",
-            "outputs": {"docs_only": "false", "graph_only": "false"},
+            "outputs": {
+                "docs_only": "false",
+                "graph_only": "false",
+                "similarity_changed": "true",
+            },
         },
         **{"similarity-integration": {"result": "skipped"}},
     )
@@ -364,3 +434,31 @@ def test_ci_required_rejects_browser_skip_when_classifier_requests_it() -> None:
     assert failed_required_jobs(needs, event_name="pull_request") == {
         "browser-security": "skipped",
     }
+
+
+def test_ci_required_rejects_missing_docs_check_on_mixed_docs_pr() -> None:
+    needs = _required_needs(
+        classify={
+            "result": "success",
+            "outputs": {"docs_changed": "true", "docs_only": "false"},
+        },
+        **{"docs-check": {"result": "skipped"}},
+    )
+
+    assert failed_required_jobs(needs, event_name="pull_request") == {
+        "docs-check": "skipped",
+    }
+
+
+def test_ci_required_rejects_missing_graph_check_on_mixed_artifact_pr() -> None:
+    needs = _required_needs(
+        classify={
+            "result": "success",
+            "outputs": {"graph_artifact_changed": "true", "graph_only": "false"},
+        },
+        **{"graph-check": {"result": "skipped"}},
+    )
+
+    assert failed_required_jobs(needs, event_name="pull_request") == {
+        "graph-check": "skipped",
+    }

src/tests/test_ctx_config.py

@@ -128,10 +128,10 @@ class TestDefaults:
         assert c.intent_boost_per_signal == 5
         assert c.graph_edge_weight_semantic == 0.70
         assert c.graph_edge_weight_tags == 0.15
-        assert c.graph_edge_weight_tokens == 0.15
-        assert c.graph_semantic_top_k == 20
-        assert c.graph_semantic_build_floor == 0.50
-        assert c.graph_semantic_min_cosine == 0.80
+        assert c.graph_edge_weight_tokens == 0.15
+        assert c.graph_semantic_top_k == 20
+        assert c.graph_semantic_build_floor == 0.50
+        assert c.graph_semantic_min_cosine == 0.80
         assert c.intake_enabled is True
 
     def test_meta_skills_default(self) -> None:
@@ -185,13 +185,13 @@ class TestRecommendationTopK:
 
 
 class TestEdgeWeights:
-    def test_custom_weights_summing_to_one(self) -> None:
-        c = Config({
-            "graph": {
-                "edge_weights": {"semantic": 0.5, "tags": 0.3, "slug_tokens": 0.2}
-            }
-        })
-        assert c.graph_edge_weight_semantic == 0.5
+    def test_custom_weights_summing_to_one(self) -> None:
+        c = Config({
+            "graph": {
+                "edge_weights": {"semantic": 0.5, "tags": 0.3, "slug_tokens": 0.2}
+            }
+        })
+        assert c.graph_edge_weight_semantic == 0.5
 
     def test_weights_must_sum_to_one(self) -> None:
         with pytest.raises(ValueError, match="edge_weights must sum"):
@@ -203,27 +203,27 @@ class TestEdgeWeights:
                 }
             })
 
-    def test_negative_weight_rejected(self) -> None:
-        with pytest.raises(ValueError, match=r"edge_weights\.\w+ must be >= 0"):
-            Config({
-                "graph": {
-                    "edge_weights": {
-                        "semantic": 1.1, "tags": -0.05, "slug_tokens": -0.05,
-                    }
-                }
-            })
-
-    def test_tolerance_within_1e6(self) -> None:
-        """Floats summing to 1.0000001 must still pass."""
-        c = Config({
-            "graph": {
-                "edge_weights": {
-                    "semantic": 0.5000001, "tags": 0.25, "slug_tokens": 0.25,
-                }
-            }
-        })
-        assert c.graph_edge_weight_semantic == pytest.approx(0.5000001)
-
+    def test_negative_weight_rejected(self) -> None:
+        with pytest.raises(ValueError, match=r"edge_weights\.\w+ must be >= 0"):
+            Config({
+                "graph": {
+                    "edge_weights": {
+                        "semantic": 1.1, "tags": -0.05, "slug_tokens": -0.05,
+                    }
+                }
+            })
+
+    def test_tolerance_within_1e6(self) -> None:
+        """Floats summing to 1.0000001 must still pass."""
+        c = Config({
+            "graph": {
+                "edge_weights": {
+                    "semantic": 0.5000001, "tags": 0.25, "slug_tokens": 0.25,
+                }
+            }
+        })
+        assert c.graph_edge_weight_semantic == pytest.approx(0.5000001)
+
 
 # ── Semantic thresholds ──────────────────────────────────────────────────────
 

src/tests/test_ctx_init.py

@@ -399,6 +399,167 @@ repo_url: https://github.com/earthtojake/text-to-cad
     assert "openscad" in results[0]["fit_signals"]
 
 
+def test_recommend_harnesses_surfaces_reliability_rubric(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "wiki"
+    harness_dir = wiki / "entities" / "harnesses"
+    harness_dir.mkdir(parents=True)
+    (harness_dir / "reliable-agent.md").write_text(
+        """---
+title: Reliable Agent
+type: harness
+tags:
+  - agents
+model_providers:
+  - openai
+capabilities:
+  - Persistent project context and task state
+  - Permission limits, sandbox rules, and policy checks
+  - Automated tests, evals, retry loops, and validation gates
+verify_commands:
+  - pytest
+repo_url: https://example.test/reliable-agent
+---
+# Reliable Agent
+""",
+        encoding="utf-8",
+    )
+    graph = nx.Graph()
+    graph.add_node(
+        "harness:reliable-agent",
+        label="reliable-agent",
+        type="harness",
+        tags=["agents"],
+    )
+    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        SimpleNamespace(
+            wiki_dir=wiki,
+            claude_dir=tmp_path / ".claude",
+            recommendation_top_k=5,
+            harness_recommendation_min_fit_score=0.20,
+            harness_reliability_weights={
+                "context": 0.34,
+                "constraints": 0.33,
+                "convergence": 0.33,
+            },
+        ),
+    )
+
+    results = ci.recommend_harnesses(
+        "openai agent workflow with tests and sandbox",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+    )
+
+    assert results
+    recommendation = results[0]
+    assert recommendation["name"] == "reliable-agent"
+    assert recommendation["reliability_score"] >= 0.90
+    assert set(recommendation["reliability_dimensions"]) == {
+        "context",
+        "constraints",
+        "convergence",
+    }
+    assert recommendation["reliability_dimensions"]["context"]["matched_terms"]
+    assert recommendation["reliability_dimensions"]["constraints"]["matched_terms"]
+    assert recommendation["reliability_dimensions"]["convergence"]["matched_terms"]
+    assert "context" in recommendation["reliability_reason"]
+    assert "constraints" in recommendation["reliability_reason"]
+    assert "convergence" in recommendation["reliability_reason"]
+
+
+def test_recommend_harnesses_prefers_reliable_harness_when_fit_ties(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "wiki"
+    harness_dir = wiki / "entities" / "harnesses"
+    harness_dir.mkdir(parents=True)
+    (harness_dir / "thin-agent.md").write_text(
+        """---
+title: Thin Agent
+type: harness
+tags:
+  - agents
+model_providers:
+  - openai
+capabilities:
+  - Agent workflow orchestration
+repo_url: https://example.test/thin-agent
+---
+# Thin Agent
+""",
+        encoding="utf-8",
+    )
+    (harness_dir / "reliable-agent.md").write_text(
+        """---
+title: Reliable Agent
+type: harness
+tags:
+  - agents
+model_providers:
+  - openai
+capabilities:
+  - Agent workflow orchestration
+  - Persistent context state and durable task documents
+  - Permission limits, sandbox boundaries, and approval policies
+  - Automated tests, evals, validation gates, and retry loops
+verify_commands:
+  - pytest
+repo_url: https://example.test/reliable-agent
+---
+# Reliable Agent
+""",
+        encoding="utf-8",
+    )
+    graph = nx.Graph()
+    for slug in ("thin-agent", "reliable-agent"):
+        graph.add_node(
+            f"harness:{slug}",
+            label=slug,
+            type="harness",
+            tags=["agents"],
+        )
+    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        SimpleNamespace(
+            wiki_dir=wiki,
+            claude_dir=tmp_path / ".claude",
+            recommendation_top_k=5,
+            harness_recommendation_min_fit_score=0.20,
+            harness_reliability_weights={
+                "context": 0.34,
+                "constraints": 0.33,
+                "convergence": 0.33,
+            },
+        ),
+    )
+
+    results = ci.recommend_harnesses(
+        "openai agent workflow",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+    )
+
+    assert [row["name"] for row in results[:2]] == [
+        "reliable-agent",
+        "thin-agent",
+    ]
+    assert results[0]["fit_score"] == results[1]["fit_score"]
+    assert results[0]["reliability_score"] > results[1]["reliability_score"]
+
+
 def test_recommend_harnesses_avoids_semantic_model_load_by_default(
     tmp_path: Path,
     monkeypatch,

src/tests/test_ctx_monitor.py

@@ -40,6 +40,14 @@ def _write_events(claude: Path, records: list[dict]) -> None:
     )
 
 
+def _write_runtime_events(path: Path, records: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "\n".join(json.dumps(r) for r in records) + "\n",
+        encoding="utf-8",
+    )
+
+
 def _write_sidecar(claude: Path, slug: str, body: dict) -> None:
     (claude / "skill-quality" / f"{slug}.json").write_text(
         json.dumps(body), encoding="utf-8",
@@ -311,11 +319,20 @@ def test_queue_status_summarizes_worker_jobs(fake_claude: Path) -> None:
         source="test",
         now=11.0,
     )
+    third = wiki_queue.enqueue_maintenance_job(
+        wiki,
+        kind=wiki_queue.CATALOG_REFRESH_JOB,
+        payload={"catalog": "graph/skills-sh-catalog.json.gz"},
+        source="test",
+        now=12.0,
+    )
     leased = wiki_queue.lease_next(db_path, worker_id="worker-a", now=12.0)
     assert leased is not None
     wiki_queue.mark_failed(db_path, leased.id, error="boom", retry=False, now=13.0)
+    wiki_queue.cancel_job(db_path, third.id, reason="operator skipped", now=14.0)
 
     status = cm._queue_status()
+    html_out = cm._render_status()
 
     assert status["available"] is True
     assert status["counts"] == {
@@ -323,10 +340,12 @@ def test_queue_status_summarizes_worker_jobs(fake_claude: Path) -> None:
         wiki_queue.STATUS_RUNNING: 0,
         wiki_queue.STATUS_SUCCEEDED: 0,
         wiki_queue.STATUS_FAILED: 1,
+        wiki_queue.STATUS_CANCELLED: 1,
     }
-    assert status["total"] == 2
-    assert [job["id"] for job in status["recent_jobs"]] == [second.id, first.id]
-    assert status["recent_jobs"][0]["kind"] == wiki_queue.TAR_REFRESH_JOB
+    assert status["total"] == 3
+    assert [job["id"] for job in status["recent_jobs"]] == [third.id, second.id, first.id]
+    assert status["recent_jobs"][0]["status"] == wiki_queue.STATUS_CANCELLED
+    assert "cancelled: 1" in html_out
 
 
 def test_artifact_status_reads_promotion_metadata(
@@ -398,6 +417,33 @@ def test_status_page_and_api_show_queue_and_artifacts(
         server.server_close()
 
 
+def test_status_page_shows_queue_db_errors(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    db_path = wiki_queue.queue_db_path(fake_claude / "skill-wiki")
+    db_path.parent.mkdir(parents=True)
+    db_path.write_bytes(b"exists")
+
+    def fail_count_jobs_by_status(_db_path: Path) -> dict[str, int]:
+        raise RuntimeError("cannot read queue")
+
+    monkeypatch.setattr(
+        cm.wiki_queue,
+        "count_jobs_by_status",
+        fail_count_jobs_by_status,
+    )
+
+    status = cm._queue_status()
+    html_out = cm._render_status()
+
+    assert status["available"] is False
+    assert status["error"] == "cannot read queue"
+    assert "Queue DB error" in html_out
+    assert "cannot read queue" in html_out
+    assert "Durable worker DB: error" in html_out
+
+
 def test_render_loaded_shows_manifest_entries(fake_claude: Path) -> None:
     (fake_claude / "skill-manifest.json").write_text(
         json.dumps({
@@ -434,6 +480,92 @@ def test_render_loaded_shows_harness_install_without_unload_button(fake_claude:
     assert "data-slug='langgraph'" not in html
 
 
+def test_runtime_lifecycle_summary_reads_validation_and_escalation_events(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    events = tmp_path / "runtime" / "events.jsonl"
+    monkeypatch.setattr(cm, "_runtime_lifecycle_path", lambda: events)
+    _write_runtime_events(events, [
+        {
+            "action": "validation",
+            "session_id": "s-1",
+            "check_name": "pytest",
+            "status": "passed",
+            "created_at": "2026-05-08T01:00:00Z",
+        },
+        {
+            "action": "validation",
+            "session_id": "s-1",
+            "check_name": "mypy",
+            "status": "failed",
+            "summary": "type gate failed",
+            "created_at": "2026-05-08T01:05:00Z",
+        },
+        {
+            "action": "escalation",
+            "session_id": "s-1",
+            "trigger": "validation-failed",
+            "reason": "mypy failed after retry",
+            "status": "open",
+            "severity": "blocking",
+            "created_at": "2026-05-08T01:06:00Z",
+        },
+        {
+            "action": "escalation",
+            "session_id": "s-2",
+            "trigger": "user-review",
+            "reason": "review completed",
+            "status": "resolved",
+            "severity": "info",
+            "created_at": "2026-05-08T01:07:00Z",
+        },
+    ])
+
+    summary = cm._runtime_lifecycle_summary()
+
+    assert summary["validations_total"] == 2
+    assert summary["validation_failures"] == 1
+    assert summary["open_escalations_total"] == 1
+    assert summary["latest_validation"]["check_name"] == "mypy"
+    assert summary["open_escalations"][0]["trigger"] == "validation-failed"
+
+
+def test_render_runtime_lifecycle_surfaces_checks_and_open_escalations(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    events = tmp_path / "runtime" / "events.jsonl"
+    monkeypatch.setattr(cm, "_runtime_lifecycle_path", lambda: events)
+    _write_runtime_events(events, [
+        {
+            "action": "validation",
+            "session_id": "s-1",
+            "check_name": "mypy",
+            "status": "failed",
+            "summary": "<type gate failed>",
+            "created_at": "2026-05-08T01:05:00Z",
+        },
+        {
+            "action": "escalation",
+            "session_id": "s-1",
+            "trigger": "validation-failed",
+            "reason": "<mypy failed>",
+            "status": "open",
+            "severity": "blocking",
+            "created_at": "2026-05-08T01:06:00Z",
+        },
+    ])
+
+    html = cm._render_runtime_lifecycle()
+
+    assert "Runtime lifecycle" in html
+    assert "mypy" in html
+    assert "validation-failed" in html
+    assert "&lt;type gate failed&gt;" in html
+    assert "&lt;mypy failed&gt;" in html
+
+
 def test_render_logs_filters_and_renders(fake_claude: Path) -> None:
     _write_audit(fake_claude, [
         {"ts": "t1", "event": "skill.loaded", "subject_type": "skill",

src/tests/test_ctx_monitor_3type.py

@@ -206,6 +206,38 @@ class TestWikiIndexEntries:
 # ────────────────────────────────────────────────────────────────────
 
 
+def test_wiki_index_sampling_is_sorted_by_slug(wiki_3type: Path) -> None:
+    (wiki_3type / "entities" / "skills" / "aaa-first.md").write_text(
+        "---\ntype: skill\ndescription: first\n---\n# aaa-first\n",
+        encoding="utf-8",
+    )
+
+    entries = _cm._wiki_index_entries(limit_per_type=1)
+    skill_entries = [entry for entry in entries if entry["type"] == "skill"]
+
+    assert [entry["slug"] for entry in skill_entries] == ["aaa-first"]
+
+
+def test_wiki_entity_page_marks_truncated_body_and_frontmatter(
+    wiki_3type: Path,
+) -> None:
+    long_description = "x" * 160
+    long_body = "body-line\n" * 1400
+    (wiki_3type / "entities" / "skills" / "long-page.md").write_text(
+        "---\n"
+        f"description: {long_description}\n"
+        "type: skill\n"
+        "---\n"
+        f"{long_body}",
+        encoding="utf-8",
+    )
+
+    html = _cm._render_wiki_entity("long-page", entity_type="skill")
+
+    assert "Body preview truncated at 12,000 characters." in html
+    assert "(truncated)" in html
+
+
 class TestRenderHome3Type:
     def test_wiki_card_shows_mcp_count(self, wiki_3type, monkeypatch):
         # Other dependencies of _render_home need shims that don't touch

src/tests/test_harness_cli_run.py

@@ -218,6 +218,13 @@ class TestToolPolicy:
 
 
 class TestRunCommand:
+    def _write_model_profile(self, root: Path, data: dict[str, Any]) -> None:
+        root.mkdir(parents=True)
+        (root / "ctx-model-profile.json").write_text(
+            json.dumps(data),
+            encoding="utf-8",
+        )
+
     def test_happy_path_writes_session(
         self, fake_litellm: Any, tmp_path: Path, capsys: pytest.CaptureFixture[str],
     ) -> None:
@@ -239,6 +246,101 @@ class TestRunCommand:
         captured = capsys.readouterr()
         assert "final answer" in captured.out
 
+    def test_run_uses_ctx_init_model_profile_when_model_omitted(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        claude = tmp_path / "claude"
+        sessions = tmp_path / "sessions"
+        self._write_model_profile(
+            claude,
+            {
+                "mode": "custom",
+                "provider": "openai",
+                "model": "openai/gpt-5.5",
+                "api_key_env": "OPENAI_API_KEY",
+                "base_url": "https://api.example.test/v1",
+                "goal": "build agents",
+            },
+        )
+        monkeypatch.setattr(run_cli, "_claude_dir", lambda: claude)
+        monkeypatch.setenv("OPENAI_API_KEY", "profile-secret")
+
+        exit_code = main(
+            [
+                "run",
+                "--task", "say hi",
+                "--sessions-dir", str(sessions),
+                "--session-id", "profile-run",
+                "--no-ctx-tools",
+                "--quiet",
+            ],
+        )
+
+        assert exit_code == 0
+        call = fake_litellm._calls[0]
+        assert call["model"] == "openai/gpt-5.5"
+        assert call["api_key"] == "profile-secret"
+        assert call["api_base"] == "https://api.example.test/v1"
+        first_line = (sessions / "profile-run.jsonl").read_text(
+            encoding="utf-8",
+        ).splitlines()[0]
+        event = json.loads(first_line)
+        assert event["model"] == "openai/gpt-5.5"
+        assert event["provider"] == "openai"
+        assert event["api_key_env"] == "OPENAI_API_KEY"
+        captured = capsys.readouterr()
+        assert "final answer" in captured.out
+
+    def test_cli_model_override_does_not_inherit_stale_profile_provider(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        claude = tmp_path / "claude"
+        sessions = tmp_path / "sessions"
+        self._write_model_profile(
+            claude,
+            {
+                "mode": "custom",
+                "provider": "openai",
+                "model": "openai/gpt-5.5",
+                "api_key_env": "OPENAI_API_KEY",
+                "base_url": "https://api.example.test/v1",
+            },
+        )
+        monkeypatch.setattr(run_cli, "_claude_dir", lambda: claude)
+        monkeypatch.setenv("OPENAI_API_KEY", "profile-secret")
+
+        exit_code = main(
+            [
+                "run",
+                "--model", "ollama/qwen",
+                "--task", "say hi",
+                "--sessions-dir", str(sessions),
+                "--session-id", "override-run",
+                "--no-ctx-tools",
+                "--quiet",
+            ],
+        )
+
+        assert exit_code == 0
+        call = fake_litellm._calls[0]
+        assert call["model"] == "ollama/qwen"
+        assert "api_key" not in call
+        assert "api_base" not in call
+        first_line = (sessions / "override-run.jsonl").read_text(
+            encoding="utf-8",
+        ).splitlines()[0]
+        event = json.loads(first_line)
+        assert event["provider"] == "ollama"
+        assert event["api_key_env"] == ""
+        assert event["base_url"] == ""
+
     def test_session_id_flag_pins_id(
         self, fake_litellm: Any, tmp_path: Path, capsys: pytest.CaptureFixture[str],
     ) -> None:
@@ -397,10 +499,15 @@ class TestRunCommand:
         assert "session_id" in payload
 
     def test_model_required(
-        self, capsys: pytest.CaptureFixture[str],
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
     ) -> None:
-        with pytest.raises(SystemExit):
-            main(["run", "--task", "hi"])
+        monkeypatch.setattr(run_cli, "_claude_dir", lambda: tmp_path / "claude")
+
+        assert main(["run", "--task", "hi"]) == 2
+        assert "--model is required" in capsys.readouterr().err
 
     def test_task_required(
         self, capsys: pytest.CaptureFixture[str],

src/tests/test_harness_ctx_core.py

@@ -159,6 +159,8 @@ class TestToolDefinitions:
             "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",
@@ -228,6 +230,19 @@ class TestRuntimeLifecycle:
                 "slug": "fastapi-pro",
                 "evidence": "used in implementation",
             }),
+            ("ctx__record_validation", {
+                "session_id": "s-1",
+                "check_name": "pytest",
+                "status": "passed",
+                "command": "python -m pytest",
+                "summary": "all tests passed",
+            }),
+            ("ctx__record_escalation", {
+                "session_id": "s-1",
+                "trigger": "destructive-action",
+                "reason": "delete requires user approval",
+                "severity": "blocking",
+            }),
             ("ctx__unload_entity", {
                 "session_id": "s-1",
                 "entity_type": "skill",
@@ -253,6 +268,8 @@ class TestRuntimeLifecycle:
             "dev_event",
             "load_requested",
             "used",
+            "validation",
+            "escalation",
             "unload_requested",
             "session_end",
         ]
@@ -315,7 +332,138 @@ class TestRuntimeLifecycle:
         ]
 
 
-# ── recommend_bundle ───────────────────────────────────────────────────────
+# -- runtime validation ledger ----------------------------------------------
+
+
+class TestRuntimeValidationLedger:
+    def test_session_state_surfaces_validation_and_escalation_ledger(
+        self,
+        toolbox: CtxCoreToolbox,
+    ) -> None:
+        for name, arguments in [
+            ("ctx__record_validation", {
+                "session_id": "s-ledger",
+                "check_name": "mypy",
+                "status": "failed",
+                "command": "python -m mypy src",
+                "summary": "type gate failed",
+                "payload": {"errors": 3},
+            }),
+            ("ctx__record_escalation", {
+                "session_id": "s-ledger",
+                "trigger": "validation-failed",
+                "reason": "mypy failed after retry",
+                "severity": "blocking",
+                "payload": {"check_name": "mypy"},
+            }),
+        ]:
+            result = json.loads(
+                toolbox.dispatch(ToolCall(id="c1", name=name, arguments=arguments))
+            )
+            assert result["ok"] is True
+
+        state = json.loads(
+            toolbox.dispatch(ToolCall(
+                id="c1",
+                name="ctx__session_state",
+                arguments={"session_id": "s-ledger"},
+            ))
+        )
+
+        assert state["validations"] == [{
+            "check_name": "mypy",
+            "status": "failed",
+            "command": "python -m mypy src",
+            "summary": "type gate failed",
+            "entity_type": None,
+            "slug": None,
+            "payload": {"errors": 3},
+        }]
+        assert state["escalations"] == [{
+            "trigger": "validation-failed",
+            "reason": "mypy failed after retry",
+            "severity": "blocking",
+            "status": "open",
+            "entity_type": None,
+            "slug": None,
+            "payload": {"check_name": "mypy"},
+        }]
+        assert state["latest_validation_status"] == "failed"
+        assert state["open_escalations"] == state["escalations"]
+
+    def test_invalid_validation_status_is_structured(
+        self,
+        toolbox: CtxCoreToolbox,
+    ) -> None:
+        result = json.loads(
+            toolbox.dispatch(ToolCall(
+                id="c1",
+                name="ctx__record_validation",
+                arguments={
+                    "session_id": "s-ledger",
+                    "check_name": "pytest",
+                    "status": "maybe",
+                },
+            ))
+        )
+
+        assert result["ok"] is False
+        assert "status" in result["error"]
+
+
+# -- recommend_bundle --------------------------------------------------------
+
+
+def test_session_state_suppresses_current_dev_window_unloads(
+    toolbox: CtxCoreToolbox,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from ctx.adapters.generic import runtime_lifecycle
+
+    timestamps = iter([100.0, 101.0, 102.0, 103.0, 104.0, 105.0])
+    monkeypatch.setattr(runtime_lifecycle.time, "time", lambda: next(timestamps))
+
+    for name, arguments in [
+        ("ctx__observe_dev_event", {
+            "session_id": "s-window",
+            "event_type": "task",
+        }),
+        ("ctx__load_entity", {
+            "session_id": "s-window",
+            "entity_type": "skill",
+            "slug": "fastapi-pro",
+        }),
+    ]:
+        toolbox.dispatch(ToolCall(id="c1", name=name, arguments=arguments))
+
+    current_window = json.loads(
+        toolbox.dispatch(ToolCall(
+            id="c1",
+            name="ctx__session_state",
+            arguments={"session_id": "s-window"},
+        ))
+    )
+    assert current_window["unload_candidates"] == []
+
+    for name, arguments in [
+        ("ctx__session_end", {"session_id": "s-window"}),
+        ("ctx__observe_dev_event", {
+            "session_id": "s-window",
+            "event_type": "resume",
+        }),
+    ]:
+        toolbox.dispatch(ToolCall(id="c1", name=name, arguments=arguments))
+
+    next_window = json.loads(
+        toolbox.dispatch(ToolCall(
+            id="c1",
+            name="ctx__session_state",
+            arguments={"session_id": "s-window"},
+        ))
+    )
+    assert [entry["slug"] for entry in next_window["unload_candidates"]] == [
+        "fastapi-pro",
+    ]
 
 
 class TestRecommendBundle:
@@ -338,6 +486,97 @@ class TestRecommendBundle:
         names = [r["name"] for r in result["results"]]
         assert "fastapi-pro" in names
 
+    def test_companion_harnesses_are_separate_from_dev_results(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import ctx_init
+
+        calls: list[dict[str, Any]] = []
+
+        def fake_recommend_harnesses(
+            goal: str,
+            *,
+            top_k: int = 5,
+            model_provider: str | None = None,
+            model: str | None = None,
+        ) -> list[dict[str, Any]]:
+            calls.append({
+                "goal": goal,
+                "top_k": top_k,
+                "model_provider": model_provider,
+                "model": model,
+            })
+            return [{
+                "name": "langgraph",
+                "fit_score": 0.92,
+                "normalized_score": 0.88,
+                "matching_tags": ["agents"],
+                "provider_match": "openai",
+                "detail_url": "https://example.test/langgraph",
+                "install_command": "ctx-harness-install langgraph",
+            }]
+
+        monkeypatch.setattr(ctx_init, "recommend_harnesses", fake_recommend_harnesses)
+
+        result = json.loads(
+            toolbox.dispatch(
+                ToolCall(
+                    id="c1",
+                    name="ctx__recommend_bundle",
+                    arguments={
+                        "query": "python agent workflow",
+                        "top_k": 5,
+                        "model_provider": "openai",
+                        "model": "openai/gpt-5.5",
+                    },
+                )
+            )
+        )
+
+        assert calls == [{
+            "goal": "python agent workflow",
+            "top_k": 5,
+            "model_provider": "openai",
+            "model": "openai/gpt-5.5",
+        }]
+        assert all(row["type"] != "harness" for row in result["results"])
+        assert result["companion_harnesses"] == [{
+            "name": "langgraph",
+            "type": "harness",
+            "fit_score": 0.92,
+            "normalized_score": 0.88,
+            "matching_tags": ["agents"],
+            "provider_match": "openai",
+            "detail_url": "https://example.test/langgraph",
+            "install_command": "ctx-harness-install langgraph",
+        }]
+
+    def test_companion_harnesses_can_be_empty(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import ctx_init
+
+        monkeypatch.setattr(ctx_init, "recommend_harnesses", lambda *a, **kw: [])
+
+        result = json.loads(
+            toolbox.dispatch(
+                ToolCall(
+                    id="c1",
+                    name="ctx__recommend_bundle",
+                    arguments={
+                        "query": "python web api",
+                        "model_provider": "ollama",
+                    },
+                )
+            )
+        )
+
+        assert result["companion_harnesses"] == []
+
     def test_empty_query(self, toolbox: CtxCoreToolbox) -> None:
         result = json.loads(
             toolbox.dispatch(

src/tests/test_import_skills_sh_catalog.py

@@ -4,6 +4,7 @@ import json
 import sys
 import tarfile
 import zlib
+import gzip
 from io import BytesIO
 from pathlib import Path
 from typing import Any
@@ -16,6 +17,7 @@ from import_skills_sh_catalog import (
     drop_body_unavailable_skills,
     normalize_catalog,
     update_wiki_tarball,
+    write_gzip_json,
 )
 
 
@@ -36,6 +38,52 @@ def _read_json(tf: tarfile.TarFile, name: str) -> dict[str, Any]:
     return data
 
 
+def _read_gzip_json(path: Path) -> dict[str, Any]:
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        data = json.load(fh)
+    assert isinstance(data, dict)
+    return data
+
+
+def test_write_gzip_json_promotes_validated_catalog_with_metadata(tmp_path: Path) -> None:
+    catalog_path = tmp_path / "skills-sh-catalog.json.gz"
+    write_gzip_json(catalog_path, {"skills": [{"ctx_slug": "old"}]})
+
+    write_gzip_json(catalog_path, {"skills": [{"ctx_slug": "new"}]})
+
+    assert _read_gzip_json(catalog_path)["skills"][0]["ctx_slug"] == "new"
+    assert not catalog_path.with_name("skills-sh-catalog.json.gz.staged").exists()
+    metadata = json.loads(
+        catalog_path.with_name("skills-sh-catalog.json.gz.promotion.json").read_text(
+            encoding="utf-8",
+        ),
+    )
+    assert metadata["status"] == "promoted"
+    assert metadata["target"].endswith("skills-sh-catalog.json.gz")
+    assert metadata["last_good"]["exists"] is True
+    assert metadata["rollback"]["available"] is True
+
+
+def test_write_gzip_json_validation_failure_preserves_previous_catalog(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    catalog_path = tmp_path / "skills-sh-catalog.json.gz"
+    write_gzip_json(catalog_path, {"skills": [{"ctx_slug": "old"}]})
+    original = catalog_path.read_bytes()
+
+    def fail_validation(_path: Path, *, required_keys: tuple[str, ...] = ()) -> None:
+        raise ValueError("catalog candidate invalid")
+
+    monkeypatch.setattr(importer, "validate_gzip_json_artifact", fail_validation)
+
+    with pytest.raises(ValueError, match="catalog candidate invalid"):
+        write_gzip_json(catalog_path, {"skills": [{"ctx_slug": "new"}]})
+
+    assert catalog_path.read_bytes() == original
+    assert _read_gzip_json(catalog_path)["skills"][0]["ctx_slug"] == "old"
+
+
 def test_normalize_catalog_resolves_truncated_ctx_slug_collisions(monkeypatch) -> None:
     monkeypatch.setattr(
         "import_skills_sh_catalog._read_site_reported_total",
@@ -71,6 +119,7 @@ def test_normalize_catalog_resolves_truncated_ctx_slug_collisions(monkeypatch) -
 
 def test_update_wiki_tarball_adds_skills_sh_as_first_class_skill_nodes_and_pages(
     tmp_path: Path,
+    monkeypatch: Any,
 ) -> None:
     tarball = tmp_path / "wiki-graph.tar.gz"
     graph = {
@@ -120,6 +169,15 @@ def test_update_wiki_tarball_adds_skills_sh_as_first_class_skill_nodes_and_pages
         ],
     }
 
+    real_promote = importer.promote_staged_artifact
+    promoted_paths: list[tuple[str, str]] = []
+
+    def capture_promotion(staged_path: Path, target_path: Path, **kwargs: Any) -> Any:
+        promoted_paths.append((Path(staged_path).name, Path(target_path).name))
+        return real_promote(staged_path, target_path, **kwargs)
+
+    monkeypatch.setattr(importer, "promote_staged_artifact", capture_promotion)
+
     update_wiki_tarball(tarball, catalog)
 
     with tarfile.open(tarball, "r:gz") as tf:
@@ -148,6 +206,8 @@ def test_update_wiki_tarball_adds_skills_sh_as_first_class_skill_nodes_and_pages
     assert catalog_out["body_available_count"] == 0
     assert "body_available: false" in page
     assert "Security review: metadata-only" in page
+    assert promoted_paths == [("wiki-graph.tar.gz.staged", "wiki-graph.tar.gz")]
+    assert not tarball.with_name("wiki-graph.tar.gz.staged").exists()
 
 
 def test_update_wiki_tarball_preserves_existing_skills_sh_semantic_edges(

src/tests/test_mcp_server.py

@@ -60,6 +60,8 @@ _EXPECTED_TOOL_NAMES = {
     "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/tests/test_public_api.py

@@ -365,6 +365,8 @@ class TestCtxCoreToolboxRexport:
             "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/tests/test_validate_graph_artifacts.py

@@ -5,6 +5,7 @@ import json
 import tarfile
 from io import BytesIO
 from pathlib import Path
+from typing import Any
 
 import pytest
 import yaml  # type: ignore[import-untyped]
@@ -48,8 +49,20 @@ def _write_archive(
     include_converted: bool = True,
     include_original: bool = False,
     include_lock: bool = False,
+    include_delta: bool = True,
+    include_report: bool = True,
+    include_manifest: bool = True,
+    graph_export_id: str = "export-test",
+    delta_export_id: str = "export-test",
+    communities_export_id: str | None = None,
+    report_export_id: str | None = None,
+    manifest_export_id: str | None = None,
 ) -> None:
+    communities_export_id = communities_export_id or graph_export_id
+    report_export_id = report_export_id or graph_export_id
+    manifest_export_id = manifest_export_id or graph_export_id
     graph = {
+        "graph": {"export_id": graph_export_id},
         "nodes": [
             {
                 "id": "skill:skills-sh-example-skill",
@@ -69,7 +82,39 @@ def _write_archive(
     with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
         _add_text(tf, "./index.md", "# Wiki\n")
         _add_text(tf, "./graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
-        _add_text(tf, "./graphify-out/communities.json", json.dumps({"total_communities": 1}))
+        if include_delta:
+            _add_text(
+                tf,
+                "./graphify-out/graph-delta.json",
+                json.dumps({"export_id": delta_export_id, "nodes": [], "edges": []}),
+            )
+        _add_text(
+            tf,
+            "./graphify-out/communities.json",
+            json.dumps({"export_id": communities_export_id, "total_communities": 1}),
+        )
+        if include_report:
+            _add_text(
+                tf,
+                "./graphify-out/graph-report.md",
+                f"# Graph Report\n\n> Export ID: {report_export_id}\n",
+            )
+        if include_manifest:
+            _add_text(
+                tf,
+                "./graphify-out/graph-export-manifest.json",
+                json.dumps({
+                    "version": 1,
+                    "export_id": manifest_export_id,
+                    "artifacts": {
+                        "graph": "graph.json",
+                        "delta": "graph-delta.json",
+                        "communities": "communities.json",
+                        "report": "graph-report.md",
+                    },
+                    "counts": {"nodes": 2, "edges": 1, "communities": 1},
+                }),
+            )
         _add_text(tf, "./external-catalogs/skills-sh/catalog.json", "{}")
         _add_text(tf, "./entities/skills/skills-sh-example-skill.md", "# Example\n")
         _add_text(tf, "./entities/harnesses/langgraph.md", "# LangGraph\n")
@@ -145,6 +190,79 @@ def test_validate_graph_artifacts_checks_catalog_paths_and_deep_graph_stats(
         )
 
 
+def test_validate_graph_artifacts_rejects_mixed_export_generation(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, graph_export_id="new-export", delta_export_id="old-export")
+
+    with pytest.raises(GraphArtifactError, match="export_id mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+@pytest.mark.parametrize(
+    ("archive_kwargs", "missing_name"),
+    [
+        ({"include_delta": False}, "graph-delta.json"),
+        ({"include_report": False}, "graph-report.md"),
+        ({"include_manifest": False}, "graph-export-manifest.json"),
+    ],
+)
+def test_validate_graph_artifacts_rejects_missing_graph_export_files(
+    tmp_path: Path,
+    archive_kwargs: dict[str, Any],
+    missing_name: str,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, **archive_kwargs)
+
+    with pytest.raises(GraphArtifactError, match=missing_name):
+        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
+
+
+@pytest.mark.parametrize(
+    "archive_kwargs",
+    [
+        {"graph_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
+        {"delta_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
+        {
+            "communities_export_id": "artifact-export",
+            "manifest_export_id": "manifest-export",
+        },
+        {"report_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
+    ],
+)
+def test_validate_graph_artifacts_rejects_artifact_export_id_mismatch(
+    tmp_path: Path,
+    archive_kwargs: dict[str, Any],
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, **archive_kwargs)
+
+    with pytest.raises(GraphArtifactError, match="export_id mismatch"):
+        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
+
+
 def test_validate_graph_artifacts_rejects_missing_converted_catalog_path(
     tmp_path: Path,
 ) -> None:
@@ -242,7 +360,46 @@ def test_scan_graph_json_handles_pretty_printed_graph() -> None:
     }
     payload = json.dumps(graph, indent=2).encode("utf-8")
 
-    assert _scan_graph_json(BytesIO(payload)) == (2, 2, 1, 1, 1)
+    assert _scan_graph_json(BytesIO(payload)) == (2, 2, 1, 1, 1, None)
+
+
+def test_scan_graph_json_extracts_top_level_graph_export_id() -> None:
+    graph = {
+        "directed": False,
+        "graph": {
+            "source_catalog_nodes": {"skills.sh": 1},
+            "source_catalog_edges": {"skills.sh": 0},
+            "export_id": "graph-export",
+        },
+        "nodes": [
+            {
+                "id": "skill:skills-sh-example-skill",
+                "type": "skill",
+                "source_catalog": "skills.sh",
+            },
+        ],
+        "edges": [],
+    }
+    payload = json.dumps(graph, separators=(",", ":")).encode("utf-8")
+
+    assert _scan_graph_json(BytesIO(payload)) == (1, 0, 0, 1, 0, "graph-export")
+
+
+def test_scan_graph_json_ignores_node_level_export_id() -> None:
+    graph = {
+        "nodes": [
+            {
+                "id": "skill:skills-sh-example-skill",
+                "type": "skill",
+                "source_catalog": "skills.sh",
+                "export_id": "node-export",
+            },
+        ],
+        "edges": [],
+    }
+    payload = json.dumps(graph, separators=(",", ":")).encode("utf-8")
+
+    assert _scan_graph_json(BytesIO(payload)) == (1, 0, 0, 1, 0, None)
 
 
 def test_graph_only_workflow_uses_exact_release_counts() -> None:

src/tests/test_wiki_graphify_density.py

@@ -363,6 +363,8 @@ def test_source_overlap_creates_explainable_edge_without_tags(
     tmp_path,
     monkeypatch,
 ) -> None:
+    import ctx_config
+
     wiki, _ = _isolate_graphify(tmp_path, monkeypatch)
     shared_source = "https://github.com/acme/toolkit"
     _write_entity(
@@ -387,6 +389,18 @@ def test_source_overlap_creates_explainable_edge_without_tags(
     assert "source-overlap" in edge["edge_reasons"]
     assert edge["score_components"]["source_overlap"] > 0
 
+    custom_config = ctx_config.Config({"graph": {"min_edge_weight": 0.09}})
+    assert custom_config.graph_edge_min_weight == 0.09
+    try:
+        ctx_config.Config({"graph": {"min_edge_weight": 1.01}})
+    except ValueError as exc:
+        assert "min_edge_weight" in str(exc)
+    else:  # pragma: no cover - the assertion above is the behavior under test
+        raise AssertionError("graph.min_edge_weight above 1.0 must be rejected")
+    monkeypatch.setattr(ctx_config.cfg, "graph_edge_min_weight", 0.09)
+    filtered, _ = wg.build_graph(incremental=False)
+    assert not filtered.has_edge("skill:alpha-source", "agent:beta-target")
+
 
 def test_direct_links_quality_usage_type_and_adamic_are_explainable(
     tmp_path,

src/tests/test_wiki_graphify_security.py

@@ -273,7 +273,7 @@ def test_export_graph_uses_atomic_writer_for_artifacts(
     graphify_out: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """Graphify artifacts are large enough that direct writes can truncate state."""
+    """Graphify artifacts are staged, validated, promoted, and metadata-backed."""
     from ctx.core.wiki import wiki_graphify
 
     calls: list[str] = []
@@ -291,14 +291,27 @@ def test_export_graph_uses_atomic_writer_for_artifacts(
 
     wiki_graphify.export_graph(_make_sample_graph(), communities={})
 
-    assert set(calls) == {
+    assert {name for name in calls if name.endswith(".staged")} == {
+        "graph.json.staged",
+        "graph-delta.json.staged",
+        "communities.json.staged",
+        "graph-report.md.staged",
+        "graph-export-manifest.json.staged",
+    }
+    assert calls[-1] == "graph-export-manifest.json.staged"
+    for name in (
         "graph.json",
         "graph-delta.json",
         "communities.json",
         "graph-report.md",
         "graph-export-manifest.json",
-    }
-    assert calls[-1] == "graph-export-manifest.json"
+    ):
+        metadata = json.loads(
+            (graphify_out / f"{name}.promotion.json").read_text(encoding="utf-8")
+        )
+        assert metadata["status"] == "promoted"
+        assert metadata["target"].endswith(name)
+        assert "last_good" in metadata
 
 
 def test_load_prior_graph_rejects_post_graph_replace_crash(
@@ -317,17 +330,18 @@ def test_load_prior_graph_rejects_post_graph_replace_crash(
     new_graph = _make_sample_graph()
     new_graph.add_node("skill:new", label="new", type="skill", tags=["python"])
 
-    real_atomic = wiki_graphify.safe_atomic_write_text
+    real_promote = wiki_graphify.promote_staged_artifact
 
-    def crash_after_graph(path: Path, text: str, encoding: str = "utf-8") -> None:
-        real_atomic(path, text, encoding=encoding)
-        if path.name == "graph.json":
+    def crash_after_graph_promotion(*args, **kwargs):
+        result = real_promote(*args, **kwargs)
+        if Path(args[1]).name == "graph.json":
             raise RuntimeError("simulated crash after graph replacement")
+        return result
 
     monkeypatch.setattr(
         wiki_graphify,
-        "safe_atomic_write_text",
-        crash_after_graph,
+        "promote_staged_artifact",
+        crash_after_graph_promotion,
         raising=False,
     )
 

src/tests/test_wiki_queue.py

@@ -4,18 +4,50 @@ from __future__ import annotations
 
 import sqlite3
 from pathlib import Path
+from typing import Any
 
 import pytest
 
 from ctx.core.wiki import wiki_queue
 
 
-def test_init_queue_enables_wal_and_creates_schema(tmp_path: Path) -> None:
+def test_init_queue_enables_wal_and_creates_schema(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     db_path = tmp_path / "wiki-queue.sqlite3"
+    raw_connect = sqlite3.connect
+    closed = 0
+
+    class TrackingConnection:
+        def __init__(self, conn: sqlite3.Connection) -> None:
+            self._conn = conn
+
+        def __getattr__(self, name: str) -> object:
+            return getattr(self._conn, name)
+
+        @property
+        def row_factory(self) -> Any:
+            return self._conn.row_factory
+
+        @row_factory.setter
+        def row_factory(self, value: Any) -> None:
+            self._conn.row_factory = value
+
+        def close(self) -> None:
+            nonlocal closed
+            closed += 1
+            self._conn.close()
+
+    def tracking_connect(*args: Any, **kwargs: Any) -> TrackingConnection:
+        return TrackingConnection(raw_connect(*args, **kwargs))
+
+    monkeypatch.setattr(wiki_queue.sqlite3, "connect", tracking_connect)
 
     wiki_queue.init_queue(db_path)
 
-    with sqlite3.connect(db_path) as conn:
+    assert closed == 1
+    with raw_connect(db_path) as conn:
         assert conn.execute("PRAGMA journal_mode").fetchone()[0] == "wal"
         table_count = conn.execute(
             "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='wiki_queue_jobs'",
@@ -48,6 +80,7 @@ def test_enqueue_is_idempotent_by_key(tmp_path: Path) -> None:
 
 def test_enqueue_maintenance_job_is_idempotent_by_payload(tmp_path: Path) -> None:
     wiki = tmp_path / "wiki"
+    db_path = wiki_queue.queue_db_path(wiki)
 
     first = wiki_queue.enqueue_maintenance_job(
         wiki,
@@ -68,7 +101,31 @@ def test_enqueue_maintenance_job_is_idempotent_by_payload(tmp_path: Path) -> Non
     assert second.kind == wiki_queue.GRAPH_EXPORT_JOB
     assert second.payload["source"] == "test"
     assert second.payload["graph_only"] is True
-    assert wiki_queue.list_jobs(wiki_queue.queue_db_path(wiki)) == [first]
+    assert wiki_queue.list_jobs(db_path) == [first]
+
+    leased = wiki_queue.lease_next(db_path, worker_id="worker-a", now=20.0)
+    assert leased is not None
+    wiki_queue.mark_succeeded(db_path, leased.id, worker_id="worker-a", now=21.0)
+
+    third = wiki_queue.enqueue_maintenance_job(
+        wiki,
+        kind=wiki_queue.GRAPH_EXPORT_JOB,
+        payload={"incremental": True, "graph_only": True},
+        source="test",
+        now=30.0,
+    )
+    fourth = wiki_queue.enqueue_maintenance_job(
+        wiki,
+        kind=wiki_queue.GRAPH_EXPORT_JOB,
+        payload={"graph_only": True, "incremental": True},
+        source="test",
+        now=31.0,
+    )
+
+    assert third.id != first.id
+    assert third.status == wiki_queue.STATUS_PENDING
+    assert fourth.id == third.id
+    assert [job.id for job in wiki_queue.list_jobs(db_path)] == [first.id, third.id]
 
 
 def test_enqueue_maintenance_job_rejects_unknown_kind(tmp_path: Path) -> None:
@@ -81,6 +138,25 @@ def test_enqueue_maintenance_job_rejects_unknown_kind(tmp_path: Path) -> None:
         )
 
 
+def test_count_jobs_by_status_and_list_recent_jobs_are_bounded(tmp_path: Path) -> None:
+    db_path = tmp_path / "wiki-queue.sqlite3"
+    jobs = [
+        wiki_queue.enqueue(
+            db_path,
+            kind="graph-export",
+            payload={"n": index},
+            now=float(index),
+        )
+        for index in range(25)
+    ]
+
+    assert wiki_queue.count_jobs_by_status(db_path) == {wiki_queue.STATUS_PENDING: 25}
+    assert [job.id for job in wiki_queue.list_recent_jobs(db_path, limit=5)] == [
+        job.id for job in reversed(jobs[-5:])
+    ]
+    assert wiki_queue.list_recent_jobs(db_path, limit=0) == []
+
+
 def test_lease_next_claims_oldest_available_job(tmp_path: Path) -> None:
     db_path = tmp_path / "wiki-queue.sqlite3"
     first = wiki_queue.enqueue(db_path, kind="graph-export", payload={"n": 1}, now=10.0)
@@ -180,6 +256,68 @@ def test_expired_running_job_is_recovered_for_retry(tmp_path: Path) -> None:
     assert recovered.worker_id == "worker-b"
     assert recovered.attempts == 2
 
+    with pytest.raises(RuntimeError, match="not leased by worker worker-a"):
+        wiki_queue.mark_succeeded(db_path, job.id, worker_id="worker-a", now=27.0)
+
+    current = wiki_queue.get_job(db_path, job.id)
+    assert current.status == wiki_queue.STATUS_RUNNING
+    assert current.worker_id == "worker-b"
+
+    with pytest.raises(RuntimeError, match="not leased by worker worker-a"):
+        wiki_queue.mark_failed(
+            db_path,
+            job.id,
+            worker_id="worker-a",
+            error="late failure",
+            retry=True,
+            now=27.0,
+        )
+
+    current = wiki_queue.get_job(db_path, job.id)
+    assert current.status == wiki_queue.STATUS_RUNNING
+    assert current.worker_id == "worker-b"
+    assert current.last_error is None
+
+    recovery_db = tmp_path / "wiki-queue-recovery.sqlite3"
+    retryable = wiki_queue.enqueue(
+        recovery_db,
+        kind="graph-export",
+        payload={"n": 1},
+        max_attempts=2,
+        now=30.0,
+    )
+    exhausted = wiki_queue.enqueue(
+        recovery_db,
+        kind="tar-refresh",
+        payload={"n": 2},
+        max_attempts=1,
+        now=31.0,
+    )
+    first_lease = wiki_queue.lease_next(
+        recovery_db,
+        worker_id="worker-a",
+        lease_seconds=5.0,
+        now=40.0,
+    )
+    assert first_lease is not None
+    assert first_lease.id == retryable.id
+    second_lease = wiki_queue.lease_next(
+        recovery_db,
+        worker_id="worker-b",
+        lease_seconds=5.0,
+        now=41.0,
+    )
+    assert second_lease is not None
+    assert second_lease.id == exhausted.id
+
+    recovered_counts = wiki_queue.recover_expired_leases(recovery_db, now=47.0)
+
+    assert recovered_counts == {"requeued": 1, "failed": 1}
+    assert wiki_queue.get_job(recovery_db, retryable.id).status == wiki_queue.STATUS_PENDING
+    terminal = wiki_queue.get_job(recovery_db, exhausted.id)
+    assert terminal.status == wiki_queue.STATUS_FAILED
+    assert terminal.last_error == "lease expired; max attempts exhausted"
+
 
 def test_mark_succeeded_makes_job_unavailable(tmp_path: Path) -> None:
     db_path = tmp_path / "wiki-queue.sqlite3"
@@ -194,8 +332,54 @@ def test_mark_succeeded_makes_job_unavailable(tmp_path: Path) -> None:
     assert done.worker_id is None
     assert wiki_queue.lease_next(db_path, worker_id="worker-a", now=22.0) is None
 
+    first = wiki_queue.enqueue(db_path, kind="graph-export", payload={"n": 1}, now=30.0)
+    second = wiki_queue.enqueue(db_path, kind="tar-refresh", payload={"n": 2}, now=31.0)
+
+    cancelled = wiki_queue.cancel_job(
+        db_path,
+        first.id,
+        reason="superseded by newer artifact refresh",
+        now=32.0,
+    )
+
+    assert cancelled.status == wiki_queue.STATUS_CANCELLED
+    assert cancelled.last_error == "superseded by newer artifact refresh"
+    assert cancelled.worker_id is None
+    assert cancelled.leased_until is None
+    assert wiki_queue.cancel_job(db_path, first.id, now=33.0).id == first.id
+    leased_second = wiki_queue.lease_next(db_path, worker_id="worker-a", now=40.0)
+    assert leased_second is not None
+    assert leased_second.id == second.id
+    assert wiki_queue.count_jobs_by_status(db_path) == {
+        wiki_queue.STATUS_SUCCEEDED: 1,
+        wiki_queue.STATUS_CANCELLED: 1,
+        wiki_queue.STATUS_RUNNING: 1,
+    }
+
+    running_job = wiki_queue.enqueue(db_path, kind="graph-export", payload={}, now=50.0)
+    running_lease = wiki_queue.lease_next(db_path, worker_id="worker-b", now=60.0)
+    assert running_lease is not None
+    assert running_lease.id == running_job.id
+
+    cancelled_running = wiki_queue.cancel_job(
+        db_path,
+        running_job.id,
+        worker_id="worker-b",
+        reason="operator cancelled hung graph export",
+        now=61.0,
+    )
+
+    assert cancelled_running.status == wiki_queue.STATUS_CANCELLED
+    with pytest.raises(RuntimeError, match="not leased by worker worker-b"):
+        wiki_queue.mark_succeeded(db_path, running_job.id, worker_id="worker-b", now=62.0)
+
 
 def test_queue_rejects_symlinked_database_path(tmp_path: Path) -> None:
+    corrupt = tmp_path / "corrupt.sqlite3"
+    corrupt.write_bytes(b"not a sqlite database")
+    with pytest.raises(wiki_queue.QueueStorageError, match="queue database is not readable"):
+        wiki_queue.count_jobs_by_status(corrupt)
+
     real = tmp_path / "real.sqlite3"
     link = tmp_path / "queue.sqlite3"
     real.write_text("", encoding="utf-8")

src/tests/test_wiki_queue_worker.py

@@ -55,6 +55,17 @@ def test_process_next_entity_upsert_succeeds_and_refreshes_index(
         wiki_queue.STATUS_SUCCEEDED
     )
     update_index.assert_called_once_with(str(wiki), ["alpha"], subject_type="skills")
+    jobs = wiki_queue.list_jobs(wiki_queue.queue_db_path(wiki))
+    assert [job.kind for job in jobs] == [
+        wiki_queue.ENTITY_UPSERT_JOB,
+        wiki_queue.GRAPH_EXPORT_JOB,
+    ]
+    assert jobs[1].status == wiki_queue.STATUS_PENDING
+    assert jobs[1].payload == {
+        "graph_only": True,
+        "incremental": True,
+        "source": "entity-upsert",
+    }
 
 
 def test_process_next_retries_hash_mismatch(
@@ -145,6 +156,39 @@ def test_process_next_graph_export_job_uses_maintenance_handler(
     assert result.message == "graph exported"
     assert calls == [(wiki, {"graph_only": True, "source": "test"})]
 
+    db_path = wiki_queue.queue_db_path(wiki)
+    stolen_job = wiki_queue.enqueue_maintenance_job(
+        wiki,
+        kind=wiki_queue.GRAPH_EXPORT_JOB,
+        payload={"graph_only": True},
+        source="lease-stolen-test",
+        now=30.0,
+    )
+
+    def steal_lease(_path: Path, _payload: dict[str, Any]) -> str:
+        stolen = wiki_queue.lease_next(db_path, worker_id="worker-b", now=46.0)
+        assert stolen is not None
+        assert stolen.id == stolen_job.id
+        return "graph exported too late"
+
+    monkeypatch.setitem(
+        wiki_queue_worker.MAINTENANCE_HANDLERS,
+        wiki_queue.GRAPH_EXPORT_JOB,
+        steal_lease,
+    )
+
+    with pytest.raises(RuntimeError, match="not leased by worker worker-a"):
+        wiki_queue_worker.process_next(
+            wiki,
+            worker_id="worker-a",
+            lease_seconds=5.0,
+            now=40.0,
+        )
+
+    current = wiki_queue.get_job(db_path, stolen_job.id)
+    assert current.status == wiki_queue.STATUS_RUNNING
+    assert current.worker_id == "worker-b"
+
 
 def test_process_next_maintenance_job_retries_handler_failure(
     tmp_path: Path,

src/validate_graph_artifacts.py

@@ -32,6 +32,8 @@ _NODE_ID_RE = re.compile(rb'"id"\s*:')
 _EDGE_TARGET_RE = re.compile(rb'"target"\s*:')
 _SOURCE_SKILLS_SH_RE = re.compile(rb'"source_catalog"\s*:\s*"skills\.sh"')
 _HARNESS_TYPE_RE = re.compile(rb'"type"\s*:\s*"harness"')
+_GRAPH_KEY_RE = re.compile(rb'"graph"\s*:\s*\{')
+_REPORT_EXPORT_ID_RE = re.compile(r"^>\s*Export ID:\s*(\S+)\s*$", re.MULTILINE)
 _SEMANTIC_SIM_RE = re.compile(
     rb'"semantic_sim"\s*:\s*(-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)',
 )
@@ -101,12 +103,17 @@ def _count_lines(payload: bytes) -> int:
     return len(payload.decode("utf-8", errors="replace").splitlines())
 
 
-def _scan_graph_json(stream: IO[bytes]) -> tuple[int, int, int, int, int]:
+def _scan_graph_json(stream: IO[bytes]) -> tuple[int, int, int, int, int, str | None]:
     nodes = edges = semantic_edges = skills_sh_nodes = harness_nodes = 0
+    export_id: str | None = None
     tail = b""
+    graph_probe = b""
     while chunk := stream.read(1024 * 1024):
         old_tail = tail
         data = tail + chunk
+        if export_id is None:
+            graph_probe = (graph_probe + chunk)[-1024 * 1024:]
+            export_id = _extract_graph_export_id(graph_probe)
         nodes += len(_NODE_ID_RE.findall(data)) - len(_NODE_ID_RE.findall(old_tail))
         edges += len(_EDGE_TARGET_RE.findall(data)) - len(_EDGE_TARGET_RE.findall(old_tail))
         semantic_edges += (
@@ -122,7 +129,59 @@ def _scan_graph_json(stream: IO[bytes]) -> tuple[int, int, int, int, int]:
             - len(_HARNESS_TYPE_RE.findall(old_tail))
         )
         tail = data[-512:]
-    return nodes, edges, semantic_edges, skills_sh_nodes, harness_nodes
+    return nodes, edges, semantic_edges, skills_sh_nodes, harness_nodes, export_id
+
+
+def _scan_graph_export_id(stream: IO[bytes], *, max_bytes: int = 1024 * 1024) -> str | None:
+    payload = stream.read(max_bytes)
+    return _extract_graph_export_id(payload)
+
+
+def _extract_graph_export_id(payload: bytes) -> str | None:
+    match = _GRAPH_KEY_RE.search(payload)
+    if match is None:
+        return None
+    start = match.end() - 1
+    end = _json_object_end(payload, start)
+    if end is None:
+        return None
+    try:
+        graph_meta = json.loads(payload[start : end + 1].decode("utf-8"))
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(graph_meta, dict):
+        return None
+    raw = graph_meta.get("export_id")
+    if not isinstance(raw, str) or not raw.strip():
+        return None
+    return raw.strip()
+
+
+def _json_object_end(payload: bytes, start: int) -> int | None:
+    if start >= len(payload) or payload[start:start + 1] != b"{":
+        return None
+    depth = 0
+    in_string = False
+    escaped = False
+    for idx in range(start, len(payload)):
+        char = payload[idx]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif char == 0x5C:  # backslash
+                escaped = True
+            elif char == 0x22:  # double quote
+                in_string = False
+            continue
+        if char == 0x22:
+            in_string = True
+        elif char == 0x7B:  # {
+            depth += 1
+        elif char == 0x7D:  # }
+            depth -= 1
+            if depth == 0:
+                return idx
+    return None
 
 
 def _count_nonzero_semantic_matches(data: bytes) -> int:
@@ -200,6 +259,8 @@ def validate_graph_artifacts(
     harness_nodes = 0
     skill_pages = agent_pages = mcp_pages = harness_pages = skills_sh_converted = 0
     expected_harnesses = DEFAULT_HARNESSES if expected_harnesses is None else expected_harnesses
+    export_ids: dict[str, str] = {}
+    manifest: dict[str, Any] | None = None
 
     with tarfile.open(tarball, "r:gz") as tf:
         for member in tf:
@@ -221,17 +282,42 @@ def validate_graph_artifacts(
                 harness_pages += 1
             if name.startswith("converted/skills-sh-") and name.endswith("/SKILL.md"):
                 skills_sh_converted += 1
-            if member.isfile() and deep and name == "graphify-out/graph.json":
+            if member.isfile() and name == "graphify-out/graph.json":
                 f = tf.extractfile(member)
                 if f is None:
                     raise GraphArtifactError("graphify-out/graph.json could not be read")
-                (
-                    graph_nodes,
-                    graph_edges,
-                    graph_semantic_edges,
-                    skills_sh_nodes,
-                    harness_nodes,
-                ) = _scan_graph_json(f)
+                if deep:
+                    (
+                        graph_nodes,
+                        graph_edges,
+                        graph_semantic_edges,
+                        skills_sh_nodes,
+                        harness_nodes,
+                        graph_export_id,
+                    ) = _scan_graph_json(f)
+                else:
+                    graph_export_id = _scan_graph_export_id(f)
+                _record_export_id(export_ids, name, graph_export_id)
+            elif member.isfile() and name == "graphify-out/graph-delta.json":
+                data = _read_tar_json(tf, member, name)
+                _record_export_id(export_ids, name, _export_id_from_json(data, name))
+            elif member.isfile() and name == "graphify-out/communities.json":
+                data = _read_tar_json(tf, member, name)
+                _record_export_id(
+                    export_ids,
+                    name,
+                    _export_id_from_json(data, name),
+                )
+            elif member.isfile() and name == "graphify-out/graph-export-manifest.json":
+                data = _read_tar_json(tf, member, name)
+                if not isinstance(data, dict):
+                    raise GraphArtifactError(f"{name} did not contain a JSON object")
+                manifest = data
+            elif member.isfile() and name == "graphify-out/graph-report.md":
+                f = tf.extractfile(member)
+                if f is None:
+                    raise GraphArtifactError(f"{member.name} could not be read")
+                _record_export_id(export_ids, name, _export_id_from_report(f.read()))
             elif member.isfile() and deep and name.startswith("converted/skills-sh-"):
                 if name.endswith("/SKILL.md") or "/references/" in name:
                     f = tf.extractfile(member)
@@ -247,12 +333,24 @@ def validate_graph_artifacts(
     required_names = {
         "index.md",
         "graphify-out/graph.json",
+        "graphify-out/graph-delta.json",
         "graphify-out/communities.json",
+        "graphify-out/graph-report.md",
+        "graphify-out/graph-export-manifest.json",
         "external-catalogs/skills-sh/catalog.json",
     }
     missing_required = sorted(required_names - names)
     if missing_required:
         raise GraphArtifactError(f"wiki graph archive is missing: {missing_required}")
+    manifest_export_id = _validate_graph_export_manifest(manifest, names)
+    _record_export_id(
+        export_ids,
+        "graphify-out/graph-export-manifest.json",
+        manifest_export_id,
+    )
+    if "graphify-out/graph.json" not in export_ids:
+        raise GraphArtifactError("graphify-out/graph.json is missing export_id")
+    _validate_export_ids(export_ids, expected=manifest_export_id)
     missing_pages = sorted(required_skill_pages - names)
     if missing_pages:
         raise GraphArtifactError(f"missing Skills.sh entity pages: {missing_pages[:5]}")
@@ -330,6 +428,86 @@ def validate_graph_artifacts(
     return stats
 
 
+def _read_tar_json(tf: tarfile.TarFile, member: tarfile.TarInfo, name: str) -> Any:
+    f = tf.extractfile(member)
+    if f is None:
+        raise GraphArtifactError(f"{member.name} could not be read")
+    try:
+        return json.loads(f.read().decode("utf-8"))
+    except json.JSONDecodeError as exc:
+        raise GraphArtifactError(f"{name} is not valid JSON: {exc}") from exc
+
+
+def _export_id_from_json(data: Any, name: str) -> str:
+    if not isinstance(data, dict):
+        raise GraphArtifactError(f"{name} did not contain a JSON object")
+    raw = data.get("export_id")
+    if not isinstance(raw, str) or not raw.strip():
+        raise GraphArtifactError(f"{name} is missing export_id")
+    return raw.strip()
+
+
+def _export_id_from_report(payload: bytes) -> str:
+    text = payload.decode("utf-8", errors="replace")
+    match = _REPORT_EXPORT_ID_RE.search(text)
+    if match is None:
+        raise GraphArtifactError("graphify-out/graph-report.md is missing Export ID")
+    return match.group(1).strip()
+
+
+def _record_export_id(export_ids: dict[str, str], key: str, export_id: str | None) -> None:
+    if not export_id:
+        raise GraphArtifactError(f"{key} is missing export_id")
+    export_ids[key] = export_id
+
+
+def _validate_graph_export_manifest(
+    manifest: dict[str, Any] | None,
+    names: set[str],
+) -> str:
+    if manifest is None:
+        raise GraphArtifactError("graphify-out/graph-export-manifest.json is missing")
+    if manifest.get("version") != 1:
+        raise GraphArtifactError("graph export manifest version must be 1")
+    export_id = _export_id_from_json(manifest, "graphify-out/graph-export-manifest.json")
+    artifacts = manifest.get("artifacts")
+    if not isinstance(artifacts, dict):
+        raise GraphArtifactError("graph export manifest missing artifacts map")
+    expected = {
+        "graph": "graph.json",
+        "delta": "graph-delta.json",
+        "communities": "communities.json",
+        "report": "graph-report.md",
+    }
+    if set(artifacts) != set(expected):
+        raise GraphArtifactError(
+            "graph export manifest artifacts map must contain exactly "
+            f"{sorted(expected)}",
+        )
+    for key, filename in expected.items():
+        actual = artifacts.get(key)
+        if actual != filename:
+            raise GraphArtifactError(
+                f"graph export manifest artifact {key!r} expected {filename!r}, got {actual!r}",
+            )
+        archive_name = f"graphify-out/{filename}"
+        if archive_name not in names:
+            raise GraphArtifactError(f"graph export manifest references missing {archive_name}")
+    return export_id
+
+
+def _validate_export_ids(export_ids: dict[str, str], *, expected: str) -> None:
+    mismatches = {
+        key: value
+        for key, value in sorted(export_ids.items())
+        if value != expected
+    }
+    if mismatches:
+        raise GraphArtifactError(
+            f"graph export_id mismatch: expected {expected}, mismatches={mismatches}",
+        )
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--graph-dir", type=Path, default=Path("graph"))