codecortex 0.8.0__tar.gz → 0.8.2__tar.gz

{codecortex-0.8.0/src/codecortex.egg-info → codecortex-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.0
+Version: 0.8.2
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.8.0 → codecortex-0.8.2/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.0
+Version: 0.8.2
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.8.0 → codecortex-0.8.2}/src/codecortex.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ tests/test_graph_stdin.py
 tests/test_hardening.py
 tests/test_http_auth.py
 tests/test_http_server.py
+tests/test_installer.py
 tests/test_integration.py
 tests/test_lsp_provider.py
 tests/test_lsp_real.py

codecortex-0.8.2/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.2"

{codecortex-0.8.0 → codecortex-0.8.2}/src/codeintel/__main__.py

@@ -166,8 +166,12 @@ def main() -> None:
         gen = MapGenerator(provider)
         try:
             content = gen.generate(project_root, budget_bytes=args.budget)
-            path = gen.write(project_root, content)
-            print(f"Wrote {path} ({len(content.encode())} bytes)")
+            path, wrote = gen.write(project_root, content)
+            if wrote:
+                print(f"Wrote {path} ({len(content.encode())} bytes)")
+            else:
+                print(f"Kept existing {path} — new map was a stub (graph empty/unindexed; "
+                      f"run `codeintel index` first)")
             if args.inject:
                 inj_path, inj_action = Injector().inject(project_root)
                 if inj_path:

codecortex-0.8.2/src/codeintel/installer.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+
+_AGENTS = ["claude", "codex", "gemini", "zed"]
+
+
+def _atomic_write_text(path: pathlib.Path, text: str) -> None:
+    """Write via a sibling temp file + os.replace so an interrupted write can never truncate
+    the user's existing agent config (which holds unrelated settings) to a partial/empty file.
+    The temp lives in the same directory as ``path`` so the replace stays on one filesystem."""
+    tmp = path.with_name(path.name + ".codeintel.tmp")
+    tmp.write_text(text, encoding="utf-8")
+    os.replace(tmp, path)
+
+
+# Per-agent registration recipe. Most agents take a Claude-style JSON block; Codex is different —
+# its CLI reads MCP servers from ``~/.codex/config.toml`` as ``[mcp_servers.<name>]`` TOML tables,
+# NOT a JSON ``mcpServers`` map in config.json (writing the latter registers nothing).
+_CONFIG: dict[str, dict] = {
+    "claude": {
+        "format": "json",
+        "path": "~/.claude/settings.json",
+        "key": ["mcpServers", "codeintel"],
+        "value": {"command": "codeintel", "args": ["serve"]},
+    },
+    "codex": {
+        "format": "toml-mcp",
+        "path": "~/.codex/config.toml",
+        "table": "[mcp_servers.codeintel]",
+        "block": '[mcp_servers.codeintel]\ncommand = "codeintel"\nargs = ["serve"]\n',
+    },
+    "gemini": {
+        "format": "json",
+        "path": "~/.gemini/settings.json",
+        "key": ["mcpServers", "codeintel"],
+        "value": {"command": "codeintel", "args": ["serve"]},
+    },
+    "zed": {
+        "format": "json",
+        "path": "~/.config/zed/settings.json",
+        "key": ["context_servers", "codeintel"],
+        "value": {"command": {"path": "codeintel", "args": ["serve"]}},
+    },
+}
+
+
+def _get_nested(data: dict, keys: list[str]):
+    node = data
+    for k in keys:
+        if not isinstance(node, dict) or k not in node:
+            return None
+        node = node[k]
+    return node
+
+
+def _set_nested(data: dict, keys: list[str], value) -> None:
+    node = data
+    for k in keys[:-1]:
+        if k not in node or not isinstance(node[k], dict):
+            node[k] = {}
+        node = node[k]
+    node[keys[-1]] = value
+
+
+class Installer:
+    def register(self, agent: str) -> dict:
+        spec = _CONFIG.get(agent)
+        if spec is None:
+            return self._result(agent, "", False, "failed", f"unknown agent '{agent}'")
+        config_path = pathlib.Path(spec["path"]).expanduser()
+        try:
+            if spec.get("format") == "toml-mcp":
+                return self._register_toml(agent, config_path, spec)
+            return self._register_json(agent, config_path, spec)
+        except Exception as exc:
+            return self._result(agent, str(config_path), False, "failed", str(exc))
+
+    def _register_json(self, agent: str, config_path: pathlib.Path, spec: dict) -> dict:
+        if config_path.exists():
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                data = {}
+        else:
+            data = {}
+
+        if _get_nested(data, spec["key"]) == spec["value"]:
+            return self._result(agent, str(config_path), True, "already")
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        _set_nested(data, spec["key"], spec["value"])
+        _atomic_write_text(config_path, json.dumps(data, indent=2))
+        return self._result(agent, str(config_path), True, "registered")
+
+    def _register_toml(self, agent: str, config_path: pathlib.Path, spec: dict) -> dict:
+        """Codex: append an ``[mcp_servers.codeintel]`` table to config.toml, preserving everything
+        already there (other servers, project trust levels, hooks). Text-based on purpose — it must
+        not reformat or risk corrupting a config the user hand-edits, and it stays idempotent by
+        checking for the table header. If a codeintel entry already exists it is left untouched."""
+        existing = config_path.read_text(encoding="utf-8") if config_path.exists() else ""
+        if spec["table"] in existing:
+            return self._result(agent, str(config_path), True, "already")
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        if existing == "":
+            new_text = spec["block"]
+        else:
+            prefix = existing if existing.endswith("\n") else existing + "\n"
+            new_text = prefix + "\n" + spec["block"]  # blank line before the new table
+        _atomic_write_text(config_path, new_text)
+        return self._result(agent, str(config_path), True, "registered")
+
+    @staticmethod
+    def _result(agent: str, path: str, ok: bool, action: str, reason: str = "") -> dict:
+        return {"agent": agent, "path": path, "ok": ok, "action": action, "reason": reason}
+
+    def register_all(self) -> list[dict]:
+        return [self.register(agent) for agent in _AGENTS]

