conduct-cli 0.5.3__tar.gz → 0.5.5__tar.gz

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/PKG-INFO

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

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/pyproject.toml

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

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/src/conduct_cli/api.py

@@ -31,7 +31,7 @@ def req(method: str, url: str, hdrs: dict, body=None, timeout: int = 30) -> dict
             detail = json.loads(raw).get("detail", raw)
         except Exception:
             detail = raw
-        print(f"{RED}HTTP {e.code}: {detail}{RESET}")
+        print(f"{RED}HTTP {e.code}: {detail} [{url}]{RESET}")
         sys.exit(1)
     except (socket.timeout, TimeoutError):
         print(f"{RED}Request timed out: {url}{RESET}")
@@ -50,7 +50,7 @@ def req_text(method: str, url: str, hdrs: dict, body_text: str, timeout: int = 3
             detail = json.loads(raw).get("detail", raw)
         except Exception:
             detail = raw
-        print(f"{RED}HTTP {e.code}: {detail}{RESET}")
+        print(f"{RED}HTTP {e.code}: {detail} [{url}]{RESET}")
         sys.exit(1)
     except (socket.timeout, TimeoutError):
         print(f"{RED}Request timed out: {url}{RESET}")

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/src/conduct_cli/guard.py

@@ -159,6 +159,61 @@ def _install_session_hooks() -> None:
 
 # ── Guard config helpers ──────────────────────────────────────────────────────
 
+_PERSONA_LABELS = {
+    "conservative": "Conservative  — production-safe, default deny",
+    "standard":     "Standard      — engineering teams, balanced",
+    "developer":    "Developer     — local dev, audit-first",
+}
+
+
+def _ensure_persona(workspace_id: str, api_key: str, base_url: str) -> str:
+    """Prompt for persona if none is set yet. Saves choice to guard config and API.
+
+    Returns the active persona name. Skips prompt silently if already set.
+    """
+    cfg = _load_guard_config()
+    if cfg.get("persona"):
+        return cfg["persona"]
+
+    print(f"\n{BOLD}Choose a policy persona for your agents:{RESET}")
+    choices = list(_PERSONA_LABELS.keys())
+    for i, key in enumerate(choices, 1):
+        print(f"  {i}. {_PERSONA_LABELS[key]}")
+
+    while True:
+        try:
+            raw = input(f"\nEnter 1-{len(choices)} [default: 2 — Standard]: ").strip()
+            if raw == "":
+                raw = "2"
+            idx = int(raw) - 1
+            if 0 <= idx < len(choices):
+                chosen = choices[idx]
+                break
+            print(f"  Enter a number between 1 and {len(choices)}")
+        except (ValueError, EOFError):
+            chosen = "standard"
+            break
+
+    # Push to API
+    try:
+        _req(
+            "PATCH",
+            f"{base_url}/guard/config/persona",
+            body={"persona": chosen},
+            api_key=api_key,
+        )
+    except Exception:
+        pass  # non-fatal — local config still records the choice
+
+    # Persist locally so we skip the prompt on subsequent syncs
+    cfg = _load_guard_config()
+    cfg["persona"] = chosen
+    _save_guard_config(cfg)
+
+    print(f"  {GREEN}Persona set:{RESET} {chosen.capitalize()}")
+    return chosen
+
+
 def _load_guard_config() -> dict:
     if CONFIG_PATH.exists():
         return json.loads(CONFIG_PATH.read_text())
@@ -190,6 +245,17 @@ def _api_url(cfg: dict) -> str:
 # ── MCP registration ──────────────────────────────────────────────────────────
 
 # Tools that support mcpServers JSON — only write if the config file already exists
+def _vscode_mcp_paths() -> list[tuple[Path, str]]:
+    """VS Code Copilot MCP config locations (macOS + Linux). Only if Copilot is installed."""
+    ext_dir = Path.home() / ".vscode" / "extensions"
+    if not ext_dir.exists() or not any(p.name.startswith("github.copilot") for p in ext_dir.iterdir() if p.is_dir()):
+        return []
+    candidates = [
+        Path.home() / "Library" / "Application Support" / "Code" / "User" / "mcp.json",
+        Path.home() / ".config" / "Code" / "User" / "mcp.json",
+    ]
+    return [(p, "VS Code Copilot") for p in candidates if p.parent.exists()]
+
 _MCP_TARGETS = [
     (Path.home() / ".claude"   / "settings.json", "Claude Code"),
     (Path.home() / ".cursor"   / "mcp.json",       "Cursor"),
@@ -212,8 +278,9 @@ def _register_mcp(workspace_id: str, member_token: str, api_url: str) -> None:
     if shutil.which("booster"):
         servers["agent-booster"] = {"command": "booster", "args": ["serve"]}
 
+    targets = list(_MCP_TARGETS) + _vscode_mcp_paths()
     found_any = False
-    for cfg_path, label in _MCP_TARGETS:
+    for cfg_path, label in targets:
         if not cfg_path.exists():
             continue
         found_any = True
@@ -327,7 +394,7 @@ def _req(method: str, url: str, body=None, token: str = None, api_key: str = Non
             detail = json.loads(raw).get("detail", raw)
         except Exception:
             detail = raw
-        print(f"{RED}HTTP {e.code}: {detail}{RESET}")
+        print(f"{RED}HTTP {e.code}: {detail} [{url}]{RESET}")
         sys.exit(1)
     except Exception:
         print(f"{RED}Could not reach ConductAI API. Check your connection.{RESET}")
@@ -340,6 +407,13 @@ def _save_policy(policy: dict):
     POLICY_PATH.write_text(json.dumps(policy, indent=2))
 
 
+def _load_policy() -> dict:
+    try:
+        return json.loads(POLICY_PATH.read_text())
+    except Exception:
+        return {"rules": []}
+
+
 # ── since-string parser ───────────────────────────────────────────────────────
 
 def _parse_since(since_str: str) -> str:
@@ -475,14 +549,8 @@ def cmd_guard_install(args):
     user_email     = result.get("user_email") or ""
     clerk_user_id  = result.get("clerk_user_id") or ""
 
-    # Check if Security Loop module is installed for this workspace
-    security_emit = False
-    try:
-        sec = _req("GET", f"{server}/secure/installed?workspace_id={workspace_id}", api_key=api_key)
-        if sec.get("installed"):
-            security_emit = True
-    except Exception:
-        pass
+    # 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
     import time as _time
@@ -493,11 +561,8 @@ def cmd_guard_install(args):
         "clerk_user_id":         clerk_user_id,
         "api_key":               api_key,
         "api_url":               server,
-        "security_emit_enabled": security_emit,
         "last_synced_at":        _time.time(),
     })
-    if security_emit:
-        print(f"  {GREEN}Security Loop:{RESET} installed — classifier active")
 
     # Download policies
     try:
@@ -655,15 +720,19 @@ def _report_tools_to_server() -> None:
             "hook_registered": False,
         })
 
