conduct-cli 0.12.0__tar.gz → 0.14.0__tar.gz

{conduct_cli-0.12.0 → conduct_cli-0.14.0}/PKG-INFO

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

{conduct_cli-0.12.0 → conduct_cli-0.14.0}/pyproject.toml

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

{conduct_cli-0.12.0 → conduct_cli-0.14.0}/src/conduct_cli/guard.py

@@ -471,7 +471,7 @@ def _patch_claude_desktop_proxy(api_url: str, agent_token: str) -> None:
     shell env vars, so ANTHROPIC_BASE_URL has no effect. We write the proxy
     URL directly so PII blocking, spend limits, and audit apply to Desktop too.
     """
-    proxy_url = f"{api_url}/proxy/anthropic"
+    proxy_url = f"{api_url.rstrip('/')}/gateway/v1/anthropic"
     candidates = [
         Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
         Path.home() / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json",
@@ -695,9 +695,35 @@ def _install_codex_hook(hook_path: Path) -> None:
 
     hook_section = hooks.setdefault("hooks", {})
 
+    hook_path_str = str(hook_path)
+    # Match the retired location only to delete stale registrations. The
+    # desired entry below always points at the current ~/.conduct/hook.py.
+    stale_hook_path = str(Path.home() / ".conductguard" / "hook.py")
+    conduct_hook_paths = {
+        hook_path_str,
+        str(Path.home() / ".conduct" / "hook.py"),
+        stale_hook_path,
+    }
+
+    def _is_conduct_hook(entry: dict) -> bool:
+        command = entry.get("command", "")
+        return any(path in command for path in conduct_hook_paths)
+
+    def _replace_conduct_entries(entries: list, command: str) -> tuple[list, bool]:
+        kept = []
+        removed = False
+        for registration in entries:
+            commands = registration.get("hooks", [])
+            filtered = [entry for entry in commands if not _is_conduct_hook(entry)]
+            if len(filtered) != len(commands):
+                removed = True
+            if filtered:
+                kept.append({**registration, "hooks": filtered})
+        desired = {"matcher": ".*", "hooks": [{"type": "command", "command": command}]}
+        return [*kept, desired], removed or entries != [*kept, desired]
+
     # PreToolUse
     pre_cmd = f"{_best_python()} {hook_path}"
-    hook_path_str = str(hook_path)
     pre = hook_section.setdefault("PreToolUse", [])
     # Match by hook path so old python3/python3.11 entries are treated as already registered
     pre_already = any(
@@ -706,16 +732,9 @@ def _install_codex_hook(hook_path: Path) -> None:
         for e in h.get("hooks", [])
     )
     changed = False
-    if not pre_already:
-        pre.append({"matcher": ".*", "hooks": [{"type": "command", "command": pre_cmd}]})
-        changed = True
-    else:
-        # Update existing entry to use current sys.executable
-        for h in pre:
-            for e in h.get("hooks", []):
-                if hook_path_str in e.get("command", "") and e["command"] != pre_cmd:
-                    e["command"] = pre_cmd
-                    changed = True
+    normalized_pre, pre_changed = _replace_conduct_entries(pre, pre_cmd)
+    hook_section["PreToolUse"] = normalized_pre
+    changed = pre_changed
 
     # PostToolUse
     post_cmd = f"{_best_python()} {hook_path} post"
@@ -734,9 +753,9 @@ def _install_codex_hook(hook_path: Path) -> None:
         for h in post
         for e in h.get("hooks", [])
     )
-    if not post_already:
-        post.append({"matcher": ".*", "hooks": [{"type": "command", "command": post_cmd}]})
-        changed = True
+    normalized_post, post_changed = _replace_conduct_entries(post, post_cmd)
+    hook_section["PostToolUse"] = normalized_post
+    changed = changed or post_changed
     if cleaned:
         changed = True
 
@@ -751,6 +770,36 @@ def _install_codex_hook(hook_path: Path) -> None:
         print(f"  {GRAY}Codex hooks already registered{RESET}")
 
 
+def _configure_codex_proxy(proxy_url: str) -> bool:
+    """Opt in Codex to Conduct's Responses endpoint without storing a secret."""
+    config_path = Path.home() / ".codex" / "config.toml"
+    if not config_path.parent.exists():
+        return False
+    content = config_path.read_text() if config_path.exists() else ""
+    backup = config_path.with_suffix(".toml.pre-conduct-proxy")
+    if config_path.exists() and not backup.exists():
+        backup.write_text(content)
+        backup.chmod(0o600)
+
+    import re as _re
+    sections = _re.split(r"(?m)(?=^\[)", content)
+    root = sections[0]
+    root = _re.sub(r'(?m)^model_provider\s*=.*\n?', '', root)
+    root = root.rstrip() + '\nmodel_provider = "conduct"\n\n'
+    remaining = [s for s in sections[1:] if not s.startswith("[model_providers.conduct]")]
+    base = proxy_url.rstrip("/") + "/openai/v1"
+    snippet = (
+        "[model_providers.conduct]\n"
+        'name = "Conduct Gateway"\n'
+        f"base_url = {json.dumps(base)}\n"
+        'env_key = "OPENAI_API_KEY"\n'
+        'wire_api = "responses"\n'
+        'requires_openai_auth = false\n\n'
+    )
+    config_path.write_text(root + snippet + "".join(remaining).lstrip())
+    return True
+
+
 # ── HTTP helpers (no third-party deps — mirrors api.py style) ─────────────────
 
 def _default_agent_token() -> str | None:
