s-skillkit 0.1.2__tar.gz → 0.1.4__tar.gz

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/PKG-INFO

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

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/pyproject.toml

@@ -1,48 +1,48 @@
-[project]
-name = "s-skillkit"
-version = "0.1.2"
-description = "Локальное ядро управления навыками: install из git/локальной папки, junction/symlink-линковка в scope агента, .skillignore-фильтр, build manifest, project-манифест. 0 завязок на сеть/auth — stdlib + tomli-w + pathspec + platformdirs."
-readme = "README.md"
-license = { text = "MIT" }
-requires-python = ">=3.11"
-authors = [{ name = "Dmitry" }]
-# skillkit — SIBLING librarykit (НЕ зависит от него, httpx, auth, сети).
-# Только локальная ФС-механика навыков. Core deps:
-# tomli-w — запись TOML (project-манифест .skills-hub/skills.toml,
-#   _skill_meta.toml ридеры используют stdlib tomllib на чтение);
-# pathspec — gitignore-стиль .skillignore / files-allowlist фильтр;
-# platformdirs — нативные дефолтные пути (Paths.default) по ОС.
-dependencies = [
-    "tomli-w>=1.0",
-    "pathspec>=0.12.0",
-    "platformdirs>=4.0",
-]
-
-[project.optional-dependencies]
-dev = ["pytest>=8", "pytest-asyncio>=0.24"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["skillkit"]
-
-[tool.ruff]
-line-length = 100
-target-version = "py311"
-src = ["."]
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "B", "UP", "N", "SIM", "RUF"]
-# RUF001/RUF002/RUF003 — кириллица в строках/докстрингах/комментах намеренная
-#   (русскоязычный код), ruff принимает её за «двусмысленную» латиницу.
-# RUF022 — __all__ сгруппирован по модулям с комментами осознанно.
-# RUF059 — распаковка кортежа в тестах с неиспользуемой частью (фикстура
-#   возвращает (store, target, store_dir); читаемее, чем индексирование).
-ignore = ["RUF001", "RUF002", "RUF003", "RUF022", "RUF059"]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-testpaths = ["tests"]
-pythonpath = ["."]
+[project]
+name = "s-skillkit"
+version = "0.1.4"
+description = "Локальное ядро управления навыками: install из git/локальной папки, junction/symlink-линковка в scope агента, .skillignore-фильтр, build manifest, project-манифест. 0 завязок на сеть/auth — stdlib + tomli-w + pathspec + platformdirs."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+authors = [{ name = "Dmitry" }]
+# skillkit — SIBLING librarykit (НЕ зависит от него, httpx, auth, сети).
+# Только локальная ФС-механика навыков. Core deps:
+# tomli-w — запись TOML (project-манифест .skills-hub/skills.toml,
+#   _skill_meta.toml ридеры используют stdlib tomllib на чтение);
+# pathspec — gitignore-стиль .skillignore / files-allowlist фильтр;
+# platformdirs — нативные дефолтные пути (Paths.default) по ОС.
+dependencies = [
+    "tomli-w>=1.0",
+    "pathspec>=0.12.0",
+    "platformdirs>=4.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-asyncio>=0.24"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["skillkit"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+src = ["."]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "N", "SIM", "RUF"]
+# RUF001/RUF002/RUF003 — кириллица в строках/докстрингах/комментах намеренная
+#   (русскоязычный код), ruff принимает её за «двусмысленную» латиницу.
+# RUF022 — __all__ сгруппирован по модулям с комментами осознанно.
+# RUF059 — распаковка кортежа в тестах с неиспользуемой частью (фикстура
+#   возвращает (store, target, store_dir); читаемее, чем индексирование).
+ignore = ["RUF001", "RUF002", "RUF003", "RUF022", "RUF059"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["."]

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/skillkit/deps_installer.py

@@ -68,6 +68,8 @@ def _run(cmd: list[str]) -> int:
 # --------------------------------------------------------------------------
 def install_runtime_dependencies(
     deps: list[dict[str, Any]] | tuple[dict[str, Any], ...] | None,
+    *,
+    python_executable: str | None = None,
 ) -> dict[str, list[dict[str, Any]]]:
     """Поставить runtime-зависимости навыка. Никогда не бросает.
 
@@ -75,6 +77,12 @@ def install_runtime_dependencies(
     ``runtime_dependencies`` / ``aggregated_runtime_dependencies``). Кривые
     элементы (не-dict, без kind/spec, неизвестный kind) пропускаются/идут в
     skipped. Возвращает отчёт ``{installed, skipped, failed}``.
+
+    ``python_executable`` — целевой интерпретатор для pip-веток (выделенный
+    venv инструмента). Задан → ставим ИМЕННО в него (``uv pip install --python
+    <exe>`` / ``<exe> -m pip``), чтобы цель установки совпадала с интерпретатором
+    CLI-шима и не зависела от cwd/активного venv. None → прежнее ambient-поведение
+    (uv по своему правилу выбора окружения / текущий ``sys.executable``).
     """
     report: dict[str, list[dict[str, Any]]] = {
         "installed": [],
@@ -103,16 +111,19 @@ def install_runtime_dependencies(
                 }
             )
             continue
-        _dispatch(kind, spec, report)
+        _dispatch(kind, spec, report, python_executable)
     return report
 
 
 def _dispatch(
-    kind: str, spec: str, report: dict[str, list[dict[str, Any]]]
+    kind: str,
+    spec: str,
+    report: dict[str, list[dict[str, Any]]],
+    python_executable: str | None = None,
 ) -> None:
     """Маршрутизация одной зависимости по kind в нужную ветку установки."""
     if kind == "pip":
-        _install_pip(spec, report)
+        _install_pip(spec, report, python_executable)
     elif kind == "npm":
         _install_npm(spec, report)
     else:  # system
@@ -132,16 +143,26 @@ def _dispatch(
 # --------------------------------------------------------------------------
 #  pip: uv pip install → python -m pip install
 # --------------------------------------------------------------------------
-def _install_pip(spec: str, report: dict[str, list[dict[str, Any]]]) -> None:
+def _install_pip(
+    spec: str,
+    report: dict[str, list[dict[str, Any]]],
+    python_executable: str | None = None,
+) -> None:
     entry = {"kind": "pip", "spec": spec}
     # ``--upgrade``: при обновлении навыка повторный apply «pkg>=X» должен
     # ПОДНЯТЬ уже стоящий пакет до новой версии (без флага pip/uv считают
     # требование удовлетворённым и ничего не делают). Идемпотентность сохраняется
     # — для уже-последней версии --upgrade это no-op.
+    # ``python_executable`` (выделенный venv инструмента) → ставим строго в него:
+    #   uv  → ``--python <exe>`` (uv не уходит в cwd/.venv);
+    #   pip → запускаем САМ <exe> -m pip (а не sys.executable хоста).
     if _which("uv") is not None:
-        cmd = ["uv", "pip", "install", "--upgrade", spec]
+        cmd = ["uv", "pip", "install"]
+        if python_executable:
+            cmd += ["--python", python_executable]
+        cmd += ["--upgrade", spec]
     elif _pip_available():
-        cmd = [sys.executable, "-m", "pip", "install", "--upgrade", spec]
+        cmd = [python_executable or sys.executable, "-m", "pip", "install", "--upgrade", spec]
     else:
         report["skipped"].append(
             {

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/skillkit/installer.py

@@ -409,6 +409,7 @@ class SkillStore:
         skill_id: str | int | None = None,
         local_src: Path | None = None,
         git_ref: str | None = None,
+        skill_path: str | None = None,
     ) -> InstallResult:
         """Материализует навык в стор и линкует в scope агента.
 
@@ -449,6 +450,7 @@ class SkillStore:
             slug=slug, dir_name=dir_name, version=version, commit_sha=commit_sha,
             repo_url=repo_url, manifest=manifest, scope=scope, project=project,
             skill_id=skill_id_str, local_src=local_src, git_ref=git_ref,
+            skill_path=skill_path,
         )
         # git-url источник мог уточнить версию из frontmatter клона (фикс l2).
         effective_version = mat.get("version") or version
@@ -518,10 +520,12 @@ class SkillStore:
         skill_id: str | int | None = None,
         local_src: Path | None = None,
         git_ref: str | None = None,
+        skill_path: str | None = None,
     ) -> dict[str, Any]:
         """Материализует контент навыка в стор БЕЗ линковки в scope.
 
-        Возвращает {is_update, filter_result, update_diff, version}.
+        ``skill_path`` (#268) — подпапка навыка в репо (``skills/<name>/``);
+        None ⇒ корень репо. Возвращает {is_update, filter_result, update_diff, version}.
         """
         scope = "project" if project is not None else "global"
         dir_name = skill_dir_name(slug, skill_id)
@@ -530,12 +534,13 @@ class SkillStore:
             slug=slug, dir_name=dir_name, version=version, commit_sha=commit_sha,
             repo_url=repo_url, manifest=manifest, scope=scope, project=project,
             skill_id=skill_id_str, local_src=local_src, git_ref=git_ref,
+            skill_path=skill_path,
         )
 
     def _materialize_store(
         self, *, slug, dir_name, version, commit_sha, repo_url, manifest,
         scope, project, skill_id, local_src: Path | None = None,
-        git_ref: str | None = None,
+        git_ref: str | None = None, skill_path: str | None = None,
     ) -> dict[str, Any]:
         """Кладёт контент навыка в store_dir. Возвращает {is_update, filter_result, update_diff}."""
         store_dir = self._store_path(dir_name)
@@ -550,6 +555,7 @@ class SkillStore:
                 slug=slug, version=version, commit_sha=commit_sha, repo_url=repo_url,
                 manifest=manifest, scope=scope, project=project, slug_dir=store_dir,
                 skill_id=skill_id, local_src=local_src, git_ref=git_ref,
+                skill_path=skill_path,
             )
             return {"is_update": True, "filter_result": up.filter_result,
                     "update_diff": up.update_diff, "version": up.version}
@@ -558,7 +564,9 @@ class SkillStore:
         filter_result: dict[str, int] | None = None
         source = "hub"
         if repo_url:
-            with self._clone_version(repo_url, version, ref=git_ref) as cloned:
+            with self._clone_version(
+                repo_url, version, ref=git_ref, skill_path=skill_path
+            ) as cloned:
                 safe_copy_tree(cloned, store_dir)
             filter_result = apply_skill_filter(store_dir)
             if git_ref is not None:
@@ -684,6 +692,7 @@ class SkillStore:
         skill_id: str | None = None,
         local_src: Path | None = None,
         git_ref: str | None = None,
+        skill_path: str | None = None,
     ) -> InstallResult:
         """Докачивает diff между установленной и новой версией.
 
@@ -714,7 +723,9 @@ class SkillStore:
                 src_label = "local-path"
                 meta_repo = None
             else:
-                with self._clone_version(repo_url, version, ref=git_ref) as cloned:
+                with self._clone_version(
+                    repo_url, version, ref=git_ref, skill_path=skill_path
+                ) as cloned:
                     safe_copy_tree(cloned, slug_dir)
                 src_label = "git-url"
                 meta_repo = repo_url
@@ -755,7 +766,7 @@ class SkillStore:
         # версии (как git-url путь), сохраняя preserved-пути, вместо diff.
         if not manifest.get("files"):
             preserved = _preserved_for(manifest, self._target)
-            with self._clone_version(repo_url, version) as cloned:
+            with self._clone_version(repo_url, version, skill_path=skill_path) as cloned:
                 safe_copy_tree(cloned, slug_dir)
             version = _version_from_skill_md(slug_dir, version)
             filter_result = apply_skill_filter(slug_dir, extra_preserved=preserved)
@@ -776,7 +787,7 @@ class SkillStore:
         preserved = _preserved_for(manifest, self._target)
 
         filter_result: dict[str, int] | None = None
-        with self._clone_version(repo_url, version) as cloned:
+        with self._clone_version(repo_url, version, skill_path=skill_path) as cloned:
             # 4. Копируем added + changed.
             for rel in [*added, *changed]:
                 src_file = cloned / rel
@@ -913,7 +924,10 @@ class SkillStore:
     #  helpers
     # ------------------------------------------------------------------
     @contextlib.contextmanager
-    def _clone_version(self, repo_url: str, version: str, *, ref: str | None = None):
+    def _clone_version(
+        self, repo_url: str, version: str, *, ref: str | None = None,
+        skill_path: str | None = None,
+    ):
         """git clone во временную папку (yield Path).
 
         Поведение по ``ref``:
@@ -921,7 +935,11 @@ class SkillStore:
         - ``""`` (пусто) → git-url без явного ref: клон дефолтной ветки репо
           (``--branch`` опускается — ``--branch HEAD`` git не принимает);
         - иначе → дословный ref (ветка/тег/sha).
-        Папка удаляется при выходе из контекста.
+
+        ``skill_path`` (subdir-навык, #268): если задан — yield-им ПОДПАПКУ
+        ``<clone>/<skill_path>`` (с traversal-guard), а не корень репо. Так навык
+        может лежать подкаталогом CLI-репо (``skills/<name>/``), а материализуется
+        только он. Папка удаляется при выходе из контекста.
         """
         use_default_branch = ref == ""
         ref = ref if ref is not None else f"v{version}"
@@ -949,7 +967,15 @@ class SkillStore:
                     if secret:
                         stderr = stderr.replace(secret, "***")
                 raise RuntimeError(f"git clone failed: {stderr}") from e
-            yield clone_dir
+            # subdir-навык (#268): материализуем подпапку, не корень репо.
+            target = clone_dir
+            if skill_path:
+                target = _assert_within(clone_dir, clone_dir / skill_path)
+                if not target.is_dir():
+                    raise RuntimeError(
+                        f"skill_path '{skill_path}' не найден в репо {repo_url}"
+                    )
+            yield target
         finally:
             _force_rmtree(tmp)
 

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/skillkit/manifest.py

@@ -11,7 +11,7 @@ import hashlib
 import re
 import subprocess
 import tomllib
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -47,6 +47,12 @@ class BuiltManifest:
     files: list[dict]  # [{path, sha256, size}, ...]
     dependencies: list[dict]
     preserved_paths: list[str]
+    # Tooling-поля из _skill_meta.toml (kind=tooling несёт CLI/MCP/deps). Без них
+    # publish терял бы CLI-метаданные → install не ставил бы сам инструмент.
+    kind: str | None = None
+    cli: list[dict] = field(default_factory=list)  # [{command_name, entrypoint}, ...]
+    mcp: list[dict] = field(default_factory=list)
+    runtime_dependencies: list[dict] = field(default_factory=list)  # [{kind, spec}, ...]
 
 
 def _sha256_of(path: Path) -> str:
@@ -159,6 +165,25 @@ def build_manifest(skill_dir: Path, *, version: str) -> BuiltManifest:
         if isinstance(d, dict) and "slug" in d:
             deps.append({"slug": d["slug"], "min_version": d.get("min_version", "0.0.0")})
 
+    # Tooling-поля: kind=tooling несёт CLI-инструмент(ы) + runtime-зависимости.
+    # Нормализуем под DTO бэкенда (cli: command_name/entrypoint; runtime_dependencies:
+    # kind/spec), чтобы publish сохранил их и install смог поставить сам инструмент.
+    kind = meta_toml.get("kind") or None
+    cli_tools: list[dict] = []
+    for c in meta_toml.get("cli", []):
+        if isinstance(c, dict) and c.get("command_name") and c.get("entrypoint"):
+            cli_tools.append(
+                {"command_name": str(c["command_name"]), "entrypoint": str(c["entrypoint"])}
+            )
+    mcp_servers: list[dict] = []
+    for srv in meta_toml.get("mcp", []):
+        if isinstance(srv, dict):
+            mcp_servers.append({k: v for k, v in srv.items()})
+    runtime_deps: list[dict] = []
+    for rd in meta_toml.get("runtime_dependencies", []):
+        if isinstance(rd, dict) and rd.get("kind") and rd.get("spec"):
+            runtime_deps.append({"kind": str(rd["kind"]), "spec": str(rd["spec"])})
+
     # Walk file tree
     files: list[dict] = []
     for p in skill_dir.rglob("*"):
@@ -188,4 +213,8 @@ def build_manifest(skill_dir: Path, *, version: str) -> BuiltManifest:
         files=sorted(files, key=lambda f: f["path"]),
         dependencies=deps,
         preserved_paths=["_local/", "browser_profiles/"],
+        kind=kind,
+        cli=cli_tools,
+        mcp=mcp_servers,
+        runtime_dependencies=runtime_deps,
     )

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/skillkit/tooling.py

@@ -29,6 +29,8 @@
 from __future__ import annotations
 
 import shlex
+import shutil
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -83,13 +85,20 @@ def _has_artifacts(manifest: dict[str, Any]) -> bool:
 # --------------------------------------------------------------------------
 #  entrypoint → исполняемая команда для shim
 # --------------------------------------------------------------------------
-def _entrypoint_to_command(entrypoint: str | None, *, store_dir: Path | None) -> str | None:
+def _entrypoint_to_command(
+    entrypoint: str | None,
+    *,
+    store_dir: Path | None,
+    python_executable: str | None = None,
+) -> str | None:
     """Привести ``entrypoint`` к команде для ``path_store.add_cli``.
 
     - ``None`` / пусто → ``None`` (CLI без энтрипоинта пропускаем);
     - ``module:callable`` (console-script спецификация) → python-команда,
-      вызывающая callable текущим интерпретатором (кроссплатформенно, без
-      зависимости от того, поставлен ли console-script в venv);
+      вызывающая callable ИНТЕРПРЕТАТОРОМ ``python_executable`` (выделенный venv
+      инструмента, куда поставлены runtime-зависимости) — иначе ``sys.executable``
+      хоста, где пакета может не быть. Кроссплатформенно, без зависимости от того,
+      поставлен ли console-script в venv;
     - всё прочее (``python -m pkg`` / путь к exe) → как есть (path_store сам
       различит путь-к-файлу и команду).
     """
@@ -106,13 +115,61 @@ def _entrypoint_to_command(entrypoint: str | None, *, store_dir: Path | None) ->
     ):
         module, _, func = ep.partition(":")
         if module and func:
-            py = _quote(sys.executable)
+            py = _quote(python_executable or sys.executable)
             # sys.exit(func()) — корректный код возврата CLI.
             code = f"import sys; from {module} import {func}; sys.exit({func}())"
             return f'{py} -c "{code}"'
     return ep
 
 
+# --------------------------------------------------------------------------
+#  выделенный venv инструмента (изоляция runtime-зависимостей)
+# --------------------------------------------------------------------------
+def _venv_python(venv_dir: Path) -> Path:
+    """Путь к python внутри venv (Scripts на Windows, bin на POSIX)."""
+    if sys.platform == "win32":
+        return venv_dir / "Scripts" / "python.exe"
+    return venv_dir / "bin" / "python"
+
+
+def _ensure_tool_venv(store_dir: Path | None) -> str | None:
+    """Гарантировать выделенный venv для CLI-инструмента в ``<store_dir>/.venv``.
+
+    Зачем: runtime-зависимости навыка ставятся в ИЗОЛИРОВАННЫЙ venv (не в хост-
+    интерпретатор ``skills-hub`` и не в случайный cwd/.venv), а CLI-шим целится в
+    тот же venv. Это убирает конфликт версий с хостом и делает установку
+    детерминированной.
+
+    Идемпотентно: venv уже есть → переиспользуем (deps накатятся через --upgrade).
+    Предпочитаем ``uv venv`` (быстро, без pip внутри — uv ставит снаружи); нет uv
+    → ``python -m venv``. Никогда не бросает: не вышло создать → ``None`` (вызвавший
+    откатится на ambient ``sys.executable``-поведение).
+    """
+    if store_dir is None:
+        return None
+    try:
+        venv_dir = Path(store_dir) / ".venv"
+        py = _venv_python(venv_dir)
+        if py.exists():
+            return str(py)
+        venv_dir.parent.mkdir(parents=True, exist_ok=True)
+        if shutil.which("uv") is not None:
+            rc = subprocess.run(
+                ["uv", "venv", str(venv_dir)], check=False, capture_output=True
+            ).returncode
+        else:
+            rc = subprocess.run(
+                [sys.executable, "-m", "venv", str(venv_dir)],
+                check=False,
+                capture_output=True,
+            ).returncode
+        if rc == 0 and py.exists():
+            return str(py)
+    except Exception:
+        return None
+    return None
+
+
 def _quote(value: str) -> str:
     """Кавычки для пути с пробелами (POSIX shlex; на Windows — двойные)."""
     if " " not in value:
@@ -145,11 +202,20 @@ def apply_tooling_artifacts(
     store_dir = getattr(result, "store_dir", None)
     skill_ref = _skill_ref(result)
 
-    # 1. runtime-зависимости (deps_installer сам graceful, но обернём на всякий).
+    # Выделенный venv инструмента: если есть pip-зависимости и известна store_dir —
+    # создаём <store_dir>/.venv и ставим deps ИМЕННО в него, а CLI-шим целим туда
+    # же. Без этого deps уходили в cwd/.venv или хост-интерпретатор, а шим целился в
+    # sys.executable — рассинхрон ⇒ «ModuleNotFoundError» при запуске CLI.
     deps = _deps_list(man)
+    has_pip = any(str(d.get("kind") or "") == "pip" for d in deps)
+    tool_python = _ensure_tool_venv(store_dir) if has_pip else None
+
+    # 1. runtime-зависимости (deps_installer сам graceful, но обернём на всякий).
     if deps:
         try:
-            report["deps"] = deps_installer.install_runtime_dependencies(deps)
+            report["deps"] = deps_installer.install_runtime_dependencies(
+                deps, python_executable=tool_python
+            )
         except Exception as exc:
             report["deps"] = {"error": str(exc)}
 
@@ -161,7 +227,9 @@ def apply_tooling_artifacts(
         if not command_name:
             report["cli"].append({"status": "error", "reason": "command_name пуст"})
             continue
-        command = _entrypoint_to_command(tool.get("entrypoint"), store_dir=store_dir)
+        command = _entrypoint_to_command(
+            tool.get("entrypoint"), store_dir=store_dir, python_executable=tool_python
+        )
         if command is None:
             report["cli"].append(
                 {

{s_skillkit-0.1.2 → s_skillkit-0.1.4}/tests/test_manifest.py

@@ -69,3 +69,42 @@ def test_read_meta_toml(tmp_path: Path) -> None:
     (d / "SKILL.md").write_text("---\nname: s\nversion: 1.0.0\n---\n# s\n", encoding="utf-8")
     m = build_manifest(d, version="1.0.0")
     assert m.description == "from toml"
+
+
+def test_build_manifest_tooling_fields(tmp_path: Path) -> None:
+    """tooling-навык: kind/cli/runtime_dependencies из _skill_meta.toml попадают
+    в манифест (без них publish терял бы CLI → install не ставил инструмент)."""
+    d = tmp_path / "tool"
+    d.mkdir()
+    (d / "SKILL.md").write_text("---\nname: tool\n---\n# tool\n", encoding="utf-8")
+    # ВАЖНО: runtime_dependencies (top-level массив) — ДО заголовка [[cli]],
+    # иначе tomllib относит ключ внутрь cli[0], а не на верхний уровень.
+    (d / "_skill_meta.toml").write_text(
+        'version = "0.2.1"\n'
+        'description = "tool skill"\n'
+        'kind = "tooling"\n'
+        'runtime_dependencies = [\n'
+        '    { kind = "pip", spec = "mytool @ git+https://example/x.git@v1" },\n'
+        ']\n'
+        "[[cli]]\n"
+        'command_name = "mytool"\n'
+        'entrypoint = "mytool.cli:app"\n',
+        encoding="utf-8",
+    )
+    m = build_manifest(d, version="0.2.1")
+    assert m.kind == "tooling"
+    assert m.cli == [{"command_name": "mytool", "entrypoint": "mytool.cli:app"}]
+    assert m.runtime_dependencies == [
+        {"kind": "pip", "spec": "mytool @ git+https://example/x.git@v1"}
+    ]
+    assert m.mcp == []
+
+
+def test_build_manifest_no_tooling_fields_defaults(tmp_path: Path) -> None:
+    """Не-tooling навык: tooling-поля пусты (kind=None, списки пустые)."""
+    d = _skill(tmp_path)
+    m = build_manifest(d, version="1.0.0")
+    assert m.kind is None
+    assert m.cli == []
+    assert m.mcp == []
+    assert m.runtime_dependencies == []