{codecortex-0.8.0 → codecortex-0.8.2}/src/codeintel/mapper.py

@@ -1,11 +1,30 @@
 from __future__ import annotations
 
+import logging
 import os
 from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from codeintel.providers.graph import GraphProvider
 
+logger = logging.getLogger(__name__)
+
+# A map with any of these sections carries real, indexed orientation content. Anything without
+# them is a degraded stub: `_minimal_map` (graph unavailable / repo unindexed / generation failed),
+# or a render over an empty graph. Note the ranked marker includes "(by caller count)" — the
+# empty-graph render emits a differently-worded "## Ranked Symbols" heading that is NOT this.
+_POPULATED_MARKERS = (
+    "## Architecture Overview",
+    "## Ranked Symbols (by caller count)",
+    "## Entry Points",
+)
+
+
+def _is_populated_map(text: str) -> bool:
+    """True when the map has real content (architecture overview, a ranked-symbol table, or entry
+    points) rather than a degraded stub — used to avoid overwriting a good CODE_INTEL.md."""
+    return any(marker in text for marker in _POPULATED_MARKERS)
+
 # Real codebase-memory-mcp contract (verified live): query_graph returns {columns, rows}
 # value-arrays, module-level calls are USAGE (not only CALLS), and nodes carry `is_entry_point`
 # (there is no `fn.type` property — that filter matched nothing, so the old queries were dead).
@@ -82,15 +101,38 @@ class MapGenerator:
         except Exception as exc:
             return _minimal_map(project_root, note=f"map generation failed: {exc}")
 