-    vscode_candidates = [
-        home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
-        home / ".config" / "Code" / "User" / "settings.json",
-        home / ".vscode" / "settings.json",
-    ]
-    vscode_settings = next((p for p in vscode_candidates if p.exists()), None)
-    if vscode_settings:
+    vscode_ext_dir = home / ".vscode" / "extensions"
+    copilot_installed = vscode_ext_dir.exists() and any(
+        p.name.startswith("github.copilot") for p in vscode_ext_dir.iterdir() if p.is_dir()
+    )
+    if copilot_installed:
+        vscode_candidates = [
+            home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
+            home / ".config" / "Code" / "User" / "settings.json",
+            home / ".vscode" / "settings.json",
+        ]
+        vscode_settings = next((p for p in vscode_candidates if p.exists()), None)
         try:
-            d = json.loads(vscode_settings.read_text())
+            d = json.loads(vscode_settings.read_text()) if vscode_settings else {}
             mcp_reg = "conduct" in d.get("mcp", {}).get("servers", {})
         except Exception:
             mcp_reg = False
@@ -718,7 +787,11 @@ def cmd_guard_sync(args):
     api_key      = cfg.get("api_key", "")
     base_url     = _api_url(cfg)
 
-    print(f"Syncing policy…")
+    # Persona selection — prompt once, skip if already chosen
+    _ensure_persona(workspace_id, api_key, base_url)
+
+    dry_run = getattr(args, "dry_run", False)
+    print(f"{'[dry-run] ' if dry_run else ''}Syncing policy…")
 
     try:
         policy = _req(
@@ -729,28 +802,49 @@ def cmd_guard_sync(args):
     except Exception as e:
         print(f"Guard sync skipped: {e}", file=sys.stderr)
         sys.exit(0)
+
+    rules = policy.get("rules", [])
+    rule_count = len(rules)
+
+    if dry_run:
+        current_policy = _load_policy()
+        current_rules = {r["rule_id"]: r for r in current_policy.get("rules", [])}
+        new_rules = {r["rule_id"]: r for r in rules}
+
+        added   = [r for r in new_rules   if r not in current_rules]
+        removed = [r for r in current_rules if r not in new_rules]
+        changed = [
+            r for r in new_rules
+            if r in current_rules and new_rules[r].get("action") != current_rules[r].get("action")
+        ]
+
+        print(f"\n  {BOLD}Dry run — no files written{RESET}")
+        print(f"  Rules in policy: {rule_count}")
+        if added:
+            print(f"\n  {GREEN}+ Added ({len(added)}){RESET}")
+            for rid in added:
+                r = new_rules[rid]
+                print(f"      {rid}  [{r.get('action','?').upper()}]")
+        if removed:
+            print(f"\n  {RED}- Removed ({len(removed)}){RESET}")
+            for rid in removed:
+                print(f"      {rid}")
+        if changed:
+            print(f"\n  ~ Changed action ({len(changed)})")
+            for rid in changed:
+                old_a = current_rules[rid].get("action", "?")
+                new_a = new_rules[rid].get("action", "?")
+                print(f"      {rid}  {old_a} → {new_a}")
+        if not added and not removed and not changed:
+            print(f"  {GREEN}No changes{RESET}")
+        return
+
     _save_policy(policy)
-    rule_count = len(policy.get("rules", []))
     print(f"  {GREEN}Policy refreshed:{RESET} {rule_count} rule(s)")
 
     if getattr(args, "cursor", False):
         _write_cursorrules(policy)
 
-    # Re-check Security Loop install status
-    try:
-        sec = _req("GET", f"{base_url}/secure/installed?workspace_id={workspace_id}", api_key=api_key)
-        cfg["security_emit_enabled"] = bool(sec.get("installed"))
-        _save_guard_config(cfg)
-        if sec.get("installed"):
-            print(f"  {GREEN}Security Loop:{RESET} installed — classifier active")
-            try:
-                policies = _req("GET", f"{base_url}/secure/policies?workspace_id={workspace_id}", api_key=api_key)
-                policy_count = len(policies) if isinstance(policies, list) else 0
-                print(f"  {GREEN}Security Loop policies:{RESET} {policy_count} rule(s) synced")
-            except Exception:
-                pass
-    except Exception:
-        pass
 
     # Refresh hook script + re-register in all tools
     hook_path = GUARD_DIR / "hook.py"
@@ -1198,6 +1292,7 @@ def register_guard_parser(sub):
     # conduct guard sync
     sync_p = guard_sub.add_parser("sync", help="Refresh policy and re-scan for AI tools")
     sync_p.add_argument("--cursor", action="store_true", help="Write active Guard policies to .cursorrules")
+    sync_p.add_argument("--dry-run", action="store_true", help="Preview policy changes without writing anything")
 
     # conduct guard status
     guard_sub.add_parser("status", help="Show today's spend and violations")

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/src/conduct_cli/guardmcp.py

@@ -139,12 +139,31 @@ def _load_config() -> dict:
     return {}
 
 
-_sync_lock = threading.Lock()
+_DAEMON_URL   = "http://127.0.0.1:7878"
+_sync_lock    = threading.Lock()
 _SYNC_INTERVAL = 300  # 5 minutes
 
 
+def _daemon_alive() -> bool:
+    try:
+        urllib.request.urlopen(f"{_DAEMON_URL}/health", timeout=0.3)
+        return True
+    except Exception:
+        return False
+
+
 def _maybe_sync() -> None:
-    """If config is stale (>5 min since last sync), run `conduct guard sync` in background."""
+    """Sync policy: daemon (instant) → conduct guard sync (every 5 min). Never raises."""
+    try:
+        if _daemon_alive():
+            cfg = _load_config()
+            ws_id = cfg.get("workspace_id", "")
+            if ws_id:
+                with urllib.request.urlopen(f"{_DAEMON_URL}/policy?workspace_id={ws_id}", timeout=1) as r:
+                    POLICY_PATH.write_text(r.read().decode())
+            return
+    except Exception:
+        pass  # fall through to CLI sync
     cfg = _load_config()
     last_sync = cfg.get("last_synced_at", 0)
     if time.time() - last_sync < _SYNC_INTERVAL:
@@ -153,11 +172,7 @@ def _maybe_sync() -> None:
         return  # another thread is already syncing
     def _run():
         try:
-            subprocess.run(
-                ["conduct", "guard", "sync"],
-                timeout=15,
-                capture_output=True,
-            )
+            subprocess.run(["conduct", "guard", "sync"], timeout=15, capture_output=True)
         except Exception:
             pass
         finally:
@@ -192,12 +207,11 @@ def _post_audit_event(
     token: str,
     ai_tool: str,
 ) -> None:
-    """Fire-and-forget: post a guard audit event to the Conduct API."""
+    """Fire-and-forget: queue event via daemon (batch) or direct API fallback."""
     if not workspace_id:
         return
-    cfg     = _load_config()
-    api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
-    payload = json.dumps({
+    cfg = _load_config()
+    event = {
         "workspace_id":    workspace_id,
         "clerk_user_id":   cfg.get("user_email", ""),
         "user_email":      cfg.get("user_email", ""),
@@ -207,15 +221,26 @@ def _post_audit_event(
         "decision":        decision,
         "rule_id":         rule_id,
         "hook_session_id": _SESSION_ID,
-    }).encode()
+    }
     try:
-        req = urllib.request.Request(
-            f"{api_url}/guard/events",
-            data=payload,
-            headers={
-                "Content-Type":  "application/json",
-                "Authorization": f"Bearer {token}",
-            },
+        # Fast path: daemon batches events, reducing API calls 30:1
+        if _daemon_alive():
+            body = json.dumps(event).encode()
+            req  = urllib.request.Request(
+                f"{_DAEMON_URL}/event", data=body,
+                headers={"Content-Type": "application/json"}, method="POST",
+            )
+            urllib.request.urlopen(req, timeout=1)
+            return
+    except Exception:
+        pass
+    # Fallback: direct API post
+    try:
+        api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+        body    = json.dumps(event).encode()
+        req     = urllib.request.Request(
+            f"{api_url}/guard/events", data=body,
+            headers={"Content-Type": "application/json", "Authorization": f"Bearer {token}"},
             method="POST",
         )
         urllib.request.urlopen(req, timeout=5)

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/src/conduct_cli/hook_template.py

@@ -39,8 +39,19 @@ VERSION_CACHE_TTL   = 60   # 1 minute — matches server poll window
 WARNED_RULES_PATH   = GUARD_DIR / "warned_rules.json"
 
 
+_DAEMON_URL = "http://127.0.0.1:7878"
+
+
+def _daemon_alive() -> bool:
+    try:
+        with urllib.request.urlopen(f"{_DAEMON_URL}/health", timeout=0.3):
+            return True
+    except Exception:
+        return False
+
+
 def _maybe_sync_policy():
-    """Check server policy version once per minute; re-download if stale. Never raises."""
+    """Sync policy from daemon (instant) or remote API (once per minute). Never raises."""
     try:
         cfg = json.loads(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
         workspace_id = cfg.get("workspace_id")
@@ -48,18 +59,25 @@ def _maybe_sync_policy():
         api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
         if not workspace_id:
             return
-        # Check cache TTL
+
+        # Fast path: daemon is running — it keeps policy fresh via WebSocket push
+        if _daemon_alive():
+            url = f"{_DAEMON_URL}/policy?workspace_id={workspace_id}"
+            with urllib.request.urlopen(url, timeout=1) as resp:
+                remote = json.loads(resp.read())
+            POLICY_PATH.write_text(json.dumps(remote, indent=2))
+            return
+
+        # Slow path: no daemon — poll remote API once per minute
         if VERSION_CACHE_PATH.exists():
             cache = json.loads(VERSION_CACHE_PATH.read_text())
             if time.time() - cache.get("ts", 0) < VERSION_CACHE_TTL:
                 return
-        # Fetch current version from server
         url = f"{api_url}/guard/policies/sync?workspace_id={workspace_id}"
         req = urllib.request.Request(url, headers={"Authorization": f"Bearer {api_key}"} if api_key else {})
         with urllib.request.urlopen(req, timeout=2) as resp:
             remote = json.loads(resp.read())
         remote_version = remote.get("version", "")
-        # Compare to local
         local_version = ""
         if POLICY_PATH.exists():
             local_version = json.loads(POLICY_PATH.read_text()).get("version", "")

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/src/conduct_cli/main.py

@@ -302,16 +302,21 @@ def _detect_ai_tools() -> list:
             "hook_registered": False,  # Windsurf uses MCP only
         })
 
-    # VS Code (Copilot)
-    vscode_settings_candidates = [
-        home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
-        home / ".config" / "Code" / "User" / "settings.json",
-        home / ".vscode" / "settings.json",
-    ]
-    vscode_settings = next((p for p in vscode_settings_candidates if p.exists()), None)
-    if vscode_settings:
+    # VS Code (Copilot) — only report if Copilot extension is actually installed
+    vscode_ext_dir = home / ".vscode" / "extensions"
+    copilot_installed = vscode_ext_dir.exists() and any(
+        p.name.startswith("github.copilot") for p in vscode_ext_dir.iterdir()
+        if p.is_dir()
+    )
+    if copilot_installed:
+        vscode_settings_candidates = [
+            home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
+            home / ".config" / "Code" / "User" / "settings.json",
+            home / ".vscode" / "settings.json",
+        ]
+        vscode_settings = next((p for p in vscode_settings_candidates if p.exists()), None)
         try:
-            d = json.loads(vscode_settings.read_text())
+            d = json.loads(vscode_settings.read_text()) if vscode_settings else {}
             mcp_reg = "conduct" in d.get("mcp", {}).get("servers", {})
         except Exception:
             mcp_reg = False
@@ -409,6 +414,12 @@ def cmd_mcp_install(args):
         if uncovered:
             print(f"{YELLOW}  Not covered: {', '.join(uncovered)} — run: conduct mcp install{RESET}")
 
+    # Push updated coverage to Guard so the dashboard reflects the new state immediately
+    try:
+        _report_tool_coverage()
+    except Exception:
+        pass
+
 
 def cmd_login(args):
     server    = args.server
@@ -2847,6 +2858,77 @@ def _check_guard_setup(command: str) -> None:
     )
 
 
+
+def cmd_skill(args):
+    """conduct skill list | install <slug> | uninstall <slug>"""
+    skill_command = getattr(args, "skill_command", None)
+    server, workspace, api_key, token = _require_auth(args)
+
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["X-Api-Key"] = api_key
+    elif token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    def _req(method, path, expect=None):
+        url = f"{server}{path}"
+        req = urllib.request.Request(url, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=10) as r:
+                data = json.loads(r.read())
+            return data
+        except urllib.error.HTTPError as e:
+            body = e.read().decode()
+            try:
+                msg = json.loads(body).get("detail", body)
+            except Exception:
+                msg = body
+            print(f"{RED}Error {e.code}: {msg}{RESET}")
+            sys.exit(1)
+
+    if skill_command == "list":
+        data = _req("GET", f"/compliance/packs/available?workspace_id={workspace}")
+        installed_data = _req("GET", f"/compliance/packs/installed?workspace_id={workspace}")
+        installed = set(installed_data.get("installed", []))
+
+        packs = data.get("packs", [])
+        if not packs:
+            print("No skill packs available.")
+            return
+
+        print(f"\n{'Slug':<20} {'Name':<22} {'Tier':<8} {'Rules':<7} Status")
+        print("─" * 70)
+        for p in packs:
+            slug   = p.get("slug", "")
+            name   = p.get("name", "")
+            tier   = p.get("tier", "")
+            rules  = len(p.get("rules", []))
+            status = f"{GREEN}installed{RESET}" if slug in installed else f"{GRAY}available{RESET}"
+            print(f"{slug:<20} {name:<22} {tier:<8} {rules:<7} {status}")
+        print()
+
+    elif skill_command == "install":
+        slug = getattr(args, "slug", None)
+        if not slug:
+            print(f"{RED}Usage: conduct skill install <slug>{RESET}")
+            sys.exit(1)
+        _req("POST", f"/compliance/packs/{slug}/install?workspace_id={workspace}")
+        print(f"{GREEN}✓{RESET} Installed {BOLD}{slug}{RESET}")
+        print(f"  Run {BOLD}conduct guard sync{RESET} to push the updated policy to your hook.")
+
+    elif skill_command == "uninstall":
+        slug = getattr(args, "slug", None)
+        if not slug:
+            print(f"{RED}Usage: conduct skill uninstall <slug>{RESET}")
+            sys.exit(1)
+        _req("DELETE", f"/compliance/packs/{slug}/uninstall?workspace_id={workspace}")
+        print(f"{GREEN}✓{RESET} Uninstalled {BOLD}{slug}{RESET}")
+        print(f"  Run {BOLD}conduct guard sync{RESET} to push the updated policy to your hook.")
+
+    else:
+        print("Usage: conduct skill <list|install|uninstall> [slug]")
+
+
 def main():
     _auto_update()
 
@@ -2987,6 +3069,15 @@ def main():
     mcp_sub = mcp_p.add_subparsers(dest="mcp_command")
     mcp_sub.add_parser("install", help="Register conduct-mcp in Claude Code and Codex")
 
+    # conduct skill
+    skill_p = sub.add_parser("skill", help="Manage Guard skill packs")
+    skill_sub = skill_p.add_subparsers(dest="skill_command")
+    skill_sub.add_parser("list", help="List available and installed skill packs")
+    skill_install_p = skill_sub.add_parser("install", help="Install a skill pack")
+    skill_install_p.add_argument("slug", help="Pack slug, e.g. conduct-owasp")
+    skill_uninstall_p = skill_sub.add_parser("uninstall", help="Uninstall a skill pack")
+    skill_uninstall_p.add_argument("slug", help="Pack slug, e.g. conduct-owasp")
+
     # conduct sync
     sub.add_parser("sync", help="Sync Guard policies (and Security Loop policies if installed)")
 
@@ -3080,6 +3171,8 @@ def main():
             cmd_mcp_install(args)
         else:
             mcp_p.print_help()
+    elif args.command == "skill":
+        cmd_skill(args)
     elif args.command == "sync":
         cmd_sync(args)
     elif args.command == "test-guard":

{conduct_cli-0.5.3 → conduct_cli-0.5.5}/src/conduct_cli.egg-info/PKG-INFO

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