deepagents-cli 0.0.57__tar.gz → 0.0.59__tar.gz

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Deep Agents CLI Changelog
 
+## [0.0.59](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.58...deepagents-cli==0.0.59) (2026-05-12)
+
+### Bug Fixes
+
+* Prevent import deadlock during skill discovery and prewarm ([#3385](https://github.com/langchain-ai/deepagents/issues/3385)) ([0bf8dd1](https://github.com/langchain-ai/deepagents/commit/0bf8dd1cfd680bd4d27ce19295f96c720f525787))
+
+## [0.0.58](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.57...deepagents-cli==0.0.58) (2026-05-12)
+
+### Features
+
+* Pin v0.6 and fix import race ([4db09ac](https://github.com/langchain-ai/deepagents/commit/4db09acba34b38521192b8f278723524be560779))
+
 ## [0.0.57](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.56...deepagents-cli==0.0.57) (2026-05-12)
 
 ### Features

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.57
+Version: 0.0.59
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -27,18 +27,18 @@ Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.19.0
 Requires-Dist: deepagents-acp>=0.0.4
-Requires-Dist: deepagents==0.5.9
+Requires-Dist: deepagents==0.6.1
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.3
 Requires-Dist: langchain-google-genai<5.0.0,>=4.2.2
 Requires-Dist: langchain-mcp-adapters<1.0.0,>=0.2.2
 Requires-Dist: langchain-openai<2.0.0,>=1.2.1
-Requires-Dist: langchain<2.0.0,>=1.2.17
-Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.0.3
+Requires-Dist: langchain<2.0.0,>=1.3.0
+Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.1.0
 Requires-Dist: langgraph-cli[inmem]<1.0.0,>=0.4.24
-Requires-Dist: langgraph-prebuilt<2.0.0,>=1.0.13
+Requires-Dist: langgraph-runtime-inmem<1.0.0,>=0.28.1
 Requires-Dist: langgraph-sdk<1.0.0,>=0.3.13
-Requires-Dist: langgraph<2.0.0,>=1.1.10
+Requires-Dist: langgraph<2.0.0,>=1.2.0
 Requires-Dist: langsmith[sandbox]>=0.8.0
 Requires-Dist: markdownify<2.0.0,>=0.13.0
 Requires-Dist: packaging>=23.0

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/THREAT_MODEL.md

@@ -57,7 +57,7 @@
 
 ### Architecture Diagram
 
-```
+```txt
 ┌──────────────────────────────────────────────────────────────────────┐
 │                        User (local machine)                          │
 │                                                                      │
@@ -138,6 +138,7 @@
 | C17 | Model Config Loader         | Resolves model provider, supports `class_path` for arbitrary `BaseChatModel` instantiation via `importlib`          | user-controlled      | N/A      | `config.create_model`, `config._create_model_from_class`, `model_config.ModelConfig.load`         |
 
 **Notes:**
+
 1. `http_request` and `fetch_url` enabled by default; `web_search` requires `TAVILY_API_KEY`.
 2. MCP servers only load if `.mcp.json` config files are present.
 3. Hooks only execute if `~/.deepagents/hooks.json` exists.

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/deepagents_cli/_version.py

@@ -1,6 +1,8 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.57"  # x-release-please-version
+# Keep the `x-release-please-version` annotation — release-please uses it to
+# bump `__version__` in sync with `pyproject.toml` on every release PR.
+__version__ = "0.0.59"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/cli"
 """URL for `deepagents-cli` documentation."""

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/deepagents_cli/app.py

@@ -43,6 +43,7 @@ from deepagents_cli import (
 )
 from deepagents_cli._cli_context import CLIContext
 from deepagents_cli._constants import DEFAULT_AGENT_NAME as DEFAULT_ASSISTANT_ID
+from deepagents_cli._debug import configure_debug_logging
 from deepagents_cli._git import (
     read_git_branch_from_filesystem,
     read_git_branch_via_subprocess,
@@ -90,6 +91,7 @@ from deepagents_cli.widgets.status import StatusBar
 from deepagents_cli.widgets.welcome import WelcomeBanner
 
 logger = logging.getLogger(__name__)
+configure_debug_logging(logger)
 _monotonic = time.monotonic
 
 _DEFERRED_START_NOTICE = (
@@ -1388,6 +1390,14 @@ class DeepAgentsApp(App):
         loop re-enters the same module graph (see that method for why).
         """
 
+        self._deepagents_import_lock = asyncio.Lock()
+        """Serializes cold imports into the Deep Agents graph after prewarm.
+
+        Startup model creation and skill discovery can both be triggered during
+        first paint. If prewarm failed or did not cover a transitive module,
+        both paths may cold-import overlapping modules at the same time.
+        """
+
         # Lifecycle flags & re-entry guards
         self._connecting = (
             server_kwargs is not None and not self._server_startup_deferred
@@ -1591,7 +1601,7 @@ class DeepAgentsApp(App):
         - The agent is a local `Pregel` graph (e.g. ACP mode, test harnesses).
 
         Used to gate features that require a server-backed agent (e.g. model
-        switching via `ConfigurableModelMiddleware`, checkpointer fallback).
+        switching via `ConfigurableModelMiddleware`, thread registration).
         Checks the agent type rather than server ownership so this works for
         both CLI-spawned servers and externally managed ones.
 
@@ -2144,7 +2154,12 @@ class DeepAgentsApp(App):
         from deepagents_cli.command_registry import SLASH_COMMANDS, build_skill_commands
 
         try:
-            skills, roots = await asyncio.to_thread(self._discover_skills_and_roots)
+            # Discovery and prewarm import overlapping parts of the Deep Agents
+            # graph in separate workers. Let prewarm finish first so CPython's
+            # per-module import locks cannot form a cycle.
+            await self._await_prewarm_imports()
+            async with self._deepagents_import_lock:
+                skills, roots = await asyncio.to_thread(self._discover_skills_and_roots)
         except OSError:
             logger.warning(
                 "Filesystem error during skill discovery",
@@ -2158,11 +2173,12 @@ class DeepAgentsApp(App):
                 markup=False,
             )
             return False
-        except Exception:
+        except Exception as exc:
             logger.exception("Unexpected error during skill discovery")
             self.notify(
-                "Skill discovery failed unexpectedly. "
-                "/skill: commands may not work. Check logs for details.",
+                f"Skill discovery failed unexpectedly ({type(exc).__name__}). "
+                "/skill: commands may not work. "
+                "Set DEEPAGENTS_CLI_DEBUG=1 for details.",
                 severity="warning",
                 timeout=8,
                 markup=False,
@@ -2332,7 +2348,8 @@ class DeepAgentsApp(App):
             from deepagents_cli.model_config import ModelConfigError, save_recent_model
 
             try:
-                result = create_model(**self._model_kwargs)
+                async with self._deepagents_import_lock:
+                    result = create_model(**self._model_kwargs)
             except ModelConfigError as exc:
                 self.post_message(self.ServerStartFailed(error=exc))
                 return
@@ -5486,9 +5503,6 @@ class DeepAgentsApp(App):
             if result.offload_warning:
                 await self._mount_message(ErrorMessage(result.offload_warning))
 
-            if remote := self._remote_agent():
-                await remote.aensure_thread(config)  # ty: ignore[invalid-argument-type]
-
             await self._agent.aupdate_state(
                 config, {"_summarization_event": result.new_event}
             )
@@ -5835,12 +5849,14 @@ class DeepAgentsApp(App):
         return result
 
     async def _get_thread_state_values(self, thread_id: str) -> dict[str, Any]:
-        """Fetch thread state values, with remote checkpointer fallback.
+        """Fetch thread state values for a thread.
 
-        In server mode the LangGraph dev server can report an empty thread state
-        after a restart even when checkpoints exist on disk. When that happens,
-        read the latest checkpoint directly so resumed threads can still load
-        history and offload correctly.
+        In server mode the LangGraph dev server starts with an empty in-memory
+        thread store, so `aget_state` returns empty state for any thread that
+        was not registered in the current server session. Calling
+        `aensure_thread` first registers the thread idempotently so the
+        subsequent `aget_state` call can read from the checkpointer correctly,
+        including proper reconstruction of delta channels.
 
         Args:
             thread_id: Thread ID to fetch from checkpoint storage.
@@ -5853,46 +5869,20 @@ class DeepAgentsApp(App):
             return {}
 
         config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
-        state = await self._agent.aget_state(config)
+        remote_config: dict[str, Any] = {"configurable": {"thread_id": thread_id}}
 
-        values: dict[str, Any] = {}
-        if state and state.values:
-            values = dict(state.values)
+        if remote := self._remote_agent():
+            await remote.aensure_thread(remote_config)
 
-        messages = values.get("messages")
-        if isinstance(messages, list) and messages:
-            return values
-        if not self._remote_agent():
-            return values
+        state = await self._agent.aget_state(config)
 
-        logger.debug(
-            "Remote state empty for thread %s; falling back to local checkpointer",
-            thread_id,
-        )
-        fallback_values = await self._read_channel_values_from_checkpointer(thread_id)
-        fallback_messages = fallback_values.get("messages")
-        if isinstance(fallback_messages, list) and fallback_messages:
-            values["messages"] = fallback_messages
-        if (
-            values.get("_summarization_event") is None
-            and "_summarization_event" in fallback_values
-        ):
-            values["_summarization_event"] = fallback_values["_summarization_event"]
-        if (
-            values.get("_context_tokens") is None
-            and "_context_tokens" in fallback_values
-        ):
-            values["_context_tokens"] = fallback_values["_context_tokens"]
-        return values
+        if state and state.values:
+            return dict(state.values)
+        return {}
 
     async def _fetch_thread_history_data(self, thread_id: str) -> _ThreadHistoryPayload:
         """Fetch and convert stored messages for a thread.
 
-        In server mode the LangGraph dev server starts with an empty thread
-        store, so `aget_state` via the HTTP API returns no messages even when
-        checkpoints exist on disk. We fall back to reading the SQLite
-        checkpointer directly to guarantee resumed threads load their history.
-
         Args:
             thread_id: Thread ID to fetch from checkpoint storage.
 
@@ -5910,10 +5900,8 @@ class DeepAgentsApp(App):
         if not messages:
             return _ThreadHistoryPayload([], context_tokens)
 
-        # Server mode / direct checkpointer may return dicts; convert to
+        # RemoteGraph.aget_state returns values as raw JSON dicts; convert to
         # LangChain message objects so _convert_messages_to_data works.
-        # `any(...)` guards against heterogeneous lists where only some
-        # elements are serialized.
         if any(isinstance(m, dict) for m in messages):
             from langchain_core.messages.utils import convert_to_messages
 
@@ -5923,44 +5911,6 @@ class DeepAgentsApp(App):
         data = await asyncio.to_thread(self._convert_messages_to_data, messages)
         return _ThreadHistoryPayload(data, context_tokens)
 
-    @staticmethod
-    async def _read_channel_values_from_checkpointer(thread_id: str) -> dict[str, Any]:
-        """Read checkpoint channel values directly from the SQLite checkpointer.
-
-        Args:
-            thread_id: Thread ID to look up.
-
-        Returns:
-            Channel values from the latest checkpoint, or an empty dict on
-                failure.
-        """
-        try:
-            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-
-            from deepagents_cli.sessions import get_db_path
-
-            db_path = str(get_db_path())
-            config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
-            async with AsyncSqliteSaver.from_conn_string(db_path) as saver:
-                tup = await saver.aget_tuple(config)
-                if tup and tup.checkpoint:
-                    channel_values = tup.checkpoint.get("channel_values", {})
-                    if isinstance(channel_values, dict):
-                        return dict(channel_values)
-        except (ImportError, OSError) as exc:
-            logger.warning(
-                "Failed to read checkpointer directly for %s: %s",
-                thread_id,
-                exc,
-            )
-        except Exception:
-            logger.warning(
-                "Unexpected error reading checkpointer for %s",
-                thread_id,
-                exc_info=True,
-            )
-        return {}
-
     async def _upgrade_thread_message_link(
         self,
         widget: AppMessage,

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/deepagents_cli/integrations/sandbox_factory.py

@@ -710,7 +710,7 @@ class _AgentCoreProvider(SandboxProvider):
 
         # Validate AWS credentials early for a clear error message.
         try:
-            import boto3  # ty: ignore[unresolved-import, unused-ignore-comment]
+            import boto3  # ty: ignore[unresolved-import]
 
             session = boto3.Session()
             credentials = session.get_credentials()

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/deepagents_cli/local_context.py

@@ -104,6 +104,7 @@ class _AsyncExecutableBackend(Protocol):
 
 logger = logging.getLogger(__name__)
 
+
 # ---------------------------------------------------------------------------
 # Context detection script
 #

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/deepagents_cli/remote_client.py

@@ -183,7 +183,8 @@ class RemoteAgent:
     ) -> Any:  # noqa: ANN401
         """Get the current state of a thread.
 
-        Returns `None` when the thread does not exist on the server (404).
+        Returns `None` when the thread does not exist on the server (404) or
+        when the thread exists but has no checkpoint yet (new/empty thread).
         All other errors (network, auth, 500) are logged at WARNING and
         re-raised so callers can handle them.
 
@@ -196,10 +197,11 @@ class RemoteAgent:
 
         Returns:
             Thread state object with `values` and `next` attributes, or `None`
-                if the thread is not found.
+                if the thread is not found or has no checkpoint.
 
         Raises:
             ValueError: If `thread_id` is not present in `config`.
+            TypeError: If the server returns an unexpected state shape.
         """  # noqa: DOC502 — raised by _require_thread_id
         from langgraph_sdk.errors import NotFoundError
 
@@ -211,6 +213,20 @@ class RemoteAgent:
         except NotFoundError:
             logger.debug("Thread %s not found on server", thread_id)
             return None
+        except TypeError as e:
+            # langgraph SDK bug: _create_state_snapshot does
+            # state["checkpoint"]["thread_id"], but the server returns
+            # checkpoint=null for threads with no checkpoint yet (new threads,
+            # or threads registered via aensure_thread before any run).
+            if "subscriptable" in str(e).lower():
+                logger.debug(
+                    "Thread %s has no checkpoint yet; treating as empty", thread_id
+                )
+                return None
+            logger.warning(
+                "Failed to get state for thread %s", thread_id, exc_info=True
+            )
+            raise
         except Exception:
             logger.warning(
                 "Failed to get state for thread %s", thread_id, exc_info=True

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/deepagents_cli/skills/load.py

@@ -123,7 +123,11 @@ def list_skills(
                     }
                 extended = cast("ExtendedSkillMetadata", {**skill, **extra})
                 all_skills[skill["name"]] = extended
-        except (OSError, KeyError, TypeError):
+        except Exception:
+            # Degrade gracefully — one malformed/inaccessible source must not
+            # block discovery of others, so catch broadly and log instead.
+            # WARNING (not ERROR) because a half-written SKILL.md from a user is
+            # an expected condition, not a code defect.
             logger.warning(
                 "Could not load skills from %s",
                 skill_dir,

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deepagents-cli"
-version = "0.0.57"
+version = "0.0.59"
 description = "Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities."
 readme = "README.md"
 license = { text = "MIT" }
@@ -26,15 +26,15 @@ classifiers = [
 ]
 dependencies = [
     # Framework
-    "deepagents==0.5.9",
-    "langchain>=1.2.17,<2.0.0",
-    "langgraph>=1.1.10,<2.0.0",
-    "langgraph-checkpoint-sqlite>=3.0.3,<4.0.0",
-    "langgraph-prebuilt>=1.0.13,<2.0.0",
+    "deepagents==0.6.1",
+    "langchain>=1.3.0,<2.0.0",
+    "langgraph>=1.2.0,<2.0.0",
+    "langgraph-checkpoint-sqlite>=3.1.0,<4.0.0",
 
     # Client-server architecture
     "langgraph-sdk>=0.3.13,<1.0.0",
     "langgraph-cli[inmem]>=0.4.24,<1.0.0",
+    "langgraph-runtime-inmem>=0.28.1,<1.0.0",
     "httpx>=0.28.1,<1.0.0",
 
     # Core model providers - others are added as optional

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/tests/integration_tests/test_compact_resume.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-from types import SimpleNamespace
 from typing import TYPE_CHECKING
-from unittest.mock import AsyncMock
 
 import pytest
 
@@ -62,12 +60,11 @@ def _event_field(event: object, key: str) -> object | None:
 async def test_compact_resumed_thread_uses_persisted_history(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """Compacts a resumed thread after restart using SQLite-backed history.
+    """Offloads a resumed thread after restart using remote server state.
 
     The test seeds a real persisted thread on one server instance, restarts the
     server, resumes that thread in a fresh `DeepAgentsApp`, and verifies that
-    `/compact` succeeds even when the resumed history comes from the
-    checkpointer rather than live in-memory server state.
+    `/offload` succeeds after the app registers the thread with the server.
     """
     home_dir = tmp_path / "home"
     project_dir = tmp_path / "project"
@@ -92,7 +89,7 @@ async def test_compact_resumed_thread_uses_persisted_history(
     from deepagents_cli.app import DeepAgentsApp
     from deepagents_cli.config import create_model
     from deepagents_cli.server_manager import server_session
-    from deepagents_cli.sessions import generate_thread_id, thread_exists
+    from deepagents_cli.sessions import generate_thread_id
     from deepagents_cli.widgets.messages import AppMessage, ErrorMessage
 
     config_path = home_dir / ".deepagents" / "config.toml"
@@ -124,15 +121,12 @@ async def test_compact_resumed_thread_uses_persisted_history(
                     prompt=_build_long_prompt(turn),
                 )
 
-        assert await thread_exists(thread_id)
-
         compact_backend = CompositeBackend(
             default=FilesystemBackend(root_dir=backend_root, virtual_mode=True),
             routes={},
         )
 
-        # Server 2: same SQLite DB, but a fresh server process and empty
-        # in-memory thread registry.
+        # Server 2: same SQLite DB, but a fresh server process.
         async with server_session(
             assistant_id=assistant_id,
             model_name="itest:fake",
@@ -142,15 +136,6 @@ async def test_compact_resumed_thread_uses_persisted_history(
             sandbox_type="none",
         ) as (agent, _server_proc):
             config = {"configurable": {"thread_id": thread_id}}
-            actual_state = await agent.aget_state(config)
-            actual_values = getattr(actual_state, "values", None) or {}
-
-            # Fresh dev servers may return empty state for persisted threads
-            # after restart. If that behavior changes upstream, force the
-            # empty-state precondition so this test still covers the SQLite
-            # fallback path.
-            if actual_values:
-                agent.aget_state = AsyncMock(return_value=SimpleNamespace(values={}))  # ty: ignore[invalid-assignment]
 
             app = DeepAgentsApp(
                 agent=agent,  # ty: ignore[invalid-argument-type]
@@ -170,20 +155,15 @@ async def test_compact_resumed_thread_uses_persisted_history(
                         break
 
                 assert app._message_store.total_count > 0
-                resume_messages = app.query(AppMessage)
-                assert any(
-                    "Resumed thread:" in str(widget._content)
-                    for widget in resume_messages
-                )
 
                 await app._handle_offload()
 
-                # `/compact` posts a success message after the async state write
+                # `/offload` posts a success message after the async state write
                 # and archive offload finish.
                 for _ in range(120):
                     await pilot.pause(0.1)
                     if any(
-                        "Conversation compacted." in str(widget._content)
+                        "Offloaded " in str(widget._content)
                         for widget in app.query(AppMessage)
                     ):
                         break
@@ -195,16 +175,15 @@ async def test_compact_resumed_thread_uses_persisted_history(
                     str(widget._content) for widget in app.query(ErrorMessage)
                 ]
 
-            assert "Nothing to compact" not in "\n".join(app_messages)
-            assert any("Conversation compacted." in content for content in app_messages)
+            assert "Nothing to offload" not in "\n".join(app_messages)
+            assert any("Offloaded " in content for content in app_messages)
             assert not error_messages
 
-            # The summarization event must be checkpointed so subsequent turns
-            # see compacted context instead of the full message history.
-            channel_values = await DeepAgentsApp._read_channel_values_from_checkpointer(
-                thread_id
-            )
-            summarization_event = channel_values.get("_summarization_event")
+            # The summarization event must be visible through server state so
+            # subsequent turns see compacted context instead of full history.
+            state = await agent.aget_state(config)
+            values = getattr(state, "values", None) or {}
+            summarization_event = values.get("_summarization_event")
             assert summarization_event is not None
             cutoff = _event_field(summarization_event, "cutoff_index")
             assert isinstance(cutoff, int)
@@ -219,7 +198,7 @@ async def test_compact_resumed_thread_uses_persisted_history(
         archive_path = backend_root / "conversation_history" / f"{thread_id}.md"
         assert archive_path.exists()
         archive_text = archive_path.read_text()
-        assert "Compacted at" in archive_text
+        assert "Offloaded at" in archive_text
         assert "keeps enough unique detail" in archive_text
     finally:
         model_config.clear_caches()

{deepagents_cli-0.0.57 → deepagents_cli-0.0.59}/tests/unit_tests/skills/test_load.py

@@ -719,6 +719,40 @@ class TestListSkillsBuiltIn:
         assert len(skills) == 1
         assert skills[0]["name"] == "user-skill"
 
+    def test_unexpected_source_error_does_not_break_others(
+        self, tmp_path: Path
+    ) -> None:
+        """Any per-source discovery error should preserve remaining sources."""
+        user_dir = tmp_path / "user_skills"
+        _create_skill(user_dir / "user-skill", "user-skill", "A user skill")
+
+        built_in_dir = tmp_path / "built_in_skills"
+        built_in_dir.mkdir()
+
+        original_list = __import__(
+            "deepagents.middleware.skills", fromlist=["_list_skills"]
+        )._list_skills
+
+        call_count = 0
+
+        def patched_list(backend: object, source_path: str) -> list[object]:
+            nonlocal call_count
+            call_count += 1
+            if call_count == 1:
+                msg = "simulated parser edge case"
+                raise ValueError(msg)
+            return original_list(backend=backend, source_path=source_path)
+
+        with patch("deepagents_cli.skills.load.list_skills_from_backend", patched_list):
+            skills = list_skills(
+                built_in_skills_dir=built_in_dir,
+                user_skills_dir=user_dir,
+                project_skills_dir=None,
+            )
+
+        assert len(skills) == 1
+        assert skills[0]["name"] == "user-skill"
+
 
 class TestListSkillsClaudeDirectories:
     """Test `list_skills` with experimental Claude skills directories."""