conduct-cli 0.4.38__tar.gz → 0.4.41__tar.gz

{conduct_cli-0.4.38 → conduct_cli-0.4.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.4.38
+Version: 0.4.41
 Summary: CLI for Conduct AI — install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT

{conduct_cli-0.4.38 → conduct_cli-0.4.41}/pyproject.toml

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

{conduct_cli-0.4.38 → conduct_cli-0.4.41}/src/conduct_cli/guard.py

@@ -446,6 +446,144 @@ if __name__ == "__main__":
         main()
 '''
 
+_PRECOMPACT_HOOK_SCRIPT = '''\
+#!/usr/bin/env python3
+"""ConductGuard PreCompact hook — persists session context before compaction."""
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+GUARD_DIR = Path.home() / ".conductguard"
+SNAPSHOT_PATH = GUARD_DIR / "session_snapshot.json"
+
+
+def _git(cmd):
+    try:
+        return subprocess.check_output(
+            ["git"] + cmd, stderr=subprocess.DEVNULL, text=True, timeout=3
+        ).strip()
+    except Exception:
+        return ""
+
+
+def _guard_status():
+    try:
+        out = subprocess.check_output(
+            ["conductguard", "status", "--json"],
+            stderr=subprocess.DEVNULL, text=True, timeout=3,
+        )
+        return json.loads(out.strip())
+    except Exception:
+        return None
+
+
+def _memory_headline():
+    try:
+        root = Path.cwd()
+        mem_key = str(root).replace("/", "-").lstrip("-")
+        mem_path = Path.home() / ".claude" / "projects" / mem_key / "memory" / "MEMORY.md"
+        if mem_path.exists():
+            return "\\n".join(mem_path.read_text().splitlines()[:10])
+    except Exception:
+        pass
+    return ""
+
+
+def main():
+    try:
+        sys.stdin.read()
+    except Exception:
+        pass
+
+    try:
+        GUARD_DIR.mkdir(parents=True, exist_ok=True)
+        snapshot = {
+            "compacted_at": datetime.now(timezone.utc).isoformat(),
+            "tier1": {
+                "git_branch": _git(["branch", "--show-current"]),
+                "recent_commits": _git(["log", "--oneline", "-3"]),
+                "memory_headline": _memory_headline(),
+            },
+            "tier2": {"guard_status": _guard_status()},
+            "tier3": {"cwd": str(Path.cwd()), "python": sys.version.split()[0]},
+        }
+        tmp = GUARD_DIR / "session_snapshot.tmp"
+        tmp.write_text(json.dumps(snapshot, indent=2))
+        tmp.rename(SNAPSHOT_PATH)
+    except Exception:
+        pass
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+_SESSION_START_HOOK_SCRIPT = '''\
+#!/usr/bin/env python3
+"""ConductGuard SessionStart hook — prints context after compaction."""
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+SNAPSHOT_PATH = Path.home() / ".conductguard" / "session_snapshot.json"
+MAX_AGE_HOURS = 2
+
+
+def main():
+    try:
+        sys.stdin.read()
+    except Exception:
+        pass
+
+    if not SNAPSHOT_PATH.exists():
+        sys.exit(0)
+
+    try:
+        snapshot = json.loads(SNAPSHOT_PATH.read_text())
+        compacted_at = datetime.fromisoformat(snapshot.get("compacted_at", ""))
+        age_hours = (datetime.now(timezone.utc) - compacted_at).total_seconds() / 3600
+        if age_hours > MAX_AGE_HOURS:
+            sys.exit(0)
+
+        t1 = snapshot.get("tier1", {})
+        branch = t1.get("git_branch", "")
+        commits = t1.get("recent_commits", "")
+        headline = t1.get("memory_headline", "")
+        t2 = snapshot.get("tier2", {})
+        guard = t2.get("guard_status") or {}
+
+        lines = [f"## Session resumed (snapshot from {compacted_at.strftime(\'%Y-%m-%d %H:%M\')} UTC)"]
+        if branch:
+            last = commits.splitlines()[0] if commits else ""
+            lines.append(f"- Branch: {branch}" + (f" | Last: {last}" if last else ""))
+        budget = guard.get("budget_pct")
+        if budget is not None:
+            lines.append(f"- Guard: {budget}% budget used")
+        else:
+            lines.append("- Guard: state unavailable")
+        if headline:
+            lines.append(f"- Memory index:\\n  {headline}")
+        else:
+            lines.append("- Memory index:\\n  (none)")
+
+        print("\\n".join(lines))
+    except Exception:
+        pass
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
 # ── Python interpreter selection ─────────────────────────────────────────────
 
 def _best_python() -> str:
@@ -478,6 +616,42 @@ def _write_hook(path: Path) -> None:
         ) from exc
 
 
+def _install_session_hooks() -> None:
+    """Write PreCompact + SessionStart hook scripts and register them in ~/.claude/settings.json."""
+    python = _best_python()
+
+    precompact_path = GUARD_DIR / "guard-precompact.py"
+    session_start_path = GUARD_DIR / "guard-session-start.py"
+
+    precompact_path.write_text(_PRECOMPACT_HOOK_SCRIPT)
+    precompact_path.chmod(0o755)
+    session_start_path.write_text(_SESSION_START_HOOK_SCRIPT)
+    session_start_path.chmod(0o755)
+
+    claude_settings = Path.home() / ".claude" / "settings.json"
+    settings: dict = {}
+    if claude_settings.exists():
+        try:
+            settings = json.loads(claude_settings.read_text())
+        except Exception:
+            pass
+
+    hooks = settings.setdefault("hooks", {})
+
+    pre_cmd = f"{python} {precompact_path}"
+    compact_hooks = hooks.setdefault("PreCompact", [])
+    if not any(pre_cmd in str(e) for h in compact_hooks for e in h.get("hooks", [])):
+        compact_hooks.append({"hooks": [{"type": "command", "command": pre_cmd}]})
+
+    start_cmd = f"{python} {session_start_path}"
+    start_hooks = hooks.setdefault("SessionStart", [])
+    if not any(start_cmd in str(e) for h in start_hooks for e in h.get("hooks", [])):
+        start_hooks.append({"hooks": [{"type": "command", "command": start_cmd}]})
+
+    claude_settings.parent.mkdir(parents=True, exist_ok=True)
+    claude_settings.write_text(json.dumps(settings, indent=2) + "\n")
+
+
 # ── Guard config helpers ──────────────────────────────────────────────────────
 
 def _load_guard_config() -> dict:
@@ -815,6 +989,12 @@ def cmd_guard_install(args):
     # Register MCP in all found AI tools — Cursor/Windsurf (advisory)
     _register_mcp(workspace_id, member_token or "", server)
 
+    # Install session persistence hooks (PreCompact + SessionStart)
+    try:
+        _install_session_hooks()
+    except Exception:
+        pass
+
 
 def cmd_guard_join(args):
     invite_code = args.invite_code
@@ -1020,6 +1200,10 @@ def cmd_guard_sync(args):
     _install_codex_hook(hook_path)
     cfg2 = _load_guard_config()
     _register_mcp(workspace_id, cfg2.get("member_token", ""), base_url)
+    try:
+        _install_session_hooks()
+    except Exception:
+        pass
     print(f"  {GREEN}Hook script updated{RESET}")
 
     # Capture savings from RTK and Agent Booster

{conduct_cli-0.4.38 → conduct_cli-0.4.41}/src/conduct_cli/main.py

@@ -1289,6 +1289,175 @@ def _build_state(issue: dict, repo_full_name: str) -> dict:
     return {"github_issue": trigger, "_trigger": trigger}
 
 
+def _atomic_write(path: Path, data: dict) -> None:
+    """Write data to path atomically via a .tmp sibling."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2))
+    os.replace(tmp, path)
+
+
+def cmd_switch(args):
+    cfg = _load_config()
+    server  = cfg.get("server", "").rstrip("/")
+    api_key = cfg.get("api_key", "")
+    token   = cfg.get("token", "")
+
+    if not server or (not api_key and not token):
+        print(f"{RED}Not logged in. Run: conduct login --server <url> --api-key <key>{RESET}")
+        sys.exit(1)
+
+    hdrs = {"Content-Type": "application/json"}
+    if api_key:
+        hdrs["X-Api-Key"] = api_key
+    elif token:
+        hdrs["Authorization"] = f"Bearer {token}"
+
+    workspaces = api.req("GET", f"{server}/projects", hdrs)
+
+    current_id = cfg.get("workspace", "")
+    target = getattr(args, "workspace", None)
+
+    if not target:
+        # List mode — print numbered list with current marked
+        if not workspaces:
+            print("No workspaces found.")
+            return
+        print(f"\n{BOLD}Workspaces:{RESET}")
+        for i, ws in enumerate(workspaces, 1):
+            marker = f"{GREEN}*{RESET}" if str(ws.get("id", "")) == str(current_id) else " "
+            wid = str(ws.get("id", ""))
+            print(f"  {marker} {i}. {ws['name']:<35} {GRAY}{wid}{RESET}")
+        print()
+        return
+
+    # Match workspace: exact name (case-insensitive) first
+    target_lower = target.lower()
+
+    exact = [ws for ws in workspaces if ws["name"].lower() == target_lower]
+    if not exact:
+        # Partial name match
+        partial = [ws for ws in workspaces if target_lower in ws["name"].lower()]
+        if not partial:
+            # UUID prefix match
+            partial = [ws for ws in workspaces if str(ws.get("id", "")).startswith(target)]
+        candidates = partial
+    else:
+        candidates = exact
+
+    if len(candidates) > 1:
+        print(f"{YELLOW}Ambiguous — multiple matches for '{target}':{RESET}")
+        for ws in candidates:
+            print(f"  {ws['name']}  {GRAY}({ws['id']}){RESET}")
+        print("Be more specific.")
+        sys.exit(1)
+
+    if not candidates:
+        print(f"{RED}No workspace matching '{target}' found. Available:{RESET}")
+        for ws in workspaces:
+            print(f"  {ws['name']}  {GRAY}({ws['id']}){RESET}")
+        sys.exit(1)
+
+    chosen = candidates[0]
+    new_id   = str(chosen["id"])
+    new_name = chosen["name"]
+
+    # Update ~/.conduct/config.json atomically
+    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:
+        policy = _guard._req(
+            "GET",
+            f"{server}/guard/policies/sync?workspace_id={new_id}",
+            api_key=api_key,
+        )
+        _guard._save_policy(policy)
+        rule_count = len(policy.get("rules", []))
+        print(f"  {GRAY}Guard policies synced: {rule_count} rule(s){RESET}")
+    except SystemExit:
+        pass  # Guard not configured for this workspace — skip silently
+    except Exception:
+        pass
+
+    print(f"{GREEN}✓ Switched to \"{new_name}\" ({new_id[:8]}){RESET}")
+
+
+def cmd_whoami(args):
+    cfg = _load_config()
+
+    workspace_id   = cfg.get("workspace", "")
+    server         = cfg.get("server", "—")
+    api_key        = cfg.get("api_key", "")
+
+    # Try to resolve workspace name from /projects
+    workspace_name = ""
+    if workspace_id and server != "—" and api_key:
+        try:
+            hdrs = {"Content-Type": "application/json", "X-Api-Key": api_key}
+            projects = api.req("GET", f"{server.rstrip('/')}/projects", hdrs)
+            match = next((p for p in projects if str(p.get("id", "")) == str(workspace_id)), None)
+            if match:
+                workspace_name = match["name"]
+        except Exception:
+            pass
+
+    ws_display = workspace_name if workspace_name else workspace_id
+    ws_id_hint = f"  ({workspace_id[:8]})" if workspace_id else ""
+    api_key_display = (api_key[:12] + "…  (set)") if api_key else "not set"
+
+    print(f"\n{BOLD}Workspace:{RESET}  {ws_display}{ws_id_hint}")
+    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}")
+    else:
+        print(f"{BOLD}Guard:{RESET}      not configured")
+
+    # Booster section
+    booster_paths = [
+        Path.home() / ".booster" / "config.json",
+        Path.home() / ".agent-booster" / "config.json",
+    ]
+    booster_found = any(p.exists() for p in booster_paths)
+    if booster_found:
+        print(f"{BOLD}Booster:{RESET}    {GREEN}✓ configured{RESET}")
+    else:
+        print(f"{BOLD}Booster:{RESET}    not configured")
+
+    print()
+
+
 def cmd_run(args):
     server, workspace_id, api_key, token = _require_auth(args)
     json_h = api.headers(workspace_id, token, "application/json", api_key)
@@ -1327,10 +1496,13 @@ def cmd_run(args):
             print(f"  {GRAY}{k}={v}{RESET}")
     print()
 
-    run = api.req("POST", f"{server}/workflows/{workflow_id}/runs", json_h, {
+    body: dict = {
         "triggered_by": "cli",
         "initial_state": {"__manual": True, "inputs": initial_state},
-    })
+    }
+    if getattr(args, "max_turns", None):
+        body["max_turns"] = args.max_turns
+    run = api.req("POST", f"{server}/workflows/{workflow_id}/runs", json_h, body)
     _stream_run(server, workflow_id, run["id"], workspace_id, token, api_key)
 
 
@@ -1435,9 +1607,18 @@ def main():
 
     # conduct run (existing)
     run_p = sub.add_parser("run", help="Run an installed agent by name")
-    run_p.add_argument("agent",    help="Agent name (e.g. 'security_autopilot_fix')")
-    run_p.add_argument("--project", metavar="name", help="Narrow to a specific project")
-    run_p.add_argument("--input",   action="append", metavar="key=value", help="Runtime input (repeatable)")
+    run_p.add_argument("agent",       help="Agent name (e.g. 'security_autopilot_fix')")
+    run_p.add_argument("--project",   metavar="name",  help="Narrow to a specific project")
+    run_p.add_argument("--input",     action="append", metavar="key=value", help="Runtime input (repeatable)")
+    run_p.add_argument("--max-turns", dest="max_turns", type=int, metavar="N", help="Max agentic turns (default: auto)")
+
+    # conduct switch [workspace]
+    switch_p = sub.add_parser("switch", help="Switch active workspace (or list workspaces)")
+    switch_p.add_argument("workspace", nargs="?", metavar="name_or_id",
+                          help="Workspace name or UUID prefix to switch to (omit to list)")
+
+    # conduct whoami
+    sub.add_parser("whoami", help="Show current workspace, server, API key, and Guard/Booster status")
 
     # conduct guard
     guard_p, _guard_sub = _guard.register_guard_parser(sub)
@@ -1491,6 +1672,10 @@ def main():
         cmd_test(args)
     elif args.command == "run":
         cmd_run(args)
+    elif args.command == "switch":
+        cmd_switch(args)
+    elif args.command == "whoami":
+        cmd_whoami(args)
     elif args.command == "guard":
         _guard.dispatch_guard(args, guard_p)
     elif args.command == "mcp":

{conduct_cli-0.4.38 → conduct_cli-0.4.41}/src/conduct_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.4.38
+Version: 0.4.41
 Summary: CLI for Conduct AI — install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT

{conduct_cli-0.4.38 → conduct_cli-0.4.41}/src/conduct_cli.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ src/conduct_cli.egg-info/SOURCES.txt
 src/conduct_cli.egg-info/dependency_links.txt
 src/conduct_cli.egg-info/entry_points.txt
 src/conduct_cli.egg-info/requires.txt
-src/conduct_cli.egg-info/top_level.txt
+src/conduct_cli.egg-info/top_level.txt
+tests/test_switch.py

conduct_cli-0.4.41/tests/test_switch.py

@@ -0,0 +1,215 @@
+"""Tests for `conduct switch` and `conduct whoami` commands."""
+
+import json
+import sys
+import types
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_args(**kwargs):
+    ns = types.SimpleNamespace(**kwargs)
+    return ns
+
+
+def _fake_workspaces():
+    return [
+        {"id": "ef0a7e36-0000-0000-0000-000000000001", "name": "Engineering",    "owner_id": "u1", "workflow_count": 3},
+        {"id": "ab1b2c3d-0000-0000-0000-000000000002", "name": "Marketing",      "owner_id": "u1", "workflow_count": 1},
+        {"id": "deadbeef-0000-0000-0000-000000000003", "name": "Eng Backup",     "owner_id": "u1", "workflow_count": 0},
+    ]
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — list mode (no arg)
+# ---------------------------------------------------------------------------
+
+def test_switch_list_prints_workspaces(tmp_path, capsys):
+    """conduct switch with no arg exits 0 and prints workspace list."""
+    from conduct_cli import main as m
+
+    config = {
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }
+    cfg_path = tmp_path / "config.json"
+    cfg_path.write_text(json.dumps(config))
+
+    args = _make_args(workspace=None)
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+    ):
+        m.cmd_switch(args)
+
+    out = capsys.readouterr().out
+    assert "Engineering" in out
+    assert "Marketing"   in out
+    assert "*" in out          # current workspace marked
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — exact match updates both config files
+# ---------------------------------------------------------------------------
+
+def test_switch_exact_name_updates_configs(tmp_path, capsys):
+    """conduct switch 'Marketing' updates ~/.conduct/config.json and guard config."""
+    from conduct_cli import main as m
+    from conduct_cli import guard as g
+
+    cfg_path        = tmp_path / "conduct" / "config.json"
+    # Guard config lives at <home>/.conductguard/config.json; home is patched to tmp_path
+    guard_cfg_path  = tmp_path / ".conductguard" / "config.json"
+
+    cfg_path.parent.mkdir(parents=True)
+    guard_cfg_path.parent.mkdir(parents=True)
+
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+    guard_cfg_path.write_text(json.dumps({
+        "workspace_id": "ef0a7e36-0000-0000-0000-000000000001",
+        "user_email":   "dev@example.com",
+    }))
+
+    args = _make_args(workspace="Marketing")
+
+    fake_policy = {"version": "2", "rules": [{"rule_id": "r1", "action": "audit"}]}
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch("pathlib.Path.home", return_value=tmp_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+        patch.object(g, "_req", return_value=fake_policy),
+        patch.object(g, "_save_policy") as mock_save_policy,
+    ):
+        m.cmd_switch(args)
+
+    out = capsys.readouterr().out
+    assert "Marketing" in out
+    assert "ab1b2c3d" in out   # first 8 chars of the new workspace id
+
+    updated_cfg = json.loads(cfg_path.read_text())
+    assert updated_cfg["workspace"] == "ab1b2c3d-0000-0000-0000-000000000002"
+
+    updated_guard = json.loads(guard_cfg_path.read_text())
+    assert updated_guard["workspace_id"] == "ab1b2c3d-0000-0000-0000-000000000002"
+
+    mock_save_policy.assert_called_once_with(fake_policy)
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — ambiguous partial match
+# ---------------------------------------------------------------------------
+
+def test_switch_ambiguous_exits_1(tmp_path, capsys):
+    """Partial match that hits multiple workspaces prints error and exits 1."""
+    from conduct_cli import main as m
+
+    cfg_path = tmp_path / "config.json"
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+
+    # "Eng" matches both "Engineering" and "Eng Backup"
+    args = _make_args(workspace="Eng")
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+        pytest.raises(SystemExit) as exc,
+    ):
+        m.cmd_switch(args)
+
+    assert exc.value.code == 1
+    out = capsys.readouterr().out
+    assert "Ambiguous" in out or "ambiguous" in out.lower() or "more specific" in out
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — no match exits 1
+# ---------------------------------------------------------------------------
+
+def test_switch_no_match_exits_1(tmp_path, capsys):
+    """conduct switch 'Nonexistent' exits 1 and lists available workspaces."""
+    from conduct_cli import main as m
+
+    cfg_path = tmp_path / "config.json"
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+
+    args = _make_args(workspace="Nonexistent")
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+        pytest.raises(SystemExit) as exc,
+    ):
+        m.cmd_switch(args)
+
+    assert exc.value.code == 1
+    out = capsys.readouterr().out
+    assert "Engineering" in out   # shows available list
+
+
+# ---------------------------------------------------------------------------
+# cmd_whoami — basic output
+# ---------------------------------------------------------------------------
+
+def test_whoami_prints_all_sections(tmp_path, capsys):
+    """conduct whoami prints workspace, server, api_key, Guard, and Booster lines."""
+    from conduct_cli import main as m
+
+    cfg_path = tmp_path / "conduct" / "config.json"
+    cfg_path.parent.mkdir(parents=True)
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_88a4longkeyxxx",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+
+    guard_dir = tmp_path / ".conductguard"
+    guard_dir.mkdir()
+    (guard_dir / "config.json").write_text(json.dumps({
+        "workspace_id": "ef0a7e36-0000-0000-0000-000000000001",
+        "user_email":   "sudhi@b2bsphere.com",
+    }))
+    (guard_dir / "policy.json").write_text(json.dumps({
+        "version": "1",
+        "rules":   [{"rule_id": "r1"}, {"rule_id": "r2"}, {"rule_id": "r3"}],
+    }))
+    # No hook.py — hook_status should say "hook missing"
+
+    args = _make_args()
+
+    def fake_home():
+        return tmp_path
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch("pathlib.Path.home", return_value=tmp_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+    ):
+        m.cmd_whoami(args)
+
+    out = capsys.readouterr().out
+    assert "https://api.conductai.ai" in out
+    assert "cond_live_88" in out   # first 12 chars of the api_key
+    assert "sudhi@b2bsphere.com" in out
+    assert "3 rules" in out
+    assert "Booster" in out