plugin-scanner 2.0.99__tar.gz → 2.0.101__tar.gz

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.99
+Version: 2.0.101
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/ai-plugin-scanner
 Project-URL: Repository, https://github.com/hashgraph-online/ai-plugin-scanner

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/pyproject.toml

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

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/pyproject.toml.bak

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

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/approvals.py

@@ -88,6 +88,7 @@ def queue_blocked_approvals(
             launch_summary=incident["launch_summary"],
             risk_headline=incident["risk_headline"],
             action_envelope_json=_item_action_envelope_json(item),
+            decision_v2_json=_item_decision_v2_json(item),
         )
         persisted_request_id = store.add_approval_request(request, timestamp)
         if persisted_request_id != request.request_id:
@@ -342,6 +343,13 @@ def _item_action_envelope_json(item: dict[str, object]) -> dict[str, object] | N
     return {str(key): item_value for key, item_value in value.items() if isinstance(key, str)}
 
 
+def _item_decision_v2_json(item: dict[str, object]) -> dict[str, object] | None:
+    value = item.get("decision_v2_json")
+    if not isinstance(value, Mapping):
+        return None
+    return {str(key): item_value for key, item_value in value.items() if isinstance(key, str)}
+
+
 def _string_list(value: object) -> list[str]:
     if not isinstance(value, list):
         return []

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/cli/commands.py

@@ -15,6 +15,7 @@ import sys
 import urllib.error
 import urllib.parse
 import webbrowser
+from collections.abc import Mapping
 from contextlib import suppress
 from dataclasses import replace
 from datetime import datetime, timedelta, timezone
@@ -3130,6 +3131,9 @@ def _native_prompt_context(artifact: GuardArtifact) -> str:
 
 
 def _runtime_artifact_native_reason(artifact: GuardArtifact, response_payload: dict[str, object]) -> str:
+    decision_message = _decision_v2_harness_message(response_payload)
+    if decision_message is not None:
+        return decision_message
     if artifact.artifact_type == "prompt_request":
         harness = response_payload.get("harness")
         prompt_classes = _prompt_request_classes(artifact)
