plugin-scanner 2.0.1112__tar.gz → 2.0.1113__tar.gz

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1112
+Version: 2.0.1113
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://hol.org/guard
 Project-URL: Documentation, https://github.com/hashgraph-online/hol-guard/tree/main/docs/guard

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.1112"
+version = "2.0.1113"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1112"
+version = "2.0.1113"
 description = "Open-source antivirus and runtime protection for AI agents, tools, MCP servers, plugins, skills, and package installs."
 readme = "README.md"
 license = "Apache-2.0"

plugin_scanner-2.0.1112/release-metadata/plugin-scanner-v2.0.1112.toolchain.cdx.json → plugin_scanner-2.0.1113/release-metadata/plugin-scanner-v2.0.1113.toolchain.cdx.json

@@ -27,7 +27,7 @@
     "component": {
       "name": "hol-guard-release-toolchain",
       "type": "application",
-      "version": "2.0.1112"
+      "version": "2.0.1113"
     }
   },
   "specVersion": "1.6",

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/cli/commands_dispatch_local.py

@@ -162,6 +162,18 @@ def _run_guard_update_command(
         now=_now(),
         wheel=getattr(args, "wheel", None),
     )
+    if not dry_run and exit_code == 0 and context is not None:
+        from .update_commands import refresh_guard_daemon_after_update
+
+        daemon_refresh, daemon_refresh_note = refresh_guard_daemon_after_update(context)
+        if daemon_refresh is not None:
+            payload["daemon_refresh"] = daemon_refresh
+        if daemon_refresh_note is not None:
+            notes_value = payload.get("notes")
+            note_items = notes_value if isinstance(notes_value, list) else []
+            notes = [str(item) for item in note_items if isinstance(item, str)]
+            notes.append(daemon_refresh_note)
+            payload["notes"] = notes
     if update_store_error is not None:
         notes_value = payload.get("notes")
         notes = [str(item) for item in (notes_value if isinstance(notes_value, list) else []) if isinstance(item, str)]

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/cli/update_commands.py

@@ -78,6 +78,38 @@ if before.get("installed_managers"):
 after = package_shim_status(context)
 print(json.dumps({"before": before, "repair": repair, "after": after}))
 """.strip()
+_DAEMON_REFRESH_TIMEOUT_SECONDS = 35.0
+_DAEMON_REFRESH_SCRIPT = """
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from codex_plugin_scanner.guard.daemon.manager import (
+    clear_guard_daemon_state,
+    ensure_guard_daemon_after_update,
+    repair_approval_center_locator,
+    retire_all_guard_daemons_for_home,
+)
+
+payload = json.loads(sys.stdin.read())
+guard_home = Path(payload["guard_home"]).expanduser().resolve()
+state_path = guard_home / "daemon-state.json"
+if not state_path.is_file():
+    print(json.dumps({"status": "not_running"}))
+    raise SystemExit(0)
+try:
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+except (OSError, json.JSONDecodeError):
+    state = {}
+preferred_port = state.get("port") if isinstance(state.get("port"), int) else None
+retired = retire_all_guard_daemons_for_home(guard_home)
+clear_guard_daemon_state(guard_home)
+repair_approval_center_locator(guard_home)
+daemon_url = ensure_guard_daemon_after_update(guard_home, preferred_port=preferred_port)
+print(json.dumps({"status": "restarted", "retired": retired, "daemon_url": daemon_url}))
+""".strip()
 
 
 def _read_direct_url_dir_info(direct_url: dict[str, object] | None) -> dict[str, object]:
@@ -1226,6 +1258,42 @@ def _refresh_package_shims_after_update(
     return refresh_payload, _package_shim_refresh_note(refresh_payload)
 
 
+def refresh_guard_daemon_after_update(context: HarnessContext) -> tuple[dict[str, object] | None, str | None]:
+    """Restart a resident daemon in a fresh interpreter after a CLI package update."""
+
+    if not (context.guard_home / "daemon-state.json").is_file():
+        return None, None
+    try:
+        refresh_env = dict(os.environ)
+        refresh_env.pop("PYTHONPATH", None)
+        result = subprocess.run(
+            [sys.executable, *_trusted_python_flags(), "-c", _DAEMON_REFRESH_SCRIPT],
+            input=json.dumps({"guard_home": str(context.guard_home)}),
+            capture_output=True,
+            check=False,
+            cwd=str(_trusted_import_root()),
+            env=refresh_env,
+            text=True,
+            timeout=_DAEMON_REFRESH_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        return None, f"Could not restart the Guard daemon after update: {redact_sensitive_text(str(error))}"
+    stdout = _normalize_output_text(result.stdout)
+    stderr = _normalize_output_text(result.stderr)
+    if result.returncode != 0:
+        details = stderr or stdout or f"exit code {result.returncode}"
+        return None, f"Could not restart the Guard daemon after update: {details}"
+    try:
+        payload = json.loads(stdout) if stdout else {}
+    except json.JSONDecodeError as error:
+        return None, f"Could not parse the Guard daemon restart result after update: {error}"
+    if not isinstance(payload, dict):
+        return None, "Could not parse the Guard daemon restart result after update: invalid payload"
+    status = payload.get("status")
+    note = "Restarted the Guard daemon to load the updated package." if status == "restarted" else None
+    return payload, note
+
+
 def _package_shim_manifest_has_installed_managers(context: HarnessContext) -> bool:
     manifest_path = context.guard_home / "package-shims" / "manifest.json"
     try:

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/runtime/github_command_capabilities.py

@@ -1,8 +1,8 @@
 """Classify GitHub CLI commands by their observable security capability.
 
