conduct-cli 0.7.11__tar.gz → 0.7.16__tar.gz

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.7.11
+Version: 0.7.16
 Summary: CLI for Conduct AI — secure, govern, install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conduct-cli"
-version = "0.7.11"
+version = "0.7.16"
 description = "CLI for Conduct AI — secure, govern, install agents, manage projects, run tests"
 readme = "README.md"
 license = { text = "MIT" }

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli/guard.py

@@ -759,7 +759,7 @@ def cmd_guard_install(args):
         # Mirror fail_mode into guard config so the hook can enforce it
         # even when POLICY_PATH is missing or unreadable.
         cfg = _load_guard_config()
-        cfg["fail_mode"] = policy.get("fail_mode", "fail_open")
+        cfg["fail_mode"] = policy.get("fail_mode", "fail_closed")
         cfg["advisory_mode"] = policy.get("advisory_mode", False)
         _save_guard_config(cfg)
         rule_count = len(policy.get("rules", []))
@@ -1722,9 +1722,49 @@ def cmd_guard_status(args):
 
     session_str = f"{proxy_sessions} proxy  ·  {hook_sessions} direct"
 
+    # Drain daemon health
+    try:
+        from conduct_cli.hooks.base import drain_daemon_status
+        d_status, d_pid = drain_daemon_status()
+    except Exception:
+        d_status, d_pid = "unknown", None
+
+    if d_status == "running":
+        daemon_line = f"{GREEN}running{RESET} (pid {d_pid})"
+    elif d_status == "stale":
+        daemon_line = f"{YELLOW}stale{RESET} (pid {d_pid}, not flushing — will restart on next tool call)"
+    else:
+        daemon_line = f"{RED}not running{RESET} — will start on next tool call, journal events queued"
+
+    # Proxy coverage — check active env vars in this shell
+    proxy_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/") + "/proxy"
+    _env           = os.environ
+    anthropic_ok   = proxy_url in _env.get("ANTHROPIC_BASE_URL", "")
+    openai_ok      = proxy_url in _env.get("OPENAI_BASE_URL",    "")
+    perplexity_ok  = proxy_url in _env.get("PERPLEXITY_BASE_URL","")
+    env_file_exists = (Path.home() / ".conduct" / "env").exists()
+
+    def _cov(ok: bool, name: str) -> str:
+        return f"{GREEN}{name}{RESET}" if ok else f"{YELLOW}{name}{RESET}"
+
+    covered   = [n for n, ok in [("Anthropic", anthropic_ok), ("OpenAI", openai_ok), ("Perplexity", perplexity_ok)] if ok]
+    uncovered = [n for n, ok in [("Anthropic", anthropic_ok), ("OpenAI", openai_ok), ("Perplexity", perplexity_ok)] if not ok]
+
+    if covered and not uncovered:
+        proxy_line = f"{GREEN}active{RESET} — {', '.join(covered)} routed through Guard proxy"
+    elif covered:
+        proxy_line = f"{YELLOW}partial{RESET} — {', '.join(covered)} covered · {', '.join(uncovered)} NOT intercepted"
+    elif env_file_exists:
+        proxy_line = f"{YELLOW}inactive{RESET} — ~/.conduct/env exists but not sourced in this shell. Run: {BOLD}. ~/.conduct/env{RESET}"
+    else:
+        proxy_line = f"{RED}not configured{RESET} — run: {BOLD}conduct guard sync{RESET}"
+
     print(f"\n{BOLD}Guard status{RESET} — {user_email}")
     print(f"{rule_count} polic{'y' if rule_count == 1 else 'ies'} active")
     print()
+    print(f"Proxy coverage: {proxy_line}")
+    print(f"Drain daemon:   {daemon_line}")
+    print()
     print(f"Today:")
     print(f"  Sessions: {session_str}")
     print(f"  Tokens used: {tokens_used:,}  (saved {token_saved_pct}% via optimization)")
@@ -2508,144 +2548,102 @@ def _map_owasp(rule_id: str) -> tuple[str, str]:
     return _OWASP_UNKNOWN
 
 
+_GRADE_COLORS = {"A": "\033[32m", "B": "\033[32m", "C": "\033[33m", "D": "\033[33m", "F": "\033[31m"}
+_GRADE_ORDER  = ["A", "B", "C", "D", "F"]
+
+
+def _grade_below(actual: str, minimum: str) -> bool:
+    return _GRADE_ORDER.index(actual) > _GRADE_ORDER.index(minimum.upper())
+
+
 def cmd_verify(args) -> None:
-    """conduct verify — map guard audit events to OWASP Agentic Top 10; exit non-zero in CI."""
+    """conduct verify — governance grade + OWASP Agentic Top 10 coverage."""
     import json as _json
-    import datetime as _dt
 
-    evidence_path = getattr(args, "evidence", None)
-    strict        = getattr(args, "strict", False)
-    fmt           = getattr(args, "format", "text")
-    since_str     = getattr(args, "since", None) or "24h"
+    evidence_out = getattr(args, "evidence", None)
+    badge        = getattr(args, "badge", False)
+    min_grade    = getattr(args, "min_grade", None)
+    strict       = getattr(args, "strict", False)
+    fmt          = getattr(args, "format", "text")
 
-    # ── load events ──────────────────────────────────────────────────────────
-    if evidence_path:
-        try:
-            raw = _json.loads(Path(evidence_path).read_text())
-        except FileNotFoundError:
-            print(f"{RED}✗ File not found: {evidence_path}{RESET}", file=sys.stderr)
-            sys.exit(2)
-        except _json.JSONDecodeError as exc:
-            print(f"{RED}✗ Invalid JSON: {exc}{RESET}", file=sys.stderr)
-            sys.exit(2)
-        events = raw if isinstance(raw, list) else raw.get("events", [])
-    else:
-        cfg          = _require_guard_config()
-        workspace_id = cfg.get("workspace_id")
-        user_email   = cfg.get("user_email", "")
-        api_key      = cfg.get("api_key", "")
-        base_url     = _api_url(cfg)
-        since_iso    = _parse_since(since_str)
-        resp = _req(
-            "GET",
-            (
-                f"{base_url}/guard/events"
-                f"?workspace_id={workspace_id}"
-                f"&user_email={user_email}"
-                f"&since={since_iso}"
-                f"&limit=200"
-            ),
-            api_key=api_key,
-        )
-        events = resp if isinstance(resp, list) else resp.get("events", [])
-
-    if not events:
-        if fmt == "json":
-            print(_json.dumps({"status": "pass", "violations": 0, "findings": []}, indent=2))
-        else:
-            print(f"{GREEN}✓ No guard events found — nothing to verify.{RESET}")
-        return
+    cfg          = _require_guard_config()
+    workspace_id = cfg.get("workspace_id")
+    api_key      = cfg.get("api_key", "")
+    base_url     = _api_url(cfg)
 
-    # ── classify ──────────────────────────────────────────────────────────────
-    findings: list[dict] = []
-    for ev in events:
-        decision = ev.get("decision", "allowed")
-        rule_id  = ev.get("rule_id") or ev.get("rule_message") or ""
-        owasp_code, owasp_title = _map_owasp(rule_id)
-        findings.append({
-            "timestamp":   (ev.get("ts") or ev.get("timestamp") or ev.get("created_at") or "")[:19].replace("T", " ") or "—",
-            "tool":        ev.get("ai_tool") or "—",
-            "action":      (ev.get("tool_call") or "—")[:40],
-            "decision":    decision,
-            "rule_id":     rule_id or "—",
-            "owasp":       owasp_code,
-            "owasp_title": owasp_title,
-            "entry_hash":  (ev.get("entry_hash") or "")[:12] or None,
-            "policy_hash": (ev.get("policy_hash") or "")[:12] or None,
-        })
+    # ── fetch evidence from API ───────────────────────────────────────────────
+    ev = _req(
+        "GET",
+        f"{base_url}/guard/verify/evidence?workspace_id={workspace_id}",
+        api_key=api_key,
+    )
 
-    blocked_count = sum(1 for f in findings if f["decision"] == "blocked")
-    warned_count  = sum(1 for f in findings if f["decision"] == "warned")
-    total         = len(findings)
+    grade        = ev.get("grade", "F")
+    coverage_pct = ev.get("coverage_pct", 0)
+    score        = ev.get("score", 0)
+    blocked_24h  = ev.get("blocked_24h", 0)
+    controls     = ev.get("controls", [])
+    generated_at = ev.get("generated_at", "")
+
+    # ── --badge ───────────────────────────────────────────────────────────────
+    if badge:
+        color = {"A": "brightgreen", "B": "green", "C": "yellow", "D": "orange", "F": "red"}.get(grade, "lightgrey")
+        print(f"![Conduct Guard](https://img.shields.io/badge/Guard-Grade_{grade}-{color})")
+        return
 
-    owasp_counts: dict[str, int] = {}
-    for f in findings:
-        if f["decision"] in ("blocked", "warned"):
-            owasp_counts[f["owasp"]] = owasp_counts.get(f["owasp"], 0) + 1
+    # ── --evidence (write artifact) ───────────────────────────────────────────
+    if evidence_out:
+        artifact = {
+            "grade":        grade,
+            "coverage_pct": coverage_pct,
+            "score":        score,
+            "blocked_24h":  blocked_24h,
+            "controls":     controls,
+            "generated_at": generated_at,
+            "workspace_id": workspace_id,
+        }
+        Path(evidence_out).write_text(_json.dumps(artifact, indent=2))
+        print(f"{GREEN}✓ Evidence artifact written to {evidence_out}{RESET}")
 
-    # ── output ───────────────────────────────────────────────────────────────
+    # ── output ────────────────────────────────────────────────────────────────
     if fmt == "json":
-        out = {
-            "status":             "fail" if (strict and blocked_count) else "pass",
-            "generated_at":       _dt.datetime.utcnow().isoformat() + "Z",
-            "summary":            {"total": total, "blocked": blocked_count, "warned": warned_count},
-            "owasp_distribution": owasp_counts,
-            "findings":           findings,
-        }
-        print(_json.dumps(out, indent=2))
+        print(_json.dumps(ev, indent=2))
     else:
+        grade_color = _GRADE_COLORS.get(grade, GRAY)
+        print()
+        print(f"{BOLD}conduct verify — Governance Grade{RESET}")
+        print("─" * 60)
+        print(f"\n  Grade:    {grade_color}{BOLD}{grade}{RESET}  (score {score}/100)")
+        print(f"  Coverage: {coverage_pct}% of OWASP ASI controls active")
+        print(f"  Blocked (24h): {blocked_24h}")
         print()
-        print(f"{BOLD}conduct verify — OWASP Agentic Top 10 Report{RESET}")
-        print("─" * 78)
-
-        if owasp_counts:
-            print(f"\n{BOLD}OWASP Distribution{RESET}")
-            for _kws, code, title in _OWASP_MAP:
-                count = owasp_counts.get(code, 0)
-                if count:
-                    bar   = "█" * min(count, 20)
-                    label = f"{code}: {title}"
-                    print(f"  {label:<40} {RED}{bar} {count}{RESET}")
-            unk = owasp_counts.get("A??", 0)
-            if unk:
-                print(f"  {'A??: Uncategorised':<40} {GRAY}{'█' * min(unk, 20)} {unk}{RESET}")
-
-        print(f"\n{BOLD}{'Timestamp':<20} {'Tool':<14} {'Decision':<10} {'OWASP':<5} Rule{RESET}")
-        print("─" * 78)
-        for f in findings:
-            if f["decision"] == "blocked":
-                dec_col = f"{RED}blocked{RESET}"
-            elif f["decision"] == "warned":
-                dec_col = f"{YELLOW}warned{RESET}"
-            elif f["decision"] == "audited":
-                dec_col = f"{BLUE}audited{RESET}"
+        print(f"{BOLD}  {'Control':<8} {'Status':<10} Name{RESET}")
+        print("  " + "─" * 56)
+        for c in controls:
+            status = c.get("status", "missing")
+            if status == "active":
+                sc = f"{GREEN}active   {RESET}"
+            elif status == "partial":
+                sc = f"{YELLOW}partial  {RESET}"
             else:
-                dec_col = f"{GRAY}{f['decision']}{RESET}"
-            chain_note = f"  {GRAY}chain:{f['entry_hash']}{RESET}" if f["entry_hash"] else ""
-            print(
-                f"  {f['timestamp']:<20} {f['tool']:<14} {dec_col:<10} "
-                f"{f['owasp']:<5} {f['rule_id']}{chain_note}"
-            )
-
+                sc = f"{RED}missing  {RESET}"
+            print(f"  {c.get('id',''):<8} {sc} {c.get('name','')}")
         print()
-        if blocked_count:
-            status_icon  = f"{RED}✗{RESET}"
-            status_label = f"{RED}FAIL{RESET}" if strict else f"{YELLOW}WARN{RESET}"
-        else:
-            status_icon  = f"{GREEN}✓{RESET}"
-            status_label = f"{GREEN}PASS{RESET}"
 
-        print(
-            f"  {status_icon} {status_label}  "
-            f"{total} events  ·  "
-            f"{RED if blocked_count else GRAY}{blocked_count} blocked{RESET}  ·  "
-            f"{YELLOW if warned_count else GRAY}{warned_count} warned{RESET}"
-        )
-        if strict and blocked_count:
-            print(f"\n  {RED}Strict mode: non-zero exit — {blocked_count} blocked event(s).{RESET}")
+        # CI checks
+        failed = False
+        if strict and blocked_24h > 0:
+            print(f"  {RED}✗ Strict mode: {blocked_24h} blocked event(s) in last 24h.{RESET}")
+            failed = True
+        if min_grade and _grade_below(grade, min_grade):
+            print(f"  {RED}✗ Grade {grade} is below minimum {min_grade.upper()}.{RESET}")
+            failed = True
+        if not failed:
+            print(f"  {GREEN}✓ PASS{RESET}")
         print()
 
-    if strict and blocked_count:
+    # ── exit codes ────────────────────────────────────────────────────────────
+    if (strict and blocked_24h > 0) or (min_grade and _grade_below(grade, min_grade)):
         sys.exit(1)
 
 

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli/guardmcp.py

@@ -183,14 +183,23 @@ def _maybe_sync() -> None:
 def _detect_surface(client_info: dict) -> str:
     """Map MCP clientInfo.name → ai_tool label sent to Guard API."""
     name = (client_info.get("name") or "").lower()
-    if "desktop" in name:
-        return "claude_desktop"
+    # ── Anthropic ─────────────────────────────────────────────────────────────
+    if "code" in name and "claude" in name:
+        return "claude-code"
+    if "desktop" in name and "claude" in name:
+        return "claude-desktop"
     if "work" in name or "teams" in name or "enterprise" in name:
-        return "claude_work"
+        return "claude-desktop"   # Claude for Work / Teams
     if "claude" in name:
-        return "claude_chat"
+        return "claude-ai"        # claude.ai web
+    # ── OpenAI ────────────────────────────────────────────────────────────────
+    if "chatgpt" in name or "openai" in name:
+        return "openai-chatgpt"
+    if "codex" in name and "desktop" in name:
+        return "codex-desktop"
     if "codex" in name:
-        return "codex"
+        return "codex-cli"
+    # ── Other IDEs ────────────────────────────────────────────────────────────
     if "cursor" in name:
         return "cursor"
     if "windsurf" in name:
@@ -259,9 +268,13 @@ def _match_policy(tool_name: str, tool_input: dict) -> dict | None:
     for rule in rules:
         match_tool = (rule.get("match_tool") or "*").lower()
         if match_tool != "*":
-            allowed = [t.strip() for t in match_tool.split(",")]
-            if tool_name.lower() not in allowed:
+            if tool_name.lower() not in [t.strip() for t in match_tool.split(",")]:
                 continue
+        match_ai = rule.get("match_ai_tool")
+        if match_ai:
+            surfaces = [s.strip().lower() for s in match_ai.split(",")]
+            if not any(s in ai_tool.lower() for s in surfaces):
+                continue  # rule targets a different surface
 
         pattern = rule.get("match_pattern")
         if pattern:

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli/hooks/base.py

@@ -74,24 +74,38 @@ def detect_repo() -> Optional[str]:
 
 
 def detect_ai_tool() -> str:
-    """Return a string identifying the active AI coding tool."""
+    """Return a string identifying the active AI coding tool / surface."""
     import os
+    # ── Anthropic ─────────────────────────────────────────────────────────────
     if os.environ.get("CLAUDE_CODE_ENTRYPOINT") or os.environ.get("CLAUDECODE"):
         return "claude-code"
-    if os.environ.get("CODEX_SESSION_ID") or os.environ.get("CODEX_CLI_VERSION"):
-        return "codex"
+    if os.environ.get("CLAUDE_DESKTOP_ENTRYPOINT") or os.environ.get("CLAUDE_DESKTOP"):
+        return "claude-desktop"
+    # ── OpenAI / Codex ────────────────────────────────────────────────────────
+    if os.environ.get("CODEX_CLI_VERSION") or os.environ.get("CODEX_SESSION_ID"):
+        return "codex-cli"
+    if os.environ.get("CODEX_DESKTOP") or os.environ.get("OPENAI_CODEX_DESKTOP"):
+        return "codex-desktop"
+    if os.environ.get("OPENAI_CHATGPT_MCP") or os.environ.get("CHATGPT_SESSION_ID"):
+        return "openai-chatgpt"
+    # ── TERM_PROGRAM ──────────────────────────────────────────────────────────
     term = os.environ.get("TERM_PROGRAM", "").lower()
     if term == "cursor":
         return "cursor"
     if term == "windsurf":
         return "windsurf"
+    # ── PATH heuristics ───────────────────────────────────────────────────────
     path = os.environ.get("PATH", "")
-    if "Codex.app" in path or "codex" in path.lower():
-        return "codex"
+    if "Codex.app" in path:
+        return "codex-desktop"
+    if "codex" in path.lower():
+        return "codex-cli"
     if "cursor" in path.lower():
         return "cursor"
     if "windsurf" in path.lower():
         return "windsurf"
+    if "claude" in path.lower():
+        return "claude-desktop"
     return "claude-code"
 
 
@@ -111,21 +125,68 @@ def journal_append(payload_str: str, api_url: str) -> None:
         pass
 
 
+_DAEMON_STALE_SECS = 600       # PID file not touched in 10 min → daemon is stale
+_POLICY_REFRESH_INTERVAL = 30  # daemon refreshes policy.json every 30 s
+
+
+def _refresh_policy_from_api() -> None:
+    """Pull fresh policy from API and write to POLICY_PATH atomically."""
+    try:
+        cfg = load_config()
+        workspace_id = cfg.get("workspace_id")
+        api_key = cfg.get("api_key", "")
+        api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+        if not api_key:
+            return
+        url = f"{api_url}/guard/policies/sync"
+        if workspace_id:
+            url += f"?workspace_id={workspace_id}"
+        req = urllib.request.Request(url, headers={"X-Api-Key": api_key})
+        with urllib.request.urlopen(req, timeout=8) as resp:
+            data = resp.read()
+        POLICY_PATH.parent.mkdir(parents=True, exist_ok=True)
+        tmp = POLICY_PATH.with_suffix(".tmp")
+        tmp.write_bytes(data)
+        tmp.rename(POLICY_PATH)
+    except Exception:
+        pass
+
+
+def drain_daemon_status() -> tuple[str, int | None]:
+    """Return (status, pid) where status is 'running'|'stale'|'dead'."""
+    import os as _os
+    if not JOURNAL_PID_PATH.exists():
+        return "dead", None
+    try:
+        pid = int(JOURNAL_PID_PATH.read_text().strip())
+        _os.kill(pid, 0)  # raises if process gone
+        age = time.time() - JOURNAL_PID_PATH.stat().st_mtime
+        if age > _DAEMON_STALE_SECS:
+            return "stale", pid
+        return "running", pid
+    except (ProcessLookupError, PermissionError, ValueError):
+        return "dead", None
+    except Exception:
+        return "dead", None
+
+
 def ensure_drain_daemon(hook_module_path: Optional[Path] = None) -> None:
