iris-security-cli 0.1.9__tar.gz → 0.2.1__tar.gz

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-security-cli
-Version: 0.1.9
+Version: 0.2.1
 Summary: IRIS CLI — declare, compile, preview, enforce, witness, certify, sentinel
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/gimartinb/iris-sdk
@@ -15,8 +15,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: iris-security-core>=0.1.7
-Requires-Dist: iris-security-sdk>=0.1.9
+Requires-Dist: iris-security-core>=0.1.9
+Requires-Dist: iris-security-sdk>=0.2.1
 Requires-Dist: click>=8.1
 Requires-Dist: rich>=13.0
 Requires-Dist: pyyaml>=6.0

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_cli/certify.py

@@ -99,6 +99,55 @@ def certify_cmd(framework: str, agent_name: str, output_format: str) -> None:
     else:
         _render_certification_header(framework, agent_name, result)
         _render_table(result, has_pro)
+        _render_response_configuration(framework, passport)
+
+
+def _render_response_configuration(framework: str, passport: AgentPassport) -> None:
+    from iris_core.compliance.framework_check import load_bundle_data
+    from iris_core.compliance.violation_response import (
+        get_effective_response,
+        rule_response_label,
+        ViolationResponse,
+    )
+
+    try:
+        bundle = load_bundle_data(framework)
+    except ValueError:
+        return
+    rules = bundle.get("rules", [])
+    if not rules:
+        return
+
+    console.print("\n[bold]RESPONSE CONFIGURATION[/bold]")
+    console.print("─" * 65)
+    overrides = passport.compliance_response_overrides or {}
+    for rule in rules:
+        rule_id = rule.get("rule_id", "")
+        default = rule.get("violation_response", "inform").upper()
+        effective = rule_response_label(rule, overrides)
+        line = f"{rule_id:<12} {effective:<8}"
+        if rule.get("violation_response"):
+            base = ViolationResponse(rule["violation_response"])
+            if base == ViolationResponse.BLOCK:
+                line += " (unconditional — cannot be overridden)"
+            elif effective != default:
+                line += f" (override active)"
+            else:
+                line += " (default)"
+        console.print(line)
+
+    if overrides:
+        console.print("\n[dim]Active overrides in passport.yaml:[/dim]")
+        for rule_id, cfg in overrides.items():
+            console.print(f"  {rule_id}: {cfg.get('response', 'inform')} — {cfg.get('reason', '')}")
+    else:
+        console.print(
+            "\n[dim]Override example (add to passport.yaml if needed):[/dim]\n"
+            "  compliance_response_overrides:\n"
+            "    CO-003:\n"
+            "      response: inform\n"
+            "      reason: Pre-production — not serving CO consumers yet"
+        )
 
 
 # Legacy alias: iris test → iris certify

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_cli/compliance_check_cmd.py

@@ -8,6 +8,7 @@ from typing import Optional
 
 import click
 from rich.console import Console
+from rich.table import Table
 
 from iris import AgentPassport
 from iris_core.compliance.framework_check import run_framework_check
