unique-sdk 2026.42.0.dev2__tar.gz → 2026.42.0.dev4__tar.gz

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-sdk
-Version: 2026.42.0.dev2
+Version: 2026.42.0.dev4
 Summary: 
 Author: Martin Fadler, Konstantin Krauss, Andreas Hauri
 Author-email: Martin Fadler <martin.fadler@unique.ch>, Konstantin Krauss <konstantin@unique.ch>, Andreas Hauri <andreas@unique.ch>

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.42.0.dev2"
+version = "2026.42.0.dev4"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }
@@ -91,6 +91,7 @@ markers = [
     "asyncio: asyncio tests",
     "integration: integration tests that require API access or credentials",
     "serial: tests that must run serially",
+    "skill_guard: CLI tests that exercise the real skill guard",
     "unit: unit tests",
     "verified: AI-generated tests with human verification",
 ]

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/api_resources/_agentic_table.py

@@ -348,6 +348,19 @@ class AgenticTable(APIResource["AgenticTable"]):
         rowId: str
         entries: list[MagicTableMetadataEntry]
 
+    class UpdateRowMetadata(RequestOptions):
+        """Body for `POST /magic-table/{tableId}/row/metadata/{metadataId}` (update one row metadata entry).
+
+        The entry is addressed by its own id (``id`` on a ``rowMetadata`` entry),
+        not by row or key.
+        """
+
+        tableId: str
+        metadataId: str
+        key: str
+        value: str
+        exactFilter: NotRequired[bool]
+
     @classmethod
     async def set_cell(
         cls,
@@ -505,10 +518,19 @@ class AgenticTable(APIResource["AgenticTable"]):
         company_id: str,
         tableId: str,
         cells: list[AgenticTableCell],
+        overwriteLibraryRows: bool | None = None,
     ) -> ColumnMetadataUpdateStatus:
+        """Upsert cells (`POST /magic-table/{tableId}/cells/bulk-upsert`).
+
+        ``overwriteLibraryRows=True`` asks the server to apply updates to existing
+        cells on library-sheet rows, which it otherwise drops for assistant
+        writes. The server only honors it on library sheets, for rows where the
+        caller can read every sheet named in the row's ``sourceSheetId`` metadata.
+        ``None`` omits the field; servers that predate it reject it with a 400.
+        """
         url = f"/magic-table/{tableId}/cells/bulk-upsert"
         try:
