code-agnostic 0.5.1__tar.gz → 0.7.0__tar.gz

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.5.1
+Version: 0.7.0
 Summary: Centralized hub for LLM coding config: MCP, skills, rules, and agents.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.5.1"
+__version__ = "0.7.0"

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/apps/apps_service.py

@@ -6,6 +6,7 @@ from code_agnostic.apps.common.framework import (
     create_registered_app_service,
     list_registered_app_services,
 )
+from code_agnostic.apps.claude.service import ClaudeConfigService
 from code_agnostic.apps.common.interfaces.service import IAppConfigService
 from code_agnostic.apps.common.symlink_planning import (
     load_state_links,
@@ -113,6 +114,8 @@ class AppsService:
                 self._cleanup_paths(global_paths, scope, app_id.value, skipped)
             )
         actions.extend(self._cleanup_global_mcp(app_id, global_mcp))
+        if app_id == AppId.CLAUDE:
+            actions.extend(self._cleanup_claude_projects(global_mcp))
 
         # --- Workspace scopes (ws:<app>:*) ---
         ws_prefix = f"ws:{app_id.value}:"
@@ -201,14 +204,11 @@ class AppsService:
     def _cleanup_global_mcp(
         self, app_id: AppId, managed_mcp: dict[str, Any]
     ) -> list[Action]:
-        scope = app_scope(app_id, "mcp")
-        raw = managed_mcp.get(scope, [])
-        managed = (
-            {item for item in raw if isinstance(item, str)}
-            if isinstance(raw, list)
-            else set()
+        managed = self._names_for_scope(managed_mcp, app_scope(app_id, "mcp"))
+        managed_agents = self._names_for_scope(
+            managed_mcp, app_scope(app_id, "agents_registry")
         )
-        if not managed:
+        if not managed and not managed_agents:
             return []
         try:
             service = create_registered_app_service(app_id)
@@ -216,9 +216,44 @@ class AppsService:
             return []
         if not service.repository.config_path.exists():
             return []
-        # Empty desired + our previously-managed names → prune only our servers,
-        # keep the user's, and clear managed_mcp state (mcp_managed becomes []).
-        return [service.build_action({}, previously_managed=managed)]
+        # Empty desired + our previously-managed names → prune only what we wrote
+        # (MCP servers and agent-registry entries), keep the user's, and clear the
+        # ownership state (managed_entries becomes empty).
+        return [
+            service.build_action(
+                {},
+                previously_managed=managed,
+                previously_managed_agents=managed_agents,
+            )
+        ]
+
+    def _cleanup_claude_projects(self, managed_mcp: dict[str, Any]) -> list[Action]:
+        managed = self._names_for_scope(
+            managed_mcp, app_scope(AppId.CLAUDE, "projects")
+        )
+        if not managed:
+            return []
+        try:
+            service = create_registered_app_service(AppId.CLAUDE)
+        except (KeyError, ValueError):
+            return []
+        if not isinstance(service, ClaudeConfigService):
+            return []
+        if not service.repository.config_path.exists():
+            return []
+        # Empty desired + our previously-managed project paths → prune only the
+        # `mcpServers` sub-keys we wrote, keep the rest of each project entry, and
+        # clear the ownership state (managed_entries becomes empty).
+        return [
+            service.build_project_mcp_action({}, previously_managed_projects=managed)
+        ]
+
+    @staticmethod
+    def _names_for_scope(group: dict[str, Any], scope: str) -> set[str]:
+        raw = group.get(scope, [])
+        if not isinstance(raw, list):
+            return set()
+        return {item for item in raw if isinstance(item, str)}
 
     def list_status_rows(self) -> list[AppStatusRow]:
         apps = self.load_apps()

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/apps/claude/service.py

@@ -5,7 +5,7 @@ from typing import Any
 from code_agnostic.agents.claude import claude_agent_target_path
 from code_agnostic.agents.compilers import ClaudeAgentCompiler
 from code_agnostic.agents.parser import parse_agent
-from code_agnostic.apps.app_id import AppId, app_label
+from code_agnostic.apps.app_id import AppId, app_label, app_scope
 from code_agnostic.apps.claude.config_repository import ClaudeConfigRepository
 from code_agnostic.apps.claude.mapper import ClaudeMCPMapper
 from code_agnostic.apps.common.framework import RegisteredAppConfigService
@@ -72,6 +72,7 @@ class ClaudeConfigService(RegisteredAppConfigService):
         self,
         project_servers: dict[Path, dict[str, MCPServerDTO]],
         base_payload: dict[str, Any] | None = None,
+        previously_managed_projects: set[str] | None = None,
     ) -> Action:
         existing = self._repository.load_config()
         if existing or self.repository.config_path.exists():
