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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.46.0.dev2"
+version = "2026.46.0.dev4"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }

{unique_sdk-2026.46.0.dev2 → unique_sdk-2026.46.0.dev4}/unique_sdk/api_resources/_space.py

@@ -271,9 +271,13 @@ class Space(APIResource["Space"]):
 
         Attributes:
             title: New chat title. Must be a non-empty string.
+            isGenerated: Marks the title as generated by an assistant. It is
+                applied only while the chat still has its prompt-based title;
+                otherwise the request fails with HTTP 409.
         """
 
         title: str
+        isGenerated: NotRequired[bool]
 
     class ChatResult(TypedDict):
         id: str

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

@@ -338,16 +338,23 @@ def cmd_ls(
         # Folder-only filters keep every file (each passes the folderIdPath
         # leaf); the verdict is cached per content id. See UN-21780.
         # The paging note counts rows read from the server, before the scope filter.
+        scanned_folders = len(folders)
         scanned_files = len(files)
         if state.workspace_metadata_filter is not None:
+            folders = [
+                folder
+                for folder in folders
+                if state.folder_allowed_by_metadata_filter(str(folder.get("id", "")))
+            ]
             files = [
                 f for f in files if state.is_content_within_workspace(f.get("id", ""))
             ]
+        hidden_folders = scanned_folders - len(folders)
         note = _window_note(
             target if target is not None else resolved_path,
             skip,
             limit,
-            {"folders": len(folders), "files": scanned_files},
+            {"folders": scanned_folders, "files": scanned_files},
             {"folders": total_folders, "files": total_files},
             hidden_files=scanned_files - len(files),
         )
@@ -363,6 +370,8 @@ def cmd_ls(
                 f"\n{total_folders} folder(s), {len(files)} file(s) in task scope "
                 f"(of {total_files} in folder)"
             )
+            if hidden_folders:
+                summary += f" ({hidden_folders} folder(s) hidden by task scope)"
             return output + summary + note
 
         summary = f"\n{total_folders} folder(s), {total_files} file(s)"

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

@@ -216,11 +216,9 @@ def cmd_search(
             folder_scope_id = _resolve_folder_to_scope_id(state, folder)
         elif state.scope_id and not state.workspace_metadata_filter:
             # The incidental cwd narrows search only when there is no
-            # per-message filter. `cd` is not gated by the filter, so an agent
-            # can sit in an out-of-scope folder; ANDing that cwd with the task
-            # filter would silently return no hits and look like an empty KB
-            # rather than a scope mismatch. With a filter active, only an
-            # explicit --folder narrows further. See UN-21780.
+            # per-message filter. With a filter active, only an explicit
+            # --folder narrows further: ANDing the cwd would turn a scope
+            # mismatch into an empty result. See UN-21780.
             folder_scope_id = state.scope_id
 
         scope_ids: list[str] | None = None

{unique_sdk-2026.46.0.dev2 → unique_sdk-2026.46.0.dev4}/unique_sdk/cli/metadata_filter.py

@@ -127,18 +127,54 @@ def _collect_navigable_folder_ids(
         return folder_ids
     if _is_negated_operator(node.get("operator")):
         return folder_ids
+    for scope_id in _folder_scope_ids(node):
+        if scope_id not in folder_ids:
+            folder_ids.append(scope_id)
+    return folder_ids
+
+
+def _folder_scope_ids(node: dict[Any, Any]) -> list[str]:
+    """Folder scope ids named by a ``folderIdPath`` leaf, else an empty list."""
     path = node.get("path")
     field = path[0] if isinstance(path, list) and path else path
-    if field == "folderIdPath":
-        value = node.get("value")
-        values = value if isinstance(value, list) else [value]
-        for v in values:
-            scope_id = _extract_target_scope_id(v)
-            if scope_id and scope_id not in folder_ids:
-                folder_ids.append(scope_id)
+    if field != "folderIdPath":
+        return []
+    value = node.get("value")
+    values = value if isinstance(value, list) else [value]
+    scope_ids: list[str] = []
+    for item in values:
+        scope_id = _extract_target_scope_id(item)
+        if scope_id and scope_id not in scope_ids:
+            scope_ids.append(scope_id)
+    return scope_ids
+
+
+def _collect_excluded_folder_ids(
+    node: Any, folder_ids: list[str] | None = None
+) -> list[str]:
+    """Every negated ``folderIdPath`` leaf in the tree."""
+    if folder_ids is None:
+        folder_ids = []
+    if not isinstance(node, dict):
+        return folder_ids
+    for key in ("and", "or"):
+        if key in node:
+            for child in node.get(key) or []:
+                _collect_excluded_folder_ids(child, folder_ids)
+            return folder_ids
+    if not _is_negated_operator(node.get("operator")):
+        return folder_ids
+    for scope_id in _folder_scope_ids(node):
+        if scope_id not in folder_ids:
+            folder_ids.append(scope_id)
     return folder_ids
 
 
+def _path_is_inside_any(target: str, roots: list[str]) -> bool:
+    """True when *target* is one of *roots* or a descendant of one."""
+    return any(target == root or target.startswith(root + "/") for root in roots)
+
+
 def _collect_filter_targets(
     node: Any,
     folder_ids: list[str] | None = None,
@@ -357,9 +393,15 @@ class MetadataFilter:
         """Folder scope ids the filter grants for navigation (ls/cd into).
 
         Excludes folders only reachable as an ``or`` alternative to a