@@ -1520,7 +1569,8 @@ def cmd_guard_sync(args):
     # Write LLM proxy env vars so any AI tool (Claude Code, Cursor, Codex, …)
     # routes through Conduct Guard. Customer-overridable via --proxy-url or
     # CONDUCT_PROXY_URL env var; otherwise fetched from server (workspace_config).
-    proxy_url = getattr(args, "proxy_url", None) or os.environ.get("CONDUCT_PROXY_URL")
+    explicit_proxy_url = getattr(args, "proxy_url", None) or os.environ.get("CONDUCT_PROXY_URL")
+    proxy_url = explicit_proxy_url
     if not proxy_url:
         try:
             import urllib.request as _ur, urllib.error as _ue
@@ -1533,6 +1583,8 @@ 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
+    if not explicit_proxy_url:
+        proxy_url = _gateway_v1_url(proxy_url)
     agent_token = cfg.get("agent_token", "")
     rc_path, newly_sourced = _write_proxy_env(agent_token, proxy_url)
     if agent_token:
@@ -1541,6 +1593,11 @@ def cmd_guard_sync(args):
         print(f"  {GREEN}Proxy env written:{RESET} ~/.conduct/{env_name} → {proxy_url}")
         if newly_sourced:
             print(f"  {CYAN}Run `{activate_cmd}` (or open a new shell) to activate.{RESET}")
+    if not getattr(args, "no_codex_proxy", False):
+        if _configure_codex_proxy(proxy_url):
+            print(f"  {GREEN}Codex proxy enabled:{RESET} Responses API via Conduct (restart Codex)")
+        else:
+            print(f"  {YELLOW}Codex proxy skipped:{RESET} ~/.codex is not installed")
 
     _tools = _detect_ai_tools()
     if _tools:
@@ -1628,11 +1685,19 @@ def cmd_guard_sync(args):
 CONDUCT_DIR        = Path.home() / ".conduct"
 PROXY_ENV_FILE     = CONDUCT_DIR / "env"
 PROXY_OVERRIDE     = CONDUCT_DIR / "env-override"
-DEFAULT_PROXY_URL  = "https://api.conductai.ai/proxy"
+DEFAULT_PROXY_URL  = "https://api.conductai.ai/gateway/v1"
 SHELL_RC_MARKER    = "# Conduct Guard Proxy — managed by `conduct guard sync`"
 SHELL_SOURCE_LINE  = "[ -f ~/.conduct/env ] && . ~/.conduct/env"
 
 
+def _gateway_v1_url(proxy_url: str) -> str:
+    """Convert a legacy server proxy URL to the parallel gateway surface."""
+    base = proxy_url.rstrip("/")
+    if base.endswith("/proxy"):
+        return base[:-len("/proxy")] + "/gateway/v1"
+    return base
+
+
 # ── Local key audit ──────────────────────────────────────────────────────────
 # Patterns that match real provider keys (NOT our member tokens).
 # Tuples of (provider, regex). Compiled once at import.