@@ -86,8 +87,10 @@ class ClaudeConfigService(RegisteredAppConfigService):
         else:
             projects = deepcopy(projects)
 
+        desired_keys: set[str] = set()
         for project_path, servers in project_servers.items():
             key = str(project_path.resolve())
+            desired_keys.add(key)
             project = projects.get(key)
             if not isinstance(project, dict):
                 project = {}
@@ -96,10 +99,18 @@ class ClaudeConfigService(RegisteredAppConfigService):
             project["mcpServers"] = self.mapper.from_common(servers)
             projects[key] = project
 
+        # Prune the `mcpServers` sub-key from project entries we previously wrote
+        # but no longer sync (e.g. a repo removed from a workspace). Leave the rest
+        # of the project entry (history etc.) and non-managed projects untouched.
+        for stale_key in (previously_managed_projects or set()) - desired_keys:
+            stale_project = projects.get(stale_key)
+            if isinstance(stale_project, dict):
+                stale_project.pop("mcpServers", None)
+
         merged["projects"] = projects
         self.validate_config(merged)
 
-        return Action(
+        action = Action(
             kind=self.action_kind,
             path=self.repository.config_path,
             status=self.derive_status(existing, merged),
@@ -107,6 +118,12 @@ class ClaudeConfigService(RegisteredAppConfigService):
             payload=merged,
             app=self.app_id.value,
         )
+        # Track which project paths we own so a later source removal prunes only
+        # our `mcpServers` sub-keys without touching the user's project entries.
+        projects_scope = app_scope(self.app_id, "projects")
+        action.scope = projects_scope
+        action.managed_entries = {projects_scope: sorted(desired_keys)}
+        return action
 
     def plan_skill_actions(
         self,

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/apps/codex/service.py

@@ -16,6 +16,7 @@ from code_agnostic.apps.codex.config_repository import CodexConfigRepository
 from code_agnostic.apps.codex.mapper import CodexMCPMapper
 from code_agnostic.apps.codex.schema_repository import CodexSchemaRepository
 from code_agnostic.apps.common.interfaces.mapper import IAppMCPMapper
+from code_agnostic.apps.common.utils import apply_mcp_servers
 from code_agnostic.apps.common.interfaces.repositories import (
     IAppConfigRepository,
     ISchemaRepository,
@@ -118,6 +119,7 @@ class CodexConfigService(RegisteredAppConfigService):
         common_servers: dict[str, MCPServerDTO],
         agent_sources: list[Path] | None = None,
         previously_managed: set[str] | None = None,
+        previously_managed_agents: set[str] | None = None,
         *,
         replace_mcp: bool = False,
     ) -> Action:
@@ -144,10 +146,17 @@ class CodexConfigService(RegisteredAppConfigService):
         self.set_mcp_payload(
             merged, desired_mcp, previously_managed, replace=replace_mcp
         )
-        if agent_sources:
-            merged["agents"] = self._merge_agents_payload(
-                merged.get("agents"),
-                self._build_agent_registry(agent_sources),
+        registry = self._build_agent_registry(agent_sources) if agent_sources else {}
+        if replace_mcp:
+            if registry:
+                merged["agents"] = self._merge_agents_payload(
+                    merged.get("agents"), registry
+                )
+        elif registry or previously_managed_agents:
+            # Ownership-aware: prune agent-registry entries we previously wrote
+            # that are gone from the source, keep base-config/user agents.
+            merged["agents"] = apply_mcp_servers(
+                merged.get("agents"), registry, previously_managed_agents
             )
         self.validate_config(merged)
 
@@ -161,7 +170,10 @@ class CodexConfigService(RegisteredAppConfigService):
         )
         if not replace_mcp:
             action.scope = app_scope(self.app_id, "mcp")
-            action.mcp_managed = sorted(desired_mcp)
+            action.managed_entries = {
+                app_scope(self.app_id, "mcp"): sorted(desired_mcp),
+                app_scope(self.app_id, "agents_registry"): sorted(registry),
+            }
         return action
 
     def _merge_agents_payload(

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/apps/common/interfaces/service.py

@@ -270,6 +270,7 @@ class IAppConfigService(ABC):
         common_servers: dict[str, MCPServerDTO],
         agent_sources: list[Path] | None = None,
         previously_managed: set[str] | None = None,
+        previously_managed_agents: set[str] | None = None,
         *,
         replace_mcp: bool = False,
     ) -> Action:
@@ -296,7 +297,9 @@ class IAppConfigService(ABC):
             # User-shared global config: track which servers we own so a later
             # source removal can be pruned without touching the user's servers.
             action.scope = app_scope(self.app_id, "mcp")
-            action.mcp_managed = sorted(desired_mcp)
+            action.managed_entries = {
+                app_scope(self.app_id, "mcp"): sorted(desired_mcp)
+            }
         return action
 
     def build_plan(
@@ -313,6 +316,9 @@ class IAppConfigService(ABC):
         previously_managed_mcp = self._load_state_names(
             managed_mcp_group, app_scope(self.app_id, "mcp")
         )
+        previously_managed_agents = self._load_state_names(
+            managed_mcp_group, app_scope(self.app_id, "agents_registry")
+        )
 
         skill_actions, skill_skipped = self._build_compiled_group(
             sources=source_repository.list_skill_sources(),
@@ -341,6 +347,7 @@ class IAppConfigService(ABC):
                     common_servers,
                     agent_sources=source_repository.list_agent_sources(),
                     previously_managed=previously_managed_mcp,
+                    previously_managed_agents=previously_managed_agents,
                 ),
                 *skill_actions,
                 *agent_actions,

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/apps/opencode/service.py

@@ -137,6 +137,7 @@ class OpenCodeConfigService(RegisteredAppConfigService):
         common_servers: dict[str, MCPServerDTO],
         agent_sources: list[Path] | None = None,
         previously_managed: set[str] | None = None,
+        previously_managed_agents: set[str] | None = None,
         *,
         replace_mcp: bool = False,
     ) -> Action:
@@ -174,7 +175,9 @@ class OpenCodeConfigService(RegisteredAppConfigService):
         )
         if not replace_mcp:
             action.scope = app_scope(self.app_id, "mcp")
-            action.mcp_managed = sorted(desired_mcp)
+            action.managed_entries = {
+                app_scope(self.app_id, "mcp"): sorted(desired_mcp)
+            }
         return action
 
     def _validate_common_mcp(self, common_servers: dict[str, MCPServerDTO]) -> None:

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/executor.py

@@ -770,12 +770,14 @@ class SyncExecutor:
             if action.scope is None:
                 continue
 
-            if action.mcp_managed is not None:
-                # User-shared MCP config: track the server names we own, never the
-                # shared config file itself (so cleanup prunes our servers only).
-                global_mcp_touched.add(action.scope)
-                if action.mcp_managed:
-                    global_mcp[action.scope] = sorted(set(action.mcp_managed))
+            if action.managed_entries is not None:
+                # User-shared config: track the named entries we own (MCP servers,
+                # agent-registry names, …) by scope — never the shared config file
+                # itself, so cleanup prunes only what we wrote.
+                for entry_scope, names in action.managed_entries.items():
+                    global_mcp_touched.add(entry_scope)
+                    if names:
+                        global_mcp[entry_scope] = sorted(set(names))
                 continue
 
             if action.workspace is not None:

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/models.py

@@ -74,7 +74,7 @@ class Action:
     scope: str | None = None
     workspace: str | None = None
     project: str | None = None
-    mcp_managed: list[str] | None = None
+    managed_entries: dict[str, list[str]] | None = None
 
 
 @dataclass

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic/planner.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from code_agnostic.apps.app_id import AppId, app_metadata
+from code_agnostic.apps.app_id import AppId, app_metadata, app_scope
 from code_agnostic.apps.common.compiled_planning import (
     plan_owned_compiled_text_action,
 )
@@ -283,15 +283,29 @@ class SyncPlanner:
             if existing_action is not None and isinstance(existing_action.payload, dict)
             else None
         )