-        ``contentId`` allowlist, which are not standalone-browsable.
+        ``contentId`` allowlist, which are not standalone-browsable. Also
+        drops a grant named by any exclusion in the tree.
         """
-        return _collect_navigable_folder_ids(self._tree)
+        excluded = set(_collect_excluded_folder_ids(self._tree))
+        return [
+            scope_id
+            for scope_id in _collect_navigable_folder_ids(self._tree)
+            if scope_id not in excluded
+        ]
 
     def _navigable_folder_paths(self) -> list[str]:
         return [
@@ -370,21 +412,35 @@ class MetadataFilter:
             if p
         ]
 
-    def allows_folder_scope(self, scope_id: str) -> bool:
-        """True if *scope_id* is inside one of the filter's navigable scopes.
+    def _excluded_scope_ids(self) -> list[str]:
+        return _collect_excluded_folder_ids(self._tree)
 
-        Gates explicit folder targets (e.g. ``ls <path>``) so navigation cannot
-        enumerate folders outside the per-message scope.
-        """
+    def _resolved_exclusion_paths(self) -> list[str] | None:
+        """Exclusion paths, or ``None`` when any exclusion failed to resolve."""
+        paths: list[str] = []
+        for scope_id in self._excluded_scope_ids():
+            path = self._resolve_scope_path(scope_id)
+            if not path:
+                return None
+            paths.append(path)
+        return paths
+
+    def allows_folder_scope(self, scope_id: str) -> bool:
+        """True if *scope_id* is in a navigable scope and not under an exclusion."""
+        if scope_id in self._excluded_scope_ids():
+            return False
+        excluded_paths = self._resolved_exclusion_paths()
+        if excluded_paths is None:
+            return False
         folder_paths = self._navigable_folder_paths()
         if not folder_paths:
             return False
         target_path = self._resolve_scope_path(scope_id)
         if not target_path:
             return False
-        return any(
-            target_path == p or target_path.startswith(p + "/") for p in folder_paths
-        )
+        if _path_is_inside_any(target_path, excluded_paths):
+            return False
+        return _path_is_inside_any(target_path, folder_paths)
 
     def allows_folder_path(self, folder_path: str) -> bool:
         """True if an absolute folder *path* lies within a navigable scope.
@@ -393,11 +449,16 @@ class MetadataFilter:
         scope id yet (e.g. a ``mkdir`` destination), so a ``..`` traversal can't
         create structure outside the task scope.
         """
+        excluded_paths = self._resolved_exclusion_paths()
+        if excluded_paths is None:
+            return False
         paths = self._navigable_folder_paths()
         if not paths:
             return False
         norm = os.path.normpath(folder_path)
-        return any(norm == p or norm.startswith(p + "/") for p in paths)
+        if _path_is_inside_any(norm, excluded_paths):
+            return False
+        return _path_is_inside_any(norm, paths)
 
     def scope(self) -> tuple[list[str], list[str]]:
         """Return ``(folder_paths, content_ids)`` referenced by the filter.

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