-    def write(self, project_root: str, content: str) -> str:
+    def write(self, project_root: str, content: str) -> tuple[str, bool]:
+        """Write CODE_INTEL.md; return ``(path, wrote)``. ``wrote`` is False when an existing
+        populated map was preserved rather than clobbered by a stub (or the write failed), so
+        callers can report the outcome honestly.
+
+        Don't clobber a good map with a degraded stub: `generate` returns a stub when the graph
+        backend is unavailable or hasn't indexed this repo yet — a common transient during
+        `codeintel index`'s best-effort refresh. Overwriting a previously-populated CODE_INTEL.md
+        with that stub silently destroys real orientation content, so when the new content is a
+        stub and an existing map is populated, preserve the existing file."""
         path = os.path.join(project_root, "CODE_INTEL.md")
+        if not _is_populated_map(content):
+            try:
+                if os.path.isfile(path):
+                    with open(path, encoding="utf-8") as f:
+                        existing = f.read()
+                    if _is_populated_map(existing):
+                        logger.warning(
+                            "CODE_INTEL.md: new map is a stub (graph empty/unavailable) — keeping "
+                            "the existing populated map at %s (run `codeintel index` to refresh)",
+                            path,
+                        )
+                        return path, False
+            except Exception:
+                pass  # can't read the existing file — fall through and write (best-effort)
         try:
             with open(path, "w", encoding="utf-8") as f:
                 f.write(content)
+            return path, True
         except Exception as exc:
-            import logging
-            logging.getLogger(__name__).warning("CODE_INTEL.md write failed: %s", exc)
-        return path
+            logger.warning("CODE_INTEL.md write failed: %s", exc)
+            return path, False
 
 
 def _query_ranked_symbols(provider: GraphProvider, project: str) -> list[dict]:

{codecortex-0.8.0 → codecortex-0.8.2}/src/codeintel/providers/graph.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import shutil
 import subprocess
 import threading