-    """Start the drain daemon if it is not already running.
+    """Start the drain daemon if it is not already running or is stale.
 
     hook_module_path — path of the calling hook file (used to spawn the daemon
     via `python <path> drain`).  When None the drain subprocess is not started
     (used in unit tests / debug mode where the daemon is not needed).
     """
     try:
-        if JOURNAL_PID_PATH.exists():
-            pid = int(JOURNAL_PID_PATH.read_text().strip())
+        status, stale_pid = drain_daemon_status()
+        if status == "running":
+            return
+        # Kill stale process before spawning replacement — prevents double-drain race
+        if status == "stale" and stale_pid is not None:
             import os as _os
             try:
-                _os.kill(pid, 0)
-                return  # alive
-            except (ProcessLookupError, PermissionError):
+                _os.kill(stale_pid, 15)  # SIGTERM
+            except Exception:
                 pass
         if hook_module_path is None:
             return
@@ -148,6 +209,7 @@ def run_drain_daemon() -> None:
     except Exception:
         return
     empty_scans = 0
+    _last_policy_refresh = 0.0
     while empty_scans < 3:
         files = sorted(f for f in JOURNAL_DIR.glob("*.json") if f.name != "drain.pid")
         if not files:
@@ -188,6 +250,16 @@ def run_drain_daemon() -> None:
             time.sleep(2)
         else:
             empty_scans = 0
+        # Touch PID file so drain_daemon_status() knows we're still alive
+        try:
+            JOURNAL_PID_PATH.touch()
+        except Exception:
+            pass
+        # Refresh policy on a short interval — collapses propagation window to 30 s
+        _now = time.time()
+        if _now - _last_policy_refresh >= _POLICY_REFRESH_INTERVAL:
+            _refresh_policy_from_api()
+            _last_policy_refresh = _now
     try:
         JOURNAL_PID_PATH.unlink(missing_ok=True)
     except Exception:

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli/hooks/pretooluse.py

@@ -220,8 +220,8 @@ def _maybe_sync_policy() -> None:
 
 def _get_fail_mode() -> str:
     cfg = load_config()
-    mode = cfg.get("fail_mode", "fail_open")
-    return mode if mode in ("fail_open", "fail_closed") else "fail_open"
+    mode = cfg.get("fail_mode", "fail_closed")
+    return mode if mode in ("fail_open", "fail_closed") else "fail_closed"
 
 
 def _get_advisory_mode() -> bool:
@@ -325,11 +325,17 @@ def check_policy(tool_name: str, tool_input: dict, tokens_before: int = 0):
         input_text = json.dumps(tool_input)
     path_fields = [str(tool_input.get(f, "")) for f in ["file_path", "path", "command"]]
 
+    current_ai_tool = detect_ai_tool()
     for rule in rules:
         match_tool = (rule.get("match_tool") or "*").lower()
         if match_tool != "*":
             if tool_name not in [t.strip() for t in match_tool.split(",")]:
                 continue
+        match_ai = rule.get("match_ai_tool")
+        if match_ai:
+            surfaces = [s.strip().lower() for s in match_ai.split(",")]
+            if not any(s in current_ai_tool.lower() for s in surfaces):
+                continue
         pattern = rule.get("match_pattern")
         if pattern:
             try:
@@ -422,7 +428,7 @@ def main() -> None:
         tool_name  = (data.get("tool_name") or "").lower()
         tool_input = data.get("tool_input") or {}
         session_id = data.get("session_id")
-        msg = "[ConductGuard] Policy cache unavailable — fail-closed mode is on. Run `conduct guard sync` or contact your admin."
+        msg = "[ConductGuard] Guard API unreachable and no local policy cache found — tool call blocked (fail-closed). Run `conduct guard sync` to cache your policy, or ask your admin to set fail_open."
         print(msg)
         print(msg, file=sys.stderr)
         post_event(tool_name, tool_input, "blocked", "guard-unavailable", msg, session_id, drain_via=_this_file)
@@ -436,7 +442,7 @@ def main() -> None:
             tool_name  = (data.get("tool_name") or "").lower()
             tool_input = data.get("tool_input") or {}
             session_id = data.get("session_id")
-            msg = "[ConductGuard] Spend budget check unavailable — fail-closed mode is on."
+            msg = "[ConductGuard] Guard API unreachable — tool call blocked (fail-closed). Check your connection or ask your admin to set fail_open in Guard settings."
             print(msg)
             print(msg, file=sys.stderr)
             post_event(tool_name, tool_input, "blocked", "guard-unavailable", msg, session_id, drain_via=_this_file)

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli/main.py

@@ -3097,11 +3097,13 @@ def main():
     sub.add_parser("sync", help="Sync Guard policies (and Security Loop policies if installed)")
 
     # conduct test-guard / test-security / test-security-verify
-    verify_p = sub.add_parser("verify", help="Map guard events to OWASP Agentic Top 10 and verify chain integrity")
-    verify_p.add_argument("--evidence", metavar="FILE", default=None, help="JSON evidence file (guard events). Omit to fetch from API.")
-    verify_p.add_argument("--strict",   action="store_true",           help="Exit 1 if any blocked events found (CI mode)")
-    verify_p.add_argument("--format",   choices=["text", "json"],      default="text", help="Output format (default: text)")
-    verify_p.add_argument("--since",    default="24h",                 help="Time window when fetching from API (e.g. 7d, 24h)")
+    verify_p = sub.add_parser("verify", help="OWASP Agentic Top 10 coverage + governance grade")
+    verify_p.add_argument("--evidence",  metavar="FILE", default=None, help="Write evidence artifact to FILE.")
+    verify_p.add_argument("--badge",     action="store_true",          help="Print markdown badge and exit.")
+    verify_p.add_argument("--min-grade", metavar="GRADE", default=None,help="Exit 1 if governance grade is below this (A–F).")
+    verify_p.add_argument("--strict",    action="store_true",          help="Exit 1 if any blocked events in last 24h (CI mode).")
+    verify_p.add_argument("--format",    choices=["text", "json"],     default="text", help="Output format (default: text)")
+    verify_p.add_argument("--since",     default="24h",                help="Time window for blocked event check (e.g. 7d, 24h)")
     sub.add_parser("test-guard",            help="Fire a synthetic event per guard policy rule and show decisions")
     sub.add_parser("test-security",         help="Post a synthetic finding per security classifier pattern")
     sub.add_parser("test-security-verify",  help="Post test findings and verify full triage pipeline end-to-end")

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.7.11
+Version: 0.7.16
 Summary: CLI for Conduct AI — secure, govern, install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/src/conduct_cli.egg-info/SOURCES.txt

@@ -29,11 +29,13 @@ tests/test_advisory_and_hook.py
 tests/test_bash_operator_signature.py
 tests/test_blast_radius.py
 tests/test_command_word_matcher.py
+tests/test_drain_daemon_health.py
 tests/test_guard_policy.py
 tests/test_guard_savings.py
 tests/test_hook_dispatch.py
 tests/test_journal_drain.py
 tests/test_log_util.py
+tests/test_proxy_coverage.py
 tests/test_proxy_env.py
 tests/test_signed_policy.py
 tests/test_switch.py

{conduct_cli-0.7.11 → conduct_cli-0.7.16}/tests/test_advisory_and_hook.py

@@ -425,35 +425,42 @@ class TestOWASPMapping:
         assert self._map("") == "A??"
 
 
-_EVIDENCE_BLOCKED = [
-    {"timestamp": "2026-07-06T10:00:00", "ai_tool": "Claude",
-     "tool_call": "Bash", "decision": "blocked",
-     "rule_id": "excessive_agency_shell",
-     "entry_hash": "abc123def456", "policy_hash": "pol789"},
+_MOCK_CONTROLS = [
+    {"id": f"ASI-0{i}", "name": f"Control {i}", "status": "active", "control": "desc"}
+    for i in range(1, 11)
 ]
 
-_EVIDENCE_WARN_ONLY = [
-    {"timestamp": "2026-07-06T10:01:00", "ai_tool": "Claude",
-     "tool_call": "Read", "decision": "warned",
-     "rule_id": "sensitive_data_read"},
-]
+_MOCK_EVIDENCE_PASS = {
+    "grade": "B", "coverage_pct": 60, "score": 70,
+    "blocked_24h": 0, "events_24h": 5,
+    "controls": _MOCK_CONTROLS,
+    "generated_at": "2026-07-07T10:00:00+00:00",
+    "workspace_id": "test-ws-id",
+}
 
-_EVIDENCE_CLEAN = [
-    {"timestamp": "2026-07-06T10:02:00", "ai_tool": "Claude",
-     "tool_call": "Bash", "decision": "allowed", "rule_id": None},
-]
+_MOCK_EVIDENCE_BLOCKED = {**_MOCK_EVIDENCE_PASS, "blocked_24h": 3}
+_MOCK_EVIDENCE_FAIL    = {**_MOCK_EVIDENCE_PASS, "grade": "F", "score": 10, "coverage_pct": 20}
 
 
 class TestVerifyCommand:
-    def _run(self, args_list: list[str], capsys) -> int:
+    def _run(self, args_list: list[str], capsys, monkeypatch, api_response=None) -> int:
         import argparse
+        import conduct_cli.guard as _g
         from conduct_cli.guard import cmd_verify
 
+        monkeypatch.setattr(_g, "_require_guard_config", lambda: {
+            "workspace_id": "test-ws-id", "api_key": "k", "api_url": "https://api.test",
+        })
+        monkeypatch.setattr(_g, "_api_url", lambda cfg: "https://api.test")
+        monkeypatch.setattr(_g, "_req", lambda *a, **kw: api_response or _MOCK_EVIDENCE_PASS)
+
         parser = argparse.ArgumentParser()
-        parser.add_argument("--evidence", default=None)
-        parser.add_argument("--strict", action="store_true")
-        parser.add_argument("--format", default="text")
-        parser.add_argument("--since", default="24h")
+        parser.add_argument("--evidence",  default=None)
+        parser.add_argument("--badge",     action="store_true")
+        parser.add_argument("--min-grade", dest="min_grade", default=None)
+        parser.add_argument("--strict",    action="store_true")
+        parser.add_argument("--format",    default="text")
+        parser.add_argument("--since",     default="24h")
         args = parser.parse_args(args_list)
 
         try:
@@ -462,89 +469,61 @@ class TestVerifyCommand:
         except SystemExit as exc:
             return int(exc.code) if exc.code is not None else 0
 
-    def test_clean_evidence_exits_0(self, tmp_path, capsys):
-        f = tmp_path / "ev.json"
-        f.write_text(__import__("json").dumps(_EVIDENCE_CLEAN))
-        code = self._run(["--evidence", str(f)], capsys)
+    def test_pass_grade_exits_0(self, capsys, monkeypatch):
+        code = self._run([], capsys, monkeypatch)
         assert code == 0
 
-    def test_blocked_without_strict_exits_0(self, tmp_path, capsys):
-        f = tmp_path / "ev.json"
-        f.write_text(__import__("json").dumps(_EVIDENCE_BLOCKED))
-        code = self._run(["--evidence", str(f)], capsys)
+    def test_blocked_without_strict_exits_0(self, capsys, monkeypatch):
+        code = self._run(["--strict"], capsys, monkeypatch, api_response=_MOCK_EVIDENCE_PASS)
         assert code == 0
 
-    def test_blocked_with_strict_exits_1(self, tmp_path, capsys):
-        f = tmp_path / "ev.json"
-        f.write_text(__import__("json").dumps(_EVIDENCE_BLOCKED))
-        code = self._run(["--evidence", str(f), "--strict"], capsys)
+    def test_strict_exits_1_when_blocked(self, capsys, monkeypatch):
+        code = self._run(["--strict"], capsys, monkeypatch, api_response=_MOCK_EVIDENCE_BLOCKED)
         assert code == 1
 
-    def test_warn_only_with_strict_exits_0(self, tmp_path, capsys):
-        f = tmp_path / "ev.json"
-        f.write_text(__import__("json").dumps(_EVIDENCE_WARN_ONLY))
-        code = self._run(["--evidence", str(f), "--strict"], capsys)
+    def test_min_grade_pass(self, capsys, monkeypatch):
+        code = self._run(["--min-grade", "C"], capsys, monkeypatch, api_response=_MOCK_EVIDENCE_PASS)
         assert code == 0
 
-    def test_missing_file_exits_2(self, tmp_path, capsys):
-        code = self._run(["--evidence", str(tmp_path / "missing.json")], capsys)
-        assert code == 2
+    def test_min_grade_fail(self, capsys, monkeypatch):
+        code = self._run(["--min-grade", "A"], capsys, monkeypatch, api_response=_MOCK_EVIDENCE_PASS)
+        assert code == 1
 
-    def test_invalid_json_exits_2(self, tmp_path, capsys):
-        f = tmp_path / "bad.json"
-        f.write_text("not valid {{{")
-        code = self._run(["--evidence", str(f)], capsys)
-        assert code == 2
+    def test_fail_grade_below_min(self, capsys, monkeypatch):
+        code = self._run(["--min-grade", "B"], capsys, monkeypatch, api_response=_MOCK_EVIDENCE_FAIL)
+        assert code == 1
 
-    def test_empty_array_no_error(self, tmp_path, capsys):
-        f = tmp_path / "empty.json"
-        f.write_text("[]")
-        code = self._run(["--evidence", str(f)], capsys)
-        assert code == 0
+    def test_badge_output(self, capsys, monkeypatch):
+        self._run(["--badge"], capsys, monkeypatch)
         out = capsys.readouterr().out
-        assert "nothing to verify" in out.lower() or "no guard events" in out.lower()
+        assert "img.shields.io" in out
+        assert "Grade_B" in out
 
-    def test_json_format_status_fail_when_strict_and_blocked(self, tmp_path, capsys):
+    def test_evidence_writes_file(self, tmp_path, capsys, monkeypatch):
         import json
-        f = tmp_path / "ev.json"
-        f.write_text(json.dumps(_EVIDENCE_BLOCKED))
-        self._run(["--evidence", str(f), "--strict", "--format", "json"], capsys)
-        out = capsys.readouterr().out
-        data = json.loads(out)
-        assert data["status"] == "fail"
-        assert data["summary"]["blocked"] == 1
+        out_file = tmp_path / "evidence.json"
+        self._run(["--evidence", str(out_file)], capsys, monkeypatch)
+        data = json.loads(out_file.read_text())
+        assert data["grade"] == "B"
+        assert "controls" in data
 
-    def test_json_format_status_pass_without_strict(self, tmp_path, capsys):
+    def test_json_format_output(self, capsys, monkeypatch):
         import json
-        f = tmp_path / "ev.json"
-        f.write_text(json.dumps(_EVIDENCE_BLOCKED))
-        self._run(["--evidence", str(f), "--format", "json"], capsys)
+        self._run(["--format", "json"], capsys, monkeypatch)
         out = capsys.readouterr().out
         data = json.loads(out)
-        assert data["status"] == "pass"
+        assert data["grade"] == "B"
 
-    def test_chain_hash_appears_in_text_output(self, tmp_path, capsys):
-        f = tmp_path / "ev.json"
-        f.write_text(__import__("json").dumps(_EVIDENCE_BLOCKED))
-        self._run(["--evidence", str(f)], capsys)
+    def test_grade_shown_in_text_output(self, capsys, monkeypatch):
+        self._run([], capsys, monkeypatch)
         out = capsys.readouterr().out
-        assert "chain:abc123def456" in out
+        assert "Grade" in out
+        assert "B" in out
 
-    def test_owasp_distribution_shown(self, tmp_path, capsys):
-        f = tmp_path / "ev.json"
-        f.write_text(__import__("json").dumps(_EVIDENCE_BLOCKED + _EVIDENCE_WARN_ONLY))
-        self._run(["--evidence", str(f)], capsys)
+    def test_controls_listed_in_text_output(self, capsys, monkeypatch):
+        self._run([], capsys, monkeypatch)
         out = capsys.readouterr().out
-        assert "A04" in out
-        assert "A02" in out
-
-    def test_envelope_json_input(self, tmp_path, capsys):
-        """Accept {'events': [...]} envelope as well as raw array."""
-        import json
-        f = tmp_path / "ev.json"
-        f.write_text(json.dumps({"events": _EVIDENCE_CLEAN}))
-        code = self._run(["--evidence", str(f)], capsys)
-        assert code == 0
+        assert "ASI-01" in out
 
 
 # ── invalid stdin ─────────────────────────────────────────────────────────────
@@ -563,3 +542,65 @@ class TestInvalidStdin:
         with pytest.raises(SystemExit) as exc:
             pt.main()
         assert exc.value.code == 0
+
+
+# ── Fail-closed: API unreachable (budget check path) ──────────────────────────
+
+class TestFailClosedApiUnreachable:
+    """fail_closed + policy exists + budget API unreachable → blocks with clear message."""
+
+    def test_api_unreachable_blocks_with_clear_message(self, monkeypatch, tmp_path, capsys):
+        import conduct_cli.hooks.pretooluse as pt
+        from io import StringIO
+
+        policy_file = tmp_path / "policy.json"
+        policy_file.write_text('{"rules": [], "fail_mode": "fail_closed"}')
+
+        monkeypatch.setattr(pt, "active_policy_path", lambda: policy_file)
+        monkeypatch.setattr(pt, "_get_fail_mode", lambda: "fail_closed")
+        monkeypatch.setattr(pt, "_get_advisory_mode", lambda: False)
+        monkeypatch.setattr(pt, "_maybe_sync_policy", lambda: None)
+        monkeypatch.setattr(pt, "_should_periodic_flush", lambda: False)
+        # Budget cache miss, then API unreachable → returns (False, None)
+        monkeypatch.setattr(pt, "_load_budget_cache", lambda: (None, None))
+        monkeypatch.setattr(pt, "_fetch_budget_status", lambda: (False, None))
+
+        posted: list[dict] = []
+        def _fake_post(tn, ti, decision, rule_id, msg, sid, **kw):
+            posted.append({"decision": decision, "rule_id": rule_id, "msg": msg})
+        monkeypatch.setattr(pt, "post_event", _fake_post)
+        monkeypatch.setattr(sys, "stdin", StringIO(_hook_input()))
+
+        with pytest.raises(SystemExit) as exc:
+            pt.main()
+
+        assert exc.value.code == 2
+        assert posted[0]["decision"] == "blocked"
+        assert posted[0]["rule_id"] == "guard-unavailable"
+        # Message must say "unreachable", not "budget"
+        assert "unreachable" in posted[0]["msg"].lower()
+        assert "budget" not in posted[0]["msg"].lower()
+
+    def test_api_unreachable_fail_open_passes(self, monkeypatch, tmp_path):
+        """Same scenario but fail_open → should NOT block."""
+        import conduct_cli.hooks.pretooluse as pt
+        from io import StringIO
+
+        policy_file = tmp_path / "policy.json"
+        policy_file.write_text('{"rules": []}')
+
+        monkeypatch.setattr(pt, "active_policy_path", lambda: policy_file)
+        monkeypatch.setattr(pt, "_get_fail_mode", lambda: "fail_open")
+        monkeypatch.setattr(pt, "_get_advisory_mode", lambda: False)
+        monkeypatch.setattr(pt, "_maybe_sync_policy", lambda: None)
+        monkeypatch.setattr(pt, "_should_periodic_flush", lambda: False)
+        monkeypatch.setattr(pt, "_load_budget_cache", lambda: (None, None))
+        monkeypatch.setattr(pt, "_fetch_budget_status", lambda: (False, None))
+        monkeypatch.setattr(pt, "post_event", lambda *a, **kw: None)
+        monkeypatch.setattr(sys, "stdin", StringIO(_hook_input()))
+
+        # Should not raise SystemExit(2) — exits 0 (allow)
+        try:
+            pt.main()
+        except SystemExit as e:
+            assert e.code == 0

conduct_cli-0.7.16/tests/test_drain_daemon_health.py

@@ -0,0 +1,206 @@
+"""Tests for drain daemon stale-PID detection and ensure_drain_daemon restart logic."""
+import os
+import time
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+import conduct_cli.hooks.base as base
+
+
+# ── drain_daemon_status ────────────────────────────────────────────────────────
+
+def test_status_dead_no_pid_file(tmp_path):
+    with patch.object(base, "JOURNAL_PID_PATH", tmp_path / "drain.pid"):
+        status, pid = base.drain_daemon_status()
+    assert status == "dead"
+    assert pid is None
+
+
+def test_status_dead_process_gone(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    pid_file.write_text("999999999")  # non-existent PID
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file):
+        status, pid = base.drain_daemon_status()
+    assert status == "dead"
+    assert pid is None
+
+
+def test_status_running_fresh(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    pid_file.write_text(str(os.getpid()))  # current process — definitely alive
+    # mtime is now → fresh
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file):
+        status, pid = base.drain_daemon_status()
+    assert status == "running"
+    assert pid == os.getpid()
+
+
+def test_status_stale_old_mtime(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    pid_file.write_text(str(os.getpid()))
+    # backdate mtime beyond stale threshold
+    old = time.time() - base._DAEMON_STALE_SECS - 60
+    os.utime(pid_file, (old, old))
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file):
+        status, pid = base.drain_daemon_status()
+    assert status == "stale"
+    assert pid == os.getpid()
+
+
+def test_status_corrupt_pid_file(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    pid_file.write_text("not-a-number")
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file):
+        status, pid = base.drain_daemon_status()
+    assert status == "dead"
+    assert pid is None
+
+
+# ── ensure_drain_daemon ────────────────────────────────────────────────────────
+
+def test_ensure_no_spawn_when_running(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    pid_file.write_text(str(os.getpid()))
+
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file), \
+         patch.object(base, "subprocess") as mock_sub:
+        base.ensure_drain_daemon(hook_module_path=Path("/fake/hook.py"))
+
+    mock_sub.Popen.assert_not_called()
+
+
+def test_ensure_spawns_when_dead(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    # no PID file → dead
+
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file), \
+         patch.object(base, "subprocess") as mock_sub:
+        base.ensure_drain_daemon(hook_module_path=Path("/fake/hook.py"))
+
+    mock_sub.Popen.assert_called_once()
+
+
+def test_ensure_kills_stale_and_spawns(tmp_path):
+    pid_file = tmp_path / "drain.pid"
+    pid_file.write_text(str(os.getpid()))
+    old = time.time() - base._DAEMON_STALE_SECS - 60
+    os.utime(pid_file, (old, old))
+
+    killed = []
+
+    def fake_kill(pid, sig):
+        killed.append((pid, sig))
+
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file), \
+         patch.object(base, "subprocess"), \
+         patch("os.kill", fake_kill):
+        base.ensure_drain_daemon(hook_module_path=Path("/fake/hook.py"))
+
+    # stale PID (our own process) should have received SIGTERM
+    assert any(sig == 15 for _, sig in killed)
+
+
+def test_ensure_no_spawn_without_hook_path(tmp_path):
+    """hook_module_path=None → no spawn even when dead (test/debug mode)."""
+    pid_file = tmp_path / "drain.pid"
+
+    with patch.object(base, "JOURNAL_PID_PATH", pid_file), \
+         patch.object(base, "subprocess") as mock_sub:
+        base.ensure_drain_daemon(hook_module_path=None)
+
+    mock_sub.Popen.assert_not_called()
+
+
+# ── PID file touch in drain loop ───────────────────────────────────────────────
+
+def test_pid_file_touched_after_flush(tmp_path):
+    """run_drain_daemon touches the PID file after each flush so mtime stays fresh."""
+    pid_file = tmp_path / "drain.pid"
+    journal_dir = tmp_path / "journal"
+    journal_dir.mkdir()
+
+    # Write one fake journal entry that will fail to POST (no server)
+    entry = journal_dir / "ev1.json"
+    entry.write_text('{"api_url": "http://127.0.0.1:19999", "payload": "{}"}')
+
+    before = time.time() - 5
+
+    with patch.object(base, "JOURNAL_DIR", journal_dir), \
+         patch.object(base, "JOURNAL_PID_PATH", pid_file):
+        # Run just enough of the drain loop to hit the touch
+        # Patch sleep to break out after first iteration
+        call_count = [0]
+        orig_sleep = time.sleep
+        def fast_sleep(n):
+            call_count[0] += 1
+            if call_count[0] >= 2:
+                raise KeyboardInterrupt
+        with patch("time.sleep", fast_sleep):
+            try:
+                base.run_drain_daemon()
+            except KeyboardInterrupt:
+                pass
+
+    if pid_file.exists():
+        assert pid_file.stat().st_mtime >= before
+
+
+# ── Policy refresh ─────────────────────────────────────────────────────────────
+
+def test_refresh_policy_writes_file(tmp_path):
+    """_refresh_policy_from_api writes API response to POLICY_PATH atomically."""
+    import urllib.request as _ur
+    from unittest.mock import MagicMock
+
+    fake_policy = b'{"rules": [{"id": "r1"}]}'
+    policy_path = tmp_path / "policy.json"
+
+    fake_resp = MagicMock()
+    fake_resp.read.return_value = fake_policy
+    fake_resp.__enter__ = lambda s: s
+    fake_resp.__exit__ = MagicMock(return_value=False)
+
+    with patch.object(base, "POLICY_PATH", policy_path), \
+         patch.object(base, "load_config", return_value={
+             "workspace_id": "ws_test",
+             "api_key": "cond_live_test",
+             "api_url": "https://api.conductai.ai",
+         }), \
+         patch("urllib.request.urlopen", return_value=fake_resp):
+        base._refresh_policy_from_api()
+
+    assert policy_path.exists()
+    assert policy_path.read_bytes() == fake_policy
+
+
+def test_refresh_policy_skips_without_api_key(tmp_path):
+    """_refresh_policy_from_api is a no-op when api_key is absent."""
+    policy_path = tmp_path / "policy.json"
+
+    with patch.object(base, "POLICY_PATH", policy_path), \
+         patch.object(base, "load_config", return_value={"workspace_id": "ws_test"}), \
+         patch("urllib.request.urlopen") as mock_open:
+        base._refresh_policy_from_api()
+
+    mock_open.assert_not_called()
+    assert not policy_path.exists()
+
+
+def test_refresh_policy_works_without_workspace_id(tmp_path):
+    """_refresh_policy_from_api omits workspace_id param when not in config (org-level Guard)."""
+    fake_policy = b'{"rules": []}'
+    policy_path = tmp_path / "policy.json"
+
+    fake_resp = MagicMock()
+    fake_resp.read.return_value = fake_policy
+    fake_resp.__enter__ = lambda s: s
+    fake_resp.__exit__ = MagicMock(return_value=False)
+
+    with patch.object(base, "POLICY_PATH", policy_path), \
+         patch.object(base, "load_config", return_value={"api_key": "cond_live_test"}), \
+         patch("urllib.request.urlopen", return_value=fake_resp) as mock_open:
+        base._refresh_policy_from_api()
+
+    called_url = mock_open.call_args[0][0].full_url
+    assert "workspace_id" not in called_url
+    assert policy_path.read_bytes() == fake_policy

conduct_cli-0.7.16/tests/test_proxy_coverage.py

@@ -0,0 +1,79 @@
+"""Tests for proxy coverage detection in guard status."""
+import io
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+
+def _run_coverage_block(env: dict, cfg: dict, env_file_exists: bool = True) -> str:
+    """Run only the proxy-coverage printing block from cmd_guard_status."""
+    import conduct_cli.guard as g
+
+    output = io.StringIO()
+    with patch.dict("os.environ", env, clear=True), \
+         patch.object(Path, "exists", return_value=env_file_exists):
+        proxy_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/") + "/proxy"
+        _env = env
+        anthropic_ok  = proxy_url in _env.get("ANTHROPIC_BASE_URL", "")
+        openai_ok     = proxy_url in _env.get("OPENAI_BASE_URL", "")
+        perplexity_ok = proxy_url in _env.get("PERPLEXITY_BASE_URL", "")
+
+        covered   = [n for n, ok in [("Anthropic", anthropic_ok), ("OpenAI", openai_ok), ("Perplexity", perplexity_ok)] if ok]
+        uncovered = [n for n, ok in [("Anthropic", anthropic_ok), ("OpenAI", openai_ok), ("Perplexity", perplexity_ok)] if not ok]
+
+        GREEN, YELLOW, RED, RESET, BOLD = "", "", "", "", ""
+
+        if covered and not uncovered:
+            line = f"active — {', '.join(covered)} routed through Guard proxy"
+        elif covered:
+            line = f"partial — {', '.join(covered)} covered · {', '.join(uncovered)} NOT intercepted"
+        elif env_file_exists:
+            line = "inactive — ~/.conduct/env exists but not sourced in this shell."
+        else:
+            line = "not configured — run: conduct guard sync"
+        return line
+
+
+_CFG = {"api_url": "https://api.conductai.ai"}
+_PROXY = "https://api.conductai.ai/proxy"
+
+
+def test_all_three_active():
+    env = {
+        "ANTHROPIC_BASE_URL":  _PROXY,
+        "OPENAI_BASE_URL":     f"{_PROXY}/openai",
+        "PERPLEXITY_BASE_URL": f"{_PROXY}/perplexity",
+    }
+    line = _run_coverage_block(env, _CFG)
+    assert line.startswith("active")
+    assert "Anthropic" in line
+    assert "OpenAI" in line
+    assert "Perplexity" in line
+
+
+def test_partial_coverage():
+    env = {"ANTHROPIC_BASE_URL": _PROXY}
+    line = _run_coverage_block(env, _CFG)
+    assert line.startswith("partial")
+    assert "Anthropic" in line
+    assert "NOT intercepted" in line
+    assert "OpenAI" in line
+
+
+def test_inactive_env_file_exists():
+    line = _run_coverage_block({}, _CFG, env_file_exists=True)
+    assert line.startswith("inactive")
+    assert "~/.conduct/env" in line
+
+
+def test_not_configured_no_env_file():
+    line = _run_coverage_block({}, _CFG, env_file_exists=False)
+    assert line.startswith("not configured")
+    assert "conduct guard sync" in line
+
+
+def test_wrong_proxy_url_not_counted():
+    """Env var pointing to a different proxy should not count as covered."""
+    env = {"ANTHROPIC_BASE_URL": "https://some-other-proxy.io"}
+    line = _run_coverage_block(env, _CFG, env_file_exists=True)
+    assert line.startswith("inactive")