@@ -1727,10 +1792,10 @@ def _write_proxy_env_windows(agent_token: str, proxy_url: str) -> tuple[Path, bo
         SHELL_RC_MARKER,
         "# Edit ~/.conduct/env-override.ps1 to add your own vars — sourced after this file.",
         "",
-        f'$env:ANTHROPIC_BASE_URL = "{proxy}"',
+        f'$env:ANTHROPIC_BASE_URL = "{proxy}/anthropic"',
         f'$env:ANTHROPIC_API_KEY  = "{token}"',
         "",
-        f'$env:OPENAI_BASE_URL = "{proxy}/openai"',
+        f'$env:OPENAI_BASE_URL = "{proxy}/openai/v1"',
         f'$env:OPENAI_API_KEY  = "{token}"',
         "",
         f'$env:PERPLEXITY_BASE_URL = "{proxy}/perplexity"',
@@ -1796,10 +1861,10 @@ def _write_proxy_env(agent_token: str, proxy_url: str) -> tuple[Path, bool]:
         SHELL_RC_MARKER,
         "# Edit ~/.conduct/env-override to add your own vars — sourced after this file.",
         "",
-        f'export ANTHROPIC_BASE_URL="{proxy}"',
+        f'export ANTHROPIC_BASE_URL="{proxy}/anthropic"',
         f'export ANTHROPIC_API_KEY="{token}"',
         "",
-        f'export OPENAI_BASE_URL="{proxy}/openai"',
+        f'export OPENAI_BASE_URL="{proxy}/openai/v1"',
         f'export OPENAI_API_KEY="{token}"',
         "",
         f'export PERPLEXITY_BASE_URL="{proxy}/perplexity"',
@@ -2152,14 +2217,27 @@ def cmd_guard_status(args):
     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"
+        daemon_line = f"{RED}not running{RESET} — will start on next tool call"
+
+    journal_dir = Path.home() / ".conduct" / "journal"
+    queued_events = len(list(journal_dir.glob("*.json"))) if journal_dir.exists() else 0
+    dead_events = len(list((journal_dir / "dead-letter").glob("*.json"))) if (journal_dir / "dead-letter").exists() else 0
+    heartbeat_path = Path.home() / ".conduct" / "hook-heartbeat.json"
+    heartbeat_line = "never observed"
+    try:
+        heartbeat = json.loads(heartbeat_path.read_text())
+        age = max(0, int(time.time() - float(heartbeat["ts"])))
+        heartbeat_line = f"{heartbeat.get('event', 'hook')} · {age}s ago"
+    except Exception:
+        pass
 
     # 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","")
+    def _conduct_proxy_url(value: str) -> bool:
+        return "api.conductai.ai" in value and ("/gateway/v1" in value or "/proxy" in value)
+    anthropic_ok   = _conduct_proxy_url(_env.get("ANTHROPIC_BASE_URL", ""))
+    openai_ok      = _conduct_proxy_url(_env.get("OPENAI_BASE_URL", ""))
+    perplexity_ok  = _conduct_proxy_url(_env.get("PERPLEXITY_BASE_URL", ""))
     env_file_exists = (Path.home() / ".conduct" / "env").exists()
 
     def _cov(ok: bool, name: str) -> str:
@@ -2185,6 +2263,8 @@ def cmd_guard_status(args):
     print()
     print(f"Proxy coverage: {proxy_line}")
     print(f"Drain daemon:   {daemon_line}")
+    print(f"Event journal:  {queued_events} queued · {dead_events} dead-letter")
+    print(f"Hook heartbeat: {heartbeat_line}")
     print()
     print(f"Today:")
     print(f"  Sessions: {session_str}")
@@ -2357,7 +2437,9 @@ def register_guard_parser(sub):
     sync_p.add_argument("--reset-instructions", action="store_true", dest="reset_instructions",
                         help="Remove ConductGuard blocks from all instruction files")
     sync_p.add_argument("--proxy-url", default=None,
-                        help="Override the Guard proxy URL (default: https://api.conductai.ai/proxy/anthropic)")
+                        help="Override the Guard gateway URL (default: https://api.conductai.ai/gateway/v1)")
+    sync_p.add_argument("--no-codex-proxy", action="store_true",
+                        help="Leave Codex model traffic on its current provider")
     sync_p.add_argument("--no-local-audit", action="store_true",
                         help="Skip the local pre-existing API key scan")
 