@@ -66,25 +67,37 @@ def _render_result(
     status = "[bold green]PASS[/bold green]" if not has_failures else "[bold red]FAIL[/bold red]"
     console.print(f"\nAgent: [cyan]{passport.name}[/cyan] — {status}")
 
+    if result.rule_results:
+        table = Table(title=f"{result.framework_name}", show_header=True, header_style="bold")
+        table.add_column("Rule", style="cyan")
+        table.add_column("Severity")
+        table.add_column("Status")
+        table.add_column("Response")
+        table.add_column("Notes")
+        for rule in result.rule_results:
+            status_icon = "[green]✓ PASS[/green]" if rule.status == "PASS" else "[red]✗ FAIL[/red]"
+            notes = rule.message if rule.status == "FAIL" else ""
+            table.add_row(
+                rule.rule_id,
+                rule.severity,
+                status_icon,
+                rule.response,
+                notes[:80] + ("..." if len(notes) > 80 else ""),
+            )
+        console.print(table)
+        console.print(
+            "\n[dim]RESPONSE KEY: INFORM — log and proceed | "
+            "HITL — human review required | BLOCK — unconditional block[/dim]"
+        )
+
     if result.violations:
         for violation in result.violations:
+            if any(r.rule_id == violation.rule_id for r in result.rule_results):
+                continue
             console.print(f"  [red]✗[/red] [{violation.rule_id}] {violation.message}")
             if violation.remediation:
                 console.print(f"     [yellow]→[/yellow] {violation.remediation}")
 
-    shown_ids = {v.rule_id for v in result.violations}
-    for rule in result.rule_results:
-        if rule.rule_id in shown_ids:
-            continue
-        if rule.status == "PASS":
-            console.print(f"  [green]✓[/green] [{rule.rule_id}] {rule.name}")
-        elif rule.status == "FAIL":
-            console.print(f"  [red]✗[/red] [{rule.rule_id}] {rule.name}")
-            if rule.message:
-                console.print(f"     {rule.message}")
-            if rule.remediation:
-                console.print(f"     [yellow]→[/yellow] {rule.remediation}")
-
     if not result.violations and not any(r.status == "FAIL" for r in result.rule_results):
         console.print(f"  [green]✓[/green] All {framework} rules satisfied")
 

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_cli/framework_suggest.py

@@ -267,6 +267,21 @@ def build_recommendations(answers: dict[str, Any]) -> list[Recommendation]:
     soc2 = q2 == Q2_CHOICES[5] or "SOC 2 (SaaS / enterprise)" in q7
     gdpr = "Outside the US" in q8 or "Other / multiple states" in q8
 
+    ccpa_admt = (
+        "California" in q8
+        and q5
+        and (
+            q1 == Q1_CHOICES[0]
+            or q2 in {Q2_CHOICES[2], Q2_CHOICES[3]}
+        )
+    )
+    china_pipl = (
+        "Outside the US" in q8
+        or "china" in agent_description
+        or "asia" in agent_description
+        or (q2 == Q2_CHOICES[4] and "Outside the US" in q8)
+    )
+
     colorado_reason = (
         "Your agent makes consequential decisions for Colorado users. "
         "SB 26-189 applies (replaces SB 24-205, effective Jan. 1, 2027). "
@@ -378,6 +393,32 @@ def build_recommendations(answers: dict[str, Any]) -> list[Recommendation]:
             ),
             command="iris test --framework gdpr" if gdpr else None,
         ),
+        Recommendation(
+            framework="ccpa-admt",
+            tier="PRO",
+            status="REQUIRED" if ccpa_admt else "NOT APPLICABLE",
+            reason=(
+                "California ADMT regulations (effective Jan. 1, 2026) apply to "
+                "automated decisions affecting California consumers in employment, "
+                "credit, healthcare, housing, or education."
+                if ccpa_admt
+                else "No California ADMT scope detected."
+            ),
+            command="iris compliance check --framework ccpa-admt" if ccpa_admt else None,
+        ),
+        Recommendation(
+            framework="china-pipl",
+            tier="PRO",
+            status="REQUIRED" if china_pipl else "NOT APPLICABLE",
+            reason=(
+                "China PIPL applies when processing personal information of "
+                "individuals located in China, including automated decision-making "
+                "and cross-border transfer restrictions."
+                if china_pipl
+                else "No China or Asia-Pacific user footprint detected."
+            ),
+            command="iris compliance check --framework china-pipl" if china_pipl else None,
+        ),
     ]
     return recommendations
 

iris_security_cli-0.2.1/iris_cli/hitl.py