-The classifier intentionally uses positive allowlists for prompt-free reads.  A
-new or aliased ``gh`` command therefore cannot inherit read-only status merely
-because it is followed by an output formatter in a shell pipeline.
+The classifier uses reviewed command sets for prompt-free reads and routine
+mutations. A new or aliased ``gh`` command therefore cannot inherit trusted
+status merely because it is followed by an output formatter in a shell pipeline.
 """
 
 from __future__ import annotations
@@ -78,7 +78,14 @@ _MUTATING_SUBCOMMANDS: dict[str, frozenset[str]] = {
 }
 _MAINTENANCE_SUBCOMMANDS: dict[str, frozenset[str]] = {"pr": frozenset({"merge"})}
 
-_ALWAYS_MUTATING_GROUPS = frozenset({"cache", "codespace", "gpg-key", "label", "secret", "ssh-key", "variable"})
+_HIGH_IMPACT_SUBCOMMANDS: dict[str, frozenset[str]] = {
+    "release": frozenset({"delete"}),
+    "repo": frozenset({"archive", "delete", "rename"}),
+    "workflow": frozenset({"disable"}),
+}
+
+_HIGH_IMPACT_GROUPS = frozenset({"gpg-key", "secret", "ssh-key"})
+_ROUTINE_MUTATING_GROUPS = frozenset({"cache", "codespace", "label", "variable"})
 _READ_ONLY_TOP_LEVEL = frozenset({"search", "status"})
 _LOCAL_TOP_LEVEL = frozenset({"completion", "help", "version"})
 _LOCAL_AUTH_SUBCOMMANDS = frozenset({"status", "token"})
@@ -108,6 +115,26 @@ _API_OPTIONS_WITH_VALUES = frozenset(
 _API_BOOLEAN_OPTIONS = frozenset({"--include", "--paginate", "--silent", "--slurp", "--verbose", "-i"})
 _METHOD_OVERRIDE_HEADER = re.compile(r"\Ax-http-method-override\s*:", re.IGNORECASE)
 _STATIC_ENDPOINT = re.compile(r"\A[A-Za-z0-9_./{}:+,@=-]+\Z")
+_ROUTINE_API_ROOTS = frozenset({"gists", "notifications"})
+_ROUTINE_ACTIONS_API_RESOURCES = frozenset({"artifacts", "caches", "jobs", "runs", "workflows"})
+_ROUTINE_REPO_API_RESOURCES = frozenset(
+    {
+        "actions",
+        "check-runs",
+        "check-suites",
+        "comments",
+        "deployments",
+        "dispatches",
+        "git",
+        "issues",
+        "labels",
+        "merges",
+        "milestones",
+        "pulls",
+        "releases",
+        "statuses",
+    }
+)
 
 
 def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
@@ -145,11 +172,23 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
             "github.command.proven-read",
             "The command is a known read-only GitHub operation.",
         )
-    if top_level in _ALWAYS_MUTATING_GROUPS:
+    if top_level in _HIGH_IMPACT_GROUPS:
         return _assessment(
             "mutate_remote",
-            "github.command.remote-mutation",
-            "The command group can change GitHub-hosted state.",
+            "github.command.high-impact-mutation",
+            "The command changes GitHub credentials or secrets.",
+        )
+    if top_level in _ROUTINE_MUTATING_GROUPS:
+        if _group_subcommand(normalized[1:]) == "delete":
+            return _assessment(
+                "mutate_remote",
+                "github.command.high-impact-mutation",
+                "The command deletes GitHub-hosted state.",
+            )
+        return _assessment(
+            "maintain_remote",
+            "github.command.routine-mutation",
+            "The command performs a known routine GitHub mutation.",
         )
     if top_level in _READ_ONLY_SUBCOMMANDS:
         subcommand = _group_subcommand(normalized[1:])
@@ -167,9 +206,13 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
                 "github.command.proven-read",
                 "The command is a known read-only GitHub operation.",
             )
-        if subcommand in _MAINTENANCE_SUBCOMMANDS.get(top_level, frozenset()) and not any(
-            token == "--admin" or token.startswith("--admin=") for token in normalized[2:]
-        ):
+        if _is_high_impact_command(top_level, subcommand, normalized[2:]):
+            return _assessment(
+                "mutate_remote",
+                "github.command.high-impact-mutation",
+                "The command performs an explicitly high-impact GitHub mutation.",
+            )
+        if subcommand in _MAINTENANCE_SUBCOMMANDS.get(top_level, frozenset()):
             return _assessment(
                 "maintain_remote",
                 "github.command.pr-maintenance",
@@ -177,9 +220,9 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
             )
         if subcommand in _MUTATING_SUBCOMMANDS[top_level]:
             return _assessment(
-                "mutate_remote",
-                "github.command.remote-mutation",
-                "The command can change GitHub-hosted state.",
+                "maintain_remote",
+                "github.command.routine-mutation",
+                "The command performs a known routine GitHub mutation.",
             )
         return _assessment(
             "unknown",
@@ -193,6 +236,24 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
     )
 
 
+def _is_high_impact_command(top_level: str, subcommand: str, args: Sequence[str]) -> bool:
+    if subcommand == "delete":
+        return True
+    if subcommand in _HIGH_IMPACT_SUBCOMMANDS.get(top_level, frozenset()):
+        return True
+    if top_level == "pr" and subcommand == "merge":
+        return _has_option(args, "--admin")
+    if top_level == "repo" and subcommand == "edit":
+        return _has_option(args, "--visibility")
+    if top_level == "repo" and subcommand == "sync":
+        return _has_option(args, "--force")
+    return False
+
+
+def _has_option(args: Sequence[str], option: str) -> bool:
+    return any(token == option or token.startswith(f"{option}=") for token in args)
+
+
 def _strip_global_options(args: list[str]) -> list[str]:
     index = 0
     while index < len(args):
@@ -265,12 +326,6 @@ def _classify_api(args: Sequence[str]) -> GitHubCommandAssessment:
             "An HTTP method-override header prevents reliable API capability classification.",
         )
     method = parsed.method.upper() if parsed.method is not None else None
-    if method is not None and method not in {"GET", "HEAD"}:
-        return _assessment(
-            "mutate_remote",
-            "github.api.mutating-method",
-            "The GitHub API request uses a method that can change remote state.",
-        )
     if parsed.endpoint.lower() == "graphql":
         return _classify_graphql(parsed, method=method)
     if any(_field_value_is_external(value) for _name, value in parsed.fields):
@@ -279,15 +334,56 @@ def _classify_api(args: Sequence[str]) -> GitHubCommandAssessment:
             "github.api.external-field-value",
             "A GitHub API field loaded from external data cannot be classified statically.",
         )
+    if method is not None and method not in {"GET", "HEAD"}:
+        if _api_request_is_high_impact(parsed, method=method):
+            return _assessment(
+                "mutate_remote",
+                "github.api.high-impact-mutation",
+                "The GitHub API request performs an explicitly high-impact operation.",
+            )
+        return _assessment(
+            "maintain_remote",
+            "github.api.routine-mutation",
+            "The GitHub API request performs a statically understood routine mutation.",
+        )
     if parsed.fields and method is None:
+        if _api_request_is_high_impact(parsed, method="POST"):
+            return _assessment(
+                "mutate_remote",
+                "github.api.high-impact-mutation",
+                "The GitHub API request performs an explicitly high-impact operation.",
+            )
         return _assessment(
-            "mutate_remote",
-            "github.api.implicit-write-method",
-            "GitHub API fields select a write-capable request method unless GET is explicit.",
+            "maintain_remote",
+            "github.api.routine-mutation",
+            "GitHub API fields select a statically understood routine mutation.",
         )
     return _assessment("read_remote", "github.api.proven-get", "The GitHub API request is a statically proven read.")
 
 
+def _api_request_is_high_impact(parsed: _ApiArguments, *, method: str) -> bool:
+    endpoint = parsed.endpoint.strip("/").lower()
+    segments = tuple(segment for segment in endpoint.split("/") if segment)
+    if method == "DELETE":
+        return True
+    if len(segments) < 3 or segments[0] != "repos":
+        return not segments or segments[0] not in _ROUTINE_API_ROOTS
+    resource = segments[3:]
+    if not resource:
+        return method == "PATCH"
+    if resource[0] == "rulesets" or any(segment in {"keys", "secrets"} for segment in resource):
+        return True
+    if resource[:2] in {("actions", "permissions"), ("git", "refs")}:
+        return True
+    if resource[0] == "actions":
+        return len(resource) < 2 or resource[1] not in _ROUTINE_ACTIONS_API_RESOURCES
+    if resource[0] == "branches" and "protection" in resource:
+        return True
+    if resource[0] in {"collaborators", "hooks"}:
+        return True
+    return resource[0] == "transfer" or resource[0] not in _ROUTINE_REPO_API_RESOURCES
+
+
 def _parse_api_arguments(args: Sequence[str]) -> _ApiArguments | GitHubCommandAssessment:
     endpoint: str | None = None
     method: str | None = None

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/runtime/github_graphql_capabilities.py

@@ -10,7 +10,44 @@ GitHubGraphQLAssessment = tuple[GitHubGraphQLCapability, str, str]
 
 _GRAPHQL_NAME = re.compile(r"\b[_A-Za-z][_0-9A-Za-z]*\b")
 _GRAPHQL_ALIAS = re.compile(r"\b(?P<name>[_A-Za-z][_0-9A-Za-z]*)\s*:")
-_MAINTENANCE_MUTATIONS = frozenset({"resolveReviewThread", "unresolveReviewThread"})
+_ROUTINE_MUTATIONS = frozenset(
+    {
+        "addComment",
+        "addProjectV2DraftIssue",
+        "addProjectV2ItemById",
+        "addPullRequestReview",
+        "addPullRequestReviewComment",
+        "addPullRequestReviewThread",
+        "closeDiscussion",
+        "closeIssue",
+        "convertPullRequestToDraft",
+        "createDiscussion",
+        "createIssue",
+        "createPullRequest",
+        "disablePullRequestAutoMerge",
+        "enablePullRequestAutoMerge",
+        "markDiscussionCommentAsAnswer",
+        "markPullRequestReadyForReview",
+        "mergePullRequest",
+        "minimizeComment",
+        "reopenDiscussion",
+        "reopenIssue",
+        "resolveReviewThread",
+        "submitPullRequestReview",
+        "unmarkDiscussionCommentAsAnswer",
+        "unminimizeComment",
+        "unresolveReviewThread",
+        "updateDiscussion",
+        "updateDiscussionComment",
+        "updateIssue",
+        "updateIssueComment",
+        "updateProjectV2ItemFieldValue",
+        "updatePullRequest",
+        "updatePullRequestBranch",
+        "updatePullRequestReview",
+        "updatePullRequestReviewComment",
+    }
+)
 
 
 def classify_graphql_document(document: str) -> GitHubGraphQLAssessment:
@@ -49,11 +86,11 @@ def classify_graphql_document(document: str) -> GitHubGraphQLAssessment:
     operation = operations[0]
     if operation == "mutation":
         root_fields = _root_fields(sanitized)
-        if not has_fragment_definition and root_fields and frozenset(root_fields) <= _MAINTENANCE_MUTATIONS:
+        if not has_fragment_definition and root_fields and frozenset(root_fields) <= _ROUTINE_MUTATIONS:
             return (
                 "maintain_remote",
-                "github.graphql.proven-maintenance",
-                "The GraphQL mutation performs only statically proven review-thread maintenance.",
+                "github.graphql.routine-mutation",
+                "The GraphQL mutation contains only statically understood routine root fields.",
             )
         return (
             "mutate_remote",

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for tool version."""
 
