conduct-cli 0.14.1__tar.gz → 0.14.3__tar.gz

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.14.1
+Version: 0.14.3
 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
@@ -125,8 +125,8 @@ Admin configures policies and budgets in the Guard dashboard
     └─ developers are workspace members automatically — no invite step needed
 
 Developer runs: conduct guard sync
-    ├─ pulls latest policy to ~/.conductguard/policy.json
-    ├─ writes PreToolUse hook → ~/.conductguard/hook.py
+    ├─ pulls latest policy to ~/.conduct/policy.json
+    ├─ writes PreToolUse hook → ~/.conduct/hook.py
     ├─ registers hook → ~/.claude/settings.json
     └─ registers conductguard-mcp → ~/.claude/settings.json (mcpServers) + Codex
 
@@ -153,7 +153,7 @@ That's it. Policy enforcement is active from the next tool call.
 
 | Command | Description |
 |---------|-------------|
-| `conduct guard sync` | Pull latest policy, write hook to `~/.conductguard/hook.py`, register hook + MCP |
+| `conduct guard sync` | Pull latest policy, write hook to `~/.conduct/hook.py`, register hook + MCP |
 | `conduct guard status` | Show today's spend, session count, and violations |
 | `conduct guard audit [--since 7d]` | Print recent guard events in a table |
 | `conduct verify [--evidence FILE] [--strict] [--format json]` | Map guard events to OWASP Agentic Top 10; exit 1 in CI if blocked events (--strict) |
@@ -190,7 +190,7 @@ OWASP mapping: `no-rm-rf` → A04 Excessive Agency, `no-sudo` → A09 Privilege
 
 ### How the PreToolUse hook works
 
-When you run `conduct guard sync`, the CLI writes a Python script to `~/.conductguard/hook.py` and registers it as a `PreToolUse` hook in `~/.claude/settings.json`:
+When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct/hook.py` and registers it as a `PreToolUse` hook in `~/.claude/settings.json`:
 
 ```json
 {
@@ -198,7 +198,7 @@ When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct
     "PreToolUse": [
       {
         "matcher": ".*",
-        "hooks": [{ "type": "command", "command": "python3 ~/.conductguard/hook.py" }]
+        "hooks": [{ "type": "command", "command": "python3 ~/.conduct/hook.py" }]
       }
     ]
   }
@@ -208,7 +208,7 @@ When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct
 Before every tool call, Claude Code runs the hook. The hook:
 
 1. Reads `tool_name` and `tool_input` from stdin (JSON)
-2. Loads `~/.conductguard/policy.json` (the team ruleset)
+2. Loads `~/.conduct/policy.json` (the team ruleset)
 3. Matches the call against each rule (`match_tool`, `match_pattern`, `match_path_pattern`)
 4. Takes the rule's action:
    - `block` — prints the policy message, exits with code `2` (Claude Code aborts the tool call)
@@ -260,7 +260,7 @@ guard_sync()
 
 ### Policy file format
 