@@ -12,6 +12,7 @@ from unique_sdk.cli.config import Config
 from unique_sdk.cli.metadata_filter import MetadataFilter
 from unique_sdk.cli.paths import canonical_folder_path, same_folder_path
 from unique_sdk.cli.workspace import manifest_path as workspace_manifest_path
+from unique_sdk.cli.workspace import workspace_root
 
 _SEARCH_CONFIG_FILENAME = ".unique-search.json"
 _UPLOADED_CONFIG_FILENAME = ".unique-uploaded.json"
@@ -20,8 +21,8 @@ _CHAT_FILES_MANIFEST_PATH = Path(".unique") / "chat-files.json"
 
 
 def _load_search_config() -> dict[str, Any]:
-    """Load ``.unique-search.json`` from the cwd, or ``{}`` when absent/invalid."""
-    config_path = Path.cwd() / _SEARCH_CONFIG_FILENAME
+    """Load ``.unique-search.json`` from the workspace root, not the shell cwd."""
+    config_path = workspace_root() / _SEARCH_CONFIG_FILENAME
     if not config_path.is_file():
         return {}
     try:
@@ -32,7 +33,7 @@ def _load_search_config() -> dict[str, Any]:
 
 
 def _load_uploaded_config() -> dict[str, Any]:
-    """Load ``.unique-uploaded.json`` from the cwd, or ``{}`` when absent/invalid.
+    """Load ``.unique-uploaded.json`` from the workspace root, or ``{}`` when absent or invalid.
 
     Written by the Swappable Intelligence runner when the task carries per-row
     uploaded documents (an Agentic Table row's ``selectedUploadedFiles``). It
@@ -41,7 +42,7 @@ def _load_uploaded_config() -> dict[str, Any]:
     the knowledge-base folder scopes, so the scope-bound ``unique-cli search``
     structurally cannot return them. See UN-21780.
     """
-    config_path = Path.cwd() / _UPLOADED_CONFIG_FILENAME
+    config_path = workspace_root() / _UPLOADED_CONFIG_FILENAME
     if not config_path.is_file():
         return {}
     try:
@@ -61,7 +62,7 @@ def _load_mcp_tool_configs() -> dict[str, dict[str, Any]]:
     Keyed by the same namespaced tool name the agent passes to ``unique-cli
     mcp``. Returns ``{}`` when absent or invalid.
     """
-    config_path = Path.cwd() / _MCP_TOOLS_CONFIG_FILENAME
+    config_path = workspace_root() / _MCP_TOOLS_CONFIG_FILENAME
     if not config_path.is_file():
         return {}
     try:
@@ -562,6 +563,17 @@ class ShellState:
     def prompt(self) -> str:
         return f"{self._path}> "
 
+    def _require_navigable_folder(self, scope_id: str) -> None:
+        """Refuse a folder the per-message filter excludes. See UN-28458."""
+        if self._metadata_filter is None:
+            return
+        if self.folder_allowed_by_metadata_filter(scope_id):
+            return
+        raise ValueError(
+            "permission denied: target is outside your task scope "
+            f"({self.scope_denial_hint()})."
+        )
+
     def _enter_folder(self, scope_id: str, folder_path: str) -> str:
         """Store *folder_path* only when *scope_id* is that exact folder."""
         actual = canonical_folder_path(
@@ -571,6 +583,7 @@ class ShellState:
         )
         if not same_folder_path(actual, folder_path):
             raise ValueError(f"cannot change to {folder_path}: resolved to {actual}")
+        self._require_navigable_folder(scope_id)
         self._scope_id = scope_id
         self._path = folder_path
         return self._path
@@ -618,6 +631,7 @@ class ShellState:
                 company_id=self.config.company_id,
                 scope_id=target,
             )
+            self._require_navigable_folder(info["id"])
             self._scope_id = info["id"]
             self._path = path_resp["folderPath"]
             return self._path