{conduct_cli-0.12.0 → conduct_cli-0.14.0}/src/conduct_cli/hooks/base.py

@@ -28,7 +28,9 @@ VERSION_CACHE_TTL  = 60    # seconds
 WARNED_RULES_PATH  = GUARD_DIR / "warned_rules.json"
 SIGNING_KEY_PATH   = GUARD_DIR / "signing.key"
 JOURNAL_DIR        = GUARD_DIR / "journal"
+JOURNAL_DEAD_DIR   = JOURNAL_DIR / "dead-letter"
 JOURNAL_PID_PATH   = JOURNAL_DIR / "drain.pid"
+HOOK_HEARTBEAT_PATH = GUARD_DIR / "hook-heartbeat.json"
 
 SNAPSHOT_PATH    = GUARD_DIR / "session_snapshot.json"
 CONDUCT_ENV_PATH = Path.home() / ".conduct" / "env"
@@ -42,6 +44,18 @@ class HookResult:
     metadata: dict = field(default_factory=dict)
 
 
+def record_hook_heartbeat(event_name: str) -> None:
+    """Record local hook liveness without storing request or user data."""
+    try:
+        GUARD_DIR.mkdir(parents=True, exist_ok=True)
+        tmp = HOOK_HEARTBEAT_PATH.with_suffix(".tmp")
+        tmp.write_text(json.dumps({"event": event_name, "ts": time.time()}))
+        tmp.chmod(0o600)
+        tmp.replace(HOOK_HEARTBEAT_PATH)
+    except Exception:
+        pass
+
+
 # ── Config loading ────────────────────────────────────────────────────────────
 
 def load_config() -> dict:
@@ -155,11 +169,13 @@ def journal_append(payload_str: str, api_url: str) -> None:
     """Atomically write one event to the journal for the drain daemon to pick up."""
     try:
         JOURNAL_DIR.mkdir(parents=True, exist_ok=True)
+        JOURNAL_DIR.chmod(0o700)
         import random
         name = f"{time.time_ns()}_{random.randint(0, 9999):04d}.json"
-        entry = json.dumps({"api_url": api_url, "payload": payload_str})
+        entry = json.dumps({"api_url": api_url, "payload": payload_str, "attempts": 0})
         tmp = JOURNAL_DIR / (name + ".tmp")
         tmp.write_text(entry)
+        tmp.chmod(0o600)
         tmp.rename(JOURNAL_DIR / name)
     except Exception:
         pass
@@ -256,6 +272,7 @@ def run_drain_daemon() -> None:
     try:
         JOURNAL_DIR.mkdir(parents=True, exist_ok=True)
         JOURNAL_PID_PATH.write_text(str(_os.getpid()))
+        JOURNAL_PID_PATH.chmod(0o600)
     except Exception:
         return
     empty_scans = 0
@@ -268,6 +285,7 @@ def run_drain_daemon() -> None:
             continue
         posted_any = False
         for f in files:
+            entry: dict = {}
             try:
                 entry = json.loads(f.read_text())
                 api_url = entry["api_url"]
@@ -293,8 +311,29 @@ def run_drain_daemon() -> None:
                 urllib.request.urlopen(req, timeout=8)
                 f.unlink(missing_ok=True)
                 posted_any = True
-            except Exception:
-                pass
+            except Exception as exc:
+                attempts = int(entry.get("attempts", 0)) + 1
+                status = getattr(exc, "code", None)
+                permanent = isinstance(status, int) and 400 <= status < 500 and status not in (408, 429)
+                try:
+                    if permanent or attempts >= 5:
+                        JOURNAL_DEAD_DIR.mkdir(parents=True, exist_ok=True)
+                        JOURNAL_DEAD_DIR.chmod(0o700)
+                        entry["attempts"] = attempts
+                        entry["last_error"] = f"HTTP {status}" if status else type(exc).__name__
+                        destination = JOURNAL_DEAD_DIR / f.name
+                        destination.write_text(json.dumps(entry))
+                        destination.chmod(0o600)
+                        f.unlink(missing_ok=True)
+                    else:
+                        entry["attempts"] = attempts
+                        entry["last_error"] = f"HTTP {status}" if status else type(exc).__name__
+                        tmp = f.with_suffix(".tmp")
+                        tmp.write_text(json.dumps(entry))
+                        tmp.chmod(0o600)
+                        tmp.replace(f)
+                except Exception:
+                    pass
         if not posted_any:
             empty_scans += 1
             time.sleep(2)

