agent-toggle 0.13.0__tar.gz → 0.13.1__tar.gz

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-toggle
-Version: 0.13.0
+Version: 0.13.1
 Summary: Temporarily disable / re-enable AI-agent skills, agents, commands, rules, plugins and MCP servers across harnesses (Claude Code, Codex, Grok, OpenCode, OpenClaw, Copilot, Vibe, Devin, Antigravity)
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/weskao/agent-toggle
@@ -69,7 +69,7 @@ queues the matching reload ([Claude Code pane mod](#claude-code-pane-mod)).
 
 | target | native mechanism | the gap |
 |---|---|---|
-| plugin | `claude plugin disable/enable` | fine — this tool just batches it |
+| plugin | `claude plugin disable/enable` | without `-s` the scope follows the current dir, so a project plugin enabled from elsewhere stays off; this tool pins the install's scope and project |
 | skill | none | moving files by hand hits the rename trap below |
 | agent | none | same |
 | command | none | same, plus nested `group/name.md` paths get flattened |
@@ -534,7 +534,9 @@ logo, centred, when the window is tall enough to fit the whole menu beside it; t
 | agy | `~/.gemini/config` | ✓ | — | — | — | — | ✓ `mcp_config.json` |
 
 Per-harness locations, mechanisms and the harness versions this was checked
-against are in [docs/harnesses.md](docs/harnesses.md).
+against are in [docs/harnesses.md](docs/harnesses.md). What `disable` and `enable`
+change on disk for each type, with example live, parked and backup paths, is in
+[docs/toggle-paths.md](docs/toggle-paths.md).
 
 **Homes per OS.** Every `~` above is Python's `Path.home()`: `$HOME` on macOS and
 Linux, `%USERPROFILE%` on Windows (so `~/.claude` is `C:\Users\<you>\.claude`).
@@ -551,8 +553,13 @@ Plugin ids are passed to `claude plugin ...`, which on Windows runs through
 
 Copilot's `config.json` is machine-managed and never edited by this tool; Copilot
 plugins are not yet supported. `claude` plugins are toggled through `claude
-plugin enable/disable`; `openclaw` plugins through a config flag (see [Assumed
-formats](#assumed-formats)). Codex has no plugin CLI this tool can drive: `disable
+plugin enable/disable -s <scope>`. The scope comes from the plugin's one install in
+`~/.claude/plugins/installed_plugins.json`, and a project or local install runs in its
+project dir, so a disable and an enable from different directories still hit the same
+setting. With several installs of one id, the CLI picks the scope from the current dir;
+`enable` then runs in the dir the disable ran in. Details are in
+[docs/toggle-paths.md](docs/toggle-paths.md#plugins). `openclaw` plugins are toggled
+through a config flag (see [Assumed formats](#assumed-formats)). Codex has no plugin CLI this tool can drive: `disable
 plugin x --harness codex` exits `4`, which is why the matrix leaves it unchecked.
 
 Flag items (openclaw plugins and flagged skills, opencode mcp) are toggled with
@@ -623,6 +630,11 @@ visible rather than silent.
 MCP changes need a **new session** to take effect, except in a Claude Code session running the
 agent-toggle mod, which runs `/mcp disable|enable <name>` for you (see the mod section).
 
+`/mcp disable <name>` also lists the server in that project's `disabledMcpServers` in
+`~/.claude.json`. Left there, a restored server would stay off in that project, so `enable`
+removes the name again: from every project for a user- or local-scope server, and only from
+that repo and the dirs inside it for a `--project` `.mcp.json` server.
+
 ### Claude MCP scopes
 
 Both scopes stored in `~/.claude.json` are togglable, and the scope round-trips:
@@ -1001,6 +1013,9 @@ claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
   `/reload-plugins`, an MCP server `/mcp disable|enable <name>`. The toast names it, e.g.
   `⛔ [DISABLED] skill: foo (/reload-skills)`. Agents and rules have no reload and still say
   `takes effect in a new session`. If Claude refuses a queued command, a toast says so.
+  `/reload-skills` and `/reload-plugins` only re-read what is on disk. `/mcp disable` also
+  leaves the per-project mark that `enable` clears (see
+  [MCP backups are verbatim](#mcp-backups-are-verbatim)).
 - `agent-toggle ui` in another terminal applies on Enter and writes the Claude rows it changed to
   `~/.agent-toggle/reload.json`. Every open session running the mod checks that file's mtime every
   5 s (one `stat`) and queues the same reloads, toasting `agent-toggle ui: /reload-skills`. A file

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/README.md

@@ -36,7 +36,7 @@ queues the matching reload ([Claude Code pane mod](#claude-code-pane-mod)).
 
 | target | native mechanism | the gap |
 |---|---|---|
-| plugin | `claude plugin disable/enable` | fine — this tool just batches it |
+| plugin | `claude plugin disable/enable` | without `-s` the scope follows the current dir, so a project plugin enabled from elsewhere stays off; this tool pins the install's scope and project |
 | skill | none | moving files by hand hits the rename trap below |
 | agent | none | same |
 | command | none | same, plus nested `group/name.md` paths get flattened |
@@ -501,7 +501,9 @@ logo, centred, when the window is tall enough to fit the whole menu beside it; t
 | agy | `~/.gemini/config` | ✓ | — | — | — | — | ✓ `mcp_config.json` |
 
 Per-harness locations, mechanisms and the harness versions this was checked
-against are in [docs/harnesses.md](docs/harnesses.md).
+against are in [docs/harnesses.md](docs/harnesses.md). What `disable` and `enable`
+change on disk for each type, with example live, parked and backup paths, is in
+[docs/toggle-paths.md](docs/toggle-paths.md).
 
 **Homes per OS.** Every `~` above is Python's `Path.home()`: `$HOME` on macOS and
 Linux, `%USERPROFILE%` on Windows (so `~/.claude` is `C:\Users\<you>\.claude`).
@@ -518,8 +520,13 @@ Plugin ids are passed to `claude plugin ...`, which on Windows runs through
 
 Copilot's `config.json` is machine-managed and never edited by this tool; Copilot
 plugins are not yet supported. `claude` plugins are toggled through `claude
-plugin enable/disable`; `openclaw` plugins through a config flag (see [Assumed
-formats](#assumed-formats)). Codex has no plugin CLI this tool can drive: `disable
+plugin enable/disable -s <scope>`. The scope comes from the plugin's one install in
+`~/.claude/plugins/installed_plugins.json`, and a project or local install runs in its
+project dir, so a disable and an enable from different directories still hit the same
+setting. With several installs of one id, the CLI picks the scope from the current dir;
+`enable` then runs in the dir the disable ran in. Details are in
+[docs/toggle-paths.md](docs/toggle-paths.md#plugins). `openclaw` plugins are toggled
+through a config flag (see [Assumed formats](#assumed-formats)). Codex has no plugin CLI this tool can drive: `disable
 plugin x --harness codex` exits `4`, which is why the matrix leaves it unchecked.
 
 Flag items (openclaw plugins and flagged skills, opencode mcp) are toggled with
@@ -590,6 +597,11 @@ visible rather than silent.
 MCP changes need a **new session** to take effect, except in a Claude Code session running the
 agent-toggle mod, which runs `/mcp disable|enable <name>` for you (see the mod section).
 
+`/mcp disable <name>` also lists the server in that project's `disabledMcpServers` in
+`~/.claude.json`. Left there, a restored server would stay off in that project, so `enable`
+removes the name again: from every project for a user- or local-scope server, and only from
+that repo and the dirs inside it for a `--project` `.mcp.json` server.
+
 ### Claude MCP scopes
 
 Both scopes stored in `~/.claude.json` are togglable, and the scope round-trips:
@@ -968,6 +980,9 @@ claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
   `/reload-plugins`, an MCP server `/mcp disable|enable <name>`. The toast names it, e.g.
   `⛔ [DISABLED] skill: foo (/reload-skills)`. Agents and rules have no reload and still say
   `takes effect in a new session`. If Claude refuses a queued command, a toast says so.
+  `/reload-skills` and `/reload-plugins` only re-read what is on disk. `/mcp disable` also
+  leaves the per-project mark that `enable` clears (see
+  [MCP backups are verbatim](#mcp-backups-are-verbatim)).
 - `agent-toggle ui` in another terminal applies on Enter and writes the Claude rows it changed to
   `~/.agent-toggle/reload.json`. Every open session running the mod checks that file's mtime every
   5 s (one `stat`) and queues the same reloads, toasting `agent-toggle ui: /reload-skills`. A file

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/agent_toggle/__init__.py

@@ -1,3 +1,3 @@
 """agent-toggle: temporarily disable / re-enable AI-agent resources."""
 
-__version__ = "0.13.0"
+__version__ = "0.13.1"

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/agent_toggle/backends/mcp_json.py

@@ -58,11 +58,12 @@ def claudeai_connector_names() -> set[str]:
     return set(cfg.get("claudeAiMcpEverConnected", []) or [])
 
 
-def toggle_claudeai_connector(action: str, name: str,
-                              dry_run: bool = False) -> tuple[bool, list | str]:
+def toggle_claudeai_connector(action: str, name: str, dry_run: bool = False,
+                              under: Path | None = None) -> tuple[bool, list | str]:
     """Fan a claude.ai connector on/off across every EXISTING project entry
     in ~/.claude.json's disabledMcpServers list -- the only place /mcp writes
-    that state; no `claude mcp` CLI verb reaches it.
+    that state; no `claude mcp` CLI verb reaches it. `under`: only the project
+    entries that are that dir or inside it.
 
     ponytail: covers projects that exist now; a project dir opened for the
     first time later starts without the entry until this is re-run for it.
@@ -75,7 +76,8 @@ def toggle_claudeai_connector(action: str, name: str,
 
     touched = []
     for proj, pdata in cfg.get("projects", {}).items():
-        if not isinstance(pdata, dict):
+        if not isinstance(pdata, dict) or (
+                under is not None and under != Path(proj) and under not in Path(proj).parents):
             continue
         cur = pdata.get("disabledMcpServers") or []
         has = name in cur

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/agent_toggle/backends/plugin_cli.py

@@ -10,6 +10,7 @@ import os
 import shutil
 import subprocess
 import sys
+from pathlib import Path
 from typing import Callable
 
 from .. import fs
@@ -17,6 +18,8 @@ from .. import fs
 which = shutil.which
 runner = subprocess.run
 
+PLUGIN_SCOPES = ("user", "project", "local")      # `claude plugin enable|disable -s`
+
 TIMEOUT_ENV = "AGENT_TOGGLE_CLI_TIMEOUT"
 MUTATE_TIMEOUT = 120      # enable / disable / install / mcp add|remove: may fetch from a marketplace
 READ_TIMEOUT = 30         # read-only `plugin list`
@@ -68,12 +71,39 @@ def run_cli(binary: str | None, args: list[str], cwd: str | None = None,
     return p.returncode == 0, (p.stdout + p.stderr).strip()
 
 
-def list_plugins(warn: Callable[[str], None]) -> list[dict]:
-    """`claude plugin list --json` through the injectable runner; [] when unavailable."""
+def plugin_where(name: str, claude_home: Path) -> tuple[str | None, str | None]:
+    """(scope, cwd) of plugin `name`'s one install, from Claude Code's install registry
+    (`<claude_home>/plugins/installed_plugins.json`; a bare name: its one `name@mkt` id).
+
+    Without `-s` the CLI picks the scope from its cwd, so a project-scope plugin toggled
+    from another dir lands in user scope. (None, None) when the registry cannot say --
+    absent, another shape, several installs, a project dir that is gone: the caller
+    then lets the CLI auto-detect, as before. A file read, not `claude plugin list`
+    (~0.8 s per call, paid on every pane toggle)."""
+    try:
+        reg = json.loads((claude_home / "plugins" / "installed_plugins.json")
+                         .read_text(encoding="utf-8"))
+        rows = [r for k, v in reg["plugins"].items()
+                if k == name or ("@" not in name and k.partition("@")[0] == name) for r in v]
+    except (OSError, ValueError, KeyError, TypeError, AttributeError):
+        return None, None
+    if len(rows) != 1 or not isinstance(rows[0], dict) or rows[0].get("scope") not in PLUGIN_SCOPES:
+        return None, None
+    scope, proj = rows[0]["scope"], rows[0].get("projectPath")
+    if scope == "user":
+        return scope, None
+    if isinstance(proj, str) and os.path.isabs(proj) and os.path.isdir(proj):
+        return scope, proj
+    return None, None
+
+
+def list_plugins(warn: Callable[[str], None], cwd: str | None = None) -> list[dict]:
+    """`claude plugin list --json` through the injectable runner; [] when unavailable.
+    `cwd`: its `enabled` is the plugin's state as seen from there."""
     exe = claude_bin()
     if not exe:
         return []
-    ok, text = run_cli(exe, ["plugin", "list", "--json"], timeout=READ_TIMEOUT)
+    ok, text = run_cli(exe, ["plugin", "list", "--json"], cwd=cwd, timeout=READ_TIMEOUT)
     try:       # run_cli merges stderr into the text: skip any notice before the array
         data = json.JSONDecoder().raw_decode(text, max(text.find("["), 0))[0] if ok else None
     except ValueError:

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/agent_toggle/mechanisms.py

@@ -28,7 +28,14 @@ from .backends.mcp_json import (
     write_project_mcp,
 )
 from .backends.mcp_toml import codex_mcp_add, codex_mcp_remove, toml_block
-from .backends.plugin_cli import claude_bin, full_plugin_id, list_plugins, run_cli
+from .backends.plugin_cli import (
+    PLUGIN_SCOPES,
+    claude_bin,
+    full_plugin_id,
+    list_plugins,
+    plugin_where,
+    run_cli,
+)
 from .companions import move, park_companions, restore_companions
 from .fs import prune_empty
 from .harnesses import PROBE_SUFFIXES, harnesses, project_view
@@ -118,6 +125,10 @@ def _entry_reason(entry: dict, table: dict, key: str, need: tuple[str, ...]) ->
     if entry.get("mechanism") == "native_cli" and not (
             head == "claude" and type_ == "plugin" and valid_plugin_id(name)):
         return "native_cli entry is not a claude plugin with a plain id"
+    if entry.get("mechanism") == "native_cli" and (
+            entry.get("scope", "user") not in PLUGIN_SCOPES
+            or ("cwd" in entry and not _abs_path(entry["cwd"]))):
+        return f"plugin scope {entry.get('scope')!r} / cwd {entry.get('cwd')!r} is not usable"
     if entry.get("backend") == "claude-json" and entry.get("scope") in ("user", "local"):
         if entry["scope"] == "local":
             # `project` here is the claude local-scope cwd, not a --project scope
@@ -527,7 +538,8 @@ def settle(state: dict, key: str, out: Result | None = None, *,
                            f"{json.dumps(was)} in {file} (its value before the run)")
     elif mech == "native_cli":            # the CLI is the op: ask it, never assume
         try:
-            on = _plugin_enabled(entry["name"])
+            cwd = entry.get("cwd")         # checked absolute above; a gone dir: list from here
+            on = _plugin_enabled(entry["name"], cwd if cwd and os.path.isdir(cwd) else None)
         except ValueError as e:
             return _report(out, dry_run, "stuck",
                            f"{what}: cannot tell whether it landed: {e}; fix: run `claude "
@@ -890,6 +902,18 @@ def _shared_text(verb: str, owner: str, harness: str, others: list[str]) -> str:
     return f"{verb} (shared dir: {where}also affects {', '.join(others)})"
 
 
+def _plugin_recorded(entry: dict | None, table: dict, key: str, name: str,
+                     home: Path) -> tuple[str | None, str | None]:
+    """(scope, cwd) an enable runs with: what the disable recorded (its project dir gone:
+    the CLI auto-detects), else, for an entry from before scope tracking, the registry."""
+    if entry and ("scope" in entry or "cwd" in entry) and not _refusal(entry, table, key, ()):
+        cwd = entry.get("cwd")
+        if cwd and not os.path.isdir(cwd):
+            return None, None
+        return entry.get("scope"), cwd
+    return plugin_where(name, home)
+
+
 def toggle_plugin(action: str, names: list[str], state: dict, harness: str,
                   out: Result | None = None, dry_run: bool = False, *,
                   batch: str = BATCH) -> int:
@@ -923,11 +947,20 @@ def toggle_plugin(action: str, names: list[str], state: dict, harness: str,
             continue
         key = f"{harness}:plugin:{name}"
         exe = claude_bin()
-        entry = state["disabled"].get(key) if action == "enable" else {
-            "mechanism": "native_cli", "harness": harness, "type": "plugin",
-            "name": name, "native": True,
-            "at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        }
+        if action == "enable":
+            entry = state["disabled"].get(key)
+            scope, cwd = _plugin_recorded(entry, table, key, name, table[harness].home)
+        else:
+            scope, cwd = plugin_where(name, table[harness].home)
+            if scope is None:            # the CLI auto-detects from here: enable replays it
+                with contextlib.suppress(OSError):
+                    cwd = os.getcwd()
+            entry = {
+                "mechanism": "native_cli", "harness": harness, "type": "plugin",
+                "name": name, "native": True,
+                "at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+                **({"scope": scope} if scope else {}), **({"cwd": cwd} if cwd else {}),
+            }
         # write-ahead only when state changes and settle can check it: no CLI, no entry
         # to drop, or one settle would refuse -> the op runs as before, unlogged
         logged = bool(exe and entry) and entry.get("mechanism") == "native_cli" \
@@ -939,7 +972,8 @@ def toggle_plugin(action: str, names: list[str], state: dict, harness: str,
                 fails += fail_row(out, dry_run, harness, "plugin", action, name,
                                   f"state not saved, nothing changed: {e}", batch=batch)
                 continue
-        ok, res = run_cli(exe, ["plugin", action, name])
+        ok, res = run_cli(exe, ["plugin", action, name, *(["-s", scope] if scope else [])],
+                          cwd=cwd)
         if not ok:
             # a timeout may still have landed: ask the CLI. A plain non-zero exit did not
             # (and asking would record an already-disabled plugin as ours: no `was` here)
@@ -1175,6 +1209,8 @@ def toggle_mcp(action: str, names: list[str], state: dict,
                 state["disabled"].pop(key, None)
                 if logged:                # never drop a stuck record this op did not write
                     end(state, key)
+                if not toml:
+                    _clear_mcp_marks(out, name)
                 log(action, "mcp", name, "ok", harness=harness, batch=batch,
                     project=project, scope=scope)
             _ok(out, dry_run, harness, "mcp", action, name,
@@ -1182,6 +1218,15 @@ def toggle_mcp(action: str, names: list[str], state: dict,
     return fails
 
 
+def _clear_mcp_marks(out: Result, name: str, under: Path | None = None) -> None:
+    """After a claude MCP enable: drop `name` from projects' disabledMcpServers (`under`:
+    only that project's). The mod follows a disable with `/mcp disable <name>`, which
+    lists it there; left in place, the restored server stays off in that project."""
+    cleared, res = toggle_claudeai_connector("enable", name, under=under)
+    if not cleared:
+        out.say(f"    ! {name}: per-project /mcp disable not cleared: {res}", warn=True)
+
+
 def toggle_project_mcp(action: str, names: list[str], state: dict, harness: str,
                        out: Result, dry_run: bool, table: dict, *, batch: str = BATCH) -> int:
     """`--project <dir>` MCP servers: remove_backup on the repo's own <dir>/.mcp.json.
@@ -1282,6 +1327,7 @@ def toggle_project_mcp(action: str, names: list[str], state: dict, harness: str,
                 continue
             state["disabled"].pop(key, None)
             end(state, key)
+            _clear_mcp_marks(out, name, Path(pstr))
             log(action, "mcp", name, "ok", harness=harness, batch=batch, project=pstr,
                 scope="project")
         _ok(out, dry_run, harness, "mcp", action, name,
@@ -1334,15 +1380,16 @@ def _mcp_present(entry: dict, file: Path) -> bool:
     return name in servers
 
 
-def _plugin_enabled(name: str) -> bool | None:
-    """Whether `claude plugin list --json` shows plugin `name` enabled (None: not listed;
+def _plugin_enabled(name: str, cwd: str | None = None) -> bool | None:
+    """Whether `claude plugin list --json`, run in `cwd` (where the op ran: a project-scope
+    plugin's state is the project's), shows plugin `name` enabled (None: not listed;
     a bare name matches its one `name@marketplace` id). ValueError when the CLI cannot
     say -- absent, slow (READ_TIMEOUT / AGENT_TOGGLE_CLI_TIMEOUT), failing, unparseable
     or ambiguous: the verdict is then stuck, never guessed."""
     if not claude_bin():
         raise ValueError("claude CLI not found")
     why: list[str] = []
-    listed = list_plugins(why.append)
+    listed = list_plugins(why.append, cwd)
     if why:      # its "; plugin rows come from state only" tail is list's, not ours
         raise ValueError(why[0].rpartition("; ")[0])
     hits = [p for p in listed

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/agent_toggle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-toggle
-Version: 0.13.0
+Version: 0.13.1
 Summary: Temporarily disable / re-enable AI-agent skills, agents, commands, rules, plugins and MCP servers across harnesses (Claude Code, Codex, Grok, OpenCode, OpenClaw, Copilot, Vibe, Devin, Antigravity)
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/weskao/agent-toggle
@@ -69,7 +69,7 @@ queues the matching reload ([Claude Code pane mod](#claude-code-pane-mod)).
 
 | target | native mechanism | the gap |
 |---|---|---|
-| plugin | `claude plugin disable/enable` | fine — this tool just batches it |
+| plugin | `claude plugin disable/enable` | without `-s` the scope follows the current dir, so a project plugin enabled from elsewhere stays off; this tool pins the install's scope and project |
 | skill | none | moving files by hand hits the rename trap below |
 | agent | none | same |
 | command | none | same, plus nested `group/name.md` paths get flattened |
@@ -534,7 +534,9 @@ logo, centred, when the window is tall enough to fit the whole menu beside it; t
 | agy | `~/.gemini/config` | ✓ | — | — | — | — | ✓ `mcp_config.json` |
 
 Per-harness locations, mechanisms and the harness versions this was checked
-against are in [docs/harnesses.md](docs/harnesses.md).
+against are in [docs/harnesses.md](docs/harnesses.md). What `disable` and `enable`
+change on disk for each type, with example live, parked and backup paths, is in
+[docs/toggle-paths.md](docs/toggle-paths.md).
 
 **Homes per OS.** Every `~` above is Python's `Path.home()`: `$HOME` on macOS and
 Linux, `%USERPROFILE%` on Windows (so `~/.claude` is `C:\Users\<you>\.claude`).
@@ -551,8 +553,13 @@ Plugin ids are passed to `claude plugin ...`, which on Windows runs through
 
 Copilot's `config.json` is machine-managed and never edited by this tool; Copilot
 plugins are not yet supported. `claude` plugins are toggled through `claude
-plugin enable/disable`; `openclaw` plugins through a config flag (see [Assumed
-formats](#assumed-formats)). Codex has no plugin CLI this tool can drive: `disable
+plugin enable/disable -s <scope>`. The scope comes from the plugin's one install in
+`~/.claude/plugins/installed_plugins.json`, and a project or local install runs in its
+project dir, so a disable and an enable from different directories still hit the same
+setting. With several installs of one id, the CLI picks the scope from the current dir;
+`enable` then runs in the dir the disable ran in. Details are in
+[docs/toggle-paths.md](docs/toggle-paths.md#plugins). `openclaw` plugins are toggled
+through a config flag (see [Assumed formats](#assumed-formats)). Codex has no plugin CLI this tool can drive: `disable
 plugin x --harness codex` exits `4`, which is why the matrix leaves it unchecked.
 
 Flag items (openclaw plugins and flagged skills, opencode mcp) are toggled with
@@ -623,6 +630,11 @@ visible rather than silent.
 MCP changes need a **new session** to take effect, except in a Claude Code session running the
 agent-toggle mod, which runs `/mcp disable|enable <name>` for you (see the mod section).
 
+`/mcp disable <name>` also lists the server in that project's `disabledMcpServers` in
+`~/.claude.json`. Left there, a restored server would stay off in that project, so `enable`
+removes the name again: from every project for a user- or local-scope server, and only from
+that repo and the dirs inside it for a `--project` `.mcp.json` server.
+
 ### Claude MCP scopes
 
 Both scopes stored in `~/.claude.json` are togglable, and the scope round-trips:
@@ -1001,6 +1013,9 @@ claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
   `/reload-plugins`, an MCP server `/mcp disable|enable <name>`. The toast names it, e.g.
   `⛔ [DISABLED] skill: foo (/reload-skills)`. Agents and rules have no reload and still say
   `takes effect in a new session`. If Claude refuses a queued command, a toast says so.
+  `/reload-skills` and `/reload-plugins` only re-read what is on disk. `/mcp disable` also
+  leaves the per-project mark that `enable` clears (see
+  [MCP backups are verbatim](#mcp-backups-are-verbatim)).
 - `agent-toggle ui` in another terminal applies on Enter and writes the Claude rows it changed to
   `~/.agent-toggle/reload.json`. Every open session running the mod checks that file's mtime every
   5 s (one `stat`) and queues the same reloads, toasting `agent-toggle ui: /reload-skills`. A file

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/tests/test_backends.py

@@ -127,6 +127,30 @@ class ClaudeJsonScopeTest(SandboxCase):
         # scopeless entry restores with no cwd
         self.assertIsNone(cwd)
 
+    def test_mcp_enable_clears_per_project_disabled_mark(self) -> None:
+        """The mod follows a disable with `/mcp disable <name>`, which lists the
+        server in that project's disabledMcpServers; enable must clear it or the
+        restored server stays off in that project."""
+        self.claude_json({"projects": {
+            "/work/a": {"disabledMcpServers": ["example-mcp", "other"]},
+            "/work/b": {"disabledMcpServers": ["other"]},
+        }})
+        fs.backup_dir().mkdir(parents=True)
+        bp = fs.backup_dir() / "claude__example-mcp.json"
+        bp.write_text('{"type": "http", "url": "http://127.0.0.1:1/mcp"}', encoding="utf-8")
+        self.cli_rc = 0
+        state = {"version": 2, "disabled": {"claude:mcp:example-mcp": {
+            "mechanism": "remove_backup", "harness": "claude", "type": "mcp",
+            "name": "example-mcp", "backend": "claude-json", "backup": str(bp),
+            "scope": "user", "project": None, "at": "2026-01-01"}}}
+        fails = mechanisms.toggle_mcp("enable", ["example-mcp"], state, "claude",
+                                      self.home, "claude-json")
+        self.assertEqual(fails, 0)
+        projects = json.loads(fs.claude_json().read_text(encoding="utf-8"))["projects"]
+        # the stale per-project mark is gone; unrelated names stay
+        self.assertEqual(projects["/work/a"]["disabledMcpServers"], ["other"])
+        self.assertEqual(projects["/work/b"]["disabledMcpServers"], ["other"])
+
 
 FIXTURES = Path(__file__).parent / "fixtures"
 

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/tests/test_crash.py

@@ -727,6 +727,20 @@ class PluginCrashTest(CliCrashCase):
         self.assertTrue(any("recovered interrupted disable" in w for w in env["warnings"]))
         self.assert_settled(False)
 
+    def test_a_project_scope_plugin_is_settled_from_its_project(self) -> None:
+        """The listing's `enabled` is the state seen from its cwd: ask from the project."""
+        proj = self.tmp / "work" / "repo"
+        proj.mkdir(parents=True)
+        reg = self.home / "plugins" / "installed_plugins.json"
+        reg.parent.mkdir(parents=True)
+        reg.write_text(json.dumps({"version": 2, "plugins": {"demo@mkt": [
+            {"scope": "project", "projectPath": str(proj)}]}}), encoding="utf-8")
+        self.kill_in_cli("disable", *self.ARGS, landed=True)
+        self.run_json(*NEXT)
+        self.assert_settled(True)
+        lists = [cwd for c, cwd in self.cli_calls if c[:2] == ["plugin", "list"]]
+        self.assertEqual(lists, [str(proj)])
+
     def test_kill_before_the_cli_disable_rolls_back(self) -> None:
         self.kill_in_cli("disable", *self.ARGS, landed=False)
         self.assertIn(self.KEY, self.pending())

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/tests/test_mechanisms.py

@@ -1,7 +1,10 @@
 """Park / restore of dir-type resources, and the harness/backend gates."""
 from __future__ import annotations
 
+import contextlib
+import io
 import json
+import os
 import shutil
 import unittest
 from pathlib import Path
@@ -189,6 +192,97 @@ class OpencodeDuplicateSkillTest(CliCase):
         self.assertNotIn("still loads another copy", out)
 
 
+class PluginScopeTest(SandboxCase):
+    """`claude plugin disable|enable` without `-s` picks the scope from the cwd: a
+    project-scope plugin enabled from elsewhere got a new user-scope `true` while its
+    project stayed `false`. The install registry names the scope and project."""
+
+    ID = "demo-plugin@demo-mkt"
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.cli_rc = 0
+        (self.tmp / "work" / "repo").mkdir(parents=True)
+        (self.tmp / "work" / "other").mkdir(parents=True)
+        # resolved: os.getcwd() is, and macOS /var is a symlink
+        self.proj = (self.tmp / "work" / "repo").resolve()
+        self.elsewhere = (self.tmp / "work" / "other").resolve()
+        self.state = {"version": 3, "disabled": {}}
+
+    def installs(self, *rows: dict) -> None:
+        reg = self.home / "plugins" / "installed_plugins.json"
+        reg.parent.mkdir(parents=True, exist_ok=True)
+        reg.write_text(json.dumps({"version": 2, "plugins": {self.ID: list(rows)}}),
+                       encoding="utf-8")
+
+    def toggle(self, action: str, cwd: Path) -> int:
+        old = os.getcwd()
+        os.chdir(cwd)
+        try:
+            with contextlib.redirect_stdout(io.StringIO()):
+                return mech.toggle_plugin(action, [self.ID], self.state, "claude")
+        finally:
+            os.chdir(old)
+
+    def calls(self) -> list[tuple[list[str], str | None]]:
+        return [(a, c) for a, c in self.cli_calls if a[:2] != ["plugin", "list"]]
+
+    def test_project_scope_round_trips_from_any_cwd(self) -> None:
+        self.installs({"scope": "project", "projectPath": str(self.proj)})
+        self.assertEqual(self.toggle("disable", self.elsewhere), 0)
+        self.assertEqual(self.toggle("enable", self.elsewhere), 0)
+        want = (str(self.proj),)
+        self.assertEqual(self.calls(), [
+            (["plugin", "disable", self.ID, "-s", "project"], *want),
+            (["plugin", "enable", self.ID, "-s", "project"], *want)])
+
+    def test_enable_replays_the_recorded_scope_not_todays_registry(self) -> None:
+        self.installs({"scope": "local", "projectPath": str(self.proj)})
+        self.toggle("disable", self.proj)
+        self.installs({"scope": "user"})                 # registry changed meanwhile
+        self.toggle("enable", self.elsewhere)
+        self.assertEqual(self.calls()[-1],
+                         (["plugin", "enable", self.ID, "-s", "local"], str(self.proj)))
+
+    def test_user_scope_passes_the_scope_and_no_cwd(self) -> None:
+        self.installs({"scope": "user"})
+        self.toggle("disable", self.proj)
+        self.assertEqual(self.calls(), [(["plugin", "disable", self.ID, "-s", "user"], None)])
+
+    def test_ambiguous_install_keeps_auto_detect_and_replays_its_cwd(self) -> None:
+        self.installs({"scope": "user"}, {"scope": "project", "projectPath": str(self.proj)})
+        self.toggle("disable", self.proj)
+        self.toggle("enable", self.elsewhere)
+        self.assertEqual(self.calls(), [
+            (["plugin", "disable", self.ID], str(self.proj)),
+            (["plugin", "enable", self.ID], str(self.proj))])
+
+    def test_entry_from_before_scope_tracking_resolves_from_the_registry(self) -> None:
+        self.installs({"scope": "project", "projectPath": str(self.proj)})
+        self.state["disabled"][f"claude:plugin:{self.ID}"] = {
+            "mechanism": "native_cli", "harness": "claude", "type": "plugin",
+            "name": self.ID, "native": True, "at": "2026-01-01T00:00:00+0000"}
+        self.toggle("enable", self.elsewhere)
+        self.assertEqual(self.calls(), [
+            (["plugin", "enable", self.ID, "-s", "project"], str(self.proj))])
+
+    def test_no_registry_and_a_gone_project_fall_back_to_auto_detect(self) -> None:
+        self.toggle("disable", self.elsewhere)           # no installed_plugins.json
+        self.installs({"scope": "project", "projectPath": str(self.tmp / "gone")})
+        self.toggle("enable", self.elsewhere)
+        self.assertEqual(self.calls(), [
+            (["plugin", "disable", self.ID], str(self.elsewhere)),
+            (["plugin", "enable", self.ID], str(self.elsewhere))])
+
+    def test_tampered_scope_or_cwd_is_refused(self) -> None:
+        for bad in ({"scope": "global"}, {"cwd": "relative/dir"}, {"cwd": 7}):
+            with self.subTest(bad=bad):
+                entry = {"mechanism": "native_cli", "harness": "claude", "type": "plugin",
+                         "name": self.ID, "native": True, "at": "2026", **bad}
+                self.assertTrue(mech._entry_reason(entry, mech.harnesses(),
+                                                   f"claude:plugin:{self.ID}", ()))
+
+
 class McpGateTest(SandboxCase):
     def test_mcp_without_backend_fails_loudly(self) -> None:
         state = {"version": 2, "disabled": {}}

{agent_toggle-0.13.0 → agent_toggle-0.13.1}/tests/test_project.py

@@ -442,6 +442,23 @@ class ProjectMcpTest(ProjectCase):
         self.assertIn("symlink", env["results"][0]["detail"])
         self.assertEqual(target.read_text(encoding="utf-8"), self.text)
 
+    def test_enable_clears_this_projects_mcp_disable_mark_only(self) -> None:
+        """A session's `/mcp disable example-mcp` (the mod queues it) lists it in that
+        project's disabledMcpServers; enable clears it there, never in another repo."""
+        self.assertEqual(self.p("disable", "mcp", "example-mcp")[0], 0)
+        root = self.proj.resolve()
+        self.claude_json({"projects": {
+            str(root): {"disabledMcpServers": ["example-mcp", "keep-mcp"]},
+            str(root / "sub"): {"disabledMcpServers": ["example-mcp"]},
+            str(self.tmp / "work" / "other"): {"disabledMcpServers": ["example-mcp"]},
+        }})
+        self.assertEqual(self.p("enable", "mcp", "example-mcp")[0], 0)
+        projects = json.loads(fs.claude_json().read_text(encoding="utf-8"))["projects"]
+        self.assertEqual({k: v["disabledMcpServers"] for k, v in projects.items()}, {
+            str(root): ["keep-mcp"], str(root / "sub"): [],
+            str(self.tmp / "work" / "other"): ["example-mcp"]})
+        self.assertEqual(self.cli_calls, [])
+
     def test_user_scope_mcp_state_is_never_touched(self) -> None:
         self.claude_json({"mcpServers": {"example-mcp": {"url": "https://user.example.com"}}})
         self.cli_rc = 0