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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-sdk
-Version: 2026.42.0.dev4
+Version: 2026.42.0.dev5
 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.dev4 → unique_sdk-2026.42.0.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.42.0.dev4"
+version = "2026.42.0.dev5"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }
@@ -91,7 +91,6 @@ 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.dev4 → unique_sdk-2026.42.0.dev5}/unique_sdk/api_resources/_content.py

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

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

@@ -11,7 +11,6 @@ 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
 
@@ -338,10 +337,6 @@ 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)
 
@@ -431,8 +426,6 @@ 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}"
@@ -469,8 +462,6 @@ 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,
@@ -490,8 +481,6 @@ 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.dev4 → unique_sdk-2026.42.0.dev5}/unique_sdk/cli/commands/folders.py

@@ -6,7 +6,6 @@ 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
 
 
@@ -60,8 +59,6 @@ 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,
@@ -87,14 +84,11 @@ 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)"
-    scope_id = _resolve_folder_scope_id(state, target)
-    if _metadata_filter_denies_folder(state, scope_id):
+    if _metadata_filter_denies_folder(state, _resolve_folder_scope_id(state, target)):
         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(
@@ -128,14 +122,11 @@ 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)"
-    scope_id = _resolve_folder_scope_id(state, old_name)
-    if _metadata_filter_denies_folder(state, scope_id):
+    if _metadata_filter_denies_folder(state, _resolve_folder_scope_id(state, old_name)):
         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.dev4 → unique_sdk-2026.42.0.dev5}/unique_sdk/cli/commands/navigation.py

@@ -7,7 +7,6 @@ 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
 
 
@@ -44,8 +43,6 @@ 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
@@ -70,11 +67,6 @@ 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
@@ -85,8 +77,6 @@ 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,
@@ -119,11 +109,6 @@ 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
@@ -139,8 +124,7 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
             company_id=state.config.company_id,
             **folder_params,
         )
-        listed_folders = folder_result.get("folderInfos", [])
-        folders = state.skill_guard.visible_child_folders(listed_folders)
+        folders = folder_result.get("folderInfos", [])
 
         content_result = unique_sdk.Content.get_infos(
             user_id=state.config.user_id,
@@ -149,9 +133,7 @@ def cmd_ls(state: ShellState, target: str | None = None) -> str:
         )
         files = content_result.get("contentInfos", [])
 
-        total_folders = folder_result.get("totalCount", len(listed_folders)) - (
-            len(listed_folders) - len(folders)
-        )
+        total_folders = folder_result.get("totalCount", 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.dev4 → unique_sdk-2026.42.0.dev5}/unique_sdk/cli/commands/read.py

@@ -18,7 +18,6 @@ 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:"
@@ -104,8 +103,6 @@ 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.dev4 → unique_sdk-2026.42.0.dev5}/unique_sdk/cli/commands/search.py

@@ -280,7 +280,6 @@ 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-2026.42.0.dev5}/unique_sdk/cli/skills/unique-cli-file-management/SKILL.md

@@ -288,7 +288,6 @@ 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.dev4 → unique_sdk-2026.42.0.dev5}/unique_sdk/cli/state.py

@@ -10,7 +10,6 @@ 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"
@@ -181,9 +180,6 @@ 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:
@@ -424,44 +420,6 @@ 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.
 

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

@@ -1,314 +0,0 @@
-"""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_")]