{conduct_cli-0.12.0 → conduct_cli-0.14.0}/src/conduct_cli/hooks/posttooluse.py

@@ -1,4 +1,4 @@
-"""ConductGuard PostToolUse hook — token tracking + security classifier."""
+"""ConductGuard PostToolUse hook — token tracking."""
 from __future__ import annotations
 
 import json
@@ -12,6 +12,7 @@ from conduct_cli.hooks.base import (
     detect_ai_tool,
     load_config,
     post_event,
+    record_hook_heartbeat,
     run_drain_daemon,
 )
 from conduct_cli.hooks.pretooluse import (
@@ -20,139 +21,6 @@ from conduct_cli.hooks.pretooluse import (
     check_policy,
 )
 
-# ── Security classifier ───────────────────────────────────────────────────────
-
-SECRET_PATTERNS = [
-    (r"sk-[A-Za-z0-9]{20,}",             "secret-leak",    "high",     "Potential OpenAI/Anthropic API key"),
-    (r"ghp_[A-Za-z0-9]{36}",              "secret-leak",    "high",     "GitHub Personal Access Token"),
-    (r"AKIA[0-9A-Z]{16}",                 "secret-leak",    "critical", "AWS Access Key ID"),
-    (r"Bearer\s+[A-Za-z0-9+/=]{20,}",     "secret-leak",    "high",     "Bearer token in output"),
-    (r"""password\s*=\s*['"][^'"]{4,}""", "secret-leak",    "high",     "Hardcoded password"),
-    (r"""api[_-]?key\s*=\s*['"][^'"]{4,}""", "secret-leak", "high",    "Hardcoded API key"),
-    (r"\.\./\.\./\.\./",                  "path-traversal", "medium",   "Path traversal sequence"),
-    (r"file://",                           "path-traversal", "medium",   "File URI scheme in output"),
-    (r"eval\s*\(",                         "injection",      "high",     "eval() in output"),
-    (r"exec\s*\(",                         "injection",      "high",     "exec() in output"),
-    (r"__import__\s*\(",                   "injection",      "high",     "__import__() in output"),
-    (r"ssl\.CERT_NONE",                    "crypto",         "high",     "SSL verification disabled"),
-    (r"verify\s*=\s*False",                "crypto",         "medium",   "TLS verification bypassed"),
-]
-OWASP_KEYWORDS = [
-    ("sql injection",     "injection",    "high",   "SQL injection mentioned in AI output"),
-    ("cross-site scripting", "injection", "high",   "XSS mentioned in AI output"),
-    (" xss ",             "injection",    "high",   "XSS mentioned in AI output"),
-    ("idor",              "injection",    "medium", "IDOR mentioned in AI output"),
-    ("ssrf",              "injection",    "high",   "SSRF mentioned in AI output"),
-    ("command injection", "injection",    "high",   "Command injection mentioned in AI output"),
-    ("auth bypass",       "auth-bypass",  "high",   "Auth bypass mentioned in AI output"),
-]
-
-
-def _classify_text(text: str):
-    import re as _re
-    for pattern, ftype, sev, desc in SECRET_PATTERNS:
-        if _re.search(pattern, text, _re.IGNORECASE):
-            return ftype, sev, desc, pattern
-    lower = text.lower()
-    for kw, ftype, sev, desc in OWASP_KEYWORDS:
-        if kw in lower:
-            return ftype, sev, desc, kw
-    return None, None, None, None
-
-
-def _line_number_from_text(text: str, matched_pattern: str):
-    import re as _re
-    if not matched_pattern:
-        return None
-    try:
-        for raw_line in text.splitlines():
-            m = _re.match(r"^\s*(\d+)\t(.*)$", raw_line)
-            if m:
-                lineno, content = int(m.group(1)), m.group(2)
-                try:
-                    if _re.search(matched_pattern, content, _re.IGNORECASE):
-                        return lineno
-                except Exception:
-                    if matched_pattern.lower() in content.lower():
-                        return lineno
-        m = _re.search(matched_pattern, text, _re.IGNORECASE)
-        if m:
-            return text[:m.start()].count(chr(10)) + 1
-    except Exception:
-        pass
-    return None
-
-
-def _maybe_emit_security_finding(tool_response, session_id, tool_name, tool_input=None) -> None:
-    """Classify tool output + input for security findings; POST if flag ON. Never raises."""
-    try:
-        cfg = load_config()
-    except Exception:
-        return
-    if not cfg.get("security_emit_enabled", False):
-        return
-    workspace_id = cfg.get("workspace_id")
-    agent_token = cfg.get("agent_token", "")
-    api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
-    if not workspace_id:
-        return
-
-    ti = tool_input or {}
-    candidates = [("response", str(tool_response))]
-    if tool_name in ("edit", "multiedit"):
-        candidates.append(("input", ti.get("new_string", "")))
-    elif tool_name == "write":
-        candidates.append(("input", ti.get("content", "")))
-    elif tool_name in ("bash", "terminal"):
-        candidates.append(("input", ti.get("command", "")))
-
-    finding_type = severity = description = matched_pattern = scan_text = None
-    for _src, text in candidates:
-        ft, sv, desc, pat = _classify_text(text)
-        if ft:
-            finding_type, severity, description, matched_pattern, scan_text = ft, sv, desc, pat, text
-            break
-
-    if not finding_type:
-        return
-
-    file_path = (
-        ti.get("file_path") or ti.get("path") or
-        (ti.get("command", "")[:120] if tool_name in ("bash", "terminal") else None)
-    ) or None
-
-    line_no = _line_number_from_text(scan_text, matched_pattern) if scan_text else None
-
-    payload = json.dumps({
-        "tool":          detect_ai_tool(),
-        "severity":      severity,
-        "type":          finding_type,
-        "description":   description,
-        "source_run_id": session_id,
-        "reporter_email": cfg.get("user_email") or "",
-        "file":          file_path,
-        "line":          line_no,
-    })
-    script = (
-        "import urllib.request\n"
-        "try:\n"
-        f"    req = urllib.request.Request(\"{api_url}/security-findings?workspace_id={workspace_id}\","
-        f" data={repr(payload.encode())}, headers={{\"Content-Type\": \"application/json\","
-        f" \"Authorization\": \"Bearer {agent_token}\"}}, method=\"POST\")\n"
-        "    urllib.request.urlopen(req, timeout=5)\n"
-        "except: pass\n"
-    )
-    try:
-        import subprocess as _sp
-        _sp.Popen(
-            [sys.executable, "-c", script],
-            stdout=_sp.DEVNULL,
-            stderr=_sp.DEVNULL,
-            start_new_session=True,
-        )
-    except Exception:
-        pass
-
 
 # ── Token reading ─────────────────────────────────────────────────────────────
 
@@ -392,6 +260,7 @@ def main() -> None:
     except Exception:
         sys.exit(0)
 
+    record_hook_heartbeat("post_tool_use")
     _this_file    = Path(__file__).resolve()
     tool_name     = (data.get("tool_name") or "").lower()
     tool_use_id   = data.get("tool_use_id")
@@ -442,7 +311,6 @@ def main() -> None:
                 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, blast_radius=blast_radius)
-    _maybe_emit_security_finding(str(tool_response), session_id, tool_name, tool_input)
 
     sys.exit(0)
 

{conduct_cli-0.12.0 → conduct_cli-0.14.0}/src/conduct_cli/hooks/pretooluse.py

@@ -30,6 +30,7 @@ from conduct_cli.hooks.base import (
     journal_append,
     load_config,
     post_event,
+    record_hook_heartbeat,
     run_drain_daemon,
 )
 
@@ -768,6 +769,7 @@ def main() -> None:
         data = json.load(sys.stdin)
     except Exception:
         sys.exit(0)
+    record_hook_heartbeat("pre_tool_use")
 
     # Stop hook — session ended, capture for team memory
     if data.get("hook_event_name") == "Stop" or data.get("stop_hook_active"):