deepctl-cmd-plugin 0.1.14__tar.gz → 0.1.15__tar.gz

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/.gitignore

@@ -15,6 +15,10 @@ downloads/
 eggs/
 .eggs/
 lib/
+# The npm launcher's sources, not a build output.
+!/npm/lib/
+# Written by the release (npm/scripts/write_requirements.py).
+/npm/requirements-*.txt
 lib64/
 parts/
 sdist/

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.1.15](https://github.com/deepgram/cli/compare/deepctl-cmd-plugin-v0.1.14...deepctl-cmd-plugin-v0.1.15) (2026-11-12)
+
+
+### Features
+
+* **cli:** detect npm launcher installs in update, plugin and skills ([07e6fd9](https://github.com/deepgram/cli/commit/07e6fd9f8ba337a743e6a50ad96a2b29de53d37d))
+* **npm:** make @deepgram/cli the real Deepgram CLI ([#146](https://github.com/deepgram/cli/issues/146)) ([8ed20ee](https://github.com/deepgram/cli/commit/8ed20ee349c635e7a4b5c3d8ecbae8a4fa558fe1))
+
+
+### Bug Fixes
+
+* **cli:** keep ffprobe path and plugin changes out of AI agent sessions ([2df96f0](https://github.com/deepgram/cli/commit/2df96f0ee9cee8953f7e9f8ca4bf23f8c7ccea19))
+* **plugin:** keep plugins from replacing built-in commands ([dff78a2](https://github.com/deepgram/cli/commit/dff78a233a255b17f831e599bf417f125d0e5b7f))
+* **plugin:** make the plugin folders private ([6b9c257](https://github.com/deepgram/cli/commit/6b9c2576f116d81df1a6ed5015a7ae598aa04aa6))
+
 ## [0.1.14](https://github.com/deepgram/cli/compare/deepctl-cmd-plugin-v0.1.13...deepctl-cmd-plugin-v0.1.14) (2026-10-09)
 
 

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.5
 Name: deepctl-cmd-plugin
-Version: 0.1.14
+Version: 0.1.15
 Summary: Plugin management command for deepctl
 Author-email: Deepgram DevRel <devrel@deepgram.com>
 Requires-Python: >=3.10
+Requires-Dist: deepctl-cmd-update>=0.2.8
 Requires-Dist: deepctl-core>=0.2.19
 Requires-Dist: packaging>=21.0
 Requires-Dist: toml>=0.10.2

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/pyproject.toml

@@ -2,11 +2,12 @@
 name = "deepctl-cmd-plugin"
 description = "Plugin management command for deepctl"
 readme = "README.md"
-version = "0.1.14" # x-release-please-version
+version = "0.1.15" # x-release-please-version
 requires-python = ">=3.10"
 authors = [{ name = "Deepgram DevRel", email = "devrel@deepgram.com" }]
 dependencies = [
     "deepctl-core>=0.2.19",
+    "deepctl-cmd-update>=0.2.8",
     "packaging>=21.0",
     "toml>=0.10.2",
 ]
@@ -14,6 +15,10 @@ dependencies = [
 [project.entry-points."deepctl.commands"]
 plugin = "deepctl_cmd_plugin.command:PluginCommand"
 
+[tool.uv.sources]
+deepctl-core = { workspace = true }
+deepctl-cmd-update = { workspace = true }
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/src/deepctl_cmd_plugin/command.py

@@ -8,25 +8,38 @@ import sys
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
+    from rich.text import Text
+
     from .strategies import PluginInstallStrategy
 
 import click
 from deepctl_cmd_update.installation import InstallationDetector, InstallMethod
+from deepctl_core import messages as msg
+from deepctl_core._plugin_trust import real_home_plugin_venv
 from deepctl_core.auth import AuthManager
 from deepctl_core.base_group_command import BaseGroupCommand
 from deepctl_core.client import DeepgramClient
 from deepctl_core.config import Config
-from deepctl_core.output import print_error, print_info, print_success, print_warning
+from deepctl_core.output import (
+    is_ai_agent,
+    print_error,
+    print_hint,
+    print_info,
+    print_success,
+    print_warning,
+)
 from deepctl_core.plugin_env import (
-    PLUGIN_DIR,
-    PLUGIN_STATE_FILE,
-    PLUGIN_VENV,
     find_system_python,
     get_plugin_state,
     get_venv_python,
     is_frozen,
+    make_plugin_dirs_private,
+    plugin_paths,
+    read_plugin_state_file,
     save_plugin_state,
+    skipped_plugin_venvs,
 )
+from deepctl_core.safe_text import literal
 from rich.console import Console
 from rich.markup import escape
 from rich.table import Table
@@ -42,6 +55,31 @@ from .models import (
 
 console = Console()
 
+E_PLUGIN_ENV_UNAVAILABLE = (
+    "Can't use the plugin environment: when an AI agent runs dg, plugins load "
+    "only from your account's home directory, not through a symlink or from "
+    "inside the working directory."
+)
+A_PLUGIN_ENV_UNAVAILABLE = (
+    "A person must run this command in their own terminal. If you are an AI "
+    "agent, ask the user."
+)
+
+
+def _print_env_unavailable_hint() -> None:
+    """The agent hint after E-PLUGIN-ENV-UNAVAILABLE."""
+    print_hint(A_PLUGIN_ENV_UNAVAILABLE)
+
+
+def _refuse_in_agent_session(action: str) -> None:
+    """Installed plugins run in every later dg command: an AI agent session
+    never installs, updates or removes them. Scripts and CI without an agent
+    marker still can."""
+    if is_ai_agent():
+        print_error(msg.E_PLUGIN_AGENT.format(action=action))
+        print_hint(msg.E_PERSON_ONLY_AGENT_HINT)
+        raise SystemExit(1)
+
 
 class PluginCommand(BaseGroupCommand):
     """Plugin management command."""
@@ -50,7 +88,7 @@ class PluginCommand(BaseGroupCommand):
     help = "Manage deepctl plugins"
 
     examples = [
-        "dg plugin search transcribe",
+        "dg plugin search example",
         "dg plugin install deepctl-plugin-example",
         "dg plugin list",
         "dg plugin update deepctl-plugin-example",
@@ -68,10 +106,13 @@ class PluginCommand(BaseGroupCommand):
         self.detector = InstallationDetector()
         self._python_executable = sys.executable
 
-        # Use shared plugin environment paths
-        self._plugin_dir = PLUGIN_DIR
-        self._plugin_venv = PLUGIN_VENV
-        self._plugin_state_file = PLUGIN_STATE_FILE
+        # Shared plugin environment paths. None when this run must not use
+        # the plugin environment (see plugin_env.plugin_paths).
+        paths = plugin_paths()
+        self._plugin_paths = paths
+        self._plugin_dir = paths.dir if paths else None
+        self._plugin_venv = paths.venv if paths else None
+        self._plugin_state_file = paths.state_file if paths else None
 
     def execute(self, ctx: click.Context, **kwargs: Any) -> None:
         """Execute plugin group command.
@@ -161,12 +202,18 @@ class PluginCommand(BaseGroupCommand):
         Returns:
             Tuple of (success, python_executable_path)
         """
-        # Create plugin directory if it doesn't exist
-        self._plugin_dir.mkdir(parents=True, exist_ok=True)
+        if self._plugin_dir is None or self._plugin_venv is None:
+            return False, ""
+
+        # The plugin directory and venv are owner-only (0700) whatever the
+        # umask; this also narrows ones an earlier version left open.
+        make_plugin_dirs_private(self._plugin_venv)
 
         # Check if venv exists
         if not self._plugin_venv.exists():
             print_info("Creating plugin environment...")
+            self._plugin_venv.mkdir(mode=0o700)
+            make_plugin_dirs_private(self._plugin_venv)
 
             # Determine which Python to use for venv creation
             if is_frozen():
@@ -192,7 +239,7 @@ class PluginCommand(BaseGroupCommand):
                 )
 
                 # Get the python executable in the venv
-                venv_python = get_venv_python()
+                venv_python = get_venv_python(self._plugin_venv)
                 if venv_python is None:
                     if sys.platform == "win32":
                         venv_python_path = self._plugin_venv / "Scripts" / "python.exe"
@@ -219,7 +266,7 @@ class PluginCommand(BaseGroupCommand):
                 return False, ""
 
         # Venv exists — return its python executable
-        venv_python = get_venv_python()
+        venv_python = get_venv_python(self._plugin_venv)
         if venv_python is None:
             if sys.platform == "win32":
                 venv_python = str(self._plugin_venv / "Scripts" / "python.exe")
@@ -263,7 +310,9 @@ class PluginCommand(BaseGroupCommand):
         Returns:
             Plugin state dictionary
         """
-        return get_plugin_state()
+        if self._plugin_state_file is None:
+            return {"plugins": {}}
+        return get_plugin_state(self._plugin_state_file)
 
     def _save_plugin_state(self, state: dict[str, Any]) -> None:
         """Save plugin state to file.
@@ -271,7 +320,9 @@ class PluginCommand(BaseGroupCommand):
         Args:
             state: Plugin state to save
         """
-        save_plugin_state(state)
+        if self._plugin_paths is None:
+            raise RuntimeError(E_PLUGIN_ENV_UNAVAILABLE)
+        save_plugin_state(state, self._plugin_paths)
 
     def _create_install_command(self, context_wrapper: Any) -> click.Command:
         """Create the install subcommand."""
@@ -339,6 +390,7 @@ class PluginCommand(BaseGroupCommand):
         **kwargs: Any,
     ) -> None:
         """Handle install command."""
+        _refuse_in_agent_session("install")
         # Extract package argument
         package = kwargs.pop("package", "")
 
@@ -369,6 +421,8 @@ class PluginCommand(BaseGroupCommand):
             self._maybe_update_skills()
         else:
             print_error(result.error or result.message)
+            if result.error == E_PLUGIN_ENV_UNAVAILABLE:
+                _print_env_unavailable_hint()
             raise click.ClickException(result.error or result.message)
 
     def _create_list_command(self, context_wrapper: Any) -> click.Command:
@@ -425,6 +479,7 @@ class PluginCommand(BaseGroupCommand):
         **kwargs: Any,
     ) -> None:
         """Handle update command."""
+        _refuse_in_agent_session("update")
         options = PluginInstallOptions(
             package=kwargs["package"],
             upgrade=True,
@@ -437,6 +492,8 @@ class PluginCommand(BaseGroupCommand):
             self._maybe_update_skills()
         else:
             print_error(result.error or result.message)
+            if result.error == E_PLUGIN_ENV_UNAVAILABLE:
+                _print_env_unavailable_hint()
             raise click.ClickException(result.error or result.message)
 
     def _create_remove_command(self, context_wrapper: Any) -> click.Command:
@@ -471,6 +528,7 @@ class PluginCommand(BaseGroupCommand):
         **kwargs: Any,
     ) -> None:
         """Handle remove command."""
+        _refuse_in_agent_session("remove")
         package = kwargs["package"]
         yes = kwargs.get("yes", False)
 
@@ -493,6 +551,8 @@ class PluginCommand(BaseGroupCommand):
             self._maybe_update_skills()
         else:
             print_error(result.error or result.message)
+            if result.error == E_PLUGIN_ENV_UNAVAILABLE:
+                _print_env_unavailable_hint()
             raise click.ClickException(result.error or result.message)
 
     def _create_search_command(self, context_wrapper: Any) -> click.Command:
@@ -595,18 +655,16 @@ class PluginCommand(BaseGroupCommand):
         table = Table(title="Available Plugins")
         table.add_column("Name", style="cyan", no_wrap=True)
         table.add_column("Description", style="white")
-        table.add_column("Version", style="green")
         table.add_column("Status", style="yellow")
 
         for result in search_results:
-            status = "Installed" if result.installed else "Available"
+            status: str | Text = "Installed" if result.installed else "Available"
             if result.installed and result.installed_version:
-                status = f"Installed ({result.installed_version})"
+                status = literal(f"Installed ({result.installed_version})")
 
             table.add_row(
                 result.plugin.name,
                 result.plugin.description,
-                result.plugin.version,
                 status,
             )
 
@@ -615,90 +673,36 @@ class PluginCommand(BaseGroupCommand):
         # Show install hint
         available_count = sum(1 for r in search_results if not r.installed)
         if available_count > 0:
-            print_info("\nTo install a plugin, use: deepctl plugin install <name>")
+            print_info("To install one, run: dg plugin install <name>", stderr=True)
 
     def _get_plugin_registry(self) -> list[PluginRegistryEntry]:
-        """Get the plugin registry.
-
-        For now, this returns a hardcoded list. In the future, this will
-        fetch from a .well-known URL or plugin registry service.
+        """Plugins Deepgram publishes, from a static list in this package.
 
         Returns:
             List of available plugins
         """
-        # TODO: Fetch from https://deepgram.com/.well-known/deepctl-plugins.json
         return [
             PluginRegistryEntry(
                 name="deepctl-plugin-example",
                 description="Example plugin demonstrating the plugin system",
-                version="0.1.8",
-                author="Deepgram DevRel",
-                url="https://github.com/deepgram/deepctl",
+                author="Deepgram",
+                url="https://github.com/deepgram/cli/tree/main/packages/deepctl-plugin-example",
                 keywords=["example", "demo", "plugin"],
                 install_name="deepctl-plugin-example",
             ),
-            PluginRegistryEntry(
-                name="deepctl-plugin-tts",
-                description="Text-to-speech functionality for Deepgram",
-                version="0.2.0",
-                author="Deepgram",
-                url="https://github.com/deepgram/deepctl-plugin-tts",
-                keywords=["tts", "text-to-speech", "audio", "synthesis"],
-                install_name="deepctl-plugin-tts",
-            ),
-            PluginRegistryEntry(
-                name="deepctl-plugin-analyze",
-                description="Advanced audio analysis tools",
-                version="0.1.0",
-                author="Deepgram",
-                url="https://github.com/deepgram/deepctl-plugin-analyze",
-                keywords=["analyze", "audio", "analysis", "metrics"],
-                install_name="deepctl-plugin-analyze",
-            ),
-            PluginRegistryEntry(
-                name="deepctl-plugin-batch",
-                description="Batch processing utilities for large-scale transcription",
-                version="0.3.1",
-                author="Deepgram",
-                url="https://github.com/deepgram/deepctl-plugin-batch",
-                keywords=["batch", "bulk", "processing", "scale"],
-                install_name="deepctl-plugin-batch",
-            ),
-            PluginRegistryEntry(
-                name="deepctl-plugin-export",
-                description="Export transcriptions to various formats (SRT, VTT, JSON, etc.)",
-                version="0.2.5",
-                author="Deepgram Community",
-                url="https://github.com/deepgram-community/deepctl-plugin-export",
-                keywords=["export", "srt", "vtt", "subtitle", "captions"],
-                install_name="deepctl-plugin-export",
-            ),
-            PluginRegistryEntry(
-                name="deepctl-plugin-realtime",
-                description="Enhanced real-time transcription with WebSocket support",
-                version="0.4.0",
-                author="Deepgram",
-                url="https://github.com/deepgram/deepctl-plugin-realtime",
-                keywords=["realtime", "websocket", "streaming", "live"],
-                install_name="deepctl-plugin-realtime",
-            ),
-            PluginRegistryEntry(
-                name="deepctl-plugin-translate",
-                description="Translation capabilities for transcribed text",
-                version="0.1.2",
-                author="Deepgram Labs",
-                url="https://github.com/deepgram-labs/deepctl-plugin-translate",
-                keywords=["translate", "translation", "language", "i18n"],
-                install_name="deepctl-plugin-translate",
-            ),
         ]
 
     def _needs_isolated_venv(self, method: InstallMethod) -> bool:
-        """Check if this installation method needs the isolated plugin venv."""
+        """Check if this installation method needs the isolated plugin venv.
+
+        npm counts: the launcher's venv or uv environment is replaced on every
+        npm version bump, so plugins installed into it would vanish.
+        """
         return method in (
             InstallMethod.HOMEBREW,
             InstallMethod.SYSTEM,
             InstallMethod.UNKNOWN,
+            InstallMethod.NPM,
         )
 
     def _get_strategy(
@@ -712,6 +716,8 @@ class PluginCommand(BaseGroupCommand):
         from .strategies import get_strategy
 
         if self._needs_isolated_venv(method):
+            if self._plugin_paths is None:
+                raise RuntimeError(E_PLUGIN_ENV_UNAVAILABLE)
             print_info(
                 f"{method.value.title()} installation detected, "
                 "using isolated plugin environment..."
@@ -771,7 +777,9 @@ class PluginCommand(BaseGroupCommand):
 
         # Get installed version
         target_python = (
-            get_venv_python() if using_plugin_env else self._python_executable
+            get_venv_python(self._plugin_venv)
+            if using_plugin_env
+            else self._python_executable
         )
         installed_version = self._get_package_version(options.package, target_python)
 
@@ -809,8 +817,9 @@ class PluginCommand(BaseGroupCommand):
         """
         # Get all installed packages that provide deepctl plugins
         plugins = self._discover_plugins()
+        skipped = self._skipped_plugins()
 
-        if not plugins:
+        if not plugins and not skipped:
             print_info("No plugins installed")
             return
 
@@ -826,10 +835,10 @@ class PluginCommand(BaseGroupCommand):
             table.add_column("Environment", style="blue")
 
         for plugin in plugins:
-            row = [
-                plugin.name,
-                plugin.version or "Unknown",
-                plugin.entry_point or "N/A",
+            row: list[str | Text] = [
+                literal(plugin.name),
+                literal(plugin.version or "Unknown"),
+                literal(plugin.entry_point or "N/A"),
             ]
 
             if verbose:
@@ -844,10 +853,16 @@ class PluginCommand(BaseGroupCommand):
                     else "Main Env"
                 )
 
-                row.extend([plugin_type, commands, env])
+                row.extend([plugin_type, literal(commands), env])
 
             table.add_row(*row)
 
+        for name, version in skipped:
+            skipped_row: list[str | Text] = [literal(name), literal(version), "Skipped"]
+            if verbose:
+                skipped_row.extend(["External", "", "Plugin Env"])
+            table.add_row(*skipped_row)
+
         console.print(table)
 
         if verbose:
@@ -912,6 +927,14 @@ class PluginCommand(BaseGroupCommand):
         plugin_found = any(p.name == package for p in plugins if not p.is_builtin)
 
         if not plugin_found:
+            if any(name == package for name, _version in self._skipped_plugins()):
+                return PluginOperationResult(
+                    success=False,
+                    action=PluginAction.REMOVE,
+                    package=package,
+                    message=f"Failed to remove {package}",
+                    error=E_PLUGIN_ENV_UNAVAILABLE,
+                )
             return PluginOperationResult(
                 success=False,
                 action=PluginAction.REMOVE,
@@ -930,7 +953,15 @@ class PluginCommand(BaseGroupCommand):
             # Force isolated-venv strategy for this plugin
             from .strategies import IsolatedVenvStrategy
 
-            _, python_exe = self._ensure_plugin_environment()
+            ok_env, python_exe = self._ensure_plugin_environment()
+            if not ok_env:
+                return PluginOperationResult(
+                    success=False,
+                    action=PluginAction.REMOVE,
+                    package=package,
+                    message=f"Failed to remove {package}",
+                    error=E_PLUGIN_ENV_UNAVAILABLE,
+                )
             strategy: PluginInstallStrategy = IsolatedVenvStrategy(python_exe)
         elif self._needs_isolated_venv(install_info.method):
             return PluginOperationResult(
@@ -977,6 +1008,31 @@ class PluginCommand(BaseGroupCommand):
             message=f"Successfully removed {package}",
         )
 
+    def _skipped_plugins(self) -> list[tuple[str, str]]:
+        """Plugins recorded in the real-home plugin venv when this run skips it.
+
+        Only that venv's ``plugins.json`` is read (defensively); a skipped
+        venv found through ``$HOME`` is never read, and nothing in any
+        skipped venv runs.
+        """
+        rows: list[tuple[str, str]] = []
+        trusted = real_home_plugin_venv()
+        if trusted is None:
+            return rows
+        for venv in skipped_plugin_venvs():
+            if venv != trusted:
+                continue
+            state = read_plugin_state_file(venv.parent / "plugins.json")
+            entries = state.get("plugins")
+            if not isinstance(entries, dict):
+                continue
+            for name, info in entries.items():
+                version = info.get("version") if isinstance(info, dict) else None
+                rows.append(
+                    (str(name), version if isinstance(version, str) else "Unknown")
+                )
+        return rows
+
     def _discover_plugins(self) -> list[PluginPackage]:
         """Discover all installed plugins.
 
@@ -995,10 +1051,13 @@ class PluginCommand(BaseGroupCommand):
                 discovered_names.add(plugin_key)
                 plugins.append(plugin)
 
-        # Also discover from plugin environment if it exists
-        if self._plugin_venv.exists():
-            _, plugin_python = self._ensure_plugin_environment()
-            plugin_env_plugins = self._discover_from_environment(plugin_python)
+        # Also discover from plugin environment if it exists (never from a
+        # venv this run doesn't use; see plugin_env.plugin_paths)
+        if self._plugin_venv is not None and self._plugin_venv.exists():
+            ok_env, plugin_python = self._ensure_plugin_environment()
+            plugin_env_plugins = (
+                self._discover_from_environment(plugin_python) if ok_env else []
+            )
 
             # Add only plugins not already discovered
             for plugin in plugin_env_plugins:

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/src/deepctl_cmd_plugin/models.py

@@ -33,7 +33,7 @@ class PluginRegistryEntry(BaseModel):
 
     name: str
     description: str
-    version: str
+    version: str | None = None
     author: str | None = None
     url: str | None = None
     keywords: list[str] = Field(default_factory=list)

{deepctl_cmd_plugin-0.1.14 → deepctl_cmd_plugin-0.1.15}/src/deepctl_cmd_plugin/strategies.py

@@ -272,7 +272,7 @@ def get_strategy(
     if method in (InstallMethod.UVX, InstallMethod.PIPX_RUN):
         return EphemeralStrategy(method)
 
-    # HOMEBREW, SYSTEM, UNKNOWN → isolated venv
+    # HOMEBREW, SYSTEM, UNKNOWN, NPM → isolated venv
     if venv_python is None:
         raise ValueError(
             f"venv_python is required for IsolatedVenvStrategy (method={method.value})"

deepctl_cmd_plugin-0.1.15/tests/unit/test_plugin_agent_gate.py

@@ -0,0 +1,64 @@
+"""Plugins run in every later dg command, so an AI agent session can't
+install, update or remove them. Scripts and CI without an agent marker can."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+from deepctl_cmd_plugin import command as plugin_module
+from deepctl_cmd_plugin.command import PluginCommand
+from deepctl_core import output
+
+
+@pytest.fixture(autouse=True)
+def _wide(monkeypatch):
+    monkeypatch.setattr(output.stderr_console, "_width", 400)
+
+
+HANDLERS = [
+    ("_handle_install", {"package": "deepctl-plugin-evil"}),
+    ("_handle_update", {"package": "deepctl-plugin-evil"}),
+    ("_handle_remove", {"package": "deepctl-plugin-evil", "yes": True}),
+]
+
+
+@pytest.mark.parametrize(
+    ("handler", "kwargs"),
+    [
+        ("_handle_install", {"package": "deepctl-plugin-evil"}),
+        ("_handle_update", {"package": "deepctl-plugin-evil"}),
+        ("_handle_remove", {"package": "deepctl-plugin-evil", "yes": True}),
+    ],
+)
+def test_refused_in_agent_sessions(monkeypatch, capsys, handler, kwargs):
+    monkeypatch.setattr(plugin_module, "is_ai_agent", lambda: True)
+    command = PluginCommand()
+    command.install_plugin = MagicMock()
+    command.remove_plugin = MagicMock()
+    with pytest.raises(SystemExit) as exc:
+        getattr(command, handler)(MagicMock(), MagicMock(), MagicMock(), **kwargs)
+    assert exc.value.code == 1
+    command.install_plugin.assert_not_called()
+    command.remove_plugin.assert_not_called()
+    err = capsys.readouterr().err
+    assert "doesn't run in an AI agent session. Nothing was changed." in err
+    assert "A person must run this command. If you are an AI agent, ask the user." in err
+
+
+@pytest.mark.parametrize(("handler", "kwargs"), HANDLERS)
+def test_scripts_and_ci_without_an_agent_marker_may_run(
+    monkeypatch, capsys, handler, kwargs
+):
+    """A non-TTY run or CI=true alone isn't refused; only hard AI-agent
+    signals are."""
+    monkeypatch.setenv("CI", "true")
+    monkeypatch.setattr(output, "is_agentic", lambda: True)
+    monkeypatch.setattr(plugin_module, "is_ai_agent", lambda: False)
+    command = PluginCommand()
+    command.install_plugin = MagicMock()
+    command.remove_plugin = MagicMock()
+    command._maybe_update_skills = MagicMock()
+    getattr(command, handler)(MagicMock(), MagicMock(), MagicMock(), **kwargs)
+    assert "AI agent session" not in capsys.readouterr().err
+    assert command.install_plugin.called or command.remove_plugin.called