-Policy is stored at `~/.conductguard/policy.json` and synced from the server:
+Policy is stored at `~/.conduct/policy.json` and synced from the server:
 
 ```json
 {

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/README.md

@@ -95,8 +95,8 @@ Admin configures policies and budgets in the Guard dashboard
     └─ developers are workspace members automatically — no invite step needed
 
 Developer runs: conduct guard sync
-    ├─ pulls latest policy to ~/.conductguard/policy.json
-    ├─ writes PreToolUse hook → ~/.conductguard/hook.py
+    ├─ pulls latest policy to ~/.conduct/policy.json
+    ├─ writes PreToolUse hook → ~/.conduct/hook.py
     ├─ registers hook → ~/.claude/settings.json
     └─ registers conductguard-mcp → ~/.claude/settings.json (mcpServers) + Codex
 
@@ -123,7 +123,7 @@ That's it. Policy enforcement is active from the next tool call.
 
 | Command | Description |
 |---------|-------------|
-| `conduct guard sync` | Pull latest policy, write hook to `~/.conductguard/hook.py`, register hook + MCP |
+| `conduct guard sync` | Pull latest policy, write hook to `~/.conduct/hook.py`, register hook + MCP |
 | `conduct guard status` | Show today's spend, session count, and violations |
 | `conduct guard audit [--since 7d]` | Print recent guard events in a table |
 | `conduct verify [--evidence FILE] [--strict] [--format json]` | Map guard events to OWASP Agentic Top 10; exit 1 in CI if blocked events (--strict) |
@@ -160,7 +160,7 @@ OWASP mapping: `no-rm-rf` → A04 Excessive Agency, `no-sudo` → A09 Privilege
 
 ### How the PreToolUse hook works
 
-When you run `conduct guard sync`, the CLI writes a Python script to `~/.conductguard/hook.py` and registers it as a `PreToolUse` hook in `~/.claude/settings.json`:
+When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct/hook.py` and registers it as a `PreToolUse` hook in `~/.claude/settings.json`:
 
 ```json
 {
@@ -168,7 +168,7 @@ When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct
     "PreToolUse": [
       {
         "matcher": ".*",
-        "hooks": [{ "type": "command", "command": "python3 ~/.conductguard/hook.py" }]
+        "hooks": [{ "type": "command", "command": "python3 ~/.conduct/hook.py" }]
       }
     ]
   }
@@ -178,7 +178,7 @@ When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct
 Before every tool call, Claude Code runs the hook. The hook:
 
 1. Reads `tool_name` and `tool_input` from stdin (JSON)
-2. Loads `~/.conductguard/policy.json` (the team ruleset)
+2. Loads `~/.conduct/policy.json` (the team ruleset)
 3. Matches the call against each rule (`match_tool`, `match_pattern`, `match_path_pattern`)
 4. Takes the rule's action:
    - `block` — prints the policy message, exits with code `2` (Claude Code aborts the tool call)
@@ -230,7 +230,7 @@ guard_sync()
 
 ### Policy file format
 
-Policy is stored at `~/.conductguard/policy.json` and synced from the server:
+Policy is stored at `~/.conduct/policy.json` and synced from the server:
 
 ```json
 {

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/pyproject.toml

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 import json
 import os
 import sys
+import time
 import urllib.error
 import urllib.request
 from datetime import datetime, timedelta, timezone
@@ -2140,6 +2141,33 @@ def _report_savings(cfg: dict, base_url: str, agent_token: str = "") -> None:
         pass
 
 
+def cmd_guard_replay_events(args):
+    """Requeue retained hook events after the authenticated ingest rollout."""
+    if args.limit is not None and args.limit < 1:
+        print(f"{RED}--limit must be at least 1.{RESET}")
+        sys.exit(2)
+    cfg = _require_guard_config()
+    if not cfg.get("agent_token"):
+        print(f"{RED}No Agent Identity token found. Run `conduct login` first.{RESET}")
+        sys.exit(1)
+
+    from conduct_cli.hooks.base import (
+        JOURNAL_DEAD_DIR,
+        ensure_drain_daemon,
+        requeue_dead_letters,
+    )
+
+    available = len(list(JOURNAL_DEAD_DIR.glob("*.json"))) if JOURNAL_DEAD_DIR.exists() else 0
+    selected = min(available, args.limit) if args.limit is not None else available
+    if args.dry_run:
+        print(f"{selected} of {available} dead-letter event(s) ready to replay")
+        return
+    moved = requeue_dead_letters(limit=args.limit)
+    if moved:
+        ensure_drain_daemon(GUARD_DIR / "hook.py")
+    print(f"Requeued {moved} dead-letter event(s)")
+
+
 def cmd_guard_status(args):
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
@@ -2459,6 +2487,13 @@ def register_guard_parser(sub):
     # conduct guard status
     guard_sub.add_parser("status", help="Show today's spend and violations")
 
+    replay_p = guard_sub.add_parser(
+        "replay-events",
+        help="Retry retained hook events after fixing delivery",
+    )
+    replay_p.add_argument("--limit", type=int, default=None, help="Maximum events to requeue")
+    replay_p.add_argument("--dry-run", action="store_true", help="Show how many events would be requeued")
+
     # conduct guard savings --team
     guard_sub.add_parser("savings", help="Show org-level token savings across all developers")
 
@@ -3407,6 +3442,8 @@ def dispatch_guard(args, guard_p):
         cmd_guard_sync(args)
     elif guard_command == "status":
         cmd_guard_status(args)
+    elif guard_command == "replay-events":
+        cmd_guard_replay_events(args)
     elif guard_command == "savings":
         cmd_guard_savings(args)
     elif guard_command == "audit":

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/src/conduct_cli/hooks/base.py

@@ -5,6 +5,7 @@ bare `pip install conduct-cli` with no shell rc sourced.
 """
 from __future__ import annotations
 
+import base64
 import json
 import subprocess
 import sys
@@ -165,14 +166,28 @@ def detect_ai_tool() -> str:
 
 # ── Journal / drain (fire-and-forget event posting) ───────────────────────────
 
-def journal_append(payload_str: str, api_url: str) -> None:
+_JOURNAL_ENDPOINTS = {"/guard/events", "/guard/events/usage"}
+
+
+def journal_append(
+    payload_str: str,
+    api_url: str,
+    endpoint: str = "/guard/events",
+) -> None:
     """Atomically write one event to the journal for the drain daemon to pick up."""
     try:
+        if endpoint not in _JOURNAL_ENDPOINTS:
+            return
         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, "attempts": 0})
+        entry = json.dumps({
+            "api_url": api_url,
+            "endpoint": endpoint,
+            "payload": payload_str,
+            "attempts": 0,
+        })
         tmp = JOURNAL_DIR / (name + ".tmp")
         tmp.write_text(entry)
         tmp.chmod(0o600)
@@ -288,7 +303,16 @@ def run_drain_daemon() -> None:
             entry: dict = {}
             try:
                 entry = json.loads(f.read_text())
-                api_url = entry["api_url"]
+                cfg = load_config()
+                api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+                if entry.get("api_url", "").rstrip("/") != api_url:
+                    raise ValueError("journal API URL does not match active configuration")
+                endpoint = entry.get("endpoint", "/guard/events")
+                if endpoint not in _JOURNAL_ENDPOINTS:
+                    raise ValueError("unsupported journal endpoint")
+                agent_token = cfg.get("agent_token", "")
+                if not agent_token:
+                    raise ValueError("agent token missing")
                 payload = (
                     entry["payload"].encode()
                     if isinstance(entry["payload"], str)
@@ -300,9 +324,10 @@ def run_drain_daemon() -> None:
                 except Exception:
                     _ua = "conduct-cli"
                 req = urllib.request.Request(
-                    f"{api_url}/guard/events",
+                    f"{api_url}{endpoint}",
                     data=payload,
                     headers={
+                        "Authorization": f"Bearer {agent_token}",
                         "Content-Type": "application/json",
                         "User-Agent": _ua,
                     },
@@ -363,6 +388,52 @@ def _safe_summary(tool_input: dict) -> str:
     return raw.translate(_WAF_CHARS)[:200]
 
 
+def _encode_summary_text(summary: str) -> str:
+    return base64.urlsafe_b64encode(summary.encode()).decode()
+
+
+def _encoded_summary(tool_input: dict) -> str:
+    """Encode command-like summaries so an ingress WAF cannot parse them as requests."""
+    return _encode_summary_text(_safe_summary(tool_input))
+
+
+def requeue_dead_letters(limit: int | None = None) -> int:
+    """Move retained events back to the journal after upgrading the API and CLI."""
+    if not JOURNAL_DEAD_DIR.exists():
+        return 0
+    JOURNAL_DIR.mkdir(parents=True, exist_ok=True)
+    JOURNAL_DIR.chmod(0o700)
+    moved = 0
+    for source in sorted(JOURNAL_DEAD_DIR.glob("*.json")):
+        if limit is not None and moved >= limit:
+            break
+        try:
+            entry = json.loads(source.read_text())
+            payload = json.loads(entry["payload"])
+            summary = payload.get("input_summary")
+            if summary is not None and not payload.get("input_summary_encoding"):
+                payload["input_summary"] = _encode_summary_text(str(summary))
+                payload["input_summary_encoding"] = "base64url"
+            # The authenticated API derives actor identity from the Agent Identity
+            # token. Older clients incorrectly stored an email in clerk_user_id.
+            payload.pop("clerk_user_id", None)
+            payload.pop("user_email", None)
+            entry["payload"] = json.dumps(payload)
+            entry["endpoint"] = entry.get("endpoint", "/guard/events")
+            entry["attempts"] = 0
+            entry.pop("last_error", None)
+            destination = JOURNAL_DIR / source.name
+            tmp = destination.with_suffix(".tmp")
+            tmp.write_text(json.dumps(entry))
+            tmp.chmod(0o600)
+            tmp.replace(destination)
+            source.unlink()
+            moved += 1
+        except Exception:
+            continue
+    return moved
+
+
 def post_event(
     tool_name: str,
     tool_input: dict,
@@ -393,11 +464,12 @@ def post_event(
     _gcfg = _json_gcfg.loads(_gcfg_path.read_text()) if _gcfg_path.exists() else {}
     payload = json.dumps({
         "workspace_id":    workspace_id,
-        "clerk_user_id":   cfg.get("user_email"),
+        "clerk_user_id":   cfg.get("clerk_user_id"),
         "user_email":      cfg.get("user_email"),
         "ai_tool":         detect_ai_tool(),
         "tool_call":       tool_name[:255],
-        "input_summary":   _safe_summary(tool_input),
+        "input_summary":   _encoded_summary(tool_input),
+        "input_summary_encoding": "base64url",
         "decision":        decision,
         "rule_id":         rule_id,
         "rule_message":    message,

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/src/conduct_cli/hooks/posttooluse.py

@@ -10,6 +10,8 @@ from conduct_cli.hooks.base import (
     CONFIG_PATH,
     GUARD_DIR,
     detect_ai_tool,
+    ensure_drain_daemon,
+    journal_append,
     load_config,
     post_event,
     record_hook_heartbeat,
@@ -192,7 +194,7 @@ def _compute_blast_radius(tool_name: str, tool_input: dict, tool_response: str)
 
 
 def _post_usage(session_id, tool_name, tokens_input, tokens_output, duration_ms, blast_radius=None, execution_status=None, result_summary=None) -> None:
-    """Fire-and-forget POST to /guard/events/usage."""
+    """Queue a PostToolUse update for the authenticated drain daemon."""
     cfg = load_config()
     workspace_id = cfg.get("workspace_id")
     if not workspace_id or not session_id:
@@ -210,20 +212,8 @@ def _post_usage(session_id, tool_name, tokens_input, tokens_output, duration_ms,
         "result_summary":   result_summary,
     })
     api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
-    script = (
-        "import urllib.request\n"
-        "try:\n"
-        f"    req = urllib.request.Request(\"{api_url}/guard/events/usage\","
-        f" data={repr(payload.encode())}, headers={{\"Content-Type\": \"application/json\"}}, method=\"POST\")\n"
-        "    urllib.request.urlopen(req, timeout=5)\n"
-        "except: pass\n"
-    )
-    subprocess.Popen(
-        [sys.executable, "-c", script],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        start_new_session=True,
-    )
+    journal_append(payload, api_url, endpoint="/guard/events/usage")
+    ensure_drain_daemon(GUARD_DIR / "hook.py")
 
 
 # ── Codex delayed reader (spawned as subprocess) ──────────────────────────────

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/src/conduct_cli/hooks/pretooluse.py

@@ -108,46 +108,20 @@ def _verify_policy_signature(policy_dict: dict) -> bool:
 
 def _post_signature_invalid_event(expected_sig, computed_sig, policy_version, hostname):
     """Fire-and-forget audit event for a failed signature check."""
-    try:
-        cfg = json.loads(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
-    except Exception:
-        return
-    workspace_id = cfg.get("workspace_id") or cfg.get("workspace")
-    if not workspace_id:
-        return
     import platform as _platform
     _hostname = hostname or _platform.node()
-    payload = json.dumps({
-        "workspace_id":  workspace_id,
-        "clerk_user_id": cfg.get("user_email"),
-        "user_email":    cfg.get("user_email"),
-        "ai_tool":       "hook",
-        "tool_call":     "policy_signature_invalid",
-        "input_summary": json.dumps({
+    post_event(
+        "policy_signature_invalid",
+        {
             "expected_signature": expected_sig or "",
             "computed_signature": computed_sig or "",
             "policy_version":     policy_version or "",
             "hostname":           _hostname,
-        })[:500],
-        "decision":     "blocked",
-        "rule_id":      "policy_signature_invalid",
-        "rule_message": "Policy signature verification failed",
-        "hostname":     _hostname,
-    })
-    api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
-    script = (
-        "import urllib.request\n"
-        "try:\n"
-        f"    req = urllib.request.Request(\"{api_url}/guard/events\","
-        f" data={repr(payload.encode())}, headers={{\"Content-Type\": \"application/json\"}}, method=\"POST\")\n"
-        "    urllib.request.urlopen(req, timeout=5)\n"
-        "except: pass\n"
-    )
-    subprocess.Popen(
-        [sys.executable, "-c", script],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        start_new_session=True,
+        },
+        "blocked",
+        "policy_signature_invalid",
+        "Policy signature verification failed",
+        drain_via=GUARD_DIR / "hook.py",
     )
 
 

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/src/conduct_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.14.1
+Version: 0.14.3
 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
@@ -125,8 +125,8 @@ Admin configures policies and budgets in the Guard dashboard
     └─ developers are workspace members automatically — no invite step needed
 
 Developer runs: conduct guard sync
-    ├─ pulls latest policy to ~/.conductguard/policy.json
-    ├─ writes PreToolUse hook → ~/.conductguard/hook.py
+    ├─ pulls latest policy to ~/.conduct/policy.json
+    ├─ writes PreToolUse hook → ~/.conduct/hook.py
     ├─ registers hook → ~/.claude/settings.json
     └─ registers conductguard-mcp → ~/.claude/settings.json (mcpServers) + Codex
 
@@ -153,7 +153,7 @@ That's it. Policy enforcement is active from the next tool call.
 
 | Command | Description |
 |---------|-------------|
-| `conduct guard sync` | Pull latest policy, write hook to `~/.conductguard/hook.py`, register hook + MCP |
+| `conduct guard sync` | Pull latest policy, write hook to `~/.conduct/hook.py`, register hook + MCP |
 | `conduct guard status` | Show today's spend, session count, and violations |
 | `conduct guard audit [--since 7d]` | Print recent guard events in a table |
 | `conduct verify [--evidence FILE] [--strict] [--format json]` | Map guard events to OWASP Agentic Top 10; exit 1 in CI if blocked events (--strict) |
@@ -190,7 +190,7 @@ OWASP mapping: `no-rm-rf` → A04 Excessive Agency, `no-sudo` → A09 Privilege
 
 ### How the PreToolUse hook works
 
-When you run `conduct guard sync`, the CLI writes a Python script to `~/.conductguard/hook.py` and registers it as a `PreToolUse` hook in `~/.claude/settings.json`:
+When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct/hook.py` and registers it as a `PreToolUse` hook in `~/.claude/settings.json`:
 
 ```json
 {
@@ -198,7 +198,7 @@ When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct
     "PreToolUse": [
       {
         "matcher": ".*",
-        "hooks": [{ "type": "command", "command": "python3 ~/.conductguard/hook.py" }]
+        "hooks": [{ "type": "command", "command": "python3 ~/.conduct/hook.py" }]
       }
     ]
   }
@@ -208,7 +208,7 @@ When you run `conduct guard sync`, the CLI writes a Python script to `~/.conduct
 Before every tool call, Claude Code runs the hook. The hook:
 
 1. Reads `tool_name` and `tool_input` from stdin (JSON)
-2. Loads `~/.conductguard/policy.json` (the team ruleset)
+2. Loads `~/.conduct/policy.json` (the team ruleset)
 3. Matches the call against each rule (`match_tool`, `match_pattern`, `match_path_pattern`)
 4. Takes the rule's action:
    - `block` — prints the policy message, exits with code `2` (Claude Code aborts the tool call)
@@ -260,7 +260,7 @@ guard_sync()
 
 ### Policy file format
 
-Policy is stored at `~/.conductguard/policy.json` and synced from the server:
+Policy is stored at `~/.conduct/policy.json` and synced from the server:
 
 ```json
 {

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/src/conduct_cli.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ tests/test_drain_daemon_health.py
 tests/test_guard_approvals.py
 tests/test_guard_policy.py
 tests/test_guard_savings.py
+tests/test_guard_status.py
 tests/test_hook_dispatch.py
 tests/test_hook_journal.py
 tests/test_hook_receipt.py

conduct_cli-0.14.3/tests/test_guard_status.py

@@ -0,0 +1,58 @@
+"""Tests for local health details reported by ``conduct guard status``."""
+
+import json
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import conduct_cli.guard as guard
+
+
+def test_status_reports_recent_hook_heartbeat(tmp_path, capsys, monkeypatch):
+    conduct_home = tmp_path / ".conduct"
+    conduct_home.mkdir()
+    (conduct_home / "hook-heartbeat.json").write_text(
+        json.dumps({"event": "post_tool_use", "ts": 1_000.0})
+    )
+
+    monkeypatch.setattr(guard.Path, "home", staticmethod(lambda: tmp_path))
+    monkeypatch.setattr(guard.time, "time", lambda: 1_007.9)
+    monkeypatch.setattr(guard, "_load_policy", lambda: {"rules": []})
+    monkeypatch.setattr(
+        guard,
+        "_require_guard_config",
+        lambda: {
+            "workspace_id": "workspace-test",
+            "user_email": "developer@example.com",
+            "clerk_user_id": "user-test",
+            "agent_token": "token-test",
+            "api_url": "https://api.example.test",
+        },
+    )
+
+    with patch.object(guard, "_req", side_effect=[{}, []]), patch(
+        "conduct_cli.hooks.base.drain_daemon_status", return_value=("running", 123)
+    ):
+        guard.cmd_guard_status(None)
+
+    output = capsys.readouterr().out
+    assert "Hook heartbeat: post_tool_use" in output
+    assert "7s ago" in output
+
+
+def test_replay_events_requeues_and_starts_drain(tmp_path, capsys, monkeypatch):
+    from conduct_cli.hooks import base
+
+    dead = tmp_path / "dead-letter"
+    dead.mkdir()
+    (dead / "event.json").write_text("{}")
+    monkeypatch.setattr(base, "JOURNAL_DEAD_DIR", dead)
+    monkeypatch.setattr(guard, "_require_guard_config", lambda: {"agent_token": "cond_agt_test"})
+
+    with patch.object(base, "requeue_dead_letters", return_value=1) as requeue, patch.object(
+        base, "ensure_drain_daemon"
+    ) as ensure:
+        guard.cmd_guard_replay_events(SimpleNamespace(limit=None, dry_run=False))
+
+    requeue.assert_called_once_with(limit=None)
+    ensure.assert_called_once()
+    assert "Requeued 1 dead-letter event" in capsys.readouterr().out

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/tests/test_hook_dispatch.py

@@ -25,7 +25,7 @@ GUARD_DIR  = Path(__file__).parent.parent / "src" / "conduct_cli"
 # ── 1. hook.py dispatch ───────────────────────────────────────────────────────
 
 def _hook_py_content() -> str:
-    """Read the thin-launcher template that gets written to ~/.conductguard/hook.py."""
+    """Read the thin-launcher template that gets written to ~/.conduct/hook.py."""
     from conduct_cli.guard import _THIN_LAUNCHERS
     return _THIN_LAUNCHERS["pretooluse"]
 

conduct_cli-0.14.3/tests/test_hook_journal.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+from urllib.error import HTTPError
+
+from conduct_cli.hooks import base, posttooluse
+
+
+def _redirect_journal(tmp_path, monkeypatch):
+    journal = tmp_path / "journal"
+    monkeypatch.setattr(base, "JOURNAL_DIR", journal)
+    monkeypatch.setattr(base, "JOURNAL_DEAD_DIR", journal / "dead-letter")
+    monkeypatch.setattr(base, "JOURNAL_PID_PATH", journal / "drain.pid")
+    monkeypatch.setattr(base.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(
+        base,
+        "load_config",
+        lambda: {"api_url": "https://api.test", "agent_token": "cond_agt_test"},
+    )
+    return journal
+
+
+def test_permanent_delivery_failure_moves_event_to_dead_letter(tmp_path, monkeypatch):
+    journal = _redirect_journal(tmp_path, monkeypatch)
+    base.journal_append(json.dumps({"workspace_id": "workspace"}), "https://api.test")
+
+    def _fail(*args, **kwargs):
+        raise HTTPError("https://api.test", 400, "bad request", {}, None)
+
+    monkeypatch.setattr(base.urllib.request, "urlopen", _fail)
+    base.run_drain_daemon()
+
+    assert not list(journal.glob("*.json"))
+    dead = list((journal / "dead-letter").glob("*.json"))
+    assert len(dead) == 1
+    if os.name != "nt":
+        assert dead[0].stat().st_mode & 0o077 == 0
+    entry = json.loads(dead[0].read_text())
+    assert entry["attempts"] == 1
+    assert entry["last_error"] == "HTTP 400"
+
+
+def test_successful_delivery_removes_event(tmp_path, monkeypatch):
+    journal = _redirect_journal(tmp_path, monkeypatch)
+    base.journal_append(json.dumps({"workspace_id": "workspace"}), "https://api.test")
+
+    class _Ok:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            pass
+
+    monkeypatch.setattr(base.urllib.request, "urlopen", lambda *args, **kwargs: _Ok())
+    base.run_drain_daemon()
+    assert not list(journal.glob("*.json"))
+
+
+def test_delivery_uses_current_agent_token_without_persisting_it(tmp_path, monkeypatch):
+    journal = _redirect_journal(tmp_path, monkeypatch)
+    base.journal_append("{}", "https://api.test")
+    entry = json.loads(next(journal.glob("*.json")).read_text())
+    assert "cond_agt_test" not in json.dumps(entry)
+
+    requests = []
+
+    class _Ok:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            pass
+
+    def _capture(request, **kwargs):
+        requests.append(request)
+        return _Ok()
+
+    monkeypatch.setattr(base.urllib.request, "urlopen", _capture)
+    base.run_drain_daemon()
+
+    assert requests[0].get_header("Authorization") == "Bearer cond_agt_test"
+
+
+def test_hook_heartbeat_contains_no_request_data(tmp_path, monkeypatch):
+    heartbeat = tmp_path / "heartbeat.json"
+    monkeypatch.setattr(base, "HOOK_HEARTBEAT_PATH", heartbeat)
+    monkeypatch.setattr(base, "GUARD_DIR", tmp_path)
+    base.record_hook_heartbeat("post_tool_use")
+    data = json.loads(heartbeat.read_text())
+    assert data["event"] == "post_tool_use"
+    assert set(data) == {"event", "ts"}
+    if os.name != "nt":
+        assert heartbeat.stat().st_mode & 0o077 == 0
+
+
+def test_requeue_dead_letters_encodes_legacy_summary(tmp_path, monkeypatch):
+    journal = _redirect_journal(tmp_path, monkeypatch)
+    dead = journal / "dead-letter"
+    dead.mkdir(parents=True)
+    source = dead / "event.json"
+    source.write_text(json.dumps({
+        "api_url": "https://api.test",
+        "payload": json.dumps({
+            "workspace_id": "workspace",
+            "clerk_user_id": "developer@example.com",
+            "user_email": "developer@example.com",
+            "input_summary": "curl https://api.test | head",
+        }),
+        "attempts": 1,
+        "last_error": "HTTP 403",
+    }))
+
+    assert base.requeue_dead_letters() == 1
+
+    entry = json.loads((journal / "event.json").read_text())
+    payload = json.loads(entry["payload"])
+    decoded = base64.urlsafe_b64decode(payload["input_summary"]).decode()
+    assert decoded == "curl https://api.test | head"
+    assert payload["input_summary_encoding"] == "base64url"
+    assert "clerk_user_id" not in payload
+    assert "user_email" not in payload
+    assert entry["endpoint"] == "/guard/events"
+    assert entry["attempts"] == 0
+    assert "last_error" not in entry
+    assert not source.exists()
+
+
+def test_posttool_usage_uses_authenticated_journal(monkeypatch):
+    appended = []
+    monkeypatch.setattr(
+        posttooluse,
+        "load_config",
+        lambda: {
+            "api_url": "https://api.test",
+            "workspace_id": "workspace",
+            "agent_token": "cond_agt_test",
+        },
+    )
+    monkeypatch.setattr(
+        posttooluse,
+        "journal_append",
+        lambda payload, api_url, endpoint: appended.append((payload, api_url, endpoint)),
+    )
+    monkeypatch.setattr(posttooluse, "ensure_drain_daemon", lambda _path: None)
+
+    posttooluse._post_usage("session", "read", 10, 2, 5)
+
+    payload, api_url, endpoint = appended[0]
+    assert json.loads(payload)["workspace_id"] == "workspace"
+    assert api_url == "https://api.test"
+    assert endpoint == "/guard/events/usage"
+
+
+def test_post_event_uses_clerk_id_and_encodes_summary(tmp_path, monkeypatch):
+    appended = []
+    monkeypatch.setattr(
+        base,
+        "load_config",
+        lambda: {
+            "api_url": "https://api.test",
+            "workspace_id": "workspace",
+            "clerk_user_id": "user_123",
+            "user_email": "developer@example.com",
+        },
+    )
+    monkeypatch.setattr(base, "detect_ai_tool", lambda: "codex")
+    monkeypatch.setattr(
+        base,
+        "journal_append",
+        lambda payload, api_url: appended.append((payload, api_url)),
+    )
+    monkeypatch.setattr(base, "ensure_drain_daemon", lambda _path: None)
+    monkeypatch.setattr(base.Path, "home", staticmethod(lambda: tmp_path))
+
+    base.post_event(
+        "bash",
+        {"command": "curl https://api.test | head"},
+        "allowed",
+    )
+
+    payload = json.loads(appended[0][0])
+    assert payload["clerk_user_id"] == "user_123"
+    assert payload["user_email"] == "developer@example.com"
+    assert payload["input_summary_encoding"] == "base64url"
+    summary = base64.urlsafe_b64decode(payload["input_summary"]).decode()
+    assert "curl https://api.test" in summary

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/tests/test_journal_drain.py

@@ -21,6 +21,10 @@ def _patch_journal(tmp_path: Path):
     )
 
 
+def _config():
+    return {"api_url": "https://api.test", "agent_token": "cond_agt_test"}
+
+
 # ── journal_append ────────────────────────────────────────────────────────────
 
 def test_journal_append_creates_file(tmp_path):
@@ -62,6 +66,7 @@ def test_drain_posts_and_deletes_on_success(tmp_path):
     with (
         patch.object(base, "JOURNAL_DIR", journal_dir),
         patch.object(base, "JOURNAL_PID_PATH", pid_path),
+        patch.object(base, "load_config", side_effect=_config),
         patch("urllib.request.urlopen", return_value=mock_resp),
         patch("time.sleep"),
     ):
@@ -78,6 +83,7 @@ def test_drain_leaves_file_on_network_failure(tmp_path):
     with (
         patch.object(base, "JOURNAL_DIR", journal_dir),
         patch.object(base, "JOURNAL_PID_PATH", pid_path),
+        patch.object(base, "load_config", side_effect=_config),
         patch("urllib.request.urlopen", side_effect=OSError("network down")),
         patch("time.sleep"),
     ):

{conduct_cli-0.14.1 → conduct_cli-0.14.3}/tests/test_log_util.py

@@ -44,7 +44,7 @@ def test_interceptor_passes_through_systemexit(monkeypatch):
 
 
 def test_post_skipped_when_no_creds(monkeypatch, tmp_path):
-    """No ~/.conductguard/config.json → no POST attempted."""
+    """No ~/.conduct/config.json means no POST is attempted."""
     monkeypatch.setattr(log_util, "_CONFIG", tmp_path / "missing.json")
     log_util._read_creds.cache_clear()
 

conduct_cli-0.14.1/tests/test_hook_journal.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from urllib.error import HTTPError
-
-from conduct_cli.hooks import base
-
-
-def _redirect_journal(tmp_path, monkeypatch):
-    journal = tmp_path / "journal"
-    monkeypatch.setattr(base, "JOURNAL_DIR", journal)
-    monkeypatch.setattr(base, "JOURNAL_DEAD_DIR", journal / "dead-letter")
-    monkeypatch.setattr(base, "JOURNAL_PID_PATH", journal / "drain.pid")
-    monkeypatch.setattr(base.time, "sleep", lambda _seconds: None)
-    return journal
-
-
-def test_permanent_delivery_failure_moves_event_to_dead_letter(tmp_path, monkeypatch):
-    journal = _redirect_journal(tmp_path, monkeypatch)
-    base.journal_append(json.dumps({"workspace_id": "workspace"}), "https://api.test")
-
-    def _fail(*args, **kwargs):
-        raise HTTPError("https://api.test", 400, "bad request", {}, None)
-
-    monkeypatch.setattr(base.urllib.request, "urlopen", _fail)
-    base.run_drain_daemon()
-
-    assert not list(journal.glob("*.json"))
-    dead = list((journal / "dead-letter").glob("*.json"))
-    assert len(dead) == 1
-    if os.name != "nt":
-        assert dead[0].stat().st_mode & 0o077 == 0
-    entry = json.loads(dead[0].read_text())
-    assert entry["attempts"] == 1
-    assert entry["last_error"] == "HTTP 400"
-
-
-def test_successful_delivery_removes_event(tmp_path, monkeypatch):
-    journal = _redirect_journal(tmp_path, monkeypatch)
-    base.journal_append(json.dumps({"workspace_id": "workspace"}), "https://api.test")
-
-    class _Ok:
-        def __enter__(self):
-            return self
-
-        def __exit__(self, *args):
-            pass
-
-    monkeypatch.setattr(base.urllib.request, "urlopen", lambda *args, **kwargs: _Ok())
-    base.run_drain_daemon()
-    assert not list(journal.glob("*.json"))
-
-
-def test_hook_heartbeat_contains_no_request_data(tmp_path, monkeypatch):
-    heartbeat = tmp_path / "heartbeat.json"
-    monkeypatch.setattr(base, "HOOK_HEARTBEAT_PATH", heartbeat)
-    monkeypatch.setattr(base, "GUARD_DIR", tmp_path)
-    base.record_hook_heartbeat("post_tool_use")
-    data = json.loads(heartbeat.read_text())
-    assert data["event"] == "post_tool_use"
-    assert set(data) == {"event", "ts"}
-    if os.name != "nt":
-        assert heartbeat.stat().st_mode & 0o077 == 0