-__version__ = "2.0.1112"
+__version__ = "2.0.1113"

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/tests/test_guard_github_command_capabilities.py

@@ -39,26 +39,34 @@ from codex_plugin_scanner.guard.runtime.secret_file_requests import extract_sens
                 "threadId=PRRT_example",
             ),
             "maintain_remote",
-            "github.graphql.proven-maintenance",
+            "github.graphql.routine-mutation",
         ),
         (("pr", "merge", "17", "--squash", "--delete-branch"), "maintain_remote", "github.command.pr-maintenance"),
-        (("pr", "merge", "17", "--admin"), "mutate_remote", "github.command.remote-mutation"),
-        (("pr", "edit", "17", "--title", "updated"), "mutate_remote", "github.command.remote-mutation"),
+        (("pr", "merge", "17", "--admin"), "mutate_remote", "github.command.high-impact-mutation"),
+        (("pr", "edit", "17", "--title", "updated"), "maintain_remote", "github.command.routine-mutation"),
+        (("issue", "close", "17"), "maintain_remote", "github.command.routine-mutation"),
+        (("issue", "delete", "17"), "mutate_remote", "github.command.high-impact-mutation"),
+        (("cache", "delete", "123"), "mutate_remote", "github.command.high-impact-mutation"),
+        (("release", "create", "v1.2.3"), "maintain_remote", "github.command.routine-mutation"),
+        (("release", "delete", "v1.2.3"), "mutate_remote", "github.command.high-impact-mutation"),
+        (("repo", "edit", "--visibility", "private"), "mutate_remote", "github.command.high-impact-mutation"),
+        (("repo", "sync", "--force"), "mutate_remote", "github.command.high-impact-mutation"),
+        (("secret", "set", "TOKEN"), "mutate_remote", "github.command.high-impact-mutation"),
         (
             ("api", "repos/example/project", "-f", "name=updated"),
-            "mutate_remote",
-            "github.api.implicit-write-method",
-        ),
-        (
-            ("api", "repos/example/project", "-X", "DELETE"),
-            "mutate_remote",
-            "github.api.mutating-method",
+            "maintain_remote",
+            "github.api.routine-mutation",
         ),
         (
             ("api", "graphql", "-f", "query=mutation { updateThing(input: {}) { id } }"),
             "mutate_remote",
             "github.graphql.remote-mutation",
         ),
+        (
+            ("api", "graphql", "-f", "query=mutation { closeIssue(input: {}) { issue { id } } }"),
+            "maintain_remote",
+            "github.graphql.routine-mutation",
+        ),
         (
             (
                 "api",
@@ -76,6 +84,85 @@ from codex_plugin_scanner.guard.runtime.secret_file_requests import extract_sens
             "mutate_remote",
             "github.graphql.remote-mutation",
         ),
+        (
+            ("api", "repos/example/project", "-X", "DELETE"),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            ("api", "repos/example/project/git/refs/heads/main", "-X", "PATCH", "-f", "force=true"),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            (
+                "api",
+                "repos/example/project/contents/.github/workflows/ci.yml",
+                "-X",
+                "PUT",
+                "-f",
+                "message=update workflow",
+                "-f",
+                "content=ZWNobyBvaw==",
+            ),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            ("api", "graphql", "-f", "query=mutation { updateRepository(input: {}) { repository { id } } }"),
+            "mutate_remote",
+            "github.graphql.remote-mutation",
+        ),
+        (
+            ("api", "graphql", "-f", "query=mutation { createDeployKey(input: {}) { clientMutationId } }"),
+            "mutate_remote",
+            "github.graphql.remote-mutation",
+        ),
+        (
+            ("api", "graphql", "-f", "query=mutation { createRef(input: {}) { ref { id } } }"),
+            "mutate_remote",
+            "github.graphql.remote-mutation",
+        ),
+        (
+            ("api", "graphql", "-f", "query=mutation { deleteIssue(input: {}) { clientMutationId } }"),
+            "mutate_remote",
+            "github.graphql.remote-mutation",
+        ),
+        (
+            (
+                "api",
+                "graphql",
+                "-f",
+                "query=mutation { removeOutsideCollaborator(input: {}) { clientMutationId } }",
+            ),
+            "mutate_remote",
+            "github.graphql.remote-mutation",
+        ),
+        (
+            ("api", "repos/example/project/issues/comments/123", "-X", "DELETE"),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            ("api", "orgs/example/memberships/alice", "-X", "PUT", "-f", "role=admin"),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            ("api", "repos/example/project/pages", "-X", "POST", "-f", "source=main"),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            ("api", "repos/example/project/actions/runners/registration-token", "-X", "POST"),
+            "mutate_remote",
+            "github.api.high-impact-mutation",
+        ),
+        (
+            ("api", "repos/example/project/actions/runs/123/rerun", "-X", "POST"),
+            "maintain_remote",
+            "github.api.routine-mutation",
+        ),
         (
             (
                 "api",
@@ -88,6 +175,11 @@ from codex_plugin_scanner.guard.runtime.secret_file_requests import extract_sens
             "github.graphql.remote-mutation",
         ),
         (("api", "graphql", "--input", "-"), "unknown", "github.api.input-body"),
+        (
+            ("api", "repos/example/project/issues/17/comments", "-X", "POST", "-F", "body=@body.md"),
+            "unknown",
+            "github.api.external-field-value",
+        ),
         (("project-alias",), "unknown", "github.command.extension-or-alias"),
     ),
 )
