s-skillkit 0.3.6__tar.gz → 0.3.7__tar.gz

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/CHANGELOG.md

@@ -4,6 +4,33 @@
 [Keep a Changelog](https://keepachangelog.com/ru/1.1.0/); версионирование —
 [SemVer](https://semver.org/lang/ru/).
 
+## [Unreleased]
+
+### Fixed — гейт принадлежности у CLI-команд и MCP-серверов (#2272)
+
+- **Навык больше не забирает чужую команду.** `path_store.add_cli` снимал ЛЮБОЙ
+  существующий shim и переписывал sidecar, не сверяя владельца: второй навык с
+  тем же `command_name` молча забирал команду первого. Теперь владелец читается
+  из sidecar'а (`cli_owner` / `cli_ownership`), и попытка занять чужое —
+  `ArtifactConflict`, а не перезапись.
+- **Снятие навыка не уносит чужое.** `remove_cli(command_name, skill_slug=…)`
+  удаляет запись только при совпадении владельца. Без `skill_slug`
+  (административное снятие «по имени») удаляется лишь то, у чего есть НАШ
+  sidecar: файл, которого кит не клал, не трогается никогда.
+- **MCP-сервер, настроенный пользователем РУКАМИ, защищён.** `register_mcp` /
+  `unregister_mcp` принимают `skill_slug` и сверяются с реестром владения
+  `<config_dir>/mcp_owners.json` (маркер держим СНАРУЖИ чужого конфига агента —
+  дописывать служебные ключи в запись сервера значит рисковать её валидностью).
+  Чужая или безмаркерная запись → `status=conflict`, конфиг не меняется.
+- **Отчёты.** `apply_tooling_artifacts` отдаёт `status=conflict` (с `owner`) по
+  затронутому артефакту, `revert_tooling_artifacts` — список `conflicts`.
+  Установка/снятие самого навыка при этом не ломаются.
+- **Совместимость.** Sidecar старого формата (без `skill_slug`) считается нашим
+  и получает владельца при первой перезаписи; MCP-запись, сделанная до
+  появления реестра, «усыновляется», если её содержимое совпадает с тем, что
+  положил бы этот же навык сейчас. Повторная установка ТОГО ЖЕ навыка (в т.ч. с
+  новым entrypoint/config) проходит как раньше.
+
 ## [0.3.6]
 
 ### Changed — своя политика запуска подпроцессов, s-librarykit убран (#1644)

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: s-skillkit
-Version: 0.3.6
+Version: 0.3.7
 Summary: Локальное ядро управления навыками: install из git/локальной папки, junction/symlink-линковка в scope агента, .skillignore-фильтр, build manifest, project-манифест. 0 завязок на сеть/auth — stdlib + tomli-w + pathspec + platformdirs.
 Author: Dmitry
 License: MIT

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "s-skillkit"
-version = "0.3.6"
+version = "0.3.7"
 description = "Локальное ядро управления навыками: install из git/локальной папки, junction/symlink-линковка в scope агента, .skillignore-фильтр, build manifest, project-манифест. 0 завязок на сеть/auth — stdlib + tomli-w + pathspec + platformdirs."
 readme = "README.md"
 license = { text = "MIT" }

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/skillkit/__init__.py

@@ -67,6 +67,7 @@ from skillkit.bootstrap import bootstrap_skill, run_self_check
 from skillkit.collections import LocalCollectionError
 from skillkit.config import SkillkitConfig, configure, reset_to_defaults
 from skillkit.errors import (
+    ArtifactConflict,
     CloneError,
     ForeignPathError,
     MaterializeError,
@@ -119,7 +120,7 @@ from skillkit.targets import (
 )
 from skillkit.uv_bootstrap import ensure_uv
 
-__version__ = "0.3.5"
+__version__ = "0.3.7"
 
 __all__ = [
     "__version__",
@@ -152,6 +153,7 @@ __all__ = [
     "Source",
     # доменные исключения (иерархия SkillkitError)
     "SkillkitError",
+    "ArtifactConflict",
     "CloneError",
     "ScopeConflict",
     "ForeignPathError",

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/skillkit/config.py

@@ -93,7 +93,14 @@ def configure(config: SkillkitConfig) -> None:
     дефолтного ``SkillkitConfig()`` эквивалентна ``reset_to_defaults()``.
     """
     # Импорт внутри функции — избегаем циклов на этапе загрузки пакета.
-    from skillkit import collections, installer, path_store, paths, project
+    from skillkit import (
+        collections,
+        installer,
+        mcp_register,
+        path_store,
+        paths,
+        project,
+    )
 
     # 1. platformdirs-имя приложения (Paths.default → config/data/bin каталоги).
     paths.set_app_name(config.app_name)
@@ -122,7 +129,12 @@ def configure(config: SkillkitConfig) -> None:
         config.config_dir_provider or collections._default_config_dir
     )
 
-    # 5. Установщик: брендо-строки (clone-префикс + владелец управляемых папок).
+    # 5. Реестр владения MCP-записями (#2272) — лежит в config-каталоге бренда.
+    mcp_register.set_state_dir_provider(
+        config.config_dir_provider or mcp_register._default_state_dir
+    )
+
+    # 6. Установщик: брендо-строки (clone-префикс + владелец управляемых папок).
     installer.set_clone_prefix(config.resolved_clone_prefix())
     installer.set_managed_by(config.resolved_managed_by())
 

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/skillkit/errors.py

@@ -58,3 +58,37 @@ class ScopeUnsupported(SkillkitError):  # noqa: N818 — доменное имя
     него был только глобальный каталог. Затем раскладку навыков agy владелец свёл в
     общий ``.agents/skills`` с поддержкой project-scope.
     """
+
+
+class ArtifactConflict(SkillkitError):  # noqa: N818 — доменное имя без -Error суффикса
+    """Исполняемый артефакт уже принадлежит ДРУГОМУ владельцу.
+
+    Класс дефекта (2026-08-25, #2272): CLI-команда навыка (``[[cli]]``) и
+    MCP-сервер (``[[mcp]]``) пишутся в ОБЩЕЕ пространство имён — bin-каталог и
+    конфиг агента. Без сверки владельца второй навык молча забирал команду
+    первого, а его снятие уносило чужую запись; MCP-сервер, заведённый
+    пользователем РУКАМИ, перетирался и удалялся вместе с навыком. Это потеря
+    пользовательских данных, а не «конфликт имён».
+
+    Гейт принадлежности здесь — свойство самой операции (как ``ForeignPathError``
+    у путей): владелец пишется рядом с артефактом при установке, и запись
+    занимается/снимается ТОЛЬКО при совпадении владельца. Чужое (в т.ч. запись
+    БЕЗ нашего маркера — то есть заведомо не наша) не трогается никогда.
+
+    ``artifact`` — ``"cli"`` | ``"mcp"``; ``name`` — command_name/server_name;
+    ``owner`` — slug текущего владельца или ``None``, если владелец неизвестен
+    (запись сделана вне кита — вручную пользователем или другим инструментом).
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        artifact: str,
+        name: str,
+        owner: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.artifact = artifact
+        self.name = name
+        self.owner = owner

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/skillkit/mcp_register.py

@@ -12,8 +12,11 @@
 - агент с НЕИЗВЕСТНЫМ форматом (нет дескриптора) → не падаем: возвращаем
   ``status=manual`` + готовая инструкция (graceful degradation).
 
-Идемпотентно (ключ = ``server_name``, перезапись, не дубль). ``unregister_mcp``
-снимает запись при disable/remove навыка. ``list_mcp`` — что зарегистрировано
+Идемпотентно (ключ = ``server_name``, перезапись СВОЕЙ записи, не дубль).
+Перезаписать/снять запись ДРУГОГО навыка или заведённую пользователем вручную
+нельзя — владение фиксируется в реестре кита, чужое отдаёт ``status=conflict``
+(#2272). ``unregister_mcp`` снимает запись при disable/remove навыка.
+``list_mcp`` — что зарегистрировано
 (для doctor/status). Запись атомарная (tmp + ``os.replace``). Кроссплатформа:
 пути берутся от ``Path.home()`` / project, TOML через ``tomli_w``.
 
@@ -25,11 +28,14 @@ from __future__ import annotations
 import contextlib
 import json
 import os
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 import tomli_w
 
+from skillkit.paths import Paths
+
 try:  # py311+ stdlib; не должен отсутствовать, но мягко
     import tomllib
 except ModuleNotFoundError:  # pragma: no cover
@@ -78,6 +84,143 @@ def _server_name(server: dict[str, Any]) -> str:
     return str(server.get("server_name") or "").strip()
 
 
+# --------------------------------------------------------------------------
+#  Реестр владения MCP-записями (#2272)
+# --------------------------------------------------------------------------
+# ЗАЧЕМ ОТДЕЛЬНЫЙ РЕЕСТР, А НЕ МАРКЕР ВНУТРИ ЗАПИСИ.
+#
+# Конфиг агента — ЧУЖОЙ файл со своей схемой (``~/.claude.json``,
+# ``~/.codex/config.toml``). Дописать в запись сервера наш служебный ключ значит
+# рискнуть тем, что агент её отвергнет как невалидную. Поэтому владелец хранится
+# СНАРУЖИ — в собственном файле кита ``<config_dir>/mcp_owners.json``, ключом
+# служит пара «путь конфига + имя сервера».
+#
+# Отсюда же и правило совместимости: у записей, сделанных ДО появления реестра
+# (и у всего, что пользователь завёл руками), записи владельца нет. Такая запись
+# считается НЕ нашей — кроме случая, когда её содержимое ПОБАЙТОВО совпадает с
+# тем, что положил бы этот же навык сейчас: тогда владение «усыновляется» (это
+# заведомо наша прежняя установка, и перезапись/снятие ничего не меняют).
+
+#: Классы владения (те же строки, что у ``path_store`` — контракт отчётов един).
+OWNERSHIP_FREE = "free"
+OWNERSHIP_OURS = "ours"
+OWNERSHIP_FOREIGN = "foreign"
+
+
+_OWNERS_FILE = "mcp_owners.json"
+_OWNERS_VERSION = 1
+
+
+def _default_state_dir() -> Path:
+    """Standalone-дефолт каталога состояния кита (нативный config-каталог)."""
+    return Paths.default().config_dir
+
+
+_state_dir_provider: Callable[[], Path] = _default_state_dir
+
+
+def set_state_dir_provider(provider: Callable[[], Path]) -> None:
+    """Задать каталог, где кит держит реестр владения MCP (инъекция потребителя)."""
+    global _state_dir_provider
+    _state_dir_provider = provider
+
+
+def _owners_file() -> Path:
+    return _state_dir_provider() / _OWNERS_FILE
+
+
+def _owner_key(config_path: Path, server_name: str) -> str:
+    norm = os.path.normcase(os.path.normpath(str(config_path)))
+    return f"{norm}::{server_name}"
+
+
+def _read_owners() -> dict[str, str]:
+    """Реестр владения. Никогда не бросает: битый/отсутствующий → пустой."""
+    try:
+        data = json.loads(_owners_file().read_text(encoding="utf-8"))
+    except (OSError, ValueError, UnicodeDecodeError):
+        return {}
+    entries = data.get("entries") if isinstance(data, dict) else None
+    if not isinstance(entries, dict):
+        return {}
+    return {str(k): str(v or "") for k, v in entries.items()}
+
+
+def _write_owners(entries: dict[str, str]) -> None:
+    """Атомарно сохранить реестр. Best-effort: сбой записи не ломает установку."""
+    with contextlib.suppress(OSError, ValueError):
+        path = _owners_file()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.dumps(
+            {"version": _OWNERS_VERSION, "entries": entries},
+            indent=2,
+            ensure_ascii=False,
+        ) + '\n'
+        tmp = path.with_name(path.name + ".tmp")
+        tmp.write_text(payload, encoding="utf-8")
+        os.replace(tmp, path)
+
+
+def mcp_owner(config_path: Path, server_name: str) -> str | None:
+    """Владелец записи сервера по реестру, либо None (владение не зафиксировано)."""
+    return _read_owners().get(_owner_key(config_path, server_name))
+
+
+def _record_owner(config_path: Path, server_name: str, skill_slug: str) -> None:
+    entries = _read_owners()
+    entries[_owner_key(config_path, server_name)] = str(skill_slug or "")
+    _write_owners(entries)
+
+
+def _drop_owner(config_path: Path, server_name: str) -> None:
+    entries = _read_owners()
+    if entries.pop(_owner_key(config_path, server_name), None) is not None:
+        _write_owners(entries)
+
+
+def _same_entry(current: Any, expected: dict[str, Any] | None) -> bool:
+    """Совпадает ли запись в конфиге с тем, что положил бы навык сейчас."""
+    return expected is not None and current == expected
+
+
+def mcp_ownership(
+    config_path: Path,
+    server_name: str,
+    *,
+    skill_slug: str | None,
+    current: Any = None,
+    expected: dict[str, Any] | None = None,
+    present: bool = True,
+) -> str:
+    """Кому принадлежит запись сервера: ``free`` | ``ours`` | ``foreign``.
+
+    ``present=False`` (записи в конфиге нет) → ``free``. Иначе решает реестр:
+    владелец совпал → ``ours``, не совпал → ``foreign``. Владельца в реестре
+    нет → запись «дореестровая» или ручная: ``ours`` лишь при полном совпадении
+    содержимого с ``expected`` (усыновление), иначе ``foreign``.
+    """
+    if not present:
+        return OWNERSHIP_FREE
+    owner = mcp_owner(config_path, server_name)
+    want = str(skill_slug or "").strip()
+    if owner is not None:
+        return OWNERSHIP_OURS if owner == want else OWNERSHIP_FOREIGN
+    return OWNERSHIP_OURS if _same_entry(current, expected) else OWNERSHIP_FOREIGN
+
+
+def _conflict_reason(server_name: str, owner: str | None) -> str:
+    if owner:
+        return (
+            f"MCP-сервер «{server_name}» уже принадлежит навыку «{owner}» — "
+            "чужую запись не перезаписываем и не удаляем"
+        )
+    return (
+        f"MCP-сервер «{server_name}» в конфиге агента заведён не китом "
+        "(вручную или другим инструментом) — чужую запись не перезаписываем "
+        "и не удаляем"
+    )
+
+
 # --------------------------------------------------------------------------
 #  Дескриптор формата конфига — ИНЪЕКЦИЯ от самого агента (не хардкод-мапа)
 # --------------------------------------------------------------------------
@@ -152,12 +295,19 @@ def _manual_instruction(server: dict[str, Any], agent_name: str) -> str:
 #  Public: register / unregister / list
 # --------------------------------------------------------------------------
 def register_mcp(
-    server: dict[str, Any], *, agent_target: Any, project: Path | None = None
+    server: dict[str, Any],
+    *,
+    agent_target: Any,
+    project: Path | None = None,
+    skill_slug: str | None = None,
 ) -> dict[str, Any]:
     """Зарегистрировать MCP-сервер навыка в конфиге агента. Не бросает.
 
     Возврат ``status`` ∈:
-    - ``registered`` — записан (added/перезаписан, idempotent);
+    - ``registered`` — записан (added/перезаписан своим навыком, idempotent);
+    - ``conflict``   — имя занято ДРУГИМ навыком или ручной записью пользователя
+      (#2272): чужое НЕ трогаем, в ``reason`` — объяснение, в ``owner`` — slug
+      владельца, если он известен;
     - ``manual``     — формат агента неизвестен (есть ``instruction``);
     - ``error``      — пустой ``server_name`` или сбой записи (есть ``reason``).
     """
@@ -181,21 +331,54 @@ def register_mcp(
         servers = data.get(key)
         if not isinstance(servers, dict):
             servers = {}
-        servers[name] = _build_entry(server)
+        entry = _build_entry(server)
+        # ГЕЙТ ПРИНАДЛЕЖНОСТИ (#2272): перезаписываем только СВОЮ запись.
+        if (
+            mcp_ownership(
+                path,
+                name,
+                skill_slug=skill_slug,
+                current=servers.get(name),
+                expected=entry,
+                present=name in servers,
+            )
+            == OWNERSHIP_FOREIGN
+        ):
+            owner = mcp_owner(path, name)
+            return {
+                "status": "conflict",
+                "server_name": name,
+                "owner": owner,
+                "config_path": str(path),
+                "reason": _conflict_reason(name, owner),
+            }
+        servers[name] = entry
         data[key] = servers
         _write_config(path, fmt, data)
     except (OSError, ValueError) as exc:
         return {"status": "error", "server_name": name, "reason": str(exc)}
+    _record_owner(path, name, str(skill_slug or ""))
     return {"status": "registered", "server_name": name, "config_path": str(path)}
 
 
 def unregister_mcp(
-    server_name: str, *, agent_target: Any, project: Path | None = None
+    server_name: str,
+    *,
+    agent_target: Any,
+    project: Path | None = None,
+    skill_slug: str | None = None,
+    expected: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Снять MCP-сервер из конфига агента (disable/remove навыка). Не бросает.
 
+    ГЕЙТ ПРИНАДЛЕЖНОСТИ (#2272): удаляем ТОЛЬКО свою запись. ``skill_slug`` —
+    навык, который снимается; ``expected`` — его объявление сервера
+    (``[[mcp]]``-словарь), нужное для «усыновления» дореестровых записей: если
+    в конфиге лежит ровно то, что положил бы этот навык, запись считается нашей
+    и снимается, иначе (ручная правка пользователя) остаётся на месте.
+
     Возврат ``status`` ∈ ``unregistered`` | ``absent`` (нечего снимать) |
-    ``manual`` (формат неизвестен) | ``error``.
+    ``conflict`` (запись чужая — не тронули) | ``manual`` | ``error``.
     """
     name = str(server_name or "").strip()
     if not name:
@@ -213,12 +396,33 @@ def unregister_mcp(
         data = _read_config(path, fmt)
         servers = data.get(key)
         if not isinstance(servers, dict) or name not in servers:
+            _drop_owner(path, name)
             return {"status": "absent", "server_name": name}
+        if (
+            mcp_ownership(
+                path,
+                name,
+                skill_slug=skill_slug,
+                current=servers.get(name),
+                expected=_build_entry(expected) if expected else None,
+                present=True,
+            )
+            == OWNERSHIP_FOREIGN
+        ):
+            owner = mcp_owner(path, name)
+            return {
+                "status": "conflict",
+                "server_name": name,
+                "owner": owner,
+                "config_path": str(path),
+                "reason": _conflict_reason(name, owner),
+            }
         del servers[name]
         data[key] = servers
         _write_config(path, fmt, data)
     except (OSError, ValueError) as exc:
         return {"status": "error", "server_name": name, "reason": str(exc)}
+    _drop_owner(path, name)
     return {"status": "unregistered", "server_name": name, "config_path": str(path)}
 
 

{s_skillkit-0.3.6 → s_skillkit-0.3.7}/skillkit/path_store.py

@@ -13,11 +13,14 @@ skillkit НЕ читает env/config: bin-каталог приходит от
 Модель (симметрично linker/installer):
 - ``bin_dir()`` — каталог шимов (через провайдер; CLI инъектирует свой,
   учитывающий env ``SKILLS_HUB_BIN_DIR`` / config);
-- ``add_cli(command_name, entrypoint, *, skill_slug)`` — кладёт shim (см. ниже
+- ``add_cli(command_name, entrypoint, *, skill_slug)`` — кладёт shim, если
+  команда свободна или уже принадлежит этому навыку; чужую не занимает
+  (``ArtifactConflict``, #2272). См. ниже
   «Учёт вызова»). Рядом пишется sidecar ``<command>.json`` с привязкой к навыку
   и **прямым** entrypoint (для ``list_clis``, снятия при disable/remove и —
   главное — для запуска раннером без рекурсии);
-- ``remove_cli(command_name)`` — удаляет shim + sidecar (disable/remove навыка);
+- ``remove_cli(command_name, *, skill_slug=None)`` — удаляет shim + sidecar
+  (disable/remove навыка) ТОЛЬКО если команда принадлежит этому навыку (#2272);
 - ``ensure_on_path()`` — idempotent: bin в PATH? нет → добавить без admin
   (Windows: User PATH через ``HKCU\\Environment``; POSIX: ``export PATH`` строкой
   в rc-файл). Возвращает ``{"status": added|already|manual-needed, ...}``;
@@ -71,6 +74,7 @@ import sys
 from collections.abc import Callable
 from pathlib import Path
 
+from skillkit.errors import ArtifactConflict
 from skillkit.paths import Paths
 
 IS_WINDOWS = sys.platform == "win32"
@@ -171,6 +175,81 @@ def _shim_path(command_name: str) -> Path:
     return bin_dir() / (f"{command_name}.cmd" if IS_WINDOWS else command_name)
 
 
+# --------------------------------------------------------------------------
+#  Владение командой (#2272) — sidecar рядом с шимом и есть маркер владельца
+# --------------------------------------------------------------------------
+#: Классы владения командой: свободна | наша | чужая.
+OWNERSHIP_FREE = "free"
+OWNERSHIP_OURS = "ours"
+OWNERSHIP_FOREIGN = "foreign"
+
+
+def read_cli_sidecar(command_name: str) -> dict[str, str] | None:
+    """Sidecar команды (``<bin>/<command>.json``) или None, если его нет/битый."""
+    sc = _sidecar_path(command_name)
+    try:
+        data = json.loads(sc.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def cli_owner(command_name: str) -> str | None:
+    """Slug навыка-владельца команды, либо None (нет sidecar / нет поля).
+
+    None здесь — НЕ «свободно»: это «владелец неизвестен». Отличать свободную
+    команду от занятой-без-маркера нужно по наличию файлов (см.
+    :func:`cli_ownership`).
+    """
+    data = read_cli_sidecar(command_name)
+    if data is None:
+        return None
+    owner = str(data.get("skill_slug") or "").strip()
+    return owner or None
+
+
+def _shim_exists(command_name: str) -> bool:
+    shim = _shim_path(command_name)
+    try:
+        return shim.is_symlink() or shim.exists()
+    except OSError:
+        return False
+
+
+def cli_ownership(command_name: str, *, skill_slug: str | None) -> str:
+    """Кому принадлежит команда с точки зрения навыка ``skill_slug``.
+
+    - ``free``    — команды нет (ни шима, ни sidecar) → занимать можно;
+    - ``ours``    — sidecar говорит, что владелец именно этот навык;
+    - ``foreign`` — владелец ДРУГОЙ навык, ЛИБО файл лежит без нашего sidecar
+      (значит, его положил не кит — вручную пользователь или иной инструмент).
+
+    ОБРАТНАЯ СОВМЕСТИМОСТЬ: sidecar СТАРОГО формата (без ``skill_slug``) —
+    наш по факту: его писал кит, просто версией, где владельца ещё не
+    фиксировали. Такой sidecar считается ``ours`` и при первой же перезаписи
+    получает владельца. Ломать уже установленные навыки строгостью нельзя.
+    """
+    data = read_cli_sidecar(command_name)
+    if data is None:
+        # Sidecar'а нет. Файл рядом есть → он не наш (кит всегда пишет пару).
+        return OWNERSHIP_FOREIGN if _shim_exists(command_name) else OWNERSHIP_FREE
+    owner = str(data.get("skill_slug") or "").strip()
+    if not owner:
+        return OWNERSHIP_OURS  # старый sidecar без владельца — наш
+    return OWNERSHIP_OURS if owner == str(skill_slug or "").strip() else OWNERSHIP_FOREIGN
+
+
+def _conflict(command_name: str, owner: str | None) -> ArtifactConflict:
+    who = f"навыку «{owner}»" if owner else "постороннему файлу (не кит его положил)"
+    return ArtifactConflict(
+        f"команда «{command_name}» уже принадлежит {who} — "
+        "занять её нельзя, чужое не перезаписываем",
+        artifact="cli",
+        name=command_name,
+        owner=owner,
+    )
+
+
 # --------------------------------------------------------------------------
 #  add_cli
 # --------------------------------------------------------------------------
@@ -257,8 +336,13 @@ def add_cli(command_name: str, entrypoint: str, *, skill_slug: str) -> Path:
     """Положить исполняемый shim ``command_name`` в bin-каталог стора.
 
     ``entrypoint`` — что выполнять: команда (``python -m pkg.cli``) ИЛИ путь к
-    исполняемому console-script. Идемпотентно: повторный вызов перезаписывает
-    shim и sidecar. Возвращает путь к созданному шиму.
+    исполняемому console-script. Идемпотентно: повторный вызов ТОГО ЖЕ навыка
+    перезаписывает shim и sidecar. Возвращает путь к созданному шиму.
+
+    Занять команду, принадлежащую ДРУГОМУ навыку (или лежащую в bin-каталоге
+    без нашего sidecar — то есть заведённую вручную), нельзя:
+    ``ArtifactConflict`` (#2272). Вызывающий (``tooling``) превращает это в
+    ``status=conflict`` в отчёте установки, а не в потерю чужой команды.
 
     Сам shim зовёт РАННЕР (учёт вызова, #1221), а прямой вызов entrypoint
     остаётся его fallback-веткой. В sidecar пишется именно ПРЯМОЙ entrypoint —
@@ -270,6 +354,12 @@ def add_cli(command_name: str, entrypoint: str, *, skill_slug: str) -> Path:
     if not entrypoint or not entrypoint.strip():
         raise ValueError("entrypoint не может быть пустым")
 
+    # ГЕЙТ ПРИНАДЛЕЖНОСТИ (#2272). Своё перезаписываем (идемпотентность), чужое —
+    # никогда: раньше add_cli снимал ЛЮБОЙ существующий shim и переписывал
+    # sidecar, и второй навык с тем же command_name молча забирал команду.
+    if cli_ownership(command_name, skill_slug=skill_slug) == OWNERSHIP_FOREIGN:
+        raise _conflict(command_name, cli_owner(command_name))
+
     d = bin_dir()
     d.mkdir(parents=True, exist_ok=True)
     shim = _shim_path(command_name)
@@ -315,8 +405,26 @@ def _unlink_shim(shim: Path) -> None:
 # --------------------------------------------------------------------------
 #  remove_cli
 # --------------------------------------------------------------------------
-def remove_cli(command_name: str) -> bool:
-    """Снять shim (+ sidecar) команды. True если что-то удалили, иначе False."""
+def remove_cli(command_name: str, *, skill_slug: str | None = None) -> bool:
+    """Снять shim (+ sidecar) команды. True если что-то удалили, иначе False.
+
+    ГЕЙТ ПРИНАДЛЕЖНОСТИ (#2272). Удаляем ТОЛЬКО своё:
+
+    - ``skill_slug`` задан → снимаем, лишь если sidecar называет владельцем
+      именно его (или sidecar старого формата, без владельца). Иначе False и
+      чужая команда остаётся на месте — снятие навыка B не имеет права уносить
+      команду навыка A;
+    - ``skill_slug`` не задан (административное снятие «по имени») → снимаем
+      только то, у чего ЕСТЬ наш sidecar. Файл без sidecar кит не клал —
+      значит, он не наш, и трогать его нельзя ни при каких условиях.
+    """
+    if skill_slug is None:
+        # Административный режим: sidecar (наш) есть → снимаем; нет — не наше.
+        if read_cli_sidecar(command_name) is None and _shim_exists(command_name):
+            return False
+    elif cli_ownership(command_name, skill_slug=skill_slug) == OWNERSHIP_FOREIGN:
+        return False
+
     shim = _shim_path(command_name)
     sidecar = _sidecar_path(command_name)
     removed = False