plugin-scanner 2.0.856__tar.gz → 2.0.858__tar.gz

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.856
+Version: 2.0.858
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/dashboard/src/guard-update-panel.tsx

@@ -33,6 +33,28 @@ function updateStatusLabel(status: GuardUpdateStatus | null | undefined): string
   return `Version ${status.current_version}`;
 }
 
+function shouldPromptRecoveryReinstall(status: GuardUpdateStatus | null | undefined): boolean {
+  return (
+    status?.recovery_reinstall_available === true &&
+    status?.auto_updatable !== true &&
+    status?.version_check?.update_available === true
+  );
+}
+
+function recoveryReinstallHelpCopy(status: GuardUpdateStatus | null | undefined): string | null {
+  if (!shouldPromptRecoveryReinstall(status)) {
+    return null;
+  }
+  const blockedReason = status?.blocked_reason ?? "";
+  if (blockedReason.includes("local wheel whose source file is no longer available")) {
+    return "This install came from a local wheel whose source file is no longer available, so automatic updates are off. Reinstall from PyPI to switch it back to a normal package; Guard restarts briefly and saved approvals stay.";
+  }
+  if (blockedReason.includes("local wheel")) {
+    return "This install came from a local wheel, so automatic updates are off. Reinstall from PyPI to switch it back to a normal package; Guard restarts briefly and saved approvals stay.";
+  }
+  return "This install came from a local folder, so automatic updates are off. Reinstall from PyPI to switch it back to a normal package; Guard restarts briefly and saved approvals stay.";
+}
+
 function updateHelpCopy(status: GuardUpdateStatus | null | undefined, phase: GuardUpdatePhase): string | null {
   if (phase === "updating") {
     return "Guard is installing the update. The dashboard will pause briefly and reopen when ready.";
@@ -55,9 +77,8 @@ function updateHelpCopy(status: GuardUpdateStatus | null | undefined, phase: Gua
   if (status?.update_available) {
     return "This restarts Guard for a moment. Open approvals will stay saved.";
   }
-  // Recovery case gets calmer copy that frames the fix instead of the dead end.
   if (status && !status.auto_updatable && status.recovery_reinstall_available) {
-    return "This install came from a local folder, so automatic updates are off. Reinstall from PyPI to switch it back to a normal package; Guard restarts briefly and saved approvals stay.";
+    return recoveryReinstallHelpCopy(status);
   }
   if (status && !status.auto_updatable && status.blocked_reason) {
     return status.blocked_reason;
@@ -75,11 +96,7 @@ export function GuardUpdatePanel(props: GuardUpdatePanelProps) {
     props.updateStatus.update_suppressed !== true &&
     phase !== "updating" &&
     phase !== "reconnecting";
-  const showReinstallButton =
-    props.updateStatus?.recovery_reinstall_available === true &&
-    props.updateStatus.auto_updatable !== true &&
-    phase !== "updating" &&
-    phase !== "reconnecting";
+  const showReinstallButton = shouldPromptRecoveryReinstall(props.updateStatus) && phase !== "updating" && phase !== "reconnecting";
   const busy = phase === "updating" || phase === "reconnecting";
 
   return (

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/dashboard/src/guard-update.test.ts

@@ -1,4 +1,8 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
 import { buildGuardDaemonCandidatePorts, normalizeGuardUpdateStatus, updateReconnectSucceeded } from "./guard-api";
+import { GuardUpdatePanel } from "./guard-update-panel";
 
 function assert(condition: boolean, message: string): void {
   if (!condition) {
@@ -55,6 +59,95 @@ assert(
   "recovery_reinstall_command should pass through",
 );
 
+const currentLocalWheelMarkup = renderToStaticMarkup(
+  createElement(GuardUpdatePanel, {
+    updateStatus: normalizeGuardUpdateStatus({
+      current_version: "2.0.855",
+      latest_version: "2.0.855",
+      auto_updatable: false,
+      update_available: false,
+      version_check: {
+        source: "pypi",
+        status: "current",
+        current_version: "2.0.855",
+        latest_version: "2.0.855",
+        update_available: false,
+      },
+      blocked_reason:
+        "This install was set up from a local wheel. Re-run `hol-guard update --wheel <wheel-or-directory>` or your usual local install command instead.",
+      recovery_reinstall_available: true,
+    }),
+    onReinstallGuard: () => undefined,
+  }),
+);
+
+assert(
+  !currentLocalWheelMarkup.includes("Reinstall from PyPI"),
+  "current local wheel installs should not keep showing the PyPI recovery CTA",
+);
+assert(
+  !currentLocalWheelMarkup.includes("automatic updates are off"),
+  "current local wheel installs should not keep showing the recovery warning",
+);
+
+const staleLocalWheelMarkup = renderToStaticMarkup(
+  createElement(GuardUpdatePanel, {
+    updateStatus: normalizeGuardUpdateStatus({
+      current_version: "2.0.855",
+      latest_version: "2.0.856",
+      auto_updatable: false,
+      update_available: false,
+      version_check: {
+        source: "pypi",
+        status: "stale",
+        current_version: "2.0.855",
+        latest_version: "2.0.856",
+        update_available: true,
+      },
+      blocked_reason:
+        "This install was set up from a local wheel. Re-run `hol-guard update --wheel <wheel-or-directory>` or your usual local install command instead.",
+      recovery_reinstall_available: true,
+    }),
+    onReinstallGuard: () => undefined,
+  }),
+);
+
+assert(
+  staleLocalWheelMarkup.includes("This install came from a local wheel"),
+  "stale local wheel installs should explain the real install source",
+);
+assert(
+  staleLocalWheelMarkup.includes("Reinstall from PyPI"),
+  "stale local wheel installs should keep the PyPI recovery CTA",
+);
+
+const staleLocalFolderMarkup = renderToStaticMarkup(
+  createElement(GuardUpdatePanel, {
+    updateStatus: normalizeGuardUpdateStatus({
+      current_version: "2.0.855",
+      latest_version: "2.0.856",
+      auto_updatable: false,
+      update_available: false,
+      version_check: {
+        source: "pypi",
+        status: "stale",
+        current_version: "2.0.855",
+        latest_version: "2.0.856",
+        update_available: true,
+      },
+      blocked_reason:
+        "This install was set up from a local folder. Re-run your usual local install command instead.",
+      recovery_reinstall_available: true,
+    }),
+    onReinstallGuard: () => undefined,
+  }),
+);
+
+assert(
+  staleLocalFolderMarkup.includes("This install came from a local folder"),
+  "stale local folder installs should keep the folder-specific recovery copy",
+);
+
 const noRecovery = normalizeGuardUpdateStatus({
   auto_updatable: false,
   update_available: false,

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.856"
+version = "2.0.858"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.856"
+version = "2.0.858"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/src/codex_plugin_scanner/guard/adapters/contracts.py

@@ -149,7 +149,7 @@ HARNESS_CONTRACTS: tuple[HarnessProtectionContract, ...] = (
         harness="codex",
         install_aliases=("codex",),
         config_paths=("~/.codex/config.toml",),
-        event_surfaces=("shell", "prompt", "mcp_tool", "file_read"),
+        event_surfaces=("shell", "prompt", "mcp_tool", "file_read", "tool_result"),
         native_approval=True,
         browser_fallback=True,
         resume_support=True,
@@ -162,7 +162,7 @@ HARNESS_CONTRACTS: tuple[HarnessProtectionContract, ...] = (
         harness="claude-code",
         install_aliases=("claude-code", "claude"),
         config_paths=("~/.claude/settings.json", "~/.claude/settings.local.json"),
-        event_surfaces=("shell", "prompt", "mcp_tool", "file_read"),
+        event_surfaces=("shell", "prompt", "mcp_tool", "file_read", "tool_result"),
         native_approval=True,
         browser_fallback=True,
         resume_support=True,
@@ -324,8 +324,12 @@ HARNESS_CONTRACTS: tuple[HarnessProtectionContract, ...] = (
             ".pi/settings.json",
             "~/.pi/agent/extensions/*.ts",
             ".pi/extensions/*.ts",
+            "~/.omp/agent/settings.json",
+            ".omp/settings.json",
+            "~/.omp/agent/extensions/*.ts",
+            ".omp/extensions/*.ts",
         ),
-        event_surfaces=("shell", "prompt", "mcp_tool", "file_read"),
+        event_surfaces=("shell", "prompt", "mcp_tool", "file_read", "tool_result"),
         native_approval=True,
         browser_fallback=True,
         resume_support=False,

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/src/codex_plugin_scanner/guard/adapters/pi.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from ..aibom_detection import extend_detection_with_workspace_aibom
 from ..models import GuardArtifact, HarnessDetection
 from ..shims import install_guard_shim, remove_guard_shim
-from .base import HarnessAdapter, HarnessContext, _command_available
+from .base import HarnessAdapter, HarnessContext, _resolve_command
 from .pi_support import (
     EXTENSION_SUFFIXES,
     OMP_AGENT_DIR,
@@ -67,6 +67,22 @@ class PiHarnessAdapter(HarnessAdapter):
     def _relative_label(root: Path, path: Path) -> str:
         return path.relative_to(root).as_posix()
 
+    def resolved_executable(self, context: HarnessContext) -> str | None:
+        return _resolve_command("pi", self.executable_candidates(context)) or _resolve_command(
+            "omp",
+            self.executable_candidates(context),
+        )
+
+    def diagnostic_warnings(
+        self,
+        detection: HarnessDetection,
+        runtime_probe: dict[str, object] | None,
+    ) -> list[str]:
+        return [
+            warning.replace("the pi command", "the pi or omp command").replace("pi diagnostics", "pi/omp diagnostics")
+            for warning in super().diagnostic_warnings(detection, runtime_probe)
+        ]
+
     def policy_path(self, context: HarnessContext) -> Path:
         project_root = self._project_root(context)
         if project_root is not None:
@@ -143,10 +159,11 @@ class PiHarnessAdapter(HarnessAdapter):
                 scope=scope,
                 id_root=root / "themes",
             )
+        command_available = self.resolved_executable(context) is not None
         detection = HarnessDetection(
             harness=self.harness,
-            installed=bool(found_paths) or _command_available(self.executable),
-            command_available=_command_available(self.executable),
+            installed=bool(found_paths) or command_available,
+            command_available=command_available,
             config_paths=tuple(found_paths),
             artifacts=tuple(artifacts),
             warnings=(),
@@ -508,14 +525,22 @@ class PiHarnessAdapter(HarnessAdapter):
         extension_path = self._managed_extension_path(context)
         extension_path.parent.mkdir(parents=True, exist_ok=True)
         extension_path.write_text(
-            managed_extension_source(guard_home=context.guard_home, home_dir=context.home_dir),
+            managed_extension_source(
+                guard_home=context.guard_home,
+                home_dir=context.home_dir,
+                settings_path=self._managed_settings_path(context),
+            ),
             encoding="utf-8",
         )
         enable_managed_extension(settings_path=self._managed_settings_path(context), extension_path=extension_path)
         omp_extension_path = self._managed_omp_extension_path(context)
         omp_extension_path.parent.mkdir(parents=True, exist_ok=True)
         omp_extension_path.write_text(
-            managed_extension_source(guard_home=context.guard_home, home_dir=context.home_dir),
+            managed_extension_source(
+                guard_home=context.guard_home,
+                home_dir=context.home_dir,
+                settings_path=self._managed_omp_settings_path(context),
+            ),
             encoding="utf-8",
         )
         enable_managed_extension(

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/src/codex_plugin_scanner/guard/adapters/pi_support.py

@@ -116,16 +116,18 @@ def disable_managed_extension(*, settings_path: Path, extension_path: Path) -> N
     settings_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
 
 
-def managed_extension_source(*, guard_home: Path, home_dir: Path) -> str:
+def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path: Path) -> str:
     guard_args = ["guard", "hook", "--guard-home", str(guard_home), "--harness", "pi"]
     if home_dir.resolve() != Path.home().resolve():
         guard_args.extend(["--home", str(home_dir)])
     guard_args_json = json.dumps(guard_args)
+    config_path_json = json.dumps(str(settings_path))
     return (
         'import { spawnSync } from "node:child_process";\n'
         'import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";\n'
         "\n"
         f"const GUARD_ARGS = {guard_args_json};\n"
+        f"const GUARD_CONFIG_PATH = {config_path_json};\n"
         f"const GUARD_TIMEOUT_MS = {GUARD_HOOK_TIMEOUT_MS};\n"
         "\n"
         "type GuardResponse = { decision?: string; reason?: string };\n"
@@ -157,10 +159,27 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path) -> str:
         '  return { decision: "allow" };\n'
         "}\n"
         "\n"
+        "function contentText(content: unknown): string {\n"
+        '  if (typeof content === "string") return content;\n'
+        '  if (!Array.isArray(content)) return "";\n'
+        "  return content\n"
+        "    .map((item) => {\n"
+        '      if (!item || typeof item !== "object") return "";\n'
+        "      const type = (item as { type?: unknown }).type;\n"
+        "      const text = (item as { text?: unknown }).text;\n"
+        '      return type === "text" && typeof text === "string" ? text : "";\n'
+        "    })\n"
+        "    .filter(Boolean)\n"
+        '    .join("\\n");\n'
+        "}\n"
+        "\n"
         "export default function (pi: ExtensionAPI) {\n"
         '  pi.on("input", async (event, ctx) => {\n'
         '    if (event.source === "extension") return { action: "continue" };\n'
-        '    const response = runGuard({ hook_event_name: "UserPromptSubmit", prompt: event.text }, ctx.cwd);\n'
+        "    const response = runGuard(\n"
+        '      { hook_event_name: "UserPromptSubmit", prompt: event.text, config_path: GUARD_CONFIG_PATH },\n'
+        "      ctx.cwd,\n"
+        "    );\n"
         '    if (response.decision === "deny") {\n'
         '      ctx.ui.notify(response.reason ?? "Blocked by HOL Guard.", "warning");\n'
         '      return { action: "handled", handled: true };\n'
@@ -176,6 +195,7 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path) -> str:
         "    const response = runGuard(\n"
         "      {\n"
         '        hook_event_name: "PreToolUse",\n'
+        "        config_path: GUARD_CONFIG_PATH,\n"
         "        tool_name: event.toolName,\n"
         "        tool_input: toolInput,\n"
         "      },\n"
@@ -187,5 +207,35 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path) -> str:
         "    }\n"
         "    return undefined;\n"
         "  });\n"
+        '  pi.on("tool_result", async (event, ctx) => {\n'
+        "    const toolOutput = contentText(event.content);\n"
+        "    const toolInput =\n"
+        "      (event as { input?: Record<string, unknown> }).input ??\n"
+        "      (event as { toolInput?: Record<string, unknown> }).toolInput ??\n"
+        "      (event as { arguments?: Record<string, unknown> }).arguments ??\n"
+        "      {};\n"
+        "    const response = runGuard(\n"
+        "      {\n"
+        '        hook_event_name: "PostToolUse",\n'
+        "        config_path: GUARD_CONFIG_PATH,\n"
+        "        tool_name: event.toolName,\n"
+        "        tool_input: toolInput,\n"
+        "        tool_response: event.content,\n"
+        "        stdout: toolOutput,\n"
+        "        is_error: event.isError === true,\n"
+        "      },\n"
+        "      ctx.cwd,\n"
+        "    );\n"
+        '    if (response.decision === "deny") {\n'
+        '      const reason = response.reason ?? "Blocked by HOL Guard.";\n'
+        '      ctx.ui.notify(reason, "warning");\n'
+        "      return {\n"
+        '        content: [{ type: "text", text: reason }],\n'
+        "        details: event.details,\n"
+        "        isError: true,\n"
+        "      };\n"
+        "    }\n"
+        "    return undefined;\n"
+        "  });\n"
         "}\n"
     )

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/src/codex_plugin_scanner/guard/cli/commands_support_codex_tool_output_messages.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 def _codex_tool_output_request_summary(
     *,
+    harness_label: str = "Codex",
     tool_name: str,
     command_text: str,
     local_secret_source: str | None,
@@ -12,63 +13,70 @@ def _codex_tool_output_request_summary(
     focused_pytest: bool = False,
 ) -> str:
     if local_secret_source is not None:
-        return f"Codex tool `{tool_name}` read local secrets from {local_secret_source} while running `{command_text}`."
+        return (
+            f"{harness_label} tool `{tool_name}` read local secrets from {local_secret_source} "
+            f"while running `{command_text}`."
+        )
     if focused_pytest and merged_output_capture:
         return (
-            f"Codex tool `{tool_name}` ran focused pytest, merged stderr into stdout while running "
+            f"{harness_label} tool `{tool_name}` ran focused pytest, merged stderr into stdout while running "
             f"`{command_text}`, and the captured output looked credential-like."
         )
     if focused_pytest:
         return (
-            f"Codex tool `{tool_name}` ran focused pytest and produced credential-looking output while "
+            f"{harness_label} tool `{tool_name}` ran focused pytest and produced credential-looking output while "
             f"running `{command_text}`."
         )
     if merged_output_capture:
         return (
-            f"Codex tool `{tool_name}` merged stderr into stdout while running `{command_text}`, "
+            f"{harness_label} tool `{tool_name}` merged stderr into stdout while running `{command_text}`, "
             "and the captured output looked credential-like."
         )
-    return f"Codex tool `{tool_name}` produced credential-looking output while running `{command_text}`."
+    return f"{harness_label} tool `{tool_name}` produced credential-looking output while running `{command_text}`."
 
 
 def _codex_tool_output_runtime_summary(
     local_secret_source: str | None,
     *,
+    harness_label: str = "Codex",
     merged_output_capture: bool = False,
     focused_pytest: bool = False,
 ) -> str:
     if local_secret_source is not None:
-        return f"Local secrets from {local_secret_source} reached Codex tool output."
+        return f"Local secrets from {local_secret_source} reached {harness_label} tool output."
     if focused_pytest and merged_output_capture:
         return (
             "Focused pytest merged stderr into stdout and emitted credential-looking output before it reached "
-            "Codex. Pytest can execute repository-controlled code, so this could be a real local secret."
+            f"{harness_label}. Pytest can execute repository-controlled code, so this could be a real local secret."
         )
     if focused_pytest:
         return (
-            "Focused pytest emitted credential-looking output before it reached Codex. "
+            f"Focused pytest emitted credential-looking output before it reached {harness_label}. "
             "Pytest can execute repository-controlled code, so this could be a real local secret."
         )
     if merged_output_capture:
-        return "Combined stdout/stderr looked credential-like before it reached Codex."
-    return "Requests a sensitive native tool action: credential-looking output reached Codex."
+        return f"Combined stdout/stderr looked credential-like before it reached {harness_label}."
+    return f"Requests a sensitive native tool action: credential-looking output reached {harness_label}."
 
 
 def _codex_tool_output_runtime_reason(
     local_secret_source: str | None,
     *,
+    harness_label: str = "Codex",
     merged_output_capture: bool = False,
     focused_pytest: bool = False,
 ) -> str:
     if local_secret_source is not None:
         return (
-            "Guard inspects supported Codex tool output before Codex uses it, so accidental secret reads can be "
+            f"Guard inspects supported {harness_label} tool output before {harness_label} uses it, "
+            "so accidental secret reads can be "
             "stopped even when the filename was not obviously sensitive."
         )
     if focused_pytest and merged_output_capture:
         return (
             "Guard stopped this pytest output because pytest executes repository-controlled code, and merging stderr "
-            "into stdout can forward real local secrets to Codex. If you only need the exit status, rerun without "
+            f"into stdout can forward real local secrets to {harness_label}. "
+            "If you only need the exit status, rerun without "
             "`2>&1` or keep stderr out of model-visible output."
         )
     if focused_pytest:
@@ -79,11 +87,13 @@ def _codex_tool_output_runtime_reason(
     if merged_output_capture:
         return (
             "Guard stopped this command shape because merging stderr into stdout can send credential-looking failure "
-            "output to Codex. If you only need the exit status, rerun without `2>&1` or keep stderr out of the "
+            f"output to {harness_label}. If you only need the exit status, rerun without `2>&1` or keep stderr out of "
+            "the "
             "model-visible output."
         )
     return (
-        "Guard inspects supported Codex tool output before Codex uses it, so accidental secret reads can be stopped "
+        f"Guard inspects supported {harness_label} tool output before {harness_label} uses it, "
+        "so accidental secret reads can be stopped "
         "even when the filename was not obviously sensitive."
     )
 

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/src/codex_plugin_scanner/guard/cli/commands_support_runtime_artifacts.py

@@ -169,10 +169,11 @@ def _hook_runtime_artifact(
 ) -> GuardArtifact | None:
     harness = _canonical_harness_name(harness)
     event_name = _hook_event_name(payload)
-    if harness == "codex" and event_name == "PostToolUse":
+    if harness in {"codex", "pi"} and event_name == "PostToolUse":
         output_artifact = _codex_post_tool_output_artifact(
+            harness=harness,
             payload=payload,
-            config_path=str(_runtime_policy_path(harness, home_dir, workspace)),
+            config_path=str(_runtime_policy_path(harness, home_dir, workspace, payload=payload)),
             source_scope=_coalesce_string(payload.get("source_scope"), "project"),
             cwd=workspace,
             home_dir=home_dir,
@@ -184,7 +185,7 @@ def _hook_runtime_artifact(
     if event_name == "UserPromptSubmit":
         prompt_text = payload.get("prompt")
         if isinstance(prompt_text, str) and prompt_text.strip():
-            config_path = str(_runtime_policy_path(harness, home_dir, workspace))
+            config_path = str(_runtime_policy_path(harness, home_dir, workspace, payload=payload))
             prompt_detection = HarnessDetection(
                 harness=harness,
                 installed=True,
@@ -231,7 +232,7 @@ def _hook_runtime_artifact(
             else None
         )
     source_scope = _coalesce_string(payload.get("source_scope"), "project")
-    config_path = str(_runtime_policy_path(harness, home_dir, workspace))
+    config_path = str(_runtime_policy_path(harness, home_dir, workspace, payload=payload))
     if request is not None:
         return build_file_read_request_artifact(
             harness=harness,
@@ -328,20 +329,34 @@ _CODEX_PROMPT_FILE_FINGERPRINT_LENGTH = 24
 
 def _codex_post_tool_output_artifact(
     *,
+    harness: str = "codex",
     payload: dict[str, object],
     config_path: str,
     source_scope: str,
     cwd: Path | None,
     home_dir: Path | None = None,
 ) -> GuardArtifact | None:
+    canonical_harness = _canonical_harness_name(harness)
+    harness_label = "Pi" if canonical_harness == "pi" else "Codex"
     response_text = _collect_codex_tool_response_text(payload.get("tool_response"))
+    stdout_text = _coalesce_string(payload.get("stdout"))
+    if stdout_text:
+        response_text = f"{response_text}\n{stdout_text}".strip() if response_text else stdout_text
     tool_name = _coalesce_string(payload.get("tool_name"), "Bash")
     command_text = _codex_post_tool_command_text(payload)
     if not command_text:
         command_text = tool_name
     local_source_matches = _codex_sensitive_local_source_matches(command_text, cwd=cwd)
-    references_local_content = bool(local_source_matches) or _codex_command_may_read_local_content(
-        command_text, cwd=cwd
+    sensitive_file_request = extract_sensitive_file_read_request(
+        payload.get("tool_name"),
+        payload.get("tool_input", payload.get("arguments")),
+        cwd=cwd,
+        home_dir=home_dir,
+    )
+    references_local_content = (
+        bool(local_source_matches)
+        or sensitive_file_request is not None
+        or _codex_command_may_read_local_content(command_text, cwd=cwd)
     )
     content_matches = classify_secret_content(response_text)
     if not content_matches and references_local_content:
@@ -387,7 +402,14 @@ def _codex_post_tool_output_artifact(
         if local_secret_source is not None:
             source_signal = f"command references local secrets from {local_secret_source}"
         runtime_request_signals.append(source_signal)
+    local_secret_source = _codex_local_secret_source_label(
+        local_source_matches,
+        command_text=command_text,
+    )
+    if local_secret_source is None and sensitive_file_request is not None:
+        local_secret_source = sensitive_file_request.path_match.family
     request_summary = _codex_tool_output_request_summary(
+        harness_label=harness_label,
         tool_name=tool_name,
         command_text=command_text,
         local_secret_source=local_secret_source,
@@ -396,6 +418,7 @@ def _codex_post_tool_output_artifact(
     )
     runtime_request_summary = _codex_tool_output_runtime_summary(
         local_secret_source,
+        harness_label=harness_label,
         focused_pytest=focused_pytest,
         merged_output_capture=merged_output_capture,
     )
@@ -411,6 +434,7 @@ def _codex_post_tool_output_artifact(
         "runtime_request_summary": runtime_request_summary,
         "runtime_request_reason": _codex_tool_output_runtime_reason(
             local_secret_source,
+            harness_label=harness_label,
             focused_pytest=focused_pytest,
             merged_output_capture=merged_output_capture,
         ),
@@ -420,9 +444,9 @@ def _codex_post_tool_output_artifact(
     if local_secret_source is not None:
         metadata["secret_source_family"] = local_secret_source
     return GuardArtifact(
-        artifact_id=f"codex:{source_scope}:tool-output:{fingerprint}",
+        artifact_id=f"{canonical_harness}:{source_scope}:tool-output:{fingerprint}",
         name=f"{tool_name} credential-looking output",
-        harness="codex",
+        harness=canonical_harness,
         artifact_type="tool_action_request",
         source_scope=source_scope,
         config_path=config_path,

{plugin_scanner-2.0.856 → plugin_scanner-2.0.858}/src/codex_plugin_scanner/guard/cli/commands_support_runtime_resolution.py

@@ -263,7 +263,37 @@ def _copilot_mcp_tool_token(value: str) -> str:
     token = re.sub(r"[^a-z0-9]+", "_", value.strip().lower())
     return token.strip("_")
 
-def _runtime_policy_path(harness: str, home_dir: Path, workspace: Path | None) -> Path:
+
+def _validated_pi_runtime_policy_override(
+    home_dir: Path,
+    workspace: Path | None,
+    payload: dict[str, object] | None,
+) -> Path | None:
+    raw_config_path = payload.get("config_path") if isinstance(payload, dict) else None
+    if not isinstance(raw_config_path, str) or not raw_config_path.strip():
+        return None
+    candidate = Path(raw_config_path).expanduser()
+    allowed_paths = {
+        home_dir / ".pi" / "agent" / "settings.json",
+        home_dir / ".omp" / "agent" / "settings.json",
+    }
+    if workspace is not None:
+        allowed_paths.update(
+            {
+                workspace / ".pi" / "settings.json",
+                workspace / ".omp" / "settings.json",
+            }
+        )
+    return candidate if candidate in allowed_paths else None
+
+
+def _runtime_policy_path(
+    harness: str,
+    home_dir: Path,
+    workspace: Path | None,
+    *,
+    payload: dict[str, object] | None = None,
+) -> Path:
     if harness == "hermes":
         return home_dir / ".hermes" / "config.yaml"
     if harness == "cursor":
@@ -278,6 +308,13 @@ def _runtime_policy_path(harness: str, home_dir: Path, workspace: Path | None) -
         if workspace is not None:
             return workspace / ".codex" / "config.toml"
         return home_dir / ".codex" / "config.toml"
+    if harness == "pi":
+        override_path = _validated_pi_runtime_policy_override(home_dir, workspace, payload)
+        if override_path is not None:
+            return override_path
+        if workspace is not None:
+            return workspace / ".pi" / "settings.json"
+        return home_dir / ".pi" / "agent" / "settings.json"
     if harness == "copilot":
         if workspace is not None:
             return workspace / ".github" / "hooks" / "hol-guard-copilot.json"