dulus 3.10.2__tar.gz → 3.10.4__tar.gz

{dulus-3.10.2/dulus.egg-info → dulus-3.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.10.2
+Version: 3.10.4
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0

{dulus-3.10.2 → dulus-3.10.4}/compaction.py

@@ -78,6 +78,27 @@ def estimate_tokens(messages: list, model: str = "", config: dict | None = None,
                 for v in tc.values():
                     if isinstance(v, str):
                         total_chars += len(v)
+        # ── Images / videos (2026-07-13 fix) ──────────────────────────────
+        # agent.py attaches /image and /video payloads as sibling keys
+        # user_msg["images"] / user_msg["videos"] (base64 strings), NOT
+        # inside "content". This loop used to never look at them, so a
+        # single video attachment (often 200-800k+ base64 chars) was
+        # completely invisible to the token estimate. Result: compaction
+        # thought the conversation was small and never fired auto-compact,
+        # while the model actually receiving that payload (e.g. Kimi's
+        # multimodal video support) silently ballooned past its real
+        # context window and degraded. Count them like any other content.
+        for key in ("images", "videos"):
+            items = m.get(key)
+            if not items:
+                continue
+            for item in items:
+                if isinstance(item, str):
+                    total_chars += len(item)
+                elif isinstance(item, dict):
+                    data = item.get("data", "")
+                    if isinstance(data, str):
+                        total_chars += len(data)
     content_tokens = int(total_chars / 2.8)
     framing_tokens = msg_count * 4      # role + delimiters overhead per msg
     return int((content_tokens + framing_tokens) * 1.1)

{dulus-3.10.2 → dulus-3.10.4/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.10.2
+Version: 3.10.4
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0

{dulus-3.10.2 → dulus-3.10.4}/dulus.py

@@ -121,6 +121,7 @@ Slash commands in REPL:
   /roundtable       Start a multi-model roundtable discussion
   /fork             Fork session at a given turn
   /undo             Undo last turn
+  /workspace [cmd]  Manage Dulus workspaces (switch/list/default)
   /add-dir [path]   Manage additional workspace directories
   /import <file>    Import conversation from file or session
   /harvest          Harvest Claude.ai cookies (alias: /harvest-claude)
@@ -854,6 +855,7 @@ _HELP_PAGES = [
         ("/cost",         "Show API cost this session"),
         ("/fork",         "Fork session at a given turn"),
         ("/undo",         "Undo last turn"),
+        ("/workspace [cmd]", "Manage Dulus workspaces (switch/list/default)"),
         ("/import <file>","Import conversation from file/session"),
         ("/add-dir [path]","Manage additional workspace directories"),
         ("/batch",        "Manage Kimi Batch tasks"),
@@ -4012,6 +4014,167 @@ def cmd_cwd(args: str, _state, config) -> bool:
             err(str(e))
     return True
 
+
+# ── Workspace manager ───────────────────────────────────────────────────────
+
+_WORKSPACES_DIR: Path = Path.home() / ".dulus" / "workspaces"
+_DEFAULT_WORKSPACE: str = "workspace1"
+
+
+def _workspace_path(name: str) -> Path:
+    return _WORKSPACES_DIR / name
+
+
+def _ensure_workspace(name: str) -> Path:
+    """Create workspace dir if missing and return its path."""
+    ws = _workspace_path(name)
+    ws.mkdir(parents=True, exist_ok=True)
+    return ws
+
+
+def _list_workspaces() -> list[str]:
+    if not _WORKSPACES_DIR.exists():
+        return []
+    return sorted(p.name for p in _WORKSPACES_DIR.iterdir() if p.is_dir())
+
+
+def _current_workspace_name() -> str | None:
+    """Return the workspace name if cwd is inside ~/.dulus/workspaces/."""
+    try:
+        cwd = Path.cwd().resolve()
+        root = _WORKSPACES_DIR.resolve()
+        if root in cwd.parents or cwd == root:
+            rel = cwd.relative_to(root)
+            first = rel.parts[0] if rel.parts else None
+            if first and _workspace_path(first).is_dir():
+                return first
+    except Exception:
+        pass
+    return None
+
+
+def _activate_workspace(name: str, config: dict) -> bool:
+    """Change cwd into workspace, create it if missing, and persist as last used."""
+    from config import save_config
+    ws = _ensure_workspace(name)
+    try:
+        os.chdir(ws)
+        config["workspace_last"] = name
+        save_config(config)
+        # Directory changed — git info is stale
+        if _git_prompt is not None:
+            _git_prompt.reset_git_cache()
+        return True
+    except Exception as e:
+        err(f"No pude cambiar al workspace '{name}': {e}")
+        return False
+
+
+def _apply_workspace(config: dict) -> None:
+    """At boot, move cwd into the last-used workspace (or workspace1)."""
+    last = config.get("workspace_last") or _DEFAULT_WORKSPACE
+    ws = _workspace_path(last)
+    if not ws.exists():
+        _ensure_workspace(last)
+    try:
+        os.chdir(ws)
+        if config.get("verbose", False):
+            info(f"Workspace activo: {last}")
+    except Exception as e:
+        warn(f"No pude entrar al workspace '{last}': {e}")
+
+
+def cmd_workspace(args: str, _state, config) -> bool:
+    """Manage Dulus workspaces under ~/.dulus/workspaces.
+
+    /workspace                — show current workspace + cwd
+    /workspace current        — same as above
+    /workspace list           — list workspaces
+    /workspace switch <name>  — change to workspace (creates if missing)
+    /workspace default [name] — show or set the startup workspace
+    /workspace create <name>  — create a workspace without switching
+    /workspace delete <name>  — delete a workspace (must be empty)
+    """
+    from config import save_config
+    parts = args.strip().split(None, 1)
+    subcmd = parts[0].lower() if parts else "current"
+    rest = parts[1].strip() if len(parts) > 1 else ""
+
+    if subcmd in ("current", "cwd", ""):
+        current = _current_workspace_name()
+        if current:
+            info(f"Workspace: {current}")
+        else:
+            info("No estás dentro de un workspace de Dulus.")
+        info(f"Working directory: {os.getcwd()}")
+        return True
+
+    if subcmd == "list":
+        workspaces = _list_workspaces()
+        current = _current_workspace_name()
+        if not workspaces:
+            info("No hay workspaces todavía. Usa /workspace create <nombre>.")
+            return True
+        info(f"Workspaces en {_WORKSPACES_DIR}:")
+        for w in workspaces:
+            mark = "  → " if w == current else "    "
+            print(f"{mark}{w}")
+        return True
+
+    if subcmd == "switch":
+        if not rest:
+            err("Uso: /workspace switch <nombre>")
+            return True
+        name = rest.split()[0]
+        if _activate_workspace(name, config):
+            ok(f"Workspace cambiado a: {name}")
+        return True
+
+    if subcmd == "default":
+        if not rest:
+            current_default = config.get("workspace_last") or _DEFAULT_WORKSPACE
+            info(f"Workspace por defecto: {current_default}")
+            return True
+        name = rest.split()[0]
+        _ensure_workspace(name)
+        config["workspace_last"] = name
+        save_config(config)
+        ok(f"Workspace por defecto ahora: {name}")
+        return True
+
+    if subcmd == "create":
+        if not rest:
+            err("Uso: /workspace create <nombre>")
+            return True
+        name = rest.split()[0]
+        _ensure_workspace(name)
+        ok(f"Workspace creado: {name}")
+        return True
+
+    if subcmd == "delete":
+        if not rest:
+            err("Uso: /workspace delete <nombre>")
+            return True
+        name = rest.split()[0]
+        target = _workspace_path(name)
+        if not target.exists():
+            err(f"Workspace '{name}' no existe.")
+            return True
+        current = _current_workspace_name()
+        if name == current:
+            err("No puedes borrar el workspace en el que estás. Cambia primero con /workspace switch.")
+            return True
+        try:
+            target.rmdir()
+            ok(f"Workspace borrado: {name}")
+        except OSError as e:
+            err(f"No se pudo borrar '{name}': {e}. Asegúrate de que esté vacío.")
+        return True
+
+    err(f"Subcomando desconocido: /workspace {subcmd}")
+    return True
+
+
 def _build_session_data(state, session_id: str | None = None) -> dict:
     """Serialize current conversation state to a JSON-serializable dict."""
     import uuid
@@ -4922,6 +5085,7 @@ def cmd_skill(args: str, state, config) -> bool:
         list_awesome_remote, list_composio_toolkits,
         install_awesome_remote,
         list_dulus_remote, install_dulus_remote,
+        search_skillssh, install_skillssh,
     )
     from pathlib import Path as _Path
 
@@ -4959,11 +5123,12 @@ def cmd_skill(args: str, state, config) -> bool:
             print(f"  4) {clr('local', 'yellow')}     — Anthropic + awesome marketplaces on disk (~/.claude/...)")
             print(f"  5) {clr('installed', 'yellow')} — skills already in ~/.dulus/skills/")
             print(f"  6) {clr('all', 'yellow')}       — combine dulus + awesome + composio + local")
+            print(f"  7) {clr('skillssh', 'yellow')}  — skills.sh open directory (100K+ skills, needs a search term)")
             try:
                 choice = input(clr("  > ", "cyan")).strip().lower()
             except (EOFError, KeyboardInterrupt):
                 return True
-            mapping = {"1": "dulus", "2": "awesome", "3": "composio", "4": "local", "5": "installed", "6": "all"}
+            mapping = {"1": "dulus", "2": "awesome", "3": "composio", "4": "local", "5": "installed", "6": "all", "7": "skillssh"}
             rest = mapping.get(choice, choice)
 
         if rest.startswith("dulus"):
@@ -5072,6 +5237,23 @@ def cmd_skill(args: str, state, config) -> bool:
                     print(f"  {clr(r['slug'], 'cyan'):30s}  {r.get('description','')[:60]}")
             return True
 
+        if rest.startswith("skillssh"):
+            q = rest[8:].strip()
+            if not q:
+                info("skills.sh has no browse endpoint — give me a search term: /skill list skillssh <query>")
+                return True
+            info(f"Searching skills.sh for '{q}'...")
+            results = search_skillssh(q, limit=25)
+            if not results:
+                err("No skills found on skills.sh (network or empty result).")
+                return True
+            lines = [
+                f"  {clr(s['id'], 'cyan'):60s}  {s.get('description', '')[:70]}"
+                for s in results
+            ]
+            _pager(f"skills.sh results ({len(results)}) — /skill get <id> to install — n=next q=quit", lines)
+            return True
+
         if rest.startswith("installed"):
             query = rest[9:].strip()
             skills = list_installed(query)
@@ -5179,6 +5361,8 @@ def cmd_skill(args: str, state, config) -> bool:
         if rest.startswith("clawhub:"):
             slug = rest[8:]
             success, msg = install_clawhub(slug)
+        elif rest.startswith("skillssh/"):
+            success, msg = install_skillssh(rest)
         elif rest.startswith("dulus/"):
             success, msg = install_dulus_remote(rest)
         elif rest.startswith("awesome/"):
@@ -9935,6 +10119,7 @@ COMMANDS = {
     "export":      cmd_export,
     "fork":        cmd_fork,
     "undo":        cmd_undo,
+    "workspace":   cmd_workspace,
     "add-dir":     cmd_add_dir,
     "import":      cmd_import,
     "copy":        cmd_copy,
@@ -10068,6 +10253,7 @@ _CMD_META: dict[str, tuple[str, list[str]]] = {
     "export":      ("Export conversation to file",          []),
     "fork":        ("Fork session at a turn",               []),
     "undo":        ("Undo last turn",                       []),
+    "workspace":   ("Manage Dulus workspaces",              ["current", "list", "switch", "default", "create", "delete"]),
     "add-dir":     ("Manage additional workspace dirs",     ["list", "remove"]),
     "import":      ("Import from file or session",          []),
     "copy":        ("Copy last response or file to clipboard", ["file"]),
@@ -10518,6 +10704,13 @@ def repl(config: dict, initial_prompt: str = None):
             except Exception:
                 pass
 
+        # ── Workspace: start in the last-used workspace (or workspace1) ──────────
+        try:
+            _apply_workspace(config)
+        except Exception as _e:
+            if config.get("verbose", False):
+                warn(f"Workspace init skipped: {_e}")
+
         # ── Auto-update check (on by default; /update off to disable) ─────────
         # Keep every Dulus in the world on the latest release: the organism
         # heals fastest when fixes propagate instantly. This is intentionally

{dulus-3.10.2 → dulus-3.10.4}/dulus_mcp/client.py

@@ -36,6 +36,17 @@ class StdioTransport:
 
     def start(self) -> None:
         env = {**os.environ, **(self._config.env or {})}
+        # ── Guard: empty/blank command ────────────────────────────────────
+        # A corrupted or half-filled-out .mcp.json entry (e.g. {"command": ""})
+        # used to reach subprocess.Popen([""], ...) directly. On Windows that
+        # raises a bare OSError [WinError 87] "The parameter is incorrect" with
+        # zero context — impossible to debug from the GUI toast. Fail fast with
+        # a message that names the actual broken server instead.
+        if not (self._config.command or "").strip():
+            raise RuntimeError(
+                f"MCP server '{self._config.name}' has no command configured "
+                f"(empty 'command' field in mcp.json). Fix or remove this entry."
+            )
         # ── Windows launcher resolution ──────────────────────────────────
         # On Windows, node tooling ships as .cmd shims (npx.cmd, npm.cmd) and
         # Python's subprocess won't find a bare "npx" without the extension.
@@ -46,6 +57,14 @@ class StdioTransport:
         _resolved = _shutil.which(_launcher)
         if _resolved:
             _launcher = _resolved
+        elif os.name == "nt" and not _launcher.lower().endswith((".exe", ".cmd", ".bat")):
+            # Launcher wasn't found on PATH at all (typo, uninstalled runtime,
+            # etc). Raise a clean, actionable error instead of letting Popen
+            # attempt to launch a bare/garbled name and blow up with WinError87.
+            raise RuntimeError(
+                f"MCP server '{self._config.name}': launcher '{_launcher}' not found on PATH. "
+                f"Install it or fix the 'command' field in mcp.json."
+            )
         cmd = [_launcher] + list(self._config.args or [])
         # On Windows, .cmd/.bat shims must run through the shell layer.
         _use_shell = os.name == "nt" and str(_launcher).lower().endswith((".cmd", ".bat"))

{dulus-3.10.2 → dulus-3.10.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.10.2"
+version = "3.10.4"
 description = "Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS."
 readme = "README.md"
 requires-python = ">=3.11"

{dulus-3.10.2 → dulus-3.10.4}/skill/clawhub.py

@@ -731,6 +731,206 @@ def install_clawhub(slug: str) -> tuple[bool, str]:
     return False, f"ClawHub API endpoint not yet mapped. Try: /skill get local/{slug}"
 
 
+# ── SKILLS.SH (skills.sh — the open agent skills directory) ────────────────
+# skills.sh indexes 100K+ agent skills across GitHub repos. Search hits its
+# public JSON API; install downloads the skill folder straight from the source
+# repo via raw.githubusercontent.com — no npx, no clone. Fallback catalog:
+# skillsdirectory.com public registry.
+
+_SKILLSSH_API = "https://skills.sh/api/search"
+_SKILLSSH_FALLBACK_API = "https://skillsdirectory.com/api/registry"
+_SKILLSSH_TIMEOUT = 15
+
+
+def _skillssh_gh_headers() -> dict:
+    """GitHub API headers — uses GITHUB_TOKEN/GH_TOKEN if present for rate limits."""
+    import os as _os
+    headers = {"User-Agent": "dulus-skill-manager"}
+    token = _os.environ.get("GITHUB_TOKEN") or _os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def search_skillssh(query: Optional[str], limit: int = 10) -> list[dict]:
+    """Search skills.sh for skills matching query.
+
+    Returns entries shaped like the other providers:
+      {id: "skillssh/<owner>/<repo>/<skill>", skill, name, description, source}
+    An empty query returns [] (skills.sh has no browse endpoint; use a term).
+    """
+    if not query or not str(query).strip():
+        return []
+
+    url = f"{_SKILLSSH_API}?q={urllib.parse.quote(str(query).strip())}"
+    data = None
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "dulus-skill-manager"})
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            data = json.loads(resp.read())
+    except Exception:
+        data = None
+
+    skills: list[dict] = []
+    if data and isinstance(data.get("skills"), list):
+        for it in data["skills"][: max(limit, 1)]:
+            sid = it.get("id", "")            # "owner/repo/skillId"
+            repo = it.get("source", "")       # "owner/repo"
+            name = it.get("skillId") or it.get("name", "")
+            installs = it.get("installs", 0)
+            if not sid or not name:
+                continue
+            skills.append({
+                "id": f"skillssh/{sid}",
+                "skill": name,
+                "name": name,
+                "description": f"{installs:,} installs · {repo} (skills.sh)",
+                "installs": installs,
+                "repo": repo,
+                "source": "skillssh",
+            })
+        return skills
+
+    # Fallback: skillsdirectory.com public registry (no auth, ~97K skills)
+    try:
+        q = urllib.parse.quote(str(query).strip())
+        req = urllib.request.Request(
+            f"{_SKILLSSH_FALLBACK_API}?search={q}",
+            headers={"User-Agent": "dulus-skill-manager"},
+        )
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            reg = json.loads(resp.read())
+        entries = reg if isinstance(reg, list) else reg.get("skills", reg.get("data", []))
+        for it in entries[: max(limit, 1)]:
+            repo = it.get("repository", "") or it.get("repo", "")
+            name = it.get("slug") or it.get("name", "")
+            if not repo or not name:
+                continue
+            skills.append({
+                "id": f"skillssh/{repo}/{name}",
+                "skill": name,
+                "name": name,
+                "description": (it.get("description") or "")[:160],
+                "repo": repo,
+                "source": "skillssh",
+            })
+    except Exception:
+        pass
+    return skills
+
+
+def _skillssh_default_branch(owner_repo: str) -> str:
+    """Resolve a repo's default branch (main/master/…)."""
+    try:
+        req = urllib.request.Request(
+            f"https://api.github.com/repos/{owner_repo}", headers=_skillssh_gh_headers()
+        )
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            return json.loads(resp.read()).get("default_branch", "main")
+    except Exception:
+        return "main"
+
+
+def install_skillssh(slug: str) -> tuple[bool, str]:
+    """Install a skills.sh skill into ~/.dulus/skills/.
+
+    Accepts:  skillssh/<owner>/<repo>/<skill>  ·  <owner>/<repo>/<skill>
+              <owner>/<repo>   (repo whose root SKILL.md IS the skill)
+    Downloads the whole skill folder (SKILL.md + assets/scripts/references)
+    from the source repo and rewrites frontmatter for Dulus.
+    """
+    parts = slug.replace("skillssh/", "", 1).strip("/").split("/")
+    if len(parts) < 2:
+        return False, (
+            f"Invalid skills.sh slug: '{slug}'. "
+            f"Expected <owner>/<repo>/<skill> or <owner>/<repo>."
+        )
+    owner_repo = f"{parts[0]}/{parts[1]}"
+    skill_name = parts[-1] if len(parts) >= 3 else parts[1]
+
+    branch = _skillssh_default_branch(owner_repo)
+
+    # One tree call to locate the skill dir (mirrors the skills-CLI discovery:
+    # skills/<name>/, .claude/skills/<name>/, catalog layouts, or root SKILL.md).
+    tree_url = f"https://api.github.com/repos/{owner_repo}/git/trees/{branch}?recursive=1"
+    try:
+        req = urllib.request.Request(tree_url, headers=_skillssh_gh_headers())
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            tree = json.loads(resp.read())
+    except Exception as e:
+        return False, f"Could not read repo tree for '{owner_repo}': {e}"
+
+    blobs = [
+        it.get("path", "")
+        for it in tree.get("tree", [])
+        if it.get("type") == "blob"
+    ]
+
+    # Candidate SKILL.md paths whose parent dir matches the skill name.
+    want = skill_name.lower()
+    candidates = [
+        p for p in blobs
+        if p.endswith("/SKILL.md") and p.split("/")[-2].lower() == want
+    ]
+    rel_dir = ""
+    if candidates:
+        rel_dir = "/".join(sorted(candidates, key=lambda p: p.count("/"))[0].split("/")[:-1])
+    elif "SKILL.md" in blobs and len(parts) == 2:
+        rel_dir = ""  # root-level skill: the repo itself is the skill
+    else:
+        near = sorted({p.split("/")[-2] for p in blobs if p.endswith("/SKILL.md")})[:8]
+        return False, (
+            f"No SKILL.md found for '{skill_name}' in {owner_repo}. "
+            f"Skills in that repo: {', '.join(near) if near else '(none)'}"
+        )
+
+    dest_dir = DULUS_SKILLS_DIR / skill_name
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    prefix = rel_dir + "/" if rel_dir else ""
+    targets = (
+        [p for p in blobs if p.startswith(prefix)] if rel_dir
+        else ["SKILL.md"]
+    )
+
+    raw_base = f"https://raw.githubusercontent.com/{owner_repo}/{branch}"
+    downloaded: list[str] = []
+    for p in targets:
+        rel = p[len(prefix):] if prefix and p.startswith(prefix) else p.split("/")[-1]
+        dst = dest_dir / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            with urllib.request.urlopen(f"{raw_base}/{p}", timeout=_SKILLSSH_TIMEOUT) as r:
+                dst.write_bytes(r.read())
+            downloaded.append(rel)
+        except Exception:
+            pass  # skip files we can't fetch
+
+    skill_md = dest_dir / "SKILL.md"
+    if not skill_md.exists():
+        return False, f"Could not download SKILL.md for '{skill_name}' from {owner_repo}."
+
+    # Rewrite frontmatter for Dulus (keep original description if present)
+    raw = skill_md.read_text(encoding="utf-8")
+    orig = _parse_frontmatter(raw)
+    body = _strip_frontmatter(raw)
+    frontmatter = (
+        f"---\n"
+        f"name: {skill_name}\n"
+        f"description: {orig.get('description', f'Skill from skills.sh ({owner_repo})')}\n"
+        f"source: skillssh\n"
+        f"repo: {owner_repo}\n"
+        f"triggers: [/{skill_name}]\n"
+        f"---\n\n"
+    )
+    skill_md.write_text(frontmatter + body, encoding="utf-8")
+
+    return True, (
+        f"Installed '{skill_name}' from skills.sh ({owner_repo}@{branch}) -> {dest_dir}  "
+        f"({len(downloaded)} files: {', '.join(downloaded[:5])}{'...' if len(downloaded) > 5 else ''})"
+    )
+
+
 # ── Installed skills ───────────────────────────────────────────────────────
 
 def list_installed(query: Optional[str] = None) -> list[dict]: