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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conduct-cli"
-version = "0.7.17"
+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.17 → conduct_cli-0.7.19}/src/conduct_cli/guard.py

@@ -20,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"
 
 
@@ -116,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"):
@@ -136,6 +137,11 @@ def _check_policy(tool_name, tool_input, tokens_before=0):
         if match_tool != "*":
             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.
         cw = rule.get("match_command_word")
@@ -328,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)
 
@@ -374,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] = {
@@ -414,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
@@ -731,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,
@@ -779,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:
@@ -814,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).
@@ -859,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
@@ -875,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
@@ -894,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:
@@ -929,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"
@@ -938,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():
@@ -955,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"
@@ -963,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"
@@ -985,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
 
@@ -994,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:
@@ -1165,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
@@ -1183,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)
@@ -1191,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
@@ -1222,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:
@@ -1256,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"
@@ -1351,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.
 
@@ -1366,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([
@@ -1616,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()
@@ -1934,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
@@ -1967,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
 
@@ -2103,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
 
 
@@ -2132,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():
@@ -2308,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"}
 
@@ -2359,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.17 → 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.17 → 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.17
+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.17 → conduct_cli-0.7.19}/tests/test_guard_policy.py

@@ -126,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: