Sync ctx v1.0.7 release metadata and dashboard fix

CHANGELOG.md

@@ -3,11 +3,21 @@
 All notable changes to the `ctx` project will be documented in this file.
 Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## [Unreleased]
-
-- No unreleased changes yet.
-
-## [1.0.6] - 2026-05-14
+## [Unreleased]
+
+- No unreleased changes yet.
+
+## [1.0.7] - 2026-05-15
+
+### Fixed
+
+- Fixed dashboard graph cold starts for `ctx-init --graph` installs by keeping
+  the SQLite neighborhood index fast path when the installed release overlay is
+  already represented in the shipped graph index.
+- Preserved the safe full-graph merge path for local/user runtime overlays so
+  newly attached entity edges still appear immediately in the dashboard.
+
+## [1.0.6] - 2026-05-14
 
 ### Fixed
 
@@ -1548,7 +1558,8 @@ pass. Full test suite: **1316 passed, 2 skipped**.
 - 5 dead imports removed (`os`, `Mapping`, `timedelta` from
   `ctx_lifecycle`; `Path` from `intake_gate`, `intake_pipeline`).
 
-[1.0.6]: https://github.com/stevesolun/ctx/releases/tag/v1.0.6
+[1.0.7]: https://github.com/stevesolun/ctx/releases/tag/v1.0.7
+[1.0.6]: https://github.com/stevesolun/ctx/releases/tag/v1.0.6
 [1.0.5]: https://github.com/stevesolun/ctx/releases/tag/v1.0.5
 [1.0.4]: https://github.com/stevesolun/ctx/releases/tag/v1.0.4
 [1.0.3]: https://github.com/stevesolun/ctx/releases/tag/v1.0.3

README.md

@@ -1,16 +1,21 @@
 ---
 license: mit
 pretty_name: ctx
+language:
+- en
 tags:
-  - agents
-  - mcp
-  - skills
-  - knowledge-graph
-  - llm-wiki
-  - recommendation-system
-  - harness
-  - codex
-  - claude-code
+- agents
+- mcp
+- skills
+- knowledge-graph
+- llm-wiki
+- recommendation-system
+- harness
+- codex
+- claude-code
+- python
+release: v1.0.7
+github_commit: dbd6de3daaba0ec4715c7c13125c6f2c5929f419
 ---
 
 # ctx — Skill, Agent, MCP & Harness Recommendations
@@ -18,7 +23,7 @@ tags:
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/Python-3.11+-green.svg)](https://python.org)
 [![PyPI](https://img.shields.io/pypi/v/claude-ctx.svg)](https://pypi.org/project/claude-ctx/)
-[![Tests](https://img.shields.io/badge/Tests-3818_collected-brightgreen.svg)](#)
+[![Tests](https://img.shields.io/badge/Tests-3821_collected-brightgreen.svg)](#)
 [![Graph](https://img.shields.io/badge/Graph-102%2C717_nodes_/_2.9M_edges-red.svg)](graph/)
 [![Docs](https://img.shields.io/badge/docs-MkDocs_Material-blue.svg)](https://stevesolun.github.io/ctx/)
 

docs/index.md

@@ -188,8 +188,8 @@ ones are flagged. New ones self-ingest.
 
     ---
 
-    **v1.0.6** — MIT, CI-matrixed (Ubuntu 3.12 plus Windows/macOS 3.11/3.12),
-    3,818 tests collected. Ships console scripts including `ctx-init`,
+    **v1.0.7** — MIT, CI-matrixed (Ubuntu 3.12 plus Windows/macOS 3.11/3.12),
+    3,821 tests collected. Ships console scripts including `ctx-init`,
     `ctx-monitor` (local dashboard with graph + wiki + load/unload for
     skills, agents, and MCP servers, plus Harness Setup for user-owned LLMs),
     `ctx-incremental-attach`, `ctx-incremental-shadow`, `ctx-dedup-check`

pyproject.toml

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

src/__init__.py

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

src/ctx/__init__.py

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

src/ctx_monitor.py

@@ -57,6 +57,7 @@ starting point.
 from __future__ import annotations
 
 import argparse
+import hashlib
 import html
 import ipaddress
 import json
@@ -88,6 +89,8 @@ _MONITOR_TOKEN = ""
 _MONITOR_MUTATIONS_ENABLED = True
 _GRAPH_CACHE_KEY: tuple[Any, ...] | None = None
 _GRAPH_CACHE_VALUE: Any | None = None
+_OVERLAY_INDEX_COVERAGE_CACHE_KEY: tuple[Any, ...] | None = None
+_OVERLAY_INDEX_COVERAGE_CACHE_VALUE: bool | None = None
 _SIDECAR_INDEX_CACHE_KEY: tuple[tuple[Path, float, int], ...] | None = None
 _SIDECAR_INDEX_CACHE_VALUE: dict[tuple[str, str], dict] | None = None
 _WIKI_INDEX_LIMIT_PER_TYPE = 500
@@ -2337,6 +2340,129 @@ def _dashboard_graph_has_runtime_overlays() -> bool:
         return False
 
 
+def _overlay_index_coverage_key(index_path: Path, overlay: Path) -> tuple[Any, ...] | None:
+    try:
+        index_stat = index_path.stat()
+        overlay_stat = overlay.stat()
+    except OSError:
+        return None
+    return (
+        index_path.resolve(),
+        index_stat.st_mtime,
+        index_stat.st_size,
+        overlay.resolve(),
+        overlay_stat.st_mtime,
+        overlay_stat.st_size,
+        _dashboard_graph_manifest_export_id(),
+    )
+
+
+def _active_dashboard_overlay_records(overlay: Path) -> list[dict[str, Any]] | None:
+    try:
+        from ctx.core.graph.entity_overlays import active_overlay_records
+
+        rows = []
+        for line in overlay.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            payload = json.loads(line)
+            if not isinstance(payload, dict):
+                return None
+            rows.append(payload)
+        return [dict(row) for row in active_overlay_records(rows)]
+    except (OSError, json.JSONDecodeError, TypeError, ValueError):
+        return None
+
+
+def _dashboard_overlay_matches_known_release(overlay: Path) -> bool:
+    try:
+        from ctx_init import _GRAPH_ENTITY_OVERLAY_SHA256
+    except (ImportError, AttributeError):
+        return False
+    if not isinstance(_GRAPH_ENTITY_OVERLAY_SHA256, str) or not _GRAPH_ENTITY_OVERLAY_SHA256:
+        return False
+    try:
+        data = overlay.read_bytes().replace(b"\r\n", b"\n")
+        return hashlib.sha256(data).hexdigest() == _GRAPH_ENTITY_OVERLAY_SHA256
+    except OSError:
+        return False
+
+
+def _dashboard_index_covers_runtime_overlays(index_path: Path) -> bool:
+    """Return True when the shipped SQLite index already includes overlays.
+
+    ``ctx-init`` may install ``entity-overlays.jsonl`` beside a graph export.
+    Older dashboard code treated any overlay file as runtime-only and skipped
+    the SQLite fast path. Current release artifacts can already contain those
+    overlay nodes and edges in ``dashboard-neighborhoods.sqlite3``; in that
+    case loading the full graph just to merge the same small known-release
+    overlay is wasted cold-start work. Local/user overlays still fall back to
+    the full graph merge so newly attached edges remain visible.
+    """
+    overlay = _wiki_dir() / "graphify-out" / "entity-overlays.jsonl"
+    try:
+        if not overlay.is_file() or overlay.stat().st_size == 0:
+            return True
+    except OSError:
+        return True
+    if not index_path.is_file() or not _dashboard_index_matches_manifest(index_path):
+        return False
+
+    global _OVERLAY_INDEX_COVERAGE_CACHE_KEY, _OVERLAY_INDEX_COVERAGE_CACHE_VALUE
+    cache_key = _overlay_index_coverage_key(index_path, overlay)
+    if (
+        cache_key is not None
+        and _OVERLAY_INDEX_COVERAGE_CACHE_KEY == cache_key
+        and _OVERLAY_INDEX_COVERAGE_CACHE_VALUE is not None
+    ):
+        return _OVERLAY_INDEX_COVERAGE_CACHE_VALUE
+
+    if not _dashboard_overlay_matches_known_release(overlay):
+        coverage = False
+    else:
+        records = _active_dashboard_overlay_records(overlay)
+        if records is None:
+            coverage = False
+        else:
+            coverage = True
+            try:
+                conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+                conn.row_factory = sqlite3.Row
+                try:
+                    for record in records:
+                        nodes = record.get("nodes", [])
+                        edges = record.get("edges", [])
+                        if not isinstance(nodes, list) or not isinstance(edges, list):
+                            coverage = False
+                            break
+                        if not nodes and edges:
+                            coverage = False
+                            break
+                        for node in nodes:
+                            if not isinstance(node, dict):
+                                coverage = False
+                                break
+                            node_id = node.get("id")
+                            if not isinstance(node_id, str) or not conn.execute(
+                                "SELECT 1 FROM nodes WHERE id=? LIMIT 1",
+                                (node_id,),
+                            ).fetchone():
+                                coverage = False
+                                break
+                        if not coverage:
+                            break
+                finally:
+                    conn.close()
+            except (OSError, sqlite3.Error, KeyError, TypeError):
+                coverage = False
+
+    if cache_key is not None:
+        _OVERLAY_INDEX_COVERAGE_CACHE_KEY = cache_key
+        _OVERLAY_INDEX_COVERAGE_CACHE_VALUE = coverage
+    return coverage
+
+
 def _dashboard_graph_index_archives() -> list[Path]:
     module_root = Path(__file__).resolve().parent.parent
     roots = (module_root,)
@@ -2702,7 +2828,10 @@ def _graph_neighborhood(
     if "/" in slug or "\\" in slug or ".." in slug:
         return {"nodes": [], "edges": [], "center": None}
     normalized_entity_type = _normalize_dashboard_entity_type(entity_type)
-    if not _dashboard_graph_has_runtime_overlays():
+    if (
+        not _dashboard_graph_has_runtime_overlays()
+        or _dashboard_index_covers_runtime_overlays(_dashboard_graph_index_path())
+    ):
         indexed = _graph_neighborhood_from_index(
             slug,
             hops=hops,
@@ -3287,14 +3416,18 @@ def _render_skill_detail(slug: str, entity_type: str | None = None) -> str:
 
 
 def _top_degree_seeds_from_index(limit: int = 18) -> list[dict]:
-    if _dashboard_graph_has_runtime_overlays():
+    index_path = _dashboard_graph_index_path()
+    if (
+        _dashboard_graph_has_runtime_overlays()
+        and not _dashboard_index_covers_runtime_overlays(index_path)
+    ):
         return []
-    index_path = _ensure_dashboard_graph_index()
-    if index_path is None or not index_path.is_file():
+    ensured_index_path = _ensure_dashboard_graph_index()
+    if ensured_index_path is None or not ensured_index_path.is_file():
         return []
     conn: sqlite3.Connection | None = None
     try:
-        conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+        conn = sqlite3.connect(f"file:{ensured_index_path.as_posix()}?mode=ro", uri=True)
         conn.row_factory = sqlite3.Row
         rows = conn.execute(
             "SELECT id,label,type,degree FROM nodes ORDER BY degree DESC,id LIMIT ?",

src/tests/test_ctx_monitor.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import http.client
+import hashlib
 import json
 import os
 import sqlite3
@@ -17,6 +18,7 @@ from pathlib import Path
 import pytest
 
 import ctx_monitor as cm
+import ctx_init as ci
 from ctx.core.wiki import wiki_queue
 
 
@@ -1532,6 +1534,175 @@ def test_graph_neighborhood_uses_dashboard_index_without_full_graph_load(
     }
 
 
+def test_graph_neighborhood_uses_dashboard_index_when_overlay_is_already_indexed(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_graph_manifest(fake_claude, "test-export")
+    graph_dir = fake_claude / "skill-wiki" / "graphify-out"
+    index_path = graph_dir / "dashboard-neighborhoods.sqlite3"
+    overlay_path = graph_dir / "entity-overlays.jsonl"
+    graph_dir.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("max_degree", "10"),
+                ("top_k", "40"),
+                ("export_id", json.dumps("test-export")),
+                ("nodes_count", "2"),
+                ("edges_count", "1"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            [
+                ("harness:mirage", "mirage", "harness", '["sandbox"]', "", 0.82, 0.0, 10),
+                ("skill:codex-review", "codex-review", "skill", '["review"]', "", 0.7, 0.0, 5),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            [
+                ("mirage", "harness", "harness:mirage"),
+                ("codex-review", "skill", "skill:codex-review"),
+            ],
+        )
+        conn.execute(
+            "INSERT INTO neighbors VALUES(?,?)",
+            (
+                "harness:mirage",
+                zlib.compress(json.dumps([
+                    {
+                        "target": "skill:codex-review",
+                        "weight": 0.18,
+                        "shared_tags": ["sandbox"],
+                    },
+                ]).encode("utf-8")),
+            ),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+    overlay_path.write_text(
+        json.dumps({
+            "overlay_id": "mirage-overlay",
+            "nodes": [{"id": "harness:mirage", "type": "harness"}],
+            "edges": [{"source": "harness:mirage", "target": "skill:codex-review"}],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(cm, "_dashboard_overlay_matches_known_release", lambda overlay: True)
+    monkeypatch.setattr(
+        cm,
+        "_load_dashboard_graph",
+        lambda: (_ for _ in ()).throw(AssertionError("full graph loaded")),
+    )
+
+    result = cm._graph_neighborhood("mirage", entity_type="harness")
+
+    assert result["center"] == "harness:mirage"
+    assert [node["data"]["id"] for node in result["nodes"]] == [
+        "harness:mirage",
+        "skill:codex-review",
+    ]
+
+
+def test_dashboard_overlay_release_hash_normalizes_crlf(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    overlay = tmp_path / "entity-overlays.jsonl"
+    overlay.write_bytes(b'{"overlay_id":"release"}\r\n')
+    expected = hashlib.sha256(b'{"overlay_id":"release"}\n').hexdigest()
+    monkeypatch.setattr(ci, "_GRAPH_ENTITY_OVERLAY_SHA256", expected)
+
+    assert cm._dashboard_overlay_matches_known_release(overlay)
+
+
+def test_graph_neighborhood_bypasses_index_for_local_overlay_even_when_node_exists(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import networkx as nx
+
+    _write_graph_manifest(fake_claude, "test-export")
+    graph_dir = fake_claude / "skill-wiki" / "graphify-out"
+    index_path = graph_dir / "dashboard-neighborhoods.sqlite3"
+    overlay_path = graph_dir / "entity-overlays.jsonl"
+    graph_dir.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("max_degree", "10"),
+                ("top_k", "40"),
+                ("export_id", json.dumps("test-export")),
+                ("nodes_count", "1"),
+                ("edges_count", "0"),
+            ],
+        )
+        conn.execute(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            ("skill:existing", "existing", "skill", "[]", "", 0.7, 0.0, 0),
+        )
+        conn.execute(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            ("existing", "skill", "skill:existing"),
+        )
+        conn.execute(
+            "INSERT INTO neighbors VALUES(?,?)",
+            ("skill:existing", zlib.compress(b"[]")),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+    overlay_path.write_text(
+        json.dumps({
+            "kind": "ann_attach",
+            "nodes": [{"id": "skill:existing", "type": "skill"}],
+            "edges": [{"source": "skill:existing", "target": "skill:new-runtime-edge"}],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        cm,
+        "_graph_neighborhood_from_index",
+        lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("index used")),
+    )
+    G = nx.Graph()
+    G.add_node("skill:existing", label="existing", type="skill", tags=[])
+    monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
+
+    result = cm._graph_neighborhood("existing", entity_type="skill")
+
+    assert result["center"] == "skill:existing"
+
+
 def test_graph_index_honors_requested_type_on_exact_slug(
     fake_claude: Path,
 ) -> None: