conduct-cli 0.7.14__tar.gz → 0.7.19__tar.gz

{conduct_cli-0.7.14 → conduct_cli-0.7.19}/PKG-INFO

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

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

{conduct_cli-0.7.14 → conduct_cli-0.7.19}/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"
@@ -18,8 +20,9 @@ GRAY   = "\033[90m"
 CYAN   = "\033[36m"
 YELLOW = "\033[33m"
 
-GUARD_DIR    = Path.home() / ".conductguard"
-CONFIG_PATH  = GUARD_DIR / "config.json"
+CONDUCT_HOME = Path.home() / ".conduct"
+GUARD_DIR    = CONDUCT_HOME
+CONFIG_PATH  = CONDUCT_HOME / "config.json"    # unified config — shared with main.py
 POLICY_PATH  = GUARD_DIR / "policy.json"
 
 
@@ -114,7 +117,7 @@ def _bash_command_words(cmd: str) -> list[str]:
     return words
 
 
-def _check_policy(tool_name, tool_input, tokens_before=0):
+def _check_policy(tool_name, tool_input, tokens_before=0, ai_tool=""):
     """Return (matched_rule, action, rule_id, message) or (None, 'allow', None, None)."""
     policy = _load_policy()
     if not policy.get("rules"):
@@ -132,7 +135,12 @@ 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
+        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
         # New: structural match against the actual binary being invoked.
         # Single string or list of strings; case-insensitive equality.
@@ -326,7 +334,7 @@ def _load_guard_config(workspace_id: str | None = None) -> dict:
 
 
 def _save_guard_config(data: dict, workspace_id: str | None = None):
-    GUARD_DIR.mkdir(parents=True, exist_ok=True)
+    CONDUCT_HOME.mkdir(parents=True, exist_ok=True)
     CONFIG_PATH.write_text(json.dumps(data, indent=2))
     CONFIG_PATH.chmod(0o600)
 
@@ -372,11 +380,11 @@ _MCP_TARGETS = [
 ]
 
 