+        state = self.core.load_state()
+        managed_mcp = state.get("managed_mcp")
+        if not isinstance(managed_mcp, dict):
+            managed_mcp = {}
+        prev_projects_raw = managed_mcp.get(app_scope(AppId.CLAUDE, "projects"), [])
+        previously_managed_projects = (
+            {path for path in prev_projects_raw if isinstance(path, str)}
+            if isinstance(prev_projects_raw, list)
+            else set()
+        )
         project_action = claude_service.build_project_mcp_action(
             self._claude_project_mcp,
             base_payload=base_payload,
+            previously_managed_projects=previously_managed_projects,
         )
         if existing_action is not None:
             # Carry global MCP ownership tracking onto the merged Claude action so
-            # top-level `mcpServers` orphans still get pruned on later applies.
-            project_action.scope = existing_action.scope
-            project_action.mcp_managed = existing_action.mcp_managed
+            # top-level `mcpServers` orphans still get pruned on later applies. The
+            # project-path ownership set by build_project_mcp_action is preserved.
+            project_action.scope = existing_action.scope or project_action.scope
+            merged_entries = dict(existing_action.managed_entries or {})
+            merged_entries.update(project_action.managed_entries or {})
+            project_action.managed_entries = merged_entries
         actions = [
             action
             for action in plan.actions

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.5.1
+Version: 0.7.0
 Summary: Centralized hub for LLM coding config: MCP, skills, rules, and agents.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/code_agnostic.egg-info/SOURCES.txt

@@ -128,6 +128,7 @@ tests/test_cli_agents.py
 tests/test_cli_aliases.py
 tests/test_cli_apply_apps.py
 tests/test_cli_apply_codex.py
+tests/test_cli_apply_codex_agent_cleanup.py
 tests/test_cli_apply_cursor.py
 tests/test_cli_apply_mcp_cleanup.py
 tests/test_cli_apply_target.py

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-agnostic"
-version = "0.5.1"
+version = "0.7.0"
 description = "Centralized hub for LLM coding config: MCP, skills, rules, and agents."
 readme = "README.md"
 requires-python = ">=3.10"

code_agnostic-0.7.0/tests/test_cli_apply_codex_agent_cleanup.py

@@ -0,0 +1,71 @@
+"""Codex agent-registry ownership: an agent removed from the source is pruned
+from `[agents.*]` in ~/.codex/config.toml on the next apply, while base-config
+agent settings and user-added entries survive."""
+
+from pathlib import Path
+
+from code_agnostic.__main__ import cli
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib  # type: ignore
+
+
+def _write_agent(core_root: Path, name: str) -> None:
+    agent = core_root / "agents" / f"{name}.md"
+    agent.parent.mkdir(parents=True, exist_ok=True)
+    agent.write_text(
+        f"---\nname: {name}\ndescription: {name} specialist\n---\n\nDo {name}.\n",
+        encoding="utf-8",
+    )
+
+
+def test_apply_codex_prunes_removed_agent_from_registry(
+    minimal_shared_config: Path,
+    core_root: Path,
+    tmp_path: Path,
+    cli_runner,
+    enable_app,
+) -> None:
+    enable_app("codex")
+    # Base-config agent settings + a user-managed agent entry must be preserved.
+    (core_root / "config" / "codex.base.json").write_text(
+        '{"agents": {"max_depth": 2}}', encoding="utf-8"
+    )
+    (tmp_path / ".codex").mkdir(parents=True, exist_ok=True)
+    (tmp_path / ".codex" / "config.toml").write_text(
+        '[agents.mine]\ndescription = "user agent"\nconfig_file = "agents/mine.toml"\n',
+        encoding="utf-8",
+    )
+    _write_agent(core_root, "planner")
+    _write_agent(core_root, "reviewer")
+
+    assert cli_runner.invoke(cli, ["apply", "-a", "codex"]).exit_code == 0
+    cfg = tomllib.loads(
+        (tmp_path / ".codex" / "config.toml").read_text(encoding="utf-8")
+    )
+    assert cfg["agents"]["max_depth"] == 2
+    assert set(cfg["agents"]) >= {"planner", "reviewer", "mine", "max_depth"}
+
+    state_path = core_root / ".sync-state.json"
+    import json
+
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    assert state["managed_mcp"]["app:codex:agents_registry"] == ["planner", "reviewer"]
+
+    # Remove reviewer from the source and re-apply.
+    (core_root / "agents" / "reviewer.md").unlink()
+    assert cli_runner.invoke(cli, ["apply", "-a", "codex"]).exit_code == 0
+
+    cfg = tomllib.loads(
+        (tmp_path / ".codex" / "config.toml").read_text(encoding="utf-8")
+    )
+    agents = cfg["agents"]
+    assert "reviewer" not in agents, "our removed agent must be pruned from registry"
+    assert "planner" in agents
+    assert agents["mine"]["description"] == "user agent", "user entry preserved"
+    assert agents["max_depth"] == 2, "base-config agent settings preserved"
+
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    assert state["managed_mcp"]["app:codex:agents_registry"] == ["planner"]

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/tests/test_cli_disable_cleanup.py

@@ -6,6 +6,7 @@ import json
 from pathlib import Path
 
 from code_agnostic.__main__ import cli
+from code_agnostic.core.repository import CoreRepository
 
 
 def _write_skill(core_root: Path, name: str) -> None:
@@ -67,3 +68,50 @@ def test_disable_cursor_removes_skill_and_prunes_owned_mcp(
     # Flag is off.
     apps_cfg = json.loads((core_root / "config" / "apps.json").read_text())
     assert apps_cfg["cursor"] is False
+
+
+def test_disable_claude_prunes_project_mcp_keeps_user_project(
+    minimal_shared_config: Path,
+    core_root: Path,
+    tmp_path: Path,
+    cli_runner,
+    enable_app,
+) -> None:
+    enable_app("claude")
+    workspace_root = tmp_path / "workspace"
+    (workspace_root / "repo-a" / ".git").mkdir(parents=True)
+
+    core = CoreRepository(core_root)
+    core.add_workspace("myws", workspace_root)
+    (core.workspace_config_dir("myws") / "mcp.base.json").write_text(
+        json.dumps({"mcpServers": {"ws-server": {"url": "https://example.com/mcp"}}}),
+        encoding="utf-8",
+    )
+
+    # User's own project entry — must survive disable untouched.
+    config_path = tmp_path / ".claude.json"
+    user_project = str((tmp_path / "user-repo").resolve())
+    config_path.write_text(
+        json.dumps(
+            {"projects": {user_project: {"mcpServers": {"personal": {"type": "http"}}}}}
+        ),
+        encoding="utf-8",
+    )
+
+    assert cli_runner.invoke(cli, ["apply", "-a", "claude"]).exit_code == 0
+
+    projects = json.loads(config_path.read_text())["projects"]
+    repo_key = str((workspace_root / "repo-a").resolve())
+    assert "mcpServers" in projects[repo_key]
+    state = json.loads((core_root / ".sync-state.json").read_text())
+    assert repo_key in state["managed_mcp"]["app:claude:projects"]
+
+    # Disable → our project mcpServers pruned, user's project kept.
+    assert cli_runner.invoke(cli, ["apps", "disable", "-a", "claude"]).exit_code == 0
+
+    projects = json.loads(config_path.read_text())["projects"]
+    assert "mcpServers" not in projects.get(repo_key, {})
+    assert projects[user_project] == {"mcpServers": {"personal": {"type": "http"}}}
+
+    state = json.loads((core_root / ".sync-state.json").read_text())
+    assert "app:claude:projects" not in state.get("managed_mcp", {})

{code_agnostic-0.5.1 → code_agnostic-0.7.0}/tests/test_workspace_config_sync.py

@@ -1,5 +1,7 @@
 """Tests for workspace-level config sync (MCP, skills, agents, rules)."""
 
+import json
+import shutil
 from pathlib import Path
 
 try:
@@ -747,6 +749,81 @@ def test_workspace_claude_mcp_merges_project_entries_into_home_config(
     }
 
 
+def test_workspace_claude_removed_repo_prunes_project_mcp_keeps_others(
+    minimal_shared_config: Path,
+    core_root: Path,
+    tmp_path: Path,
+    write_json,
+) -> None:
+    """P1: a repo removed from a workspace has its `projects.<path>.mcpServers`
+    pruned from ~/.claude.json on the next apply, while the other repo, the
+    workspace root, and a user-added project entry are all preserved."""
+    workspace_root = tmp_path / "workspace"
+    workspace_root.mkdir()
+    repo_a = workspace_root / "repo-a"
+    repo_b = workspace_root / "repo-b"
+    (repo_a / ".git").mkdir(parents=True)
+    (repo_b / ".git").mkdir(parents=True)
+
+    core = CoreRepository(core_root)
+    core.add_workspace("myws", workspace_root)
+
+    ws_config = core.workspace_config_dir("myws")
+    write_json(
+        ws_config / "mcp.base.json",
+        {"mcpServers": {"ws-server": {"url": "https://example.com/mcp"}}},
+    )
+
+    # User has their own project entry in ~/.claude.json that we must never touch.
+    user_project = str((tmp_path / "user-repo").resolve())
+    config_path = tmp_path / ".claude.json"
+    write_json(
+        config_path,
+        {"projects": {user_project: {"mcpServers": {"personal": {"type": "http"}}}}},
+    )
+
+    def _apply() -> dict:
+        plan = SyncPlanner(
+            core=core,
+            app_services=[_claude_service(tmp_path / ".claude")],
+        ).build()
+        _applied, failed, failures = SyncExecutor(core=core).execute(plan)
+        assert failed == 0, failures
+        return json.loads(config_path.read_text(encoding="utf-8"))
+
+    payload = _apply()
+    projects = payload["projects"]
+    assert str(workspace_root.resolve()) in projects
+    assert "mcpServers" in projects[str(repo_a.resolve())]
+    assert "mcpServers" in projects[str(repo_b.resolve())]
+    assert user_project in projects
+
+    state = json.loads((core_root / ".sync-state.json").read_text(encoding="utf-8"))
+    assert set(state["managed_mcp"]["app:claude:projects"]) == {
+        str(workspace_root.resolve()),
+        str(repo_a.resolve()),
+        str(repo_b.resolve()),
+    }
+
+    # Remove repo-a from the workspace and re-apply.
+    shutil.rmtree(repo_a)
+    payload = _apply()
+    projects = payload["projects"]
+
+    assert "mcpServers" not in projects.get(
+        str(repo_a.resolve()), {}
+    ), "removed repo's mcpServers must be pruned"
+    assert "mcpServers" in projects[str(repo_b.resolve())]
+    assert "mcpServers" in projects[str(workspace_root.resolve())]
+    assert projects[user_project] == {"mcpServers": {"personal": {"type": "http"}}}
+
+    state = json.loads((core_root / ".sync-state.json").read_text(encoding="utf-8"))
+    assert set(state["managed_mcp"]["app:claude:projects"]) == {
+        str(workspace_root.resolve()),
+        str(repo_b.resolve()),
+    }
+
+
 def test_workspace_targeted_plan_does_not_cleanup_other_app_scopes(
     minimal_shared_config: Path,
     core_root: Path,