@@ -107,6 +108,13 @@ class GraphProvider:
         older/mocked shape — accept both. Prefer an exact ``root_path`` match; otherwise the
         LONGEST prefix match (so ``.../project/codeintel`` resolves to codeintel, not its
         parent ``.../project``). Pure + static so ``_resolve_project`` and ``probe`` share it."""
+        # Normalize the input to an absolute realpath: the backend stores absolute root_paths, so a
+        # relative ``project_root`` (e.g. `codeintel map .` passing ".") would otherwise never match
+        # — the bug where the map/query silently reported "not indexed" from inside the repo.
+        try:
+            project_root = os.path.realpath(project_root)
+        except Exception:
+            pass
         entries = raw.get("projects", []) if isinstance(raw, dict) else raw
         if not isinstance(entries, list):
             return None

{codecortex-0.8.0 → codecortex-0.8.2}/src/codeintel/server.py

@@ -195,15 +195,17 @@ def code_map_handler(args: dict) -> dict:
 
         gen = MapGenerator(provider)
         content = gen.generate(project_root, budget_bytes=budget)
-        path = gen.write(project_root, content)
-        size = len(content.encode("utf-8"))
+        path, wrote = gen.write(project_root, content)
+        # size_bytes = bytes actually written; 0 when an existing populated map was preserved
+        # (the new content was a stub) — `wrote` disambiguates for the caller.
+        size = len(content.encode("utf-8")) if wrote else 0
 
         inject_result = None
         if inject:
             inj_path, inj_action = Injector().inject(project_root)
             inject_result = {"path": inj_path, "action": inj_action}
 
-        return {"ok": True, "path": path, "size_bytes": size, "inject": inject_result}
+        return {"ok": True, "path": path, "size_bytes": size, "wrote": wrote, "inject": inject_result}
     except Exception:
         return {"ok": True, "path": None, "size_bytes": 0, "note": "map-error"}
 

{codecortex-0.8.0 → codecortex-0.8.2}/tests/test_graph_provider.py

@@ -1,12 +1,25 @@
 """GraphProvider tests: never-raise invariant and key behavioral guarantees."""
 from __future__ import annotations
 
+import os
 import subprocess
 
 from codeintel.providers.graph import GraphProvider
 from codeintel.server import code_status_handler
 
 
+def test_match_project_resolves_a_relative_path(tmp_path, monkeypatch):
+    # The backend stores absolute root_paths, so a relative project_root (e.g. `codeintel map .`)
+    # must be normalized before matching — otherwise resolution fails from inside the repo and the
+    # map/graph query silently reports "not indexed" (the map-stub bug).
+    real = os.path.realpath(str(tmp_path))
+    raw = {"projects": [{"name": "myrepo", "root_path": real}]}
+    monkeypatch.chdir(tmp_path)
+    assert GraphProvider._match_project(raw, ".") == "myrepo"      # relative resolves now
+    assert GraphProvider._match_project(raw, real) == "myrepo"     # absolute still works
+    assert GraphProvider._match_project(raw, os.path.join(real, "src")) == "myrepo"  # subdir prefix
+
+
 # ---------------------------------------------------------------------------
 # Group 1 — Never-raise: None args
 # ---------------------------------------------------------------------------

codecortex-0.8.2/tests/test_installer.py

@@ -0,0 +1,97 @@
+"""Installer / agent-registration tests (added 0.8.2).
+
+The installer had no tests, which is why `--agent codex` shipped writing a Claude-style JSON
+`mcpServers` block to `~/.codex/config.json` — but Codex CLI reads MCP servers from
+`~/.codex/config.toml` as `[mcp_servers.<name>]` TOML, so nothing was actually registered.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from codeintel.installer import Installer
+
+
+def _codex_toml(home: Path) -> Path:
+    return home / ".codex" / "config.toml"
+
+
+# --------------------------------------------------------------------------- codex (TOML)
+
+def test_codex_registers_as_toml_in_config_toml(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    cfg = _codex_toml(tmp_path)
+    cfg.parent.mkdir(parents=True)
+    cfg.write_text('[mcp_servers.serena]\ncommand = "serena"\n')  # pre-existing MCP server
+
+    res = Installer().register("codex")
+
+    assert res["ok"] and res["action"] == "registered"
+    text = cfg.read_text()
+    assert "[mcp_servers.codeintel]" in text                 # written to config.toml as TOML
+    assert 'command = "codeintel"' in text and 'args = ["serve"]' in text
+    assert "[mcp_servers.serena]" in text                    # existing content preserved
+
+
+def test_codex_does_not_write_the_wrong_json_file(tmp_path, monkeypatch):
+    # regression: the old installer wrote ~/.codex/config.json (mcpServers), which Codex ignores
+    monkeypatch.setenv("HOME", str(tmp_path))
+    Installer().register("codex")
+    assert _codex_toml(tmp_path).exists()
+    assert not (tmp_path / ".codex" / "config.json").exists()
+
+
+def test_codex_creates_config_when_missing(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    res = Installer().register("codex")
+    assert res["ok"] and _codex_toml(tmp_path).read_text().startswith("[mcp_servers.codeintel]")
+
+
+def test_codex_is_idempotent(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    assert Installer().register("codex")["action"] == "registered"
+    assert Installer().register("codex")["action"] == "already"
+    assert _codex_toml(tmp_path).read_text().count("[mcp_servers.codeintel]") == 1  # not duplicated
+
+
+# --------------------------------------------------------------------------- json agents
+
+def test_claude_registers_json_mcp_servers(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    res = Installer().register("claude")
+    assert res["ok"]
+    data = json.loads((tmp_path / ".claude" / "settings.json").read_text())
+    assert data["mcpServers"]["codeintel"] == {"command": "codeintel", "args": ["serve"]}
+
+
+def test_claude_preserves_unrelated_settings(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    s = tmp_path / ".claude" / "settings.json"
+    s.parent.mkdir(parents=True)
+    s.write_text(json.dumps({"theme": "dark", "mcpServers": {"other": {"command": "x"}}}))
+    Installer().register("claude")
+    data = json.loads(s.read_text())
+    assert data["theme"] == "dark"                # unrelated key preserved
+    assert "other" in data["mcpServers"]          # other server preserved
+    assert "codeintel" in data["mcpServers"]      # ours added
+
+
+def test_zed_uses_context_servers_key(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    Installer().register("zed")
+    data = json.loads((tmp_path / ".config" / "zed" / "settings.json").read_text())
+    assert "codeintel" in data["context_servers"]
+
+
+# --------------------------------------------------------------------------- misc
+
+def test_unknown_agent_fails_safely():
+    res = Installer().register("nonesuch")
+    assert res["ok"] is False and res["action"] == "failed" and "unknown" in res["reason"]
+
+
+def test_register_all_covers_every_agent(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    results = Installer().register_all()
+    assert {r["agent"] for r in results} == {"claude", "codex", "gemini", "zed"}
+    assert all(r["ok"] for r in results)

{codecortex-0.8.0 → codecortex-0.8.2}/tests/test_mapper.py

@@ -6,9 +6,15 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from codeintel.mapper import MapGenerator
+from codeintel.mapper import MapGenerator, _minimal_map, _is_populated_map
 from codeintel.injector import Injector
 
+_POPULATED = (
+    "# CODE_INTEL.md — repo\n\n"
+    "## Ranked Symbols (by caller count)\n"
+    "| Symbol | File | Callers |\n|--------|------|---------|\n| `foo` | a.py | 9 |\n"
+)
+
 
 def _make_provider(ranked=None, entry=None, arch=None):
     """Return a mocked GraphProvider with configurable return values."""
@@ -117,13 +123,61 @@ def test_generate_reads_columns_rows_shape():
 def test_write_creates_file():
     gen = MapGenerator(None)
     with tempfile.TemporaryDirectory() as d:
-        path = gen.write(d, "# content")
+        path, wrote = gen.write(d, "# content")
         expected = os.path.join(d, "CODE_INTEL.md")
-        assert path == expected
+        assert path == expected and wrote is True
         assert os.path.exists(expected)
         assert open(expected).read() == "# content"
 
 
+def test_write_preserves_populated_map_when_new_is_a_stub():
+    # the dogfooding bug: `codeintel index`'s best-effort refresh produced a stub (graph empty/
+    # unindexed at that moment) and clobbered a rich, populated CODE_INTEL.md. It must NOT.
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "CODE_INTEL.md")
+        open(path, "w").write(_POPULATED)
+        stub = _minimal_map(d, note="project not yet indexed")
+        assert not _is_populated_map(stub) and _is_populated_map(_POPULATED)  # sanity
+        p, wrote = gen.write(d, stub)
+        assert p == path and wrote is False          # preserved → reported as not written
+        assert open(path).read() == _POPULATED        # preserved, not stubbed
+
+
+def test_write_stub_ok_when_no_existing_map():
+    # first-ever generation of a stub is fine — there's nothing to preserve
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        _, wrote = gen.write(d, _minimal_map(d, note="x"))
+        assert wrote is True
+        assert "Auto-generated" in open(os.path.join(d, "CODE_INTEL.md")).read()
+
+
+def test_write_populated_replaces_a_stub():
+    # a real map SHOULD replace a prior stub — the normal refresh-improves case still works
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "CODE_INTEL.md")
+        open(path, "w").write(_minimal_map(d, note="stale"))
+        _, wrote = gen.write(d, _POPULATED)
+        assert wrote is True
+        assert _is_populated_map(open(path).read())
+
+
+def test_entry_points_only_map_counts_as_populated():
+    # a sparse-but-real render (entry points, no arch/ranked table) is NOT a stub — it must refresh,
+    # not be misclassified and skipped (regression for the review's false-negative finding)
+    entry_only = ("# CODE_INTEL.md — repo\n\n## Ranked Symbols\n_(no symbols found)_\n\n"
+                  "## Entry Points\n- `main` (app.py)\n")
+    assert _is_populated_map(entry_only)
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "CODE_INTEL.md")
+        open(path, "w").write(_POPULATED)
+        _, wrote = gen.write(d, entry_only)   # real content replaces the old map, not skipped
+        assert wrote is True and "Entry Points" in open(path).read()
+
+
 # ---------------------------------------------------------------------------
 # Injector tests
 # ---------------------------------------------------------------------------

codecortex-0.8.0/src/codeintel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.0"

codecortex-0.8.0/src/codeintel/installer.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import pathlib
-
-_AGENTS = ["claude", "codex", "gemini", "zed"]
-
-
-def _atomic_write_text(path: pathlib.Path, text: str) -> None:
-    """Write via a sibling temp file + os.replace so an interrupted write can never truncate
-    the user's existing agent config (which holds unrelated settings) to a partial/empty file.
-    The temp lives in the same directory as ``path`` so the replace stays on one filesystem."""
-    tmp = path.with_name(path.name + ".codeintel.tmp")
-    tmp.write_text(text, encoding="utf-8")
-    os.replace(tmp, path)
-
-_CONFIG: dict[str, dict] = {
-    "claude": {
-        "path": "~/.claude/settings.json",
-        "key": ["mcpServers", "codeintel"],
-        "value": {"command": "codeintel", "args": ["serve"]},
-    },
-    "codex": {
-        "path": "~/.codex/config.json",
-        "key": ["mcpServers", "codeintel"],
-        "value": {"command": "codeintel", "args": ["serve"]},
-    },
-    "gemini": {
-        "path": "~/.gemini/settings.json",
-        "key": ["mcpServers", "codeintel"],
-        "value": {"command": "codeintel", "args": ["serve"]},
-    },
-    "zed": {
-        "path": "~/.config/zed/settings.json",
-        "key": ["context_servers", "codeintel"],
-        "value": {"command": {"path": "codeintel", "args": ["serve"]}},
-    },
-}
-
-
-def _get_nested(data: dict, keys: list[str]):
-    node = data
-    for k in keys:
-        if not isinstance(node, dict) or k not in node:
-            return None
-        node = node[k]
-    return node
-
-
-def _set_nested(data: dict, keys: list[str], value) -> None:
-    node = data
-    for k in keys[:-1]:
-        if k not in node or not isinstance(node[k], dict):
-            node[k] = {}
-        node = node[k]
-    node[keys[-1]] = value
-
-
-class Installer:
-    def register(self, agent: str) -> dict:
-        spec = _CONFIG.get(agent)
-        if spec is None:
-            return {
-                "agent": agent,
-                "path": "",
-                "ok": False,
-                "action": "failed",
-                "reason": f"unknown agent '{agent}'",
-            }
-
-        config_path = pathlib.Path(spec["path"]).expanduser()
-        try:
-            if config_path.exists():
-                data = json.loads(config_path.read_text(encoding="utf-8"))
-                if not isinstance(data, dict):
-                    data = {}
-            else:
-                data = {}
-
-            current = _get_nested(data, spec["key"])
-            if current == spec["value"]:
-                return {
-                    "agent": agent,
-                    "path": str(config_path),
-                    "ok": True,
-                    "action": "already",
-                    "reason": "",
-                }
-
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-            _set_nested(data, spec["key"], spec["value"])
-            _atomic_write_text(config_path, json.dumps(data, indent=2))
-
-            return {
-                "agent": agent,
-                "path": str(config_path),
-                "ok": True,
-                "action": "registered",
-                "reason": "",
-            }
-
-        except Exception as exc:
-            return {
-                "agent": agent,
-                "path": str(config_path),
-                "ok": False,
-                "action": "failed",
-                "reason": str(exc),
-            }
-
-    def register_all(self) -> list[dict]:
-        return [self.register(agent) for agent in _AGENTS]