-def _register_mcp(workspace_id: str, member_token: str, api_url: str) -> None:
+def _register_mcp(workspace_id: str, agent_token: str, api_url: str) -> None:
     """Write conductguard + agent-booster MCP entries into every AI tool config found.
 
     Credentials are NOT stored in the MCP config — the server reads them from
-    ~/.conductguard/config.json at startup, which is written by guard sync.
+    ~/.conduct/config.json at startup, which is written by guard sync.
     """
     import shutil
     servers: dict[str, dict] = {
@@ -412,13 +420,13 @@ def _register_mcp(workspace_id: str, member_token: str, api_url: str) -> None:
 
     # Claude Desktop doesn't source shell env — patch apiBaseUrl directly in config
     # so all LLM calls route through the Guard proxy (PII blocking, spend limits, audit).
-    _patch_claude_desktop_proxy(api_url, member_token)
+    _patch_claude_desktop_proxy(api_url, agent_token)
 
     # Cursor global rules — write Guard policies as user rules so they apply across all projects.
     _patch_cursor_global_rules()
 
 
-def _patch_claude_desktop_proxy(api_url: str, member_token: str) -> None:
+def _patch_claude_desktop_proxy(api_url: str, agent_token: str) -> None:
     """Patch Claude Desktop config to route LLM calls through the Guard proxy.
 
     Claude Desktop reads apiBaseUrl from its config JSON — it does not source
@@ -729,18 +737,18 @@ def cmd_guard_install(args):
         print(f"  {GRAY}Guard not installed for this workspace — skipping{RESET}")
         return
 
-    member_token   = result.get("member_token") or ""
+    agent_token    = result.get("agent_token") or ""
     user_email     = result.get("user_email") or ""
     clerk_user_id  = result.get("clerk_user_id") or ""
 
     # Persona selection — prompt once, skip if already chosen
     _ensure_persona(workspace_id, api_key, server)
 
-    # Persist guard config — include api_key so CLI commands can authenticate
+    # Persist unified config — single ~/.conduct/config.json
     import time as _time
     _save_guard_config({
         "workspace_id":          workspace_id,
-        "member_token":          member_token,
+        "agent_token":           agent_token,
         "user_email":            user_email,
         "clerk_user_id":         clerk_user_id,
         "api_key":               api_key,
@@ -777,7 +785,12 @@ def cmd_guard_install(args):
     _install_codex_hook(hook_path)
 
     # Register MCP in all found AI tools — Cursor/Windsurf (advisory)
-    _register_mcp(workspace_id, member_token or "", server)
+    _register_mcp(workspace_id, agent_token or "", server)
+
+    _cd = next((t for t in _detect_ai_tools() if t["name"] == "claude-desktop" and not t.get("proxy_routed")), None)
+    if _cd:
+        print(f"  {CYAN}Claude Desktop detected — patching apiBaseUrl to route through Guard proxy{RESET}")
+        _patch_claude_desktop_proxy(server, agent_token or "")
 
     # Install session persistence hooks (PreCompact + SessionStart)
     try:
@@ -812,7 +825,7 @@ def cmd_guard_install(args):
 
 
 def _write_signing_key(hex_key: str) -> None:
-    """Write a hex-encoded signing key to ~/.conductguard/signing.key.
+    """Write a hex-encoded signing key to ~/.conduct/signing.key.
 
     Validates that the path resolves within GUARD_DIR (no traversal) and
     that the value is a valid 64-char hex string (32 bytes).
@@ -857,7 +870,7 @@ def cmd_guard_join(args):
     result = _req("POST", f"{base_url}/guard/join", body=payload)
 
     workspace_id = result["workspace_id"]
-    member_token = result.get("member_token", "")
+    agent_token_install = result.get("agent_token", "")
     policy       = result.get("policy", {"workspace_id": workspace_id, "version": "1", "rules": []})
 
     # Download and persist policy
@@ -873,8 +886,8 @@ def cmd_guard_join(args):
         "api_url":        base_url,
         "last_synced_at": _time.time(),
     }
-    if member_token:
-        cfg["member_token"] = member_token
+    if agent_token_install:
+        cfg["agent_token"] = agent_token_install
     _save_guard_config(cfg)
 
     # Write hook script
@@ -892,18 +905,19 @@ def cmd_guard_join(args):
     )
 
 
-def _report_tools_to_server() -> None:
-    """Detect AI coding tools on this machine and POST coverage to Guard API. Silent on failure."""
-    home = Path.home()
+def _is_anthropic_proxied() -> bool:
+    url = os.environ.get("ANTHROPIC_BASE_URL", "")
+    return "conductai.ai" in url or "conduct" in url.lower()
 
-    def _check_json_key(path: Path, *keys) -> bool:
-        try:
-            d = json.loads(path.read_text()) if path.exists() else {}
-            for k in keys:
-                d = d.get(k, {}) if isinstance(d, dict) else {}
-            return bool(d) and isinstance(d, dict) and len(d) > 0
-        except Exception:
-            return False
+
+def _is_openai_proxied() -> bool:
+    url = os.environ.get("OPENAI_BASE_URL", "")
+    return "conductai.ai" in url or "conduct" in url.lower()
+
+
+def _detect_ai_tools() -> list[dict]:
+    """Return list of detected AI coding tools with mcp_registered, hook_registered, proxy_routed."""
+    home = Path.home()
 
     def _check_json_mcp(path: Path) -> bool:
         try:
@@ -927,6 +941,20 @@ def _report_tools_to_server() -> None:
         except Exception:
             return False
 
+    def _claude_desktop_proxied() -> bool:
+        candidates = [
+            home / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
+            home / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json",
+        ]
+        for p in candidates:
+            if p.exists():
+                try:
+                    url = json.loads(p.read_text()).get("apiBaseUrl", "")
+                    return "conductai.ai" in url or "conduct" in url.lower()
+                except Exception:
+                    pass
+        return False
+
     tools = []
 
     claude_dir = home / ".claude"
@@ -936,16 +964,27 @@ def _report_tools_to_server() -> None:
             "name": "claude-code",
             "mcp_registered": _check_json_mcp(settings),
             "hook_registered": _check_json_hook(settings),
+            "proxy_routed": _is_anthropic_proxied(),
         })
 
     codex_dir = home / ".codex"
     if codex_dir.exists():
         config = codex_dir / "config.toml"
-        tools.append({
-            "name": "codex",
-            "mcp_registered": _check_toml_str(config, "conduct-mcp"),
-            "hook_registered": _check_toml_str(config, "conductguard"),
-        })
+        is_desktop = _check_toml_str(config, "[desktop]")
+        if is_desktop:
+            tools.append({
+                "name": "codex-desktop",
+                "mcp_registered": _check_toml_str(config, "conduct-mcp"),
+                "hook_registered": _check_toml_str(config, "conductguard"),
+                "proxy_routed": False,
+            })
+        else:
+            tools.append({
+                "name": "codex",
+                "mcp_registered": _check_toml_str(config, "conduct-mcp"),
+                "hook_registered": _check_toml_str(config, "conductguard"),
+                "proxy_routed": _is_openai_proxied(),
+            })
 
     cursor_dir = home / ".cursor"
     if cursor_dir.exists():
@@ -953,6 +992,7 @@ def _report_tools_to_server() -> None:
             "name": "cursor",
             "mcp_registered": _check_json_mcp(cursor_dir / "mcp.json"),
             "hook_registered": False,
+            "proxy_routed": _is_anthropic_proxied(),
         })
 
     windsurf_dir = home / ".codeium" / "windsurf"
@@ -961,6 +1001,19 @@ def _report_tools_to_server() -> None:
             "name": "windsurf",
             "mcp_registered": _check_json_mcp(windsurf_dir / "mcp_config.json"),
             "hook_registered": False,
+            "proxy_routed": _is_anthropic_proxied(),
+        })
+
+    claude_desktop_candidates = [
+        home / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
+        home / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json",
+    ]
+    if any(p.exists() for p in claude_desktop_candidates):
+        tools.append({
+            "name": "claude-desktop",
+            "mcp_registered": False,
+            "hook_registered": False,
+            "proxy_routed": _claude_desktop_proxied(),
         })
 
     vscode_ext_dir = home / ".vscode" / "extensions"
@@ -983,8 +1036,16 @@ def _report_tools_to_server() -> None:
             "name": "vscode",
             "mcp_registered": mcp_reg,
             "hook_registered": False,
+            "proxy_routed": False,
         })
 
+    return tools
+
+
+def _report_tools_to_server() -> None:
+    """Detect AI coding tools on this machine and POST coverage to Guard API. Silent on failure."""
+    tools = _detect_ai_tools()
+
     if not tools:
         return
 
@@ -992,7 +1053,7 @@ def _report_tools_to_server() -> None:
         cfg = _load_guard_config()
         base_url = _api_url(cfg)
         email = cfg.get("user_email", "")
-        token = cfg.get("member_token", "")
+        token = cfg.get("agent_token", "")
         api_key = cfg.get("api_key", "")
 
         if not email:
@@ -1163,15 +1224,14 @@ def cmd_guard_sync(args):
             f"{base_url}/guard/config/installed?workspace_id={workspace_id}",
             api_key=api_key,
         )
-        fresh_token = installed.get("member_token") or ""
-        if fresh_token:
-            cfg["member_token"] = fresh_token
+        fresh_agent_token = installed.get("agent_token") or ""
+        if fresh_agent_token:
+            cfg["agent_token"] = fresh_agent_token
             _save_guard_config(cfg)
         else:
-            print(f"  {YELLOW}Warning: server returned no member token — proxy env may be stale{RESET}")
+            print(f"  {YELLOW}Warning: server returned no token — proxy env may be stale{RESET}")
     except Exception as e:
-        fresh_token = ""
-        print(f"  {YELLOW}Warning: could not refresh member token ({e}) — using cached value{RESET}")
+        print(f"  {YELLOW}Warning: could not refresh token ({e}) — using cached value{RESET}")
 
     # Write LLM proxy env vars so any AI tool (Claude Code, Cursor, Codex, …)
     # routes through Conduct Guard. Customer-overridable via --proxy-url or
@@ -1181,7 +1241,7 @@ def cmd_guard_sync(args):
         try:
             import urllib.request as _ur, urllib.error as _ue
             _headers = {"X-Api-Key": api_key, "Content-Type": "application/json"}
-            _token = cfg.get("member_token", "")
+            _token = cfg.get("agent_token", "")
             if _token:
                 _headers["Authorization"] = f"Bearer {_token}"
             _r = _ur.Request(f"{base_url}/guard/proxy-config", headers=_headers)
@@ -1189,13 +1249,29 @@ def cmd_guard_sync(args):
                 proxy_url = json.loads(_resp.read()).get("conduct_proxy_url") or DEFAULT_PROXY_URL
         except Exception:
             proxy_url = DEFAULT_PROXY_URL
-    member_token = cfg.get("member_token", "")
-    rc_path, newly_sourced = _write_proxy_env(member_token, proxy_url)
-    if member_token:
+    agent_token = cfg.get("agent_token", "")
+    rc_path, newly_sourced = _write_proxy_env(agent_token, proxy_url)
+    if agent_token:
         print(f"  {GREEN}Proxy env written:{RESET} ~/.conduct/env → {proxy_url}")
         if newly_sourced:
             print(f"  {CYAN}Run `source {rc_path}` (or open a new shell) to activate.{RESET}")
 
+    _tools = _detect_ai_tools()
+    if _tools:
+        print(f"\n  {'Tool':<20} {'Proxy Routed':<16} {'MCP':<8} {'Hooks'}")
+        print(f"  {'─'*20} {'─'*16} {'─'*8} {'─'*8}")
+        for t in _tools:
+            routed = "✓ Routed" if t.get("proxy_routed") else ("— Partial" if t["name"] == "codex-desktop" else "✗ Not routed")
+            mcp  = "✓" if t.get("mcp_registered") else "✗"
+            hook = "✓" if t.get("hook_registered") else "—"
+            print(f"  {t['name']:<20} {routed:<16} {mcp:<8} {hook}")
+        print()
+
+    _cd = next((t for t in _tools if t["name"] == "claude-desktop" and not t.get("proxy_routed")), None)
+    if _cd:
+        print(f"  {CYAN}Claude Desktop detected — patching apiBaseUrl to route through Guard proxy{RESET}")
+        _patch_claude_desktop_proxy(cfg.get("api_url", "https://api.conductai.ai"), agent_token)
+
     # Local key audit — scan known config files for real provider keys that
     # may have been pasted before the dev onboarded onto Conduct. Findings
     # surface in /guard/audit with a 'LOCAL RISK' badge. --no-local-audit
@@ -1220,7 +1296,7 @@ def cmd_guard_sync(args):
     _install_claude_hook(hook_path)
     _install_codex_hook(hook_path)
     cfg2 = _load_guard_config()
-    _register_mcp(workspace_id, cfg2.get("member_token", ""), base_url)
+    _register_mcp(workspace_id, cfg2.get("agent_token", ""), base_url)
     try:
         _install_session_hooks()
     except Exception:
@@ -1254,13 +1330,13 @@ def cmd_guard_sync(args):
     print(f"\n{BOLD}Policy refreshed ({rule_count} rule(s)).{RESET}")
 
     # Print Claude.ai remote MCP URL — requires one-time browser paste
-    member_token = cfg.get("member_token", "")
-    if workspace_id and member_token:
+    agent_token = cfg.get("agent_token", "")
+    if workspace_id and agent_token:
         mcp_url = "https://api.conductai.ai/guard/mcp"
         print(f"\n{BOLD}Claude.ai{RESET} (one-time browser setup):")
         print(f"  Settings → MCP Servers → Add custom server")
         print(f"  URL:    {CYAN}{mcp_url}{RESET}")
-        print(f"  Auth:   {CYAN}Bearer {member_token}{RESET}\n")
+        print(f"  Auth:   {CYAN}Bearer {agent_token}{RESET}\n")
 
 
 CONDUCT_DIR        = Path.home() / ".conduct"
@@ -1349,13 +1425,13 @@ def _post_local_findings(cfg: dict, base_url: str, findings: list[dict]) -> None
                 "findings":   findings,
             },
             api_key=cfg.get("api_key", ""),
-            token=cfg.get("member_token", ""),
+            token=cfg.get("agent_token", ""),
         )
     except Exception as e:
         print(f"  {YELLOW}Audit upload skipped: {e}{RESET}")
 
 
-def _write_proxy_env(member_token: str, proxy_url: str) -> tuple[Path, bool]:
+def _write_proxy_env(agent_token: str, proxy_url: str) -> tuple[Path, bool]:
     """Write ~/.conduct/env with the 3 provider env-var pairs and ensure the
     user's shell rc sources it.
 
@@ -1364,12 +1440,12 @@ def _write_proxy_env(member_token: str, proxy_url: str) -> tuple[Path, bool]:
     User-managed customizations go in ~/.conduct/env-override which is sourced
     after the managed file.
     """
-    if not member_token:
-        print(f"  {YELLOW}Proxy env skipped — no member token in config{RESET}")
+    if not agent_token:
+        print(f"  {YELLOW}Proxy env skipped — no agent token in config{RESET}")
         return Path(), False
 
     CONDUCT_DIR.mkdir(parents=True, exist_ok=True)
-    token = f"guard-mt-{member_token}"
+    token = agent_token  # cond_agt_* used directly as the API key value
     proxy = proxy_url.rstrip("/")
 
     PROXY_ENV_FILE.write_text("\n".join([
@@ -1614,10 +1690,10 @@ def _report_savings(cfg: dict, base_url: str, api_key: str) -> None:
     }
 
     try:
-        member_token = cfg.get("member_token", "")
+        agent_token_evt = cfg.get("agent_token", "")
         headers = {"Content-Type": "application/json"}
-        if member_token:
-            headers["Authorization"] = f"Bearer {member_token}"
+        if agent_token_evt:
+            headers["Authorization"] = f"Bearer {agent_token_evt}"
         elif api_key:
             headers["X-Api-Key"] = api_key
         data = json.dumps(payload).encode()
@@ -1932,7 +2008,7 @@ def register_guard_parser(sub):
         default=None,
         metavar="HEX",
         help="Hex-encoded 32-byte signing key from POST /workspaces/{id}/signing-key. "
-             "Written to ~/.conductguard/signing.key.",
+             "Written to ~/.conduct/signing.key.",
     )
 
     # conduct guard booster-status
@@ -1965,7 +2041,7 @@ def register_guard_parser(sub):
     # conduct guard lint [--file PATH]
     lint_p = guard_sub.add_parser("lint", help="Validate local policy — show errors and warnings")
     lint_p.add_argument("--file", default=None, metavar="FILE",
-                        help="Path to policy YAML/JSON (default: ~/.conductguard/policy.json)")
+                        help="Path to policy YAML/JSON (default: ~/.conduct/policy.json)")
 
     return guard_p, guard_sub
 
@@ -2101,8 +2177,8 @@ def _scan_processes() -> list[dict]:
     return found
 
 
-_WATCH_PID  = Path.home() / ".conductguard" / "watch.pid"
-_WATCH_LOG  = Path.home() / ".conductguard" / "watch.log"
+_WATCH_PID  = Path.home() / ".conduct" / "watch.pid"
+_WATCH_LOG  = Path.home() / ".conduct" / "watch.log"
 _WATCH_INTERVAL = 15 * 60  # seconds
 
 
@@ -2130,7 +2206,7 @@ def _watch_loop():
         try:
             c       = _cfg()
             api_url = _api_url(c)
-            token   = c.get("member_token", "")
+            token   = c.get("agent_token", "")
             api_key = c.get("api_key", "")
             agents = []
             for name, config_path, mcp_key in _discover_config_agents():
@@ -2306,7 +2382,7 @@ def cmd_guard_discover(args):
 
     cfg      = _load_guard_config()
     api_url  = _api_url(cfg)
-    token    = cfg.get("member_token", "")
+    token    = cfg.get("agent_token", "")
     api_key  = cfg.get("api_key", "")
     hdrs     = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
@@ -2357,7 +2433,16 @@ def cmd_guard_discover(args):
 
     # POST to API
     try:
-        payload = {"triggered_by": "cli", "agents": all_agents}
+        agents_payload = list(all_agents)
+        for t in _detect_ai_tools():
+            agents_payload.append({
+                "name": t["name"],
+                "framework": t["name"],
+                "source": "ai-tool",
+                "under_guard": t.get("mcp_registered", False),
+                "proxy_routed": t.get("proxy_routed", False),
+            })
+        payload = {"triggered_by": "cli", "agents": agents_payload}
         _req("POST", f"{api_url}/guard/discover/scan", body=payload, token=token, api_key=api_key)
     except SystemExit:
         pass  # 401/network errors — local output still useful

{conduct_cli-0.7.14 → conduct_cli-0.7.19}/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.14 → conduct_cli-0.7.19}/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"
 
 

{conduct_cli-0.7.14 → conduct_cli-0.7.19}/src/conduct_cli/hooks/pretooluse.py

@@ -10,6 +10,7 @@ import time
 import urllib.request
 from pathlib import Path
 
+from conduct_cli.tool_groups import expand_match_tool
 from conduct_cli.hooks.base import (
     BUDGET_CACHE_PATH,
     BUDGET_CACHE_TTL,
@@ -325,10 +326,16 @@ 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(",")]:
+            if tool_name 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 current_ai_tool.lower() for s in surfaces):
                 continue
         pattern = rule.get("match_pattern")
         if pattern:

{conduct_cli-0.7.14 → conduct_cli-0.7.19}/src/conduct_cli/main.py

@@ -339,14 +339,6 @@ def _report_tool_coverage() -> None:
         token   = cfg.get("token", "")
         email   = cfg.get("email", "")
 
-        # also check guard config for email/token
-        guard_cfg_path = Path.home() / ".conductguard" / "config.json"
-        if guard_cfg_path.exists():
-            gcfg = json.loads(guard_cfg_path.read_text())
-            if not email:
-                email = gcfg.get("user_email", "")
-            if not token:
-                token = gcfg.get("member_token", "")
 
         if not server or not email:
             return
@@ -1327,15 +1319,6 @@ def cmd_switch(args):
     cfg["workspace"] = new_id
     _atomic_write(CONFIG_PATH, cfg)
 
-    # Update ~/.conductguard/config.json atomically if it exists
-    guard_cfg_path = Path.home() / ".conductguard" / "config.json"
-    if guard_cfg_path.exists():
-        try:
-            guard_cfg = json.loads(guard_cfg_path.read_text())
-            guard_cfg["workspace_id"] = new_id
-            _atomic_write(guard_cfg_path, guard_cfg)
-        except Exception:
-            pass
 
     # Re-sync Guard policies for the new workspace
     try:
@@ -1382,26 +1365,21 @@ def cmd_whoami(args):
     print(f"{BOLD}Server:{RESET}     {server}")
     print(f"{BOLD}API key:{RESET}    {api_key_display}")
 
-    # Guard section
-    guard_cfg_path = Path.home() / ".conductguard" / "config.json"
-    policy_path    = Path.home() / ".conductguard" / "policy.json"
-    hook_path      = Path.home() / ".conductguard" / "hook.py"
-
-    if guard_cfg_path.exists():
-        try:
-            gcfg = json.loads(guard_cfg_path.read_text())
-            user_email = gcfg.get("user_email", "")
-            rule_count = 0
-            if policy_path.exists():
-                try:
-                    rule_count = len(json.loads(policy_path.read_text()).get("rules", []))
-                except Exception:
-                    pass
-            hook_status = "hook installed" if hook_path.exists() else "hook missing"
-            email_part  = f"  |  member: {user_email}" if user_email else ""
-            print(f"{BOLD}Guard:{RESET}      {GREEN}✓ {hook_status}{RESET}  |  policy: {rule_count} rules{email_part}")
-        except Exception:
-            print(f"{BOLD}Guard:{RESET}      {YELLOW}config unreadable{RESET}")
+    # Guard section — all under ~/.conduct/
+    policy_path = Path.home() / ".conduct" / "policy.json"
+    hook_path   = Path.home() / ".conduct" / "hook.py"
+    guard_email = cfg.get("user_email", "")
+    agent_token = cfg.get("agent_token", "")
+    if agent_token or hook_path.exists():
+        rule_count  = 0
+        if policy_path.exists():
+            try:
+                rule_count = len(json.loads(policy_path.read_text()).get("rules", []))
+            except Exception:
+                pass
+        hook_status = "hook installed" if hook_path.exists() else "hook missing"
+        email_part  = f"  |  member: {guard_email}" if guard_email else ""
+        print(f"{BOLD}Guard:{RESET}      {GREEN}✓ {hook_status}{RESET}  |  policy: {rule_count} rules{email_part}")
     else:
         print(f"{BOLD}Guard:{RESET}      not configured")
 
@@ -1558,8 +1536,7 @@ def _load_codex_sessions(active_cwds: set[str]) -> list[dict]:
     if not _CODEX_SESSIONS.exists():
         return []
 
-    guard_cfg = Path.home() / ".conductguard" / "config.json"
-    guard_on  = guard_cfg.exists()
+    guard_on  = (Path.home() / ".conduct" / "config.json").exists()
 
     rows = []
     # Walk the last 2 days of session dirs
@@ -1616,8 +1593,7 @@ def _load_sessions() -> list[dict]:
     if not _CLAUDE_SESSIONS.exists():
         return []
 
-    guard_cfg = Path.home() / ".conductguard" / "config.json"
-    guard_on  = guard_cfg.exists()
+    guard_on  = (Path.home() / ".conduct" / "config.json").exists()
 
     rows = []
     seen_sessions: set[str] = set()
@@ -1764,14 +1740,6 @@ def _render_tui(rows: list[dict]) -> None:
     """Full-screen TUI with live refresh. Uses rich.live if available, else ANSI loop."""
 
     cfg       = _load_config()
-    guard_cfg = {}
-    _gp = Path.home() / ".conductguard" / "config.json"
-    if _gp.exists():
-        try:
-            guard_cfg = json.loads(_gp.read_text())
-        except Exception:
-            pass
-
     def _build_rich_display(rows):
         from rich.table import Table
         from rich.panel import Panel
@@ -2849,8 +2817,8 @@ def cmd_memory(args):
 
 # ── Entry point ───────────────────────────────────────────────────────────────
 
-_GUARD_CONFIG = Path.home() / ".conductguard" / "config.json"
-_GUARD_SKIP   = Path.home() / ".conductguard" / ".setup_skip"
+_GUARD_CONFIG = Path.home() / ".conduct" / "config.json"
+_GUARD_SKIP   = Path.home() / ".conduct" / ".setup_skip"
 
 GREEN  = "\033[32m"
 YELLOW = "\033[33m"

conduct_cli-0.7.19/src/conduct_cli/tool_groups.py

@@ -0,0 +1,58 @@
+"""
+Canonical tool group mapping — single source of truth for semantic match_tool names.
+Shared across CLI hook, MCP, and API (mirrored at apps/api/app/modules/guard/tool_groups.py).
+"""
+
+TOOL_GROUPS: dict[str, set[str]] = {
+    "shell":            {"bash", "run_command", "execute", "terminal", "shell"},
+    "filesystem-write": {"write", "edit", "write_file", "edit_file", "str_replace_editor"},
+    "filesystem-read":  {"read", "read_file", "glob", "grep", "list_directory"},
+    "network":          {"web_fetch", "web_search", "http_request", "curl", "fetch"},
+}
+
+# Inverted: raw tool name → semantic group
+_RAW_TO_GROUP: dict[str, str] = {
+    raw: group
+    for group, raws in TOOL_GROUPS.items()
+    for raw in raws
+}
+
+
+def normalize_tool(tool_name: str) -> str:
+    """Map a raw tool name to its semantic group, or return as-is if unknown."""
+    return _RAW_TO_GROUP.get(tool_name.lower(), tool_name.lower())
+
+
+def expand_match_tool(match_tool: str) -> set[str]:
+    """
+    Expand a match_tool value (semantic group or raw name, comma-separated)
+    into the full set of raw tool names it covers.
+    """
+    result: set[str] = set()
+    for token in match_tool.split(","):
+        token = token.strip().lower()
+        if token == "*":
+            return {"*"}
+        if token in TOOL_GROUPS:
+            result |= TOOL_GROUPS[token]
+        else:
+            result.add(token)
+    return result
+
+
+def collapse_to_group(match_tool: str) -> str:
+    """
+    Collapse a comma-separated match_tool value to semantic group names.
+    e.g. "write,edit" → "filesystem-write"
+         "bash,run_command" → "shell"
+         "bash,write" → "shell,filesystem-write"
+    """
+    if not match_tool or match_tool.strip() == "*":
+        return "*"
+    tokens = [t.strip().lower() for t in match_tool.split(",") if t.strip()]
+    groups_seen: list[str] = []
+    for token in tokens:
+        group = _RAW_TO_GROUP.get(token, token)
+        if group not in groups_seen:
+            groups_seen.append(group)
+    return ",".join(groups_seen)

{conduct_cli-0.7.14 → conduct_cli-0.7.19}/src/conduct_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.7.14
+Version: 0.7.19
 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.14 → conduct_cli-0.7.19}/src/conduct_cli.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/conduct_cli/main.py
 src/conduct_cli/mcp_server.py
 src/conduct_cli/memory.py
 src/conduct_cli/paxel.py
+src/conduct_cli/tool_groups.py
 src/conduct_cli.egg-info/PKG-INFO
 src/conduct_cli.egg-info/SOURCES.txt
 src/conduct_cli.egg-info/dependency_links.txt
@@ -35,6 +36,7 @@ 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.14 → conduct_cli-0.7.19}/tests/test_advisory_and_hook.py

@@ -542,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.14 → conduct_cli-0.7.19}/tests/test_guard_policy.py

@@ -97,22 +97,26 @@ class TestMatchTool:
         assert action == "warn"
 
     def test_exact_tool_match(self, policy_path):
-        policy_path([_rule(match_tool="bash", action="warn")])
+        # semantic group "shell" matches raw tool "bash"
+        policy_path([_rule(match_tool="shell", action="warn")])
         _, action, _, _ = _check_policy("bash", {})
         assert action == "warn"
 
     def test_exact_tool_no_match(self, policy_path):
-        policy_path([_rule(match_tool="edit", action="block")])
+        # "filesystem-write" does not match "bash"
+        policy_path([_rule(match_tool="filesystem-write", action="block")])
         _, action, _, _ = _check_policy("bash", {})
         assert action == "allow"
 
     def test_comma_separated_includes_tool(self, policy_path):
-        policy_path([_rule(match_tool="bash,edit,write", action="warn")])
+        # "shell,filesystem-write" matches "edit" (filesystem-write group)
+        policy_path([_rule(match_tool="shell,filesystem-write", action="warn")])
         _, action, _, _ = _check_policy("edit", {})
         assert action == "warn"
 
     def test_comma_separated_excludes_tool(self, policy_path):
-        policy_path([_rule(match_tool="bash,edit,write", action="warn")])
+        # "shell,filesystem-write" does not match "read" (filesystem-read group)
+        policy_path([_rule(match_tool="shell,filesystem-write", action="warn")])
         _, action, _, _ = _check_policy("read", {})
         assert action == "allow"
 
@@ -122,6 +126,42 @@ class TestMatchTool:
         assert action == "warn"
 
 
+# ── match_ai_tool (surface filtering) ────────────────────────────────────────
+
+def _surface_rule(**kw):
+    return _rule(match_tool="shell", match_pattern=r".*", **kw)
+
+class TestMatchAiTool:
+    def test_surface_match_blocks(self, policy_path):
+        policy_path([_surface_rule(match_ai_tool="claude-ai", action="block")])
+        _, action, _, _ = _check_policy("bash", {"command": "ls"}, ai_tool="claude-ai")
+        assert action == "block"
+
+    def test_surface_no_match_allows(self, policy_path):
+        # rule targets claude-ai, tool is claude-code — should not fire
+        policy_path([_surface_rule(match_ai_tool="claude-ai", action="block")])
+        _, action, _, _ = _check_policy("bash", {"command": "ls"}, ai_tool="claude-code")
+        assert action == "allow"
+
+    def test_surface_multi_targets(self, policy_path):
+        # comma-separated: matches any listed surface
+        policy_path([_surface_rule(match_ai_tool="claude-ai,openai-chatgpt", action="warn")])
+        _, action, _, _ = _check_policy("bash", {"command": "ls"}, ai_tool="openai-chatgpt")
+        assert action == "warn"
+
+    def test_no_match_ai_tool_field_always_fires(self, policy_path):
+        # rule with no match_ai_tool applies to all surfaces
+        policy_path([_surface_rule(action="warn")])
+        _, action, _, _ = _check_policy("bash", {"command": "ls"}, ai_tool="cursor")
+        assert action == "warn"
+
+    def test_unknown_surface_skipped(self, policy_path):
+        # empty ai_tool string doesn't match a specific surface rule
+        policy_path([_surface_rule(match_ai_tool="claude-ai", action="block")])
+        _, action, _, _ = _check_policy("bash", {"command": "ls"}, ai_tool="")
+        assert action == "allow"
+
+
 # ── match_pattern ─────────────────────────────────────────────────────────────
 
 class TestMatchPattern:

conduct_cli-0.7.19/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")