conduct-cli 0.7.10__tar.gz → 0.7.17__tar.gz

{conduct_cli-0.7.10 → conduct_cli-0.7.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.7.10
+Version: 0.7.17
 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.10 → conduct_cli-0.7.17}/pyproject.toml

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

{conduct_cli-0.7.10 → conduct_cli-0.7.17}/src/conduct_cli/guard.py

@@ -9,6 +9,8 @@ import urllib.request
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
+from conduct_cli.tool_groups import expand_match_tool
+
 RESET  = "\033[0m"
 BOLD   = "\033[1m"
 GREEN  = "\033[32m"
@@ -132,7 +134,7 @@ def _check_policy(tool_name, tool_input, tokens_before=0):
     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(",")]:
+            if tool_name not in expand_match_tool(match_tool):
                 continue
         # New: structural match against the actual binary being invoked.
         # Single string or list of strings; case-insensitive equality.
@@ -759,7 +761,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 +1724,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 +2550,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.10 → conduct_cli-0.7.17}/src/conduct_cli/guardmcp.py

@@ -12,6 +12,7 @@ Exposes three tools:
   guard_sync    — pull latest policy from the ConductGuard API
 """
 from __future__ import annotations
+from conduct_cli.tool_groups import expand_match_tool
 import argparse
 import json
 import re
@@ -183,14 +184,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 +269,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 expand_match_tool(match_tool):
                 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.10 → conduct_cli-0.7.17}/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:
@@ -211,6 +283,7 @@ def post_event(
     session_id: Optional[str] = None,
     *,
     drain_via: Optional[Path] = None,
+    blast_radius: "dict | None" = None,
 ) -> None:
     """Post one guard event via the journal/drain pattern.  Never raises.
 
@@ -235,6 +308,7 @@ def post_event(
         "hook_session_id": session_id,
         "os_info":         _os_info,
         "hostname":        _platform.node(),
+        "blast_radius":    blast_radius,
     })
     api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
     journal_append(payload, api_url)

{conduct_cli-0.7.10 → conduct_cli-0.7.17}/src/conduct_cli/hooks/posttooluse.py

@@ -247,7 +247,51 @@ def _scan_codex_tokens(transcript_path: str):
     return 0, 0
 
 
-def _post_usage(session_id, tool_name, tokens_input, tokens_output, duration_ms) -> None:
+def _compute_blast_radius(tool_name: str, tool_input: dict, tool_response: str) -> "dict | None":
+    """Classify blast radius after tool execution. Returns None for read-only tools."""
+    import re as _re
+
+    READ_ONLY = {"read", "ls", "glob", "search", "grep", "websearch", "webfetch", "computer"}
+    if tool_name in READ_ONLY:
+        return None
+
+    files = 0
+    symbols: "int | None" = None
+    tier = "local"
+
+    if tool_name in ("bash", "terminal"):
+        cmd = (tool_input.get("command") or "").lower()
+        if _re.search(r"\brm\s+.*-rf|\brm\s+-rf", cmd):
+            tier = "destructive"
+        elif _re.search(r"\bgit\s+(push|commit|merge|rebase|reset|tag)\b", cmd):
+            tier = "repo"
+        elif _re.search(r"\b(curl|wget|fetch)\b|https?://", cmd):
+            tier = "network"
+        # count path-like lines in output as proxy for files touched
+        lines = (tool_response or "").splitlines()
+        files = min(sum(1 for l in lines if "/" in l or ("." in l and len(l) < 200)), 50)
+
+    elif tool_name in ("write",):
+        files = 1
+        content = tool_input.get("content") or ""
+        symbols = len(content.splitlines()) or None
+
+    elif tool_name in ("edit", "str_replace_based_edit_tool", "str_replace_editor"):
+        files = 1
+        new_str = tool_input.get("new_string") or tool_input.get("new_content") or ""
+        symbols = len(new_str.splitlines()) or None
+
+    elif tool_name in ("multiedit",):
+        edits = tool_input.get("edits") or []
+        files = len(edits)
+
+    else:
+        files = 1  # unknown write-like tool
+
+    return {"files": files, "symbols": symbols, "tier": tier}
+
+
+def _post_usage(session_id, tool_name, tokens_input, tokens_output, duration_ms, blast_radius=None) -> None:
     """Fire-and-forget POST to /guard/events/usage."""
     cfg = load_config()
     workspace_id = cfg.get("workspace_id")
@@ -261,6 +305,7 @@ def _post_usage(session_id, tool_name, tokens_input, tokens_output, duration_ms)
         "tokens_output":   tokens_output,
         "duration_ms":     duration_ms,
         "ai_tool":         detect_ai_tool(),
+        "blast_radius":    blast_radius,
     })
     api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
     script = (
@@ -300,7 +345,7 @@ def post_codex_main() -> None:
     transcript_path = args.get("transcript_path", "")
     tokens_in, tokens_out = _scan_codex_tokens(transcript_path)
     if tokens_in or tokens_out:
-        _post_usage(args.get("session_id"), args.get("tool_name"), tokens_in, tokens_out, None)
+        _post_usage(args.get("session_id"), args.get("tool_name"), tokens_in, tokens_out, None, args.get("blast_radius"))
     sys.exit(0)
 
 
@@ -320,6 +365,10 @@ def main() -> None:
     is_codex      = (tool_use_id or "").startswith("call_")
     session_id    = data.get("session_id") or (f"transcript:{transcript_path}" if transcript_path else None)
 
+    tool_response = data.get("tool_response") or data.get("output") or ""
+    tool_input    = data.get("tool_input") or {}
+    blast_radius  = _compute_blast_radius(tool_name, tool_input, str(tool_response))
+
     if is_codex and transcript_path:
         import uuid as _uuid
         pending = GUARD_DIR / f"codex_pending_{_uuid.uuid4().hex[:8]}.json"
@@ -328,6 +377,7 @@ def main() -> None:
                 "session_id":      session_id,
                 "tool_name":       tool_name,
                 "transcript_path": transcript_path,
+                "blast_radius":    blast_radius,
             }))
             subprocess.Popen(
                 [sys.executable, str(_this_file), "post-codex", str(pending)],
@@ -339,7 +389,7 @@ def main() -> None:
             pass
     elif transcript_path:
         tokens_input, tokens_output = _read_tokens_from_transcript(transcript_path, tool_use_id)
-        _post_usage(session_id, tool_name, tokens_input, tokens_output, None)
+        _post_usage(session_id, tool_name, tokens_input, tokens_output, None, blast_radius)
         _, action, rule_id, message = check_policy(tool_name, {}, tokens_before=tokens_input)
         if action in ("warn", "block"):
             decision = "warned" if action == "warn" else "blocked"
@@ -348,10 +398,7 @@ def main() -> None:
             else:
                 if action == "warn" and session_id and rule_id:
                     _record_session_warn(session_id, rule_id)
-                post_event(tool_name, {}, decision, rule_id, message, session_id, drain_via=_this_file)
-
-    tool_response = data.get("tool_response") or data.get("output") or ""
-    tool_input    = data.get("tool_input") or {}
+                post_event(tool_name, {}, decision, rule_id, message, session_id, drain_via=_this_file, blast_radius=blast_radius)
     _maybe_emit_security_finding(str(tool_response), session_id, tool_name, tool_input)
 
     sys.exit(0)