@@ -0,0 +1,303 @@
+"""iris hitl — human-in-the-loop review commands."""
+
+from __future__ import annotations
+
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import click
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from iris import AgentPassport
+from iris_core.hitl.models import HITLConfig, HITLConditionRule, HITLStatus
+from iris_core.hitl.notifier import HITLNotifier
+from iris_core.hitl.queue import HITLQueue
+
+console = Console()
+
+
+def _reviewer() -> str:
+    return os.environ.get("IRIS_USER_EMAIL", "local-reviewer")
+
+
+def _gov_dir() -> Path:
+    return Path.cwd() / "governance" / "agents"
+
+
+def _load_passport(agent: str) -> AgentPassport:
+    path = _gov_dir() / agent / "passport.yaml"
+    if not path.exists():
+        raise click.ClickException(f"No passport found for agent '{agent}' at {path}")
+    return AgentPassport.from_yaml(path.read_text())
+
+
+def _save_hitl_config(agent: str, config: HITLConfig) -> Path:
+    path = _gov_dir() / agent / "passport.yaml"
+    data = yaml.safe_load(path.read_text())
+    data.setdefault("spec", {})["hitl"] = config.to_dict()
+    path.write_text(yaml.dump(data, default_flow_style=False, sort_keys=False))
+    return path
+
+
+def _time_remaining(expires_at: str) -> str:
+    try:
+        expiry = datetime.fromisoformat(expires_at.replace("Z", ""))
+        delta = expiry - datetime.utcnow()
+        seconds = int(delta.total_seconds())
+        if seconds <= 0:
+            return "expired"
+        minutes, secs = divmod(seconds, 60)
+        return f"{minutes}m {secs}s"
+    except ValueError:
+        return "unknown"
+
+
+@click.group()
+def hitl():
+    """Human-in-the-loop review commands."""
+    pass
+
+
+@hitl.command("list")
+@click.option("--agent", default=None, help="Filter by agent name")
+@click.option("--status", default="pending", type=click.Choice(["pending", "all"]))
+def hitl_list(agent: Optional[str], status: str):
+    """List pending HITL reviews."""
+    queue = HITLQueue()
+    if status == "pending":
+        reviews = queue.list_pending(agent_name=agent)
+    else:
+        reviews = queue.list_all(agent_name=agent)
+
+    console.print(
+        "┌─ IRIS Pending Reviews ────────────────────────────────────────┐"
+    )
+    console.print(
+        f"│ {len(reviews)} review(s) awaiting human decision"
+        f"{' ' * max(0, 44 - len(str(len(reviews))))}│"
+    )
+    console.print(
+        "└───────────────────────────────────────────────────────────────┘"
+    )
+
+    if not reviews:
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("ID")
+    table.add_column("Agent")
+    table.add_column("Risk")
+    table.add_column("Action")
+    table.add_column("Expires")
+    for review in reviews:
+        table.add_row(
+            review.review_id[:14],
+            review.agent_name[:20],
+            review.risk_level,
+            f"{review.tool_name[:12]}-{review.action[:8]}",
+            _time_remaining(review.expires_at),
+        )
+    console.print(table)
+
+
+@hitl.command("approve")
+@click.argument("review_id")
+@click.option("--note", default=None, help="Approval reason")
+def hitl_approve(review_id: str, note: Optional[str]):
+    """Approve a pending review."""
+    queue = HITLQueue()
+    reviewer = _reviewer()
+    review = queue.resolve(review_id, HITLStatus.APPROVED, reviewer, reviewer_note=note)
+    console.print(f"[green]✓[/green] Review {review_id} approved by {reviewer}")
+    if note:
+        console.print(f"  Note: \"{note}\"")
+    if review.approval_token:
+        console.print(f"  Approval token: {review.approval_token[:32]}...")
+    console.print("  Logged to Evidence Vault.")
+    console.print("  The waiting agent call will now proceed.")
+
+
+@hitl.command("reject")
+@click.argument("review_id")
+@click.option("--reason", default=None, help="Rejection reason")
+def hitl_reject(review_id: str, reason: Optional[str]):
+    """Reject a pending review."""
+    queue = HITLQueue()
+    reviewer = _reviewer()
+    queue.resolve(review_id, HITLStatus.REJECTED, reviewer, reviewer_note=reason)
+    console.print(f"[red]✗[/red] Review {review_id} rejected by {reviewer}")
+    if reason:
+        console.print(f"  Reason: \"{reason}\"")
+    console.print("  The waiting agent call will raise IrisViolationError.")
+    console.print("  Logged to Evidence Vault.")
+
+
+@hitl.command("escalate")
+@click.argument("review_id")
+@click.option("--to", "escalate_to", default=None, help="Escalate to email")
+@click.option("--note", default=None, help="Escalation reason")
+def hitl_escalate(review_id: str, escalate_to: Optional[str], note: Optional[str]):
+    """Escalate a review to a senior reviewer."""
+    queue = HITLQueue()
+    reviewer = _reviewer()
+    review = queue.resolve(
+        review_id,
+        HITLStatus.ESCALATED,
+        reviewer,
+        reviewer_note=note or f"Escalated to {escalate_to or 'senior reviewer'}",
+    )
+    console.print(f"[yellow]⬆[/yellow] Review {review_id} escalated by {reviewer}")
+    if note:
+        console.print(f"  Note: \"{note}\"")
+
+
+@hitl.command("show")
+@click.argument("review_id")
+def hitl_show(review_id: str):
+    """Show full detail for a review."""
+    queue = HITLQueue()
+    review = queue.get(review_id)
+    if not review:
+        raise click.ClickException(f"Review not found: {review_id}")
+    for key, value in review.to_dict().items():
+        console.print(f"[bold]{key}:[/bold] {value}")
+
+
+@hitl.command("config")
+@click.option("--agent", required=True)
+def hitl_config(agent: str):
+    """Show HITL configuration for an agent."""
+    passport = _load_passport(agent)
+    config = passport.hitl_config or HITLConfig()
+    console.print(f"HITL for [cyan]{agent}[/cyan]: enabled={config.enabled}")
+    console.print(f"  Timeout: {config.timeout_seconds}s · Policy: {config.timeout_policy}")
+    console.print(f"  Condition rules: {len(config.condition_rules)}")
+
+
+@hitl.command("setup")
+@click.option("--agent", required=True)
+def hitl_setup(agent: str):
+    """Interactive wizard to configure HITL for an agent."""
+    passport = _load_passport(agent)
+    config = passport.hitl_config or HITLConfig()
+
+    enabled = click.confirm(f"Enable HITL for {agent}?", default=True)
+    config.enabled = enabled
+    config.timeout_seconds = click.prompt("Timeout if no response (seconds)", default=300, type=int)
+    config.timeout_policy = click.prompt(
+        "On timeout — deny or approve?",
+        default="deny",
+        type=click.Choice(["deny", "approve", "escalate"]),
+    )
+    config.escalation_seconds = click.prompt(
+        "Escalate after how many seconds?", default=180, type=int
+    )
+
+    console.print(
+        "\nDeclare which specific actions require human review.\n"
+        "HITL only fires when one of these rules matches.\n"
+    )
+    rules: list[HITLConditionRule] = []
+    while click.confirm("Add a condition rule?", default=len(rules) == 0):
+        condition = click.prompt("Condition (e.g. loan_amount > 50000)")
+        reason = click.prompt("Reason shown to reviewer")
+        channel = click.prompt(
+            "Notification channel",
+            default="all",
+            type=click.Choice(["slack", "email", "pagerduty", "all"]),
+        )
+        rules.append(HITLConditionRule(condition=condition, reason=reason, notify_channel=channel))
+    config.condition_rules = rules
+
+    if click.confirm("Configure Slack webhook URL (Pro)?", default=False):
+        config.slack_webhook_url = click.prompt("Slack webhook URL", default="")
+    if click.confirm("Configure email recipients (Pro)?", default=False):
+        emails = click.prompt("Email recipients (comma-separated)", default="")
+        config.email_recipients = [e.strip() for e in emails.split(",") if e.strip()]
+
+    path = _save_hitl_config(agent, config)
+    console.print(f"[green]✓[/green] HITL configured for {agent}")
+    console.print(f"[green]✓[/green] {len(rules)} condition rule(s) declared")
+    console.print("[green]✓[/green] HITL fires ONLY when a declared rule matches")
+    console.print(f"[green]✓[/green] Saved to {path}")
+
+
+@hitl.command("rules")
+@click.option("--agent", required=True)
+def hitl_rules(agent: str):
+    """Show what will and will not trigger HITL."""
+    passport = _load_passport(agent)
+    config = passport.hitl_config or HITLConfig()
+    console.print(f"┌─ HITL Rules — {agent} ──────────────────────────┐")
+    console.print(
+        f"│ Status: {'enabled' if config.enabled else 'disabled'} · "
+        f"Timeout: {config.timeout_seconds}s · On timeout: {config.timeout_policy}          │"
+    )
+    console.print("└───────────────────────────────────────────────────────────────┘")
+
+    if config.condition_rules:
+        console.print(f"\nWILL trigger HITL — declared condition rules ({len(config.condition_rules)}):")
+        for rule in config.condition_rules:
+            console.print(f"\n● {rule.condition}")
+            console.print(f"  Reason: {rule.reason}")
+            console.print(f"  Channel: {rule.notify_channel}")
+
+    cedar_rules = _parse_cedar_hitl_annotations(passport)
+    if cedar_rules:
+        console.print(f"\nWILL trigger HITL — Cedar annotations ({len(cedar_rules)}):")
+        for entry in cedar_rules:
+            console.print(f"\n● {entry['summary']}")
+            console.print(f"  Reason: {entry['reason']}")
+            console.print("  Channel: All channels")
+
+    console.print("\nWILL NOT trigger HITL — everything else:")
+    console.print("✗ Calls with no matching condition rule → automatic")
+    console.print("✗ Risk level alone → never triggers HITL")
+    console.print("✗ Data classification alone → never triggers HITL")
+    console.print("\nRun: iris hitl test --agent {agent} to verify.")
+
+
+def _parse_cedar_hitl_annotations(passport: AgentPassport) -> list[dict]:
+    if not passport.policy_ref:
+        return []
+    path = Path(passport.policy_ref)
+    if not path.is_absolute():
+        path = Path.cwd() / path
+    if not path.exists():
+        return []
+    text = path.read_text()
+    entries = []
+    pattern = re.compile(
+        r"permit\s*\((.*?)\).*?annotations\s*\{([^}]*)\}",
+        re.DOTALL | re.IGNORECASE,
+    )
+    for idx, match in enumerate(pattern.finditer(text), start=1):
+        header, ann = match.group(1), match.group(2)
+        if 'hitl_required' not in ann:
+            continue
+        reason_match = re.search(r'hitl_reason\s*=\s*"([^"]+)"', ann)
+        resource_match = re.search(r'resource\s*==\s*iris::API::"([^"]+)"', header)
+        resource = resource_match.group(1) if resource_match else "unknown"
+        entries.append(
+            {
+                "summary": f"policy.cedar line ~{idx}: {resource} › call",
+                "reason": reason_match.group(1) if reason_match else "Cedar annotation",
+            }
+        )
+    return entries
+
+
+@hitl.command("test")
+@click.option("--agent", required=True)
+def hitl_test(agent: str):
+    """Send a test HITL notification (no real pending review)."""
+    passport = _load_passport(agent)
+    config = passport.hitl_config or HITLConfig(enabled=True)
+    notifier = HITLNotifier()
+    notifier.send_test(agent, config)
+    console.print(f"[green]✓[/green] Test notification sent for {agent}")

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_cli/main.py