-            params_api = {
+            params_api: dict[str, Any] = {
                 "cells": [
                     {
                         "rowOrder": cell["rowOrder"],
@@ -520,6 +542,8 @@ class AgenticTable(APIResource["AgenticTable"]):
             }
         except Exception as e:
             raise ValueError(f"Invalid data or missing required fields: {e}")
+        if overwriteLibraryRows is not None:
+            params_api["overwriteLibraryRows"] = overwriteLibraryRows
         return cast(
             "ColumnMetadataUpdateStatus",
             await cls._static_request_async(
@@ -720,6 +744,48 @@ class AgenticTable(APIResource["AgenticTable"]):
             ),
         )
 
+    @classmethod
+    async def update_row_metadata(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["AgenticTable.UpdateRowMetadata"],
+    ) -> MagicTableActionResult:
+        """Update one row metadata entry (`POST /magic-table/{tableId}/row/metadata/{metadataId}`)."""
+        url = f"/magic-table/{params['tableId']}/row/metadata/{params['metadataId']}"
+        params.pop("tableId")
+        params.pop("metadataId")
+        return cast(
+            MagicTableActionResult,
+            await cls._static_request_async(
+                "post",
+                url,
+                user_id,
+                company_id,
+                params,
+            ),
+        )
+
+    @classmethod
+    async def delete_row_metadata(
+        cls,
+        user_id: str,
+        company_id: str,
+        tableId: str,
+        metadataId: str,
+    ) -> MagicTableActionResult:
+        """Delete one row metadata entry (`DELETE /magic-table/{tableId}/row/metadata/{metadataId}`)."""
+        url = f"/magic-table/{tableId}/row/metadata/{metadataId}"
+        return cast(
+            MagicTableActionResult,
+            await cls._static_request_async(
+                "delete",
+                url,
+                user_id,
+                company_id,
+            ),
+        )
+
     @classmethod
     async def delete_sheet_metadata(
         cls,

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/api_resources/_content.py

@@ -21,6 +21,7 @@ class Content(APIResource["Content"]):
 
     id: str
     key: str
+    ownerId: str
     url: str | None
     title: str | None
     updatedAt: str

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/commands/files.py

@@ -11,6 +11,7 @@ from typing import Any
 
 import unique_sdk
 from unique_sdk.cli.formatting import format_content_info
+from unique_sdk.cli.skill_guard import skill_denial
 from unique_sdk.cli.state import ShellState
 from unique_sdk.utils.file_io import download_content, upload_file
 
@@ -337,6 +338,10 @@ def cmd_upload(
                 "upload: permission denied: destination is outside your "
                 f"task scope ({state.scope_denial_hint()})."
             )
+        if state.skill_guard.is_folder_write_denied(
+            scope_id, new_file_name=display_name
+        ):
+            return skill_denial("upload", display_name)
 
         mime_type = _detect_upload_mime_type(path)
 
@@ -426,6 +431,8 @@ def cmd_download(
     """Download a file by name or content ID."""
     try:
         content_id, display_name = _resolve_content_id(state, name_or_id)
+        if state.is_skill_content_read_denied(content_id):
+            return skill_denial("download", display_name)
 
         raw_name = (
             display_name if not display_name.startswith("cont_") else f"{content_id}"
@@ -462,6 +469,8 @@ def cmd_rm(state: ShellState, name_or_id: str) -> str:
         content_id, display_name = _resolve_content_id(
             state, name_or_id, allow_chat_files=False
         )
+        if state.is_skill_content_write_denied(content_id):
+            return skill_denial("rm", display_name)
         unique_sdk.Content.delete(
             user_id=state.config.user_id,
             company_id=state.config.company_id,
@@ -481,6 +490,8 @@ def cmd_mv_file(state: ShellState, old_name: str, new_name: str) -> str:
         content_id, display_name = _resolve_content_id(
             state, old_name, allow_chat_files=False
         )
+        if state.is_skill_content_write_denied(content_id, new_name=new_name):
+            return skill_denial("mv", display_name)
         result = unique_sdk.Content.update(
             user_id=state.config.user_id,
             company_id=state.config.company_id,

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/commands/folders.py

@@ -6,6 +6,7 @@ import os
 
 import unique_sdk
 from unique_sdk.cli.formatting import format_folder_info
+from unique_sdk.cli.skill_guard import skill_denial
 from unique_sdk.cli.state import ShellState
 
 
@@ -59,6 +60,8 @@ def cmd_mkdir(state: ShellState, name: str) -> str:
             "mkdir: permission denied: destination is outside your task scope "
             f"({state.scope_denial_hint()})."
         )
+    if state.skill_guard.is_path_write_denied(full_path):
+        return skill_denial("mkdir", full_path)
     try:
         result = unique_sdk.Folder.create_paths(
             user_id=state.config.user_id,
@@ -84,11 +87,14 @@ def cmd_rmdir(state: ShellState, target: str, recursive: bool = False) -> str:
         and not state.is_folder_target_within_workspace(target)
     ):
         return "rmdir: permission denied (outside workspace scope)"
-    if _metadata_filter_denies_folder(state, _resolve_folder_scope_id(state, target)):
+    scope_id = _resolve_folder_scope_id(state, target)
+    if _metadata_filter_denies_folder(state, scope_id):
         return (
             "rmdir: permission denied: target is outside your task scope "
             f"({state.scope_denial_hint()})."
         )
+    if state.skill_guard.is_folder_write_denied(scope_id, include_subtree=True):
+        return skill_denial("rmdir", target)
     try:
         if target.startswith("scope_"):
             unique_sdk.Folder.delete(
@@ -122,11 +128,14 @@ def cmd_mvdir(state: ShellState, old_name: str, new_name: str) -> str:
         and not state.is_folder_target_within_workspace(old_name)
     ):
         return "mvdir: permission denied (outside workspace scope)"
-    if _metadata_filter_denies_folder(state, _resolve_folder_scope_id(state, old_name)):
+    scope_id = _resolve_folder_scope_id(state, old_name)
+    if _metadata_filter_denies_folder(state, scope_id):
         return (
             "mvdir: permission denied: target is outside your task scope "
             f"({state.scope_denial_hint()})."
         )
+    if state.skill_guard.is_folder_write_denied(scope_id, include_subtree=True):
+        return skill_denial("mvdir", old_name)
     try:
         if old_name.startswith("scope_"):
             result = unique_sdk.Folder.update(

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/commands/navigation.py

@@ -7,6 +7,7 @@ from typing import Any
 import unique_sdk
 from unique_sdk.cli.formatting import format_ls
 from unique_sdk.cli.metadata_filter import _collect_filter_targets
+from unique_sdk.cli.skill_guard import skill_denial
 from unique_sdk.cli.state import ShellState
 
 
@@ -43,6 +44,8 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
                 f"ls: permission denied: target is outside your task scope "
                 f"({state.scope_denial_hint()})."
             )
+        if scope_id is not None and state.skill_guard.is_folder_hidden(scope_id):
+            return skill_denial("ls", target or state.cwd)
 
         # At root with a per-message KB scope (e.g. an Agentic Table column's
         # scope_rules), show only the in-scope folders and explicitly-scoped
@@ -67,6 +70,11 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
                     )
                 except unique_sdk.UniqueError:
                     pass
+            scoped_folders = [
+                folder
+                for folder in scoped_folders
+                if not state.skill_guard.is_folder_hidden(folder.get("id", ""))
+            ]
             scoped_files: list[Any] = []
             for cid in content_ids:
                 # A contentId mentioned in the filter is not necessarily in
@@ -77,6 +85,8 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
                 # UN-21780.
                 if not state.is_content_within_workspace(cid):
                     continue
+                if state.is_skill_content_read_denied(cid):
+                    continue
                 try:
                     info = unique_sdk.Content.get_info(
                         user_id=state.config.user_id,
@@ -109,6 +119,11 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
                     folders.append(info)
                 except unique_sdk.UniqueError:
                     pass
+            folders = [
+                folder
+                for folder in folders
+                if not state.skill_guard.is_folder_hidden(folder.get("id", ""))
+            ]
             output = format_ls(folders, [])
             summary = f"\n{len(folders)} folder(s), 0 file(s)"
             return output + summary
@@ -124,7 +139,8 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
             company_id=state.config.company_id,
             **folder_params,
         )
-        folders = folder_result.get("folderInfos", [])
+        listed_folders = folder_result.get("folderInfos", [])
+        folders = state.skill_guard.visible_child_folders(listed_folders)
 
         content_result = unique_sdk.Content.get_infos(
             user_id=state.config.user_id,
@@ -133,7 +149,9 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
         )
         files = content_result.get("contentInfos", [])
 
-        total_folders = folder_result.get("totalCount", len(folders))
+        total_folders = folder_result.get("totalCount", len(listed_folders)) - (
+            len(listed_folders) - len(folders)
+        )
         total_files = content_result.get("totalCount", len(files))
 
         # With a per-message filter, listing inside an allowed folder must not

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/commands/read.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 from typing import Any
 
 import unique_sdk
+from unique_sdk.cli.skill_guard import skill_denial
 from unique_sdk.cli.state import ShellState
 
 READ_ERROR_PREFIX = "read:"
@@ -103,6 +104,8 @@ def cmd_read(
             f"task scope ({state.scope_denial_hint()}). Use 'unique-cli search' "
             "or 'ls' within that scope instead."
         )
+    if state.is_skill_content_read_denied(cont_id):
+        return skill_denial("read", cont_id)
 
     try:
         results = unique_sdk.Content.search(

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/commands/search.py

@@ -280,6 +280,7 @@ def cmd_search(
             company_id=state.config.company_id,
             **search_params,
         )
+        results = [hit for hit in results if not state.is_skill_search_hit_hidden(hit)]
 
     except (ValueError, unique_sdk.UniqueError) as e:
         return f"{SEARCH_ERROR_PREFIX} {e}"

unique_sdk-2026.42.0.dev4/unique_sdk/cli/skill_guard.py

@@ -0,0 +1,314 @@
+"""Keep CLI reads and writes out of skill folders (a ``skill.md``/``skills.md`` marker
+at or above the folder) outside the caller's personal skills
+(``<home>/skills-conduct/space-<spaceId>``)."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any
+
+import unique_sdk
+from unique_sdk.cli.config import Config
+
+_MARKER_NAME_RE = re.compile(r"^skills?\.md$", re.IGNORECASE)
+
+# The SDK JSON-encodes request params without an Enum encoder, so
+# ``mode: insensitive`` can't be sent. Match the common spellings instead and
+# re-check every hit with ``is_skill_marker_name``.
+_MARKER_KEY_SUFFIXES = tuple(
+    f"{stem}{extension}"
+    for stem in ("skill", "Skill", "SKILL", "skills", "Skills", "SKILLS")
+    for extension in (".md", ".MD")
+)
+
+_FOLDER_ID_PATH_PREFIX = "uniquepathid://"
+_MAX_FOLDER_DEPTH = 64
+
+
+class PersonalSkillsFolder(StrEnum):
+    """Folder names in ``/home/<UserName>/skills-conduct/space-<spaceId>``."""
+
+    HOME_ROOT = "home"
+    LEGACY_HOME_PREFIX = "home-"
+    SKILLS = "skills-conduct"
+    SPACE_PREFIX = "space-"
+
+
+def is_skill_marker_name(name: str) -> bool:
+    """True when the last segment of *name* is a skill marker file name."""
+    base = name.replace("\\", "/").rsplit("/", 1)[-1].strip()
+    return bool(_MARKER_NAME_RE.match(base))
+
+
+def skill_denial(command: str, target: str) -> str:
+    """Denial text in the ``<command>: permission denied`` shape the CLI exits on."""
+    return (
+        f"{command}: permission denied: {target} is part of a skill outside your "
+        "personal skills, or its skill status could not be checked."
+    )
+
+
+@dataclass(frozen=True)
+class _FolderNode:
+    scope_id: str
+    name: str
+    parent_id: str | None
+
+
+@dataclass(frozen=True)
+class _SkillMarker:
+    skill_folder_id: str
+    # Empty when the content has no ``folderIdPath``; looked up on demand.
+    folder_ids: frozenset[str]
+
+
+class SkillGuard:
+    """Answers whether a read or write would touch a protected skill."""
+
+    def __init__(self, config: Config) -> None:
+        self._config = config
+        self._folders: dict[str, _FolderNode] = {}
+        self._markers: tuple[_SkillMarker, ...] | None = None
+        self._hidden: dict[str, bool] = {}
+
+    def is_folder_hidden(self, scope_id: str) -> bool:
+        """True when *scope_id* is inside a protected skill. Fails closed."""
+        cached = self._hidden.get(scope_id)
+        if cached is not None:
+            return cached
+        try:
+            chain = self._folder_chain(scope_id)
+            hidden = not self._is_in_own_personal_layer(chain) and self._has_marker_in(
+                [node.scope_id for node in chain]
+            )
+        except unique_sdk.UniqueError:
+            hidden = True
+        self._hidden[scope_id] = hidden
+        return hidden
+
+    def is_folder_path_hidden(self, folder_ids: Sequence[str]) -> bool:
+        """True when a ``folderIdPath`` runs through a protected skill. Fails closed."""
+        try:
+            skill_folder_ids = {
+                marker.skill_folder_id for marker in self._all_skill_markers()
+            }
+        except unique_sdk.UniqueError:
+            return True
+        return any(
+            self.is_folder_hidden(folder_id)
+            for folder_id in folder_ids
+            if folder_id in skill_folder_ids
+        )
+
+    def visible_child_folders(self, folders: Sequence[Any]) -> list[Any]:
+        """Drop protected skills from the child folders of a visible folder."""
+        folder_ids = [folder.get("id") for folder in folders if folder.get("id")]
+        if not folder_ids:
+            return list(folders)
+        skill_folder_ids = {
+            _marker_owner_id(content)
+            for content in self._search_markers({"ownerId": {"in_": folder_ids}})
+            if is_skill_marker_name(content.get("key") or "")
+        }
+        return [
+            folder
+            for folder in folders
+            if folder.get("id") not in skill_folder_ids
+            or not self.is_folder_hidden(folder["id"])
+        ]
+
+    def is_folder_write_denied(
+        self,
+        scope_id: str | None,
+        *,
+        include_subtree: bool = False,
+        new_file_name: str | None = None,
+    ) -> bool:
+        """True when writing in *scope_id* would change a protected skill.
+
+        ``include_subtree`` also protects skills below the folder (``rmdir``,
+        ``mvdir``). ``new_file_name`` protects against creating a marker, which
+        would turn the folder into a skill. Fails closed when the folder is
+        unknown or a lookup fails.
+        """
+        if not scope_id:
+            return True
+        try:
+            return self._is_folder_write_denied(
+                scope_id,
+                include_subtree=include_subtree,
+                new_file_name=new_file_name,
+            )
+        except unique_sdk.UniqueError:
+            return True
+
+    def is_path_write_denied(self, folder_path: str) -> bool:
+        """True when creating *folder_path* would add structure inside a protected skill.
+
+        Checks the deepest existing folder on the path, because the target does
+        not exist yet.
+        """
+        segments = [segment for segment in folder_path.split("/") if segment]
+        while segments:
+            candidate = "/" + "/".join(segments)
+            try:
+                info = unique_sdk.Folder.get_info(
+                    user_id=self._config.user_id,
+                    company_id=self._config.company_id,
+                    folderPath=candidate,
+                )
+            except unique_sdk.UniqueError:
+                segments.pop()
+                continue
+            scope_id = info.get("id")
+            if not scope_id:
+                return True
+            return self.is_folder_write_denied(scope_id)
+        return False
+
+    def _is_folder_write_denied(
+        self,
+        scope_id: str,
+        *,
+        include_subtree: bool,
+        new_file_name: str | None,
+    ) -> bool:
+        chain = self._folder_chain(scope_id)
+        if self._is_in_own_personal_layer(chain):
+            return False
+        if new_file_name is not None and is_skill_marker_name(new_file_name):
+            return True
+        if self._has_marker_in([node.scope_id for node in chain]):
+            return True
+        if include_subtree:
+            return any(
+                scope_id in self._marker_folder_ids(marker)
+                for marker in self._all_skill_markers()
+            )
+        return False
+
+    def _is_in_own_personal_layer(self, chain: list[_FolderNode]) -> bool:
+        """True inside ``<home>/skills-conduct/space-<spaceId>``.
+
+        The API resolves no other user's home for the caller, so a home in the
+        chain is the caller's own. The API re-checks the owner on write.
+        """
+        return any(
+            node.name.startswith(PersonalSkillsFolder.SPACE_PREFIX)
+            and len(chain) > index + 2
+            and chain[index + 1].name == PersonalSkillsFolder.SKILLS
+            and self._is_own_home(chain[index + 2 :])
+            for index, node in enumerate(chain)
+        )
+
+    def _is_own_home(self, chain_from_home: list[_FolderNode]) -> bool:
+        """``/home/<UserName>``, or the legacy root ``/home-<userId>``."""
+        home, *above = chain_from_home
+        if not above:
+            return (
+                home.name
+                == f"{PersonalSkillsFolder.LEGACY_HOME_PREFIX}{self._config.user_id}"
+            )
+        return (
+            len(above) == 1
+            and above[0].name == PersonalSkillsFolder.HOME_ROOT
+            and above[0].parent_id is None
+        )
+
+    def _has_marker_in(self, folder_ids: list[str]) -> bool:
+        if not folder_ids:
+            return False
+        results = self._search_markers({"ownerId": {"in_": folder_ids}})
+        return any(
+            is_skill_marker_name(content.get("key") or "") for content in results
+        )
+
+    def _marker_folder_ids(self, marker: _SkillMarker) -> frozenset[str]:
+        if marker.folder_ids:
+            return marker.folder_ids
+        return frozenset(
+            node.scope_id for node in self._folder_chain(marker.skill_folder_id)
+        )
+
+    def _folder_chain(self, scope_id: str) -> list[_FolderNode]:
+        """The folder and its ancestors, nearest first."""
+        chain: list[_FolderNode] = []
+        current: str | None = scope_id
+        while current and len(chain) < _MAX_FOLDER_DEPTH:
+            node = self._folder(current)
+            chain.append(node)
+            current = node.parent_id
+        return chain
+
+    def _folder(self, scope_id: str) -> _FolderNode:
+        cached = self._folders.get(scope_id)
+        if cached is not None:
+            return cached
+        info = unique_sdk.Folder.get_info(
+            user_id=self._config.user_id,
+            company_id=self._config.company_id,
+            scopeId=scope_id,
+        )
+        node = _FolderNode(
+            scope_id=info["id"],
+            name=info.get("name") or "",
+            parent_id=info.get("parentId"),
+        )
+        self._folders[scope_id] = node
+        return node
+
+    def _search_markers(
+        self, where: unique_sdk.Content.ContentWhereInput | None = None
+    ) -> list[unique_sdk.Content]:
+        key_filter: unique_sdk.Content.ContentWhereInput = {
+            "OR": [{"key": {"endsWith": suffix}} for suffix in _MARKER_KEY_SUFFIXES]
+        }
+        clauses = [key_filter] if where is None else [key_filter, where]
+        return unique_sdk.Content.search(
+            user_id=self._config.user_id,
+            company_id=self._config.company_id,
+            where={"AND": clauses},
+        )
+
+    def _all_skill_markers(self) -> tuple[_SkillMarker, ...]:
+        """Every marker the caller can read. Only subtree checks need this."""
+        if self._markers is not None:
+            return self._markers
+        markers: list[_SkillMarker] = []
+        for content in self._search_markers():
+            if not is_skill_marker_name(content.get("key") or ""):
+                continue
+            path_ids = folder_ids_from_metadata(content.get("metadata"))
+            owner_id = _marker_owner_id(content)
+            if not owner_id.startswith("scope_"):
+                continue
+            markers.append(
+                _SkillMarker(
+                    skill_folder_id=owner_id,
+                    folder_ids=frozenset({owner_id, *path_ids})
+                    if path_ids
+                    else frozenset(),
+                )
+            )
+        self._markers = tuple(markers)
+        return self._markers
+
+
+def _marker_owner_id(content: unique_sdk.Content) -> str:
+    """The marker's folder: ``ownerId``, else the last ``folderIdPath`` segment."""
+    path_ids = folder_ids_from_metadata(content.get("metadata"))
+    return content.get("ownerId") or (path_ids[-1] if path_ids else "")
+
+
+def folder_ids_from_metadata(metadata: object) -> list[str]:
+    """Folder ids in a content's ``folderIdPath``, or ``[]`` when absent."""
+    if not isinstance(metadata, dict):
+        return []
+    folder_id_path = metadata.get("folderIdPath")
+    if not isinstance(folder_id_path, str):
+        return []
+    path = folder_id_path.removeprefix(_FOLDER_ID_PATH_PREFIX)
+    return [segment for segment in path.split("/") if segment.startswith("scope_")]

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/skills/unique-cli-file-management/SKILL.md

@@ -288,6 +288,7 @@ verified page numbers (if any) and `--read-method`.
 - File-not-found and folder-not-found errors are returned as text, not exceptions.
 - Successful results print to stdout -- parse output as needed.
 - Scope denials (e.g. a file or folder outside the task scope) print to **stderr** and exit with a **non-zero** status, so a denial in an `&&` chain stops the chain instead of being treated as success. Read the stderr message: it names the in-scope folders/documents to redirect you, rather than retrying the same out-of-scope target.
+- Skills in the knowledge base are off limits. A skill is a folder with a `SKILL.md` (or `skills.md`) file, including everything inside it. `search` and `ls` hide them, and `read`, `download`, `upload`, `rm`, `mv`, `mkdir`, `rmdir` and `mvdir` refuse them. Only your personal skills folders (`<home>/skills-conduct/space-<spaceId>` in your own home) are exempt. Never retry a denied command another way.
 
 ## Interactive Mode
 

{unique_sdk-2026.42.0.dev2 → unique_sdk-2026.42.0.dev4}/unique_sdk/cli/state.py

@@ -10,6 +10,7 @@ from typing import Any
 import unique_sdk
 from unique_sdk.cli.config import Config
 from unique_sdk.cli.metadata_filter import MetadataFilter
+from unique_sdk.cli.skill_guard import SkillGuard, folder_ids_from_metadata
 from unique_sdk.cli.workspace import manifest_path as workspace_manifest_path
 
 _SEARCH_CONFIG_FILENAME = ".unique-search.json"
@@ -180,6 +181,9 @@ class ShellState:
         self.mcp_tool_reference_mappings: dict[str, dict[str, Any]] = (
             _load_mcp_tool_configs()
         )
+        # Independent of scopeIds and metaDataFilter: a skill folder inside the
+        # KB scope is still off limits for writes. See UN-25784.
+        self.skill_guard = SkillGuard(config)
 
     @property
     def uploaded_search_available(self) -> bool:
@@ -420,6 +424,44 @@ class ShellState:
         self._content_info_cache[content_id] = info
         return info
 
+    def is_skill_content_write_denied(
+        self, content_id: str, *, new_name: str | None = None
+    ) -> bool:
+        """True when changing *content_id* would change a protected skill.
+
+        Content owned by a chat instead of a folder is never part of a skill.
+        Fails closed when the content can't be looked up.
+        """
+        info = self._get_content_info(content_id)
+        if not info:
+            return True
+        owner_id = info.get("ownerId") or ""
+        if not owner_id.startswith("scope_"):
+            return False
+        return self.skill_guard.is_folder_write_denied(owner_id, new_file_name=new_name)
+
+    def is_skill_content_read_denied(self, content_id: str) -> bool:
+        """True when *content_id* is part of a protected skill.
+
+        Content owned by a chat instead of a folder is never part of a skill.
+        Fails closed when the content can't be looked up.
+        """
+        info = self._get_content_info(content_id)
+        if not info:
+            return True
+        owner_id = info.get("ownerId") or ""
+        if not owner_id.startswith("scope_"):
+            return False
+        return self.skill_guard.is_folder_hidden(owner_id)
+
+    def is_skill_search_hit_hidden(self, hit: Any) -> bool:
+        """True when a search result sits in a protected skill."""
+        folder_ids = folder_ids_from_metadata(getattr(hit, "metadata", None))
+        if folder_ids:
+            return self.skill_guard.is_folder_path_hidden(folder_ids)
+        content_id = getattr(hit, "id", "") or ""
+        return bool(content_id) and self.is_skill_content_read_denied(content_id)
+
     def resolve_content_title(self, content_id: str) -> str:
         """Human-readable title for a content id, falling back to the id.