@@ -137,6 +229,14 @@ def test_classify_github_cli_rejects_ambiguous_graphql_inputs(args):
             "'query=mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{id}}}' "
             "-f threadId=PRRT_example"
         ),
+        (
+            "gh api graphql -f query='mutation { resolveReviewThread(input: "
+            "{threadId: \"PRRT_example\"}) { thread { isResolved } } }'"
+        ),
+        "gh pr edit 17 --title updated",
+        "gh issue close 17",
+        "gh release create v1.2.3 --notes 'release notes'",
+        "gh api repos/example/project/issues/17/comments -f body='looks good'",
         "gh pr merge 17 --repo example/project --squash --delete-branch",
         (
             "gh api graphql -f 'query=query { viewer { login } }' 2>&1 | "
@@ -154,11 +254,8 @@ def test_guard_keeps_proven_github_reads_prompt_free(tmp_path, command):
     ("command", "action_class"),
     (
         (
-            "gh api repos/example/project -f name=updated --jq '.name' | jq -r '.'",
-            "GitHub remote mutation command",
-        ),
-        (
-            "gh api graphql -f 'query=mutation { updateThing(input: {}) { id } }' | jq -r '.data'",
+            "gh api graphql -f 'query=mutation { deleteRepository(input: {repositoryId: \"R_1\"}) "
+            "{ clientMutationId } }' | jq -r '.data'",
             "GitHub remote mutation command",
         ),
         (
@@ -167,10 +264,12 @@ def test_guard_keeps_proven_github_reads_prompt_free(tmp_path, command):
             "deleteRepository(input:{repositoryId:$threadId}){repository{id}}}' -f threadId=R_123",
             "GitHub remote mutation command",
         ),
-        ("gh pr edit 17 --title updated | jq -r '.'", "GitHub remote mutation command"),
         ("gh pr merge 17 --admin", "GitHub remote mutation command"),
-        ("env GH_HOST=github.example command gh pr edit 17 --title updated", "GitHub remote mutation command"),
-        ("sh -c 'gh pr edit 17 --title updated | jq -r .'", "GitHub remote mutation command"),
+        ("gh repo delete example/project --yes", "GitHub remote mutation command"),
+        ("gh issue delete 17 --yes", "GitHub remote mutation command"),
+        ("gh release delete v1.2.3 --yes", "GitHub remote mutation command"),
+        ("gh secret set TOKEN --body value", "GitHub remote mutation command"),
+        ("gh api repos/example/project -X DELETE", "GitHub remote mutation command"),
         ("gh project-alias | jq -r '.'", "Unverified GitHub command capability"),
         ("gh pr view 17 | tee result.json", "destructive shell command"),
         ("gh pr view 17 > result.json", "destructive shell command"),

{plugin_scanner-2.0.1112 → plugin_scanner-2.0.1113}/tests/test_guard_phase03_local_install.py

@@ -27,6 +27,31 @@ def _context(tmp_path: Path) -> HarnessContext:
     return HarnessContext(home_dir=home, workspace_dir=workspace, guard_home=guard_home)
 
 
+def test_daemon_refresh_after_update_uses_fresh_interpreter(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    context = _context(tmp_path)
+    context.guard_home.mkdir(parents=True)
+    (context.guard_home / "daemon-state.json").write_text("{}", encoding="utf-8")
+
+    def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        assert command[-2:] == ["-c", update_commands._DAEMON_REFRESH_SCRIPT]
+        assert json.loads(str(kwargs["input"])) == {"guard_home": str(context.guard_home)}
+        return subprocess.CompletedProcess(command, 0, '{"status":"restarted","retired":[123]}', "")
+
+    monkeypatch.setattr(update_commands.subprocess, "run", fake_run)
+
+    payload, note = update_commands.refresh_guard_daemon_after_update(context)
+
+    assert payload == {"status": "restarted", "retired": [123]}
+    assert note == "Restarted the Guard daemon to load the updated package."
+
+
+def test_daemon_refresh_after_update_skips_when_daemon_is_not_running(tmp_path: Path) -> None:
+    payload, note = update_commands.refresh_guard_daemon_after_update(_context(tmp_path))
+
+    assert payload is None
+    assert note is None
+
+
 def test_update_failure_redacts_output_and_returns_retry_command(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(update_commands, "_current_version", lambda: "2.0.0")
     monkeypatch.setattr(update_commands, "_current_version_from_subprocess", lambda: "2.0.0")