@@ -24,7 +24,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="0.1.9", prog_name="iris")
+@click.version_option(version="0.2.1", prog_name="iris")
 def cli():
     """
     IRIS — Policy as Code for AI Agents
@@ -497,6 +497,9 @@ cli.add_command(regulatory)
 from iris_cli.delegation import delegation
 cli.add_command(delegation)
 
+from iris_cli.hitl import hitl
+cli.add_command(hitl)
+
 
 @cli.command("ping", hidden=True)
 def ping():

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_security_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-security-cli
-Version: 0.1.9
+Version: 0.2.1
 Summary: IRIS CLI — declare, compile, preview, enforce, witness, certify, sentinel
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/gimartinb/iris-sdk
@@ -15,8 +15,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: iris-security-core>=0.1.7
-Requires-Dist: iris-security-sdk>=0.1.9
+Requires-Dist: iris-security-core>=0.1.9
+Requires-Dist: iris-security-sdk>=0.2.1
 Requires-Dist: click>=8.1
 Requires-Dist: rich>=13.0
 Requires-Dist: pyyaml>=6.0

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_security_cli.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ iris_cli/evidence.py
 iris_cli/explain.py
 iris_cli/framework_suggest.py
 iris_cli/framework_test.py
+iris_cli/hitl.py
 iris_cli/license_cmd.py
 iris_cli/main.py
 iris_cli/mcp_server.py
@@ -48,6 +49,7 @@ tests/test_entitlements_display.py
 tests/test_evidence.py
 tests/test_framework_suggest.py
 tests/test_framework_test.py
+tests/test_hitl_cli.py
 tests/test_mcp_model_governance.py
 tests/test_policy_diff.py
 tests/test_quickstart.py

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/iris_security_cli.egg-info/requires.txt

@@ -1,5 +1,5 @@
-iris-security-core>=0.1.7
-iris-security-sdk>=0.1.9
+iris-security-core>=0.1.9
+iris-security-sdk>=0.2.1
 click>=8.1
 rich>=13.0
 pyyaml>=6.0

{iris_security_cli-0.1.9 → iris_security_cli-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iris-security-cli"
-version = "0.1.9"
+version = "0.2.1"
 description = "IRIS CLI — declare, compile, preview, enforce, witness, certify, sentinel"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -20,8 +20,8 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-  "iris-security-core>=0.1.7",
-  "iris-security-sdk>=0.1.9",
+  "iris-security-core>=0.1.9",
+  "iris-security-sdk>=0.2.1",
   "click>=8.1",
   "rich>=13.0",
   "pyyaml>=6.0",

iris_security_cli-0.2.1/tests/test_hitl_cli.py

@@ -0,0 +1,111 @@
+"""CLI tests for iris hitl commands."""
+
+from __future__ import annotations
+
+from click.testing import CliRunner
+from unittest.mock import patch
+
+from iris_cli.hitl import hitl
+from iris_core.hitl.models import HITLReview, HITLStatus
+from iris_core.hitl.queue import HITLQueue
+
+
+def test_iris_hitl_list_shows_pending(tmp_path, monkeypatch):
+    queue_path = tmp_path / "queue.jsonl"
+    monkeypatch.setattr(HITLQueue, "QUEUE_PATH", queue_path)
+    queue = HITLQueue(queue_path=queue_path)
+    queue.submit(
+        HITLReview(
+            review_id="rev_cli_test01",
+            agent_name="demo-agent",
+            agent_id="a1",
+            tool_name="tool",
+            action="read",
+            triggered_by_rule="test",
+            risk_level="HIGH",
+            environment="dev",
+            created_at="2026-06-15T12:00:00Z",
+            expires_at="2026-06-15T12:05:00Z",
+        )
+    )
+    runner = CliRunner()
+    result = runner.invoke(hitl, ["list"])
+    assert result.exit_code == 0
+    assert "rev_cli_test" in result.output or "demo-agent" in result.output
+
+
+def test_iris_hitl_approve_resolves_review(tmp_path, monkeypatch):
+    queue_path = tmp_path / "queue.jsonl"
+    monkeypatch.setattr(HITLQueue, "QUEUE_PATH", queue_path)
+    queue = HITLQueue(queue_path=queue_path)
+    queue.submit(
+        HITLReview(
+            review_id="rev_approve01",
+            agent_name="demo-agent",
+            agent_id="a1",
+            tool_name="tool",
+            action="read",
+            triggered_by_rule="test",
+            risk_level="HIGH",
+            environment="dev",
+            created_at="2026-06-15T12:00:00Z",
+            expires_at="2026-06-15T12:05:00Z",
+        )
+    )
+    runner = CliRunner()
+    with patch("iris_cli.hitl.HITLQueue", return_value=queue):
+        result = runner.invoke(hitl, ["approve", "rev_approve01", "--note", "ok"])
+    assert result.exit_code == 0
+    assert "approved" in result.output.lower()
+    assert queue.get("rev_approve01").status == HITLStatus.APPROVED
+
+
+def test_iris_hitl_reject_resolves_review(tmp_path, monkeypatch):
+    queue_path = tmp_path / "queue.jsonl"
+    monkeypatch.setattr(HITLQueue, "QUEUE_PATH", queue_path)
+    queue = HITLQueue(queue_path=queue_path)
+    queue.submit(
+        HITLReview(
+            review_id="rev_reject01",
+            agent_name="demo-agent",
+            agent_id="a1",
+            tool_name="tool",
+            action="read",
+            triggered_by_rule="test",
+            risk_level="HIGH",
+            environment="dev",
+            created_at="2026-06-15T12:00:00Z",
+            expires_at="2026-06-15T12:05:00Z",
+        )
+    )
+    runner = CliRunner()
+    with patch("iris_cli.hitl.HITLQueue", return_value=queue):
+        result = runner.invoke(hitl, ["reject", "rev_reject01", "--reason", "no"])
+    assert result.exit_code == 0
+    assert "rejected" in result.output.lower()
+    assert queue.get("rev_reject01").status == HITLStatus.REJECTED
+
+
+def test_iris_hitl_test_sends_test_notification(monkeypatch, tmp_path):
+    gov = tmp_path / "governance" / "agents" / "demo-agent"
+    gov.mkdir(parents=True)
+    gov.joinpath("passport.yaml").write_text(
+        """
+apiVersion: iris.io/v1alpha1
+kind: AgentPassport
+metadata:
+  name: demo-agent
+  agent_id: agent-1
+spec:
+  owner: test@test.com
+  hitl:
+    enabled: true
+    timeout_seconds: 300
+    timeout_policy: deny
+"""
+    )
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(hitl, ["test", "--agent", "demo-agent"])
+    assert result.exit_code == 0
+    assert "Test notification" in result.output