@@ -3173,6 +3177,16 @@ def _runtime_artifact_native_reason(artifact: GuardArtifact, response_payload: d
     return "HOL Guard flagged this request for review."
 
 
+def _decision_v2_harness_message(response_payload: dict[str, object]) -> str | None:
+    decision_v2 = response_payload.get("decision_v2_json")
+    if not isinstance(decision_v2, Mapping):
+        return None
+    message = decision_v2.get("harness_message")
+    if isinstance(message, str) and message.strip():
+        return message.strip()
+    return None
+
+
 def _claude_prompt_additional_context(
     *,
     harness: str,

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/consumer/service.py

@@ -15,9 +15,10 @@ from ..capabilities import compute_capability_delta, normalize_artifact_capabili
 from ..config import GuardConfig
 from ..incident import build_incident_context
 from ..models import GuardArtifact, HarnessDetection, PolicyDecision
-from ..policy import decide_action
+from ..policy import build_decision_v2, decide_action
 from ..receipts import build_receipt
 from ..risk import artifact_risk_signals_typed, artifact_risk_summary, summarize_signals
+from ..runtime.signals import RiskSignalV2
 from ..schemas import build_consumer_mode_contract
 from ..store import GuardStore
 from ..types import (
@@ -384,6 +385,7 @@ def evaluate_detection(
         current_capabilities = normalize_artifact_capabilities(artifact)
         capability_delta = compute_capability_delta(previous_capabilities, current_capabilities)
         structured_signals = artifact_risk_signals_typed(artifact)
+        risk_signals_v2 = tuple(RiskSignalV2.from_guard_signal(signal) for signal in structured_signals)
         history_context = build_history_context(store, detection.harness, artifact.artifact_id, artifact.publisher)
         provenance_bundle = build_provenance_bundle(store, artifact.publisher)
         verdict = score_verdict(structured_signals, capability_delta, provenance_bundle, history_context)
@@ -405,6 +407,7 @@ def evaluate_detection(
             )
         if _is_blocking_action(policy_action):
             blocked = True
+        decision_v2 = build_decision_v2(policy_action, reason=policy_action, signals=risk_signals_v2)
         risk_signals = tuple(signal.explanation for signal in structured_signals)
         risk_summary = artifact_risk_summary(artifact) if structured_signals else summarize_signals(())
         changed_capabilities = [delta.delta_type for delta in capability_delta] or list(diff["changed_fields"])
@@ -495,6 +498,7 @@ def evaluate_detection(
                 "changed": diff["changed"],
                 "changed_fields": diff["changed_fields"],
                 "policy_action": policy_action,
+                "decision_v2_json": decision_v2.to_dict(),
                 "artifact_hash": diff["current_hash"],
                 "risk_signals": list(risk_signals),
                 "risk_summary": risk_summary,
@@ -536,6 +540,7 @@ def evaluate_detection(
         )
         if _is_blocking_action(policy_action):
             blocked = True
+        decision_v2 = build_decision_v2(policy_action, reason=policy_action)
         artifact_name = previous.get("name")
         source_scope = previous.get("source_scope")
         config_path = previous.get("config_path")
@@ -605,6 +610,7 @@ def evaluate_detection(
                 "changed": True,
                 "changed_fields": ["removed"],
                 "policy_action": policy_action,
+                "decision_v2_json": decision_v2.to_dict(),
                 "artifact_hash": previous_hash,
                 "removed": True,
                 "risk_signals": ["artifact removed from local harness configuration"],

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/models.py

@@ -179,6 +179,7 @@ class GuardApprovalRequest:
     launch_summary: str | None = None
     risk_headline: str | None = None
     action_envelope_json: dict[str, object] | None = None
+    decision_v2_json: dict[str, object] | None = None
 
     def to_dict(self) -> dict[str, object]:
         payload = asdict(self)

plugin_scanner-2.0.101/src/codex_plugin_scanner/guard/policy/__init__.py

@@ -0,0 +1,5 @@
+"""Guard policy helpers."""
+
+from .engine import build_decision_v2, decide_action, decide_action_with_v2
+
+__all__ = ["build_decision_v2", "decide_action", "decide_action_with_v2"]

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/policy/engine.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
+
 from ..config import GuardConfig
 from ..models import GuardAction
+from ..runtime.decisions import GuardDecisionV2, decision_from_legacy_policy_action
+from ..runtime.signals import RiskSignalV2
 
 VALID_GUARD_ACTIONS = {"allow", "warn", "review", "block", "sandbox-required", "require-reapproval"}
 SAFE_CHANGED_HASH_ACTION: GuardAction = "require-reapproval"
@@ -29,3 +33,30 @@ def decide_action(
     if config.default_action in VALID_GUARD_ACTIONS:
         return config.default_action
     return SAFE_DEFAULT_ACTION
+
+
+def build_decision_v2(
+    policy_action: GuardAction,
+    *,
+    reason: str,
+    signals: Sequence[RiskSignalV2] = (),
+) -> GuardDecisionV2:
+    return decision_from_legacy_policy_action(policy_action, reason=reason, signals=signals)
+
+
+def decide_action_with_v2(
+    configured_action: str | None,
+    default_action: str | None,
+    config: GuardConfig,
+    changed: bool,
+    *,
+    reason: str,
+    signals: Sequence[RiskSignalV2] = (),
+) -> tuple[GuardAction, GuardDecisionV2]:
+    action = decide_action(
+        configured_action=configured_action,
+        default_action=default_action,
+        config=config,
+        changed=changed,
+    )
+    return action, build_decision_v2(action, reason=reason, signals=signals)

plugin_scanner-2.0.101/src/codex_plugin_scanner/guard/runtime/decisions.py

@@ -0,0 +1,211 @@
+"""Typed runtime decisions for Guard pause and approval UX."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Literal
+
+from codex_plugin_scanner.guard.models import GuardAction
+from codex_plugin_scanner.guard.runtime.signals import (
+    RiskConfidenceLabel,
+    RiskSignalV2,
+)
+
+GuardDecisionAction = Literal["allow", "warn", "ask", "block"]
+
+_ACTION_MESSAGES: dict[GuardAction, tuple[GuardDecisionAction, str, str, str]] = {
+    "allow": (
+        "allow",
+        "Allowed by policy",
+        "Policy allows this action.",
+        "HOL Guard allowed this action because policy already trusts it.",
+    ),
+    "warn": (
+        "warn",
+        "Risk signals found",
+        "HOL Guard noticed risk signals, but policy allows the harness to continue.",
+        "Review the warning if this action was unexpected.",
+    ),
+    "review": (
+        "ask",
+        "Approval required",
+        "HOL Guard needs your approval before this action can run.",
+        "Choose an approval scope, then retry in the harness.",
+    ),
+    "sandbox-required": (
+        "ask",
+        "Sandbox review required",
+        "HOL Guard wants this action reviewed and run in a sandboxed path.",
+        "Run it in a sandbox or choose a scoped approval before retrying.",
+    ),
+    "require-reapproval": (
+        "ask",
+        "Fresh approval required",
+        "HOL Guard needs a fresh approval because this action changed.",
+        "Choose the smallest approval scope that matches your intent, then retry.",
+    ),
+    "block": (
+        "block",
+        "Blocked by policy",
+        "HOL Guard blocked this action.",
+        "Review the details before changing policy or retrying.",
+    ),
+}
+
+
+@dataclass(frozen=True, slots=True)
+class GuardDecisionV2:
+    """Product-facing Guard decision with harness and dashboard copy."""
+
+    action: GuardDecisionAction
+    reason: str
+    user_title: str
+    user_body: str
+    harness_message: str
+    dashboard_primary_detail: str
+    approval_scopes: tuple[str, ...]
+    retry_instruction: str | None
+    signals: tuple[RiskSignalV2, ...]
+    confidence: RiskConfidenceLabel
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "action": self.action,
+            "reason": self.reason,
+            "user_title": self.user_title,
+            "user_body": self.user_body,
+            "harness_message": self.harness_message,
+            "dashboard_primary_detail": self.dashboard_primary_detail,
+            "approval_scopes": list(self.approval_scopes),
+            "retry_instruction": self.retry_instruction,
+            "signals": [signal.to_dict() for signal in self.signals],
+            "confidence": self.confidence,
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, object]) -> GuardDecisionV2:
+        return cls(
+            action=_parse_action(payload.get("action")),
+            reason=_required_string(payload, "reason"),
+            user_title=_required_string(payload, "user_title"),
+            user_body=_required_string(payload, "user_body"),
+            harness_message=_required_string(payload, "harness_message"),
+            dashboard_primary_detail=_required_string(payload, "dashboard_primary_detail"),
+            approval_scopes=_parse_string_tuple(payload.get("approval_scopes"), "approval_scopes"),
+            retry_instruction=_optional_string(payload, "retry_instruction"),
+            signals=_parse_signals(payload.get("signals")),
+            confidence=_parse_confidence(payload.get("confidence")),
+        )
+
+
+def decision_from_legacy_policy_action(
+    policy_action: GuardAction,
+    *,
+    reason: str,
+    signals: Sequence[RiskSignalV2] = (),
+) -> GuardDecisionV2:
+    action, user_title, harness_message, retry_instruction = _ACTION_MESSAGES[policy_action]
+    signal_tuple = tuple(signals)
+    confidence = _highest_confidence(signal_tuple)
+    dashboard_detail = _dashboard_detail_from_signals(signal_tuple, harness_message)
+    return GuardDecisionV2(
+        action=action,
+        reason=reason,
+        user_title=user_title,
+        user_body=dashboard_detail,
+        harness_message=harness_message,
+        dashboard_primary_detail=dashboard_detail,
+        approval_scopes=_approval_scopes_for_action(action),
+        retry_instruction=None if action in {"allow", "warn"} else retry_instruction,
+        signals=signal_tuple,
+        confidence=confidence,
+    )
+
+
+def _approval_scopes_for_action(action: GuardDecisionAction) -> tuple[str, ...]:
+    if action != "ask":
+        return ()
+    return ("artifact", "workspace", "publisher", "harness")
+
+
+def _dashboard_detail_from_signals(signals: tuple[RiskSignalV2, ...], fallback: str) -> str:
+    if not signals:
+        return fallback
+    strongest = max(signals, key=lambda item: _confidence_rank(item.confidence))
+    return strongest.plain_reason
+
+
+def _highest_confidence(signals: tuple[RiskSignalV2, ...]) -> RiskConfidenceLabel:
+    if not signals:
+        return "likely"
+    return max((signal.confidence for signal in signals), key=_confidence_rank)
+
+
+def _confidence_rank(confidence: RiskConfidenceLabel) -> int:
+    match confidence:
+        case "strong":
+            return 3
+        case "likely":
+            return 2
+        case "weak":
+            return 1
+
+
+def _parse_action(value: object) -> GuardDecisionAction:
+    match value:
+        case "allow":
+            return "allow"
+        case "warn":
+            return "warn"
+        case "ask":
+            return "ask"
+        case "block":
+            return "block"
+        case _:
+            raise ValueError("action must be a known Guard decision action")
+
+
+def _parse_confidence(value: object) -> RiskConfidenceLabel:
+    match value:
+        case "weak":
+            return "weak"
+        case "likely":
+            return "likely"
+        case "strong":
+            return "strong"
+        case _:
+            raise ValueError("confidence must be a known confidence label")
+
+
+def _parse_signals(value: object) -> tuple[RiskSignalV2, ...]:
+    if not isinstance(value, list):
+        raise ValueError("signals must be a list")
+    signals: list[RiskSignalV2] = []
+    for item in value:
+        if not isinstance(item, Mapping):
+            raise ValueError(f"signal item must be an object, got {type(item).__name__}")
+        signals.append(RiskSignalV2.from_dict(item))
+    return tuple(signals)
+
+
+def _parse_string_tuple(value: object, key: str) -> tuple[str, ...]:
+    if not isinstance(value, list) or not all(isinstance(item, str) and item.strip() for item in value):
+        raise ValueError(f"{key} must be a list of non-empty strings")
+    return tuple(value)
+
+
+def _required_string(payload: Mapping[str, object], key: str) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{key} must be a non-empty string")
+    return value
+
+
+def _optional_string(payload: Mapping[str, object], key: str) -> str | None:
+    value = payload.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError(f"{key} must be a string or null")
+    return value

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/store.py

@@ -667,6 +667,7 @@ class GuardStore:
             self._ensure_approval_column(connection, "launch_summary", "text")
             self._ensure_approval_column(connection, "risk_headline", "text")
             self._ensure_approval_column(connection, "action_envelope_json", "text")
+            self._ensure_approval_column(connection, "decision_v2_json", "text")
             self._ensure_approval_column(connection, "workspace", "text")
             self._ensure_attachment_column(connection, "lease_id", "text not null default ''")
             self._ensure_attachment_column(connection, "lease_expires_at", "text")

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/guard/store_approvals.py

@@ -34,8 +34,9 @@ def approval_schema_statement() -> str:
            why_now text,
            launch_summary text,
            risk_headline text,
-           action_envelope_json text,
-           review_command text not null,
+            action_envelope_json text,
+            decision_v2_json text,
+            review_command text not null,
            approval_url text not null,
           status text not null,
           resolution_action text,
@@ -69,7 +70,7 @@ def add_approval_request(connection: sqlite3.Connection, request: GuardApprovalR
                 recommended_scope = ?, changed_fields_json = ?, source_scope = ?, config_path = ?, workspace = ?,
                 launch_target = ?, transport = ?, risk_summary = ?, risk_signals_json = ?,
                 artifact_label = ?, source_label = ?, trigger_summary = ?, why_now = ?, launch_summary = ?,
-                risk_headline = ?, action_envelope_json = ?,
+                risk_headline = ?, action_envelope_json = ?, decision_v2_json = ?,
                 review_command = ?, approval_url = ?, created_at = ?
             where request_id = ?
             """,
@@ -95,6 +96,7 @@ def add_approval_request(connection: sqlite3.Connection, request: GuardApprovalR
                 request.launch_summary,
                 request.risk_headline,
                 json.dumps(request.action_envelope_json) if request.action_envelope_json is not None else None,
+                json.dumps(request.decision_v2_json) if request.decision_v2_json is not None else None,
                 review_command,
                 approval_url,
                 now,
@@ -109,10 +111,10 @@ def add_approval_request(connection: sqlite3.Connection, request: GuardApprovalR
           recommended_scope, changed_fields_json, source_scope, config_path, workspace,
            launch_target, transport, risk_summary,
            risk_signals_json, artifact_label, source_label, trigger_summary, why_now, launch_summary, risk_headline,
-           action_envelope_json, review_command,
-           approval_url, status, resolution_action, resolution_scope, reason, created_at, resolved_at
-         )
-         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            action_envelope_json, decision_v2_json, review_command,
+            approval_url, status, resolution_action, resolution_scope, reason, created_at, resolved_at
+          )
+          values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             request.request_id,
@@ -139,6 +141,7 @@ def add_approval_request(connection: sqlite3.Connection, request: GuardApprovalR
             request.launch_summary,
             request.risk_headline,
             json.dumps(request.action_envelope_json) if request.action_envelope_json is not None else None,
+            json.dumps(request.decision_v2_json) if request.decision_v2_json is not None else None,
             request.review_command,
             request.approval_url,
             "pending",
@@ -186,7 +189,7 @@ def list_approval_requests(
         select request_id, harness, artifact_id, artifact_name, artifact_type, artifact_hash, publisher, policy_action,
                recommended_scope, changed_fields_json, source_scope, config_path, workspace, launch_target, transport,
                 risk_summary, risk_signals_json, artifact_label, source_label, trigger_summary, why_now,
-                launch_summary, risk_headline, action_envelope_json, review_command,
+                launch_summary, risk_headline, action_envelope_json, decision_v2_json, review_command,
                 approval_url, status, resolution_action, resolution_scope, reason, created_at, resolved_at
         from approval_requests
         {where_clause}
@@ -205,7 +208,7 @@ def get_approval_request(connection: sqlite3.Connection, request_id: str) -> dic
         select request_id, harness, artifact_id, artifact_name, artifact_type, artifact_hash, publisher, policy_action,
                recommended_scope, changed_fields_json, source_scope, config_path, workspace, launch_target, transport,
                 risk_summary, risk_signals_json, artifact_label, source_label, trigger_summary, why_now,
-                launch_summary, risk_headline, action_envelope_json, review_command,
+                launch_summary, risk_headline, action_envelope_json, decision_v2_json, review_command,
                 approval_url, status, resolution_action, resolution_scope, reason, created_at, resolved_at
         from approval_requests
         where request_id = ?
@@ -277,6 +280,7 @@ def _row_to_payload(row: sqlite3.Row) -> dict[str, object]:
         "launch_summary": row["launch_summary"],
         "risk_headline": row["risk_headline"],
         "action_envelope_json": _optional_json_object(row["action_envelope_json"]),
+        "decision_v2_json": _optional_json_object(row["decision_v2_json"]),
         "review_command": str(row["review_command"]),
         "approval_url": str(row["approval_url"]),
         "status": str(row["status"]),

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.99 → plugin_scanner-2.0.101}/tests/test_guard_approvals.py

@@ -90,6 +90,18 @@ class TestGuardApprovals:
             "script_name": None,
             "raw_payload_redacted": {"tool_name": "Bash"},
         }
+        decision_v2_json = {
+            "action": "ask",
+            "reason": "require-reapproval",
+            "user_title": "Review workspace_skill",
+            "user_body": "HOL Guard needs approval before this action continues.",
+            "harness_message": "HOL Guard paused this action for approval.",
+            "dashboard_primary_detail": "Shell command can read a local secret file.",
+            "approval_scopes": ["artifact", "workspace"],
+            "retry_instruction": "Approve it in HOL Guard, then retry.",
+            "signals": [],
+            "confidence": "likely",
+        }
         request = GuardApprovalRequest(
             request_id="req-123",
             harness="codex",
@@ -105,6 +117,7 @@ class TestGuardApprovals:
             review_command="hol-guard approvals approve req-123",
             approval_url="http://127.0.0.1:4455/approvals/req-123",
             action_envelope_json=action_envelope_json,
+            decision_v2_json=decision_v2_json,
         )
 
         store.add_approval_request(request, "2026-04-11T00:00:00+00:00")
@@ -122,11 +135,13 @@ class TestGuardApprovals:
         assert pending[0]["approval_url"] == "http://127.0.0.1:4455/approvals/req-123"
         assert pending[0]["workspace"] == str(workspace_dir)
         assert pending[0]["action_envelope_json"] == action_envelope_json
+        assert pending[0]["decision_v2_json"] == decision_v2_json
         assert resolved is not None
         assert resolved["status"] == "resolved"
         assert resolved["resolution_action"] == "allow"
         assert resolved["resolution_scope"] == "artifact"
         assert resolved["action_envelope_json"] == action_envelope_json
+        assert resolved["decision_v2_json"] == decision_v2_json
 
     def test_guard_store_loads_old_approval_rows_without_action_envelope(self, tmp_path):
         guard_home = tmp_path / "guard-home"
@@ -225,8 +240,9 @@ class TestGuardApprovals:
         assert request is not None
         assert request["request_id"] == "req-old"
         assert request["action_envelope_json"] is None
+        assert request["decision_v2_json"] is None
 
-    def test_guard_store_ignores_malformed_action_envelope_json(self, tmp_path):
+    def test_guard_store_ignores_malformed_action_and_decision_json(self, tmp_path):
         store = GuardStore(tmp_path / "guard-home")
         connection = sqlite3.connect(store.path)
         try:
@@ -236,10 +252,13 @@ class TestGuardApprovals:
                   request_id, harness, artifact_id, artifact_name, artifact_type, artifact_hash, publisher,
                   policy_action, recommended_scope, changed_fields_json, source_scope, config_path, workspace,
                   launch_target, transport, risk_summary, risk_signals_json, artifact_label, source_label,
-                  trigger_summary, why_now, launch_summary, risk_headline, action_envelope_json, review_command,
+                  trigger_summary, why_now, launch_summary, risk_headline, action_envelope_json, decision_v2_json,
+                  review_command,
                   approval_url, status, resolution_action, resolution_scope, reason, created_at, resolved_at
                 )
-                values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                values (
+                  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+                )
                 """,
                 (
                     "req-bad-envelope",
@@ -266,6 +285,7 @@ class TestGuardApprovals:
                     None,
                     None,
                     "{not-json",
+                    "{also-not-json",
                     "hol-guard approvals approve req-bad-envelope",
                     "http://127.0.0.1/pending",
                     "pending",
@@ -284,6 +304,7 @@ class TestGuardApprovals:
 
         assert request is not None
         assert request["action_envelope_json"] is None
+        assert request["decision_v2_json"] is None
 
     def test_guard_surface_daemon_client_recovers_missing_auth_token(self, tmp_path, monkeypatch):
         guard_home = tmp_path / "guard-home"
@@ -1960,6 +1981,11 @@ class TestGuardApprovals:
         assert output["approval_center_url"].startswith("http://127.0.0.1:")
         assert approvals[0]["harness"] == "codex"
         assert approvals[0]["status"] == "pending"
+        assert approvals[0]["decision_v2_json"]["action"] == "ask"
+        assert (
+            approvals[0]["decision_v2_json"]["harness_message"]
+            == "HOL Guard needs a fresh approval because this action changed."
+        )
 
     def test_guard_approvals_cli_lists_and_resolves_requests(self, tmp_path, capsys):
         home_dir = tmp_path / "home"