agentmetry 0.4.0__py3-none-any.whl

agentmetry/core/audit/external.py

@@ -0,0 +1,213 @@
+"""Canonical events from external agent adapters (Tier B — Cursor, Claude, etc.)."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Literal
+
+from agentmetry.core.audit.canonical import SCHEMA_VERSION
+from agentmetry.core.audit.identity import identity_fields
+from agentmetry.core.audit.hashing import arguments_sha256
+from agentmetry.core.audit.redaction import scrub_arg_values, scrub_secrets
+from agentmetry.core.audit.run_context import actor_from_initiator, build_initiator
+from agentmetry.core.config import settings
+
+ExternalApp = Literal[
+    "cursor", "claude", "antigravity", "codex", "mcp_proxy",
+    "qwen", "kimi", "qoder", "codebuddy", "trae", "crewai", "opensre", "agentmetry",
+]
+
+KNOWN_EXTERNAL_APPS = frozenset({
+    "cursor", "claude", "antigravity", "codex", "mcp_proxy",
+    "qwen", "kimi", "qoder", "codebuddy", "trae", "crewai", "opensre",
+})
+
+_ACTION_MAP = {
+    "session_start": ("session_start", "success"),
+    "session_end": ("session_end", "success"),
+    "tool_called": ("tool_called", "success"),
+    "tool_denied": ("tool_called", "denied"),
+    "tool_failed": ("tool_called", "error"),
+    "approval_request": ("approval_request", "pending"),
+    "approval_response": ("approval_response", "success"),
+}
+
+
+def _operator_id() -> str:
+    return settings.operator_id.strip() or "local"
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _split_tool(qualified: str) -> tuple[str, str]:
+    if "." in qualified:
+        driver, name = qualified.split(".", 1)
+        return driver, name
+    return "", qualified
+
+
+def build_external_canonical(payload: dict[str, Any]) -> dict[str, Any]:
+    """Normalize an adapter payload into canonical v1.1 JSON."""
+    source_app = str(payload.get("source_app") or "cursor").lower()
+    if source_app not in KNOWN_EXTERNAL_APPS and source_app != "agentmetry":
+        source_app = "cursor"
+
+    event_type = str(payload.get("event_type") or "tool_called")
+    action_type, default_outcome = _ACTION_MAP.get(event_type, ("tool_called", "success"))
+    outcome = str(payload.get("outcome") or default_outcome)
+    reason = str(payload.get("reason") or "")
+
+    correlation_id = str(payload.get("correlation_id") or payload.get("thread_id") or "")
+    session_id = str(payload.get("session_id") or "")
+
+    initiator_raw = payload.get("initiator")
+    if isinstance(initiator_raw, dict) and initiator_raw.get("actor_type"):
+        initiator = {
+            "actor_type": str(initiator_raw.get("actor_type") or "human"),
+            "trigger": str(initiator_raw.get("trigger") or "manual"),
+            "operator_id": str(initiator_raw.get("operator_id") or _operator_id()),
+        }
+    else:
+        trigger = str(payload.get("triggered_by") or "manual")
+        initiator = build_initiator(trigger)
+
+    tool_block = payload.get("tool") if isinstance(payload.get("tool"), dict) else {}
+    tool_qualified = str(
+        tool_block.get("qualified")
+        or payload.get("tool_qualified")
+        or payload.get("tool_name")
+        or ""
+    )
+    driver_name, tool_name = _split_tool(tool_qualified)
+
+    args = tool_block.get("arguments")
+    if isinstance(args, dict):
+        input_hash = str(tool_block.get("input_hash") or arguments_sha256(args))
+    else:
+        input_hash = str(tool_block.get("input_hash") or payload.get("input_hash") or "")
+
+    skill_id = str(payload.get("skill_id") or payload.get("skill") or "")
+
+    model_raw = payload.get("model") if isinstance(payload.get("model"), dict) else {}
+    model_provider = str(model_raw.get("provider") or source_app)
+    model_id = str(model_raw.get("id") or payload.get("model_id") or source_app)
+
+    adapter = str(payload.get("adapter") or f"{source_app}_hook")
+
+    event: dict[str, Any] = {
+        "schema_version": SCHEMA_VERSION,
+        "event_id": str(uuid.uuid4()),
+        "session_id": session_id,
+        "correlation_id": correlation_id,
+        "timestamp_utc": str(payload.get("timestamp_utc") or _utc_now()),
+        **identity_fields(),
+        "source_topic": f"external/{source_app}/{event_type}",
+        "source": {
+            "tier": "external",
+            "app": source_app,
+            "adapter": adapter,
+        },
+        "initiator": initiator,
+        "actor": actor_from_initiator(initiator),
+        "action": {
+            "type": action_type,
+            "outcome": outcome,
+            "reason": reason,
+        },
+        "agent": {
+            "name": source_app,
+            "skill_id": skill_id,
+        },
+        "model": {"id": model_id, "provider": model_provider},
+    }
+
+    if tool_qualified:
+        server = str(tool_block.get("server") or driver_name or source_app)
+        command = str(tool_block.get("command") or "").strip()
+        redaction = "hash+command" if command else "hash"
+        event["tool"] = {
+            "name": tool_name or tool_qualified,
+            "qualified": tool_qualified,
+            "server": server,
+            "input_redaction": redaction,
+            "input_hash": input_hash,
+            "parameters_redacted": not bool(command) and not isinstance(tool_block.get("arguments"), dict),
+        }
+        if command:
+            event["tool"]["command"] = scrub_secrets(command)[:4096]
+        if isinstance(tool_block.get("arguments"), dict):
+            event["tool"]["arguments"] = scrub_arg_values(tool_block.get("arguments"))
+
+        # Hook-side command classification labels. In the default hashed-only
+        # config these are the ONLY detection signal the command leaves behind.
+        traits_raw = tool_block.get("traits")
+        if isinstance(traits_raw, list):
+            traits = [str(t) for t in traits_raw if t]
+            if traits:
+                event["tool"]["traits"] = traits
+
+        # Prefer the hook's MITRE mapping: it saw the plaintext command before
+        # hashing, so its content upgrade (e.g. a key-file read → T1552) is
+        # strictly better informed than a name-only recompute here.
+        adapter_mitre = tool_block.get("mitre")
+        if isinstance(adapter_mitre, dict) and adapter_mitre.get("tactic_id"):
+            event["tool"]["mitre"] = {
+                key: str(adapter_mitre.get(key) or "")
+                for key in ("tactic_id", "tactic", "technique_id", "technique")
+            }
+        else:
+            from agentmetry.core.audit.canonical import get_mitre_mapping
+            # Pass command/args as evidence so a read of a key/secret upgrades to
+            # Credential Access (T1552) instead of generic Collection.
+            evidence = command or tool_block.get("arguments")
+            mitre = get_mitre_mapping(tool_qualified, evidence)
+            if mitre:
+                event["tool"]["mitre"] = mitre
+
+    gated = payload.get("gated_action")
+    if isinstance(gated, dict) and gated.get("tool"):
+        event["gated_action"] = {
+            "tool": str(gated.get("tool") or ""),
+            "server": str(gated.get("server") or ""),
+            "input_hash": str(gated.get("input_hash") or ""),
+        }
+
+    # DLP verdict — rule metadata only, never the matched value. The hook scans
+    # plaintext before hashing; if we drop the verdict here, a `log`-mode match
+    # (the default mode) leaves no trace anywhere and the DLP engine is a no-op.
+    dlp = payload.get("dlp")
+    if isinstance(dlp, dict) and dlp.get("rule_id"):
+        event["dlp"] = {
+            "rule_id": str(dlp.get("rule_id") or ""),
+            "mode": str(dlp.get("mode") or ""),
+            "pattern_type": str(dlp.get("pattern_type") or "regex"),
+            "category": str(dlp.get("category") or ""),
+            "severity": str(dlp.get("severity") or ""),
+            "rule_ids": [str(r) for r in (dlp.get("rule_ids") or []) if r],
+        }
+
+    tool_policy = payload.get("tool_policy")
+    if isinstance(tool_policy, dict) and tool_policy.get("rule_id"):
+        event["tool_policy"] = {
+            "rule_id": str(tool_policy.get("rule_id") or ""),
+            "action": str(tool_policy.get("action") or ""),
+            "mode": str(tool_policy.get("mode") or ""),
+            "blocked": bool(tool_policy.get("blocked")),
+        }
+
+    if payload.get("seq") is not None:
+        event["seq"] = payload["seq"]
+
+    # Policy verdicts annotate; they never rewrite what happened. This event has
+    # already executed on the agent's machine, so claiming "denied" here would
+    # put a lie in the trail and hide the event from every detection rule that
+    # keys on outcome == "success". See core/audit/policy.py.
+    if settings.policy_enabled and event["action"]["type"] in ("tool_called", "approval_request"):
+        from agentmetry.core.audit.policy import annotate as annotate_policy
+
+        annotate_policy(event)
+
+    return event

agentmetry/core/audit/hashing.py

@@ -0,0 +1,21 @@
+"""Canonical hashing for tool arguments and audit payloads."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+def canonical_json(data: Any) -> str:
+    return json.dumps(data, sort_keys=True, separators=(",", ":"), default=str)
+
+
+def sha256_hex(data: str | bytes) -> str:
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return hashlib.sha256(data).hexdigest()
+
+
+def arguments_sha256(arguments: dict[str, Any]) -> str:
+    return sha256_hex(canonical_json(arguments))

agentmetry/core/audit/hook_bootstrap.py

@@ -0,0 +1,451 @@
+"""Install global Tier B hooks on orchestrator boot (Cursor, etc.)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Hook subprocesses read these from orchestrator .env (Claude also gets them in settings env).
+HOOK_ENV_KEYS = (
+    "AGENTMETRY_TOOL_POLICY_MODE",
+    "AGENTMETRY_DLP_MODE",
+    "AGENTMETRY_URL",
+)
+
+CURSOR_HOOK_EVENTS = (
+    "sessionStart",
+    "sessionEnd",
+    "stop",
+    "beforeShellExecution",
+    "afterShellExecution",
+    "beforeMCPExecution",
+    "afterMCPExecution",
+    "preToolUse",
+    "postToolUse",
+    "postToolUseFailure",
+)
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[5]
+
+
+def _ingest_script(repo_root: Path | None = None) -> Path:
+    root = repo_root or _repo_root()
+    return root / "scripts" / "agentmetry_ingest.py"
+
+
+def cursor_hooks_payload(*, python: str, ingest: Path) -> dict[str, Any]:
+    hook_cmd = f'"{python}" "{ingest}" cursor hook'
+    return {
+        "version": 1,
+        "hooks": {
+            event: [{"command": f"{hook_cmd} {event}"}]
+            for event in CURSOR_HOOK_EVENTS
+        },
+    }
+
+
+def install_cursor_global_hooks(
+    *,
+    repo_root: Path | None = None,
+    python: str | None = None,
+    remove_project_hooks: bool = True,
+) -> Path | None:
+    """Write ~/.cursor/hooks.json so every Cursor workspace is audited."""
+    root = repo_root or _repo_root()
+    ingest = _ingest_script(root)
+    if not ingest.is_file():
+        logger.warning("Cursor hook bootstrap skipped: missing %s", ingest)
+        return None
+
+    py = python or sys.executable
+    hooks_dir = Path.home() / ".cursor"
+    hooks_path = hooks_dir / "hooks.json"
+    payload = cursor_hooks_payload(python=py, ingest=ingest)
+
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    hooks_path.write_text(
+        json.dumps(payload, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    logger.info("Installed global Cursor audit hooks -> %s", hooks_path)
+
+    if remove_project_hooks:
+        project_hooks = root / ".cursor" / "hooks.json"
+        if project_hooks.is_file():
+            project_hooks.unlink()
+            logger.info("Removed project Cursor hooks (global covers all workspaces): %s", project_hooks)
+
+    return hooks_path
+
+
+# --- Claude Code (global ~/.claude/settings.json) -------------------------------
+# Claude's settings.json is USER-OWNED (theme, permissions, MCP servers, env).
+# We MERGE only the hooks we own — never overwrite the file. Uses the nested
+# Claude Code hook schema: event -> [ { "hooks": [ { type, command } ] } ].
+
+CLAUDE_HOOK_EVENTS = (
+    "SessionStart",
+    "PreToolUse",
+    "PostToolUse",
+    "Notification",
+    "Stop",
+)
+
+# Qwen Code and Kimi Code — Claude-compatible wire protocol (JSON stdin).
+FAMILY_HOOK_EVENTS = (
+    "SessionStart",
+    "SessionEnd",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "SubagentStart",
+    "SubagentStop",
+    "Stop",
+)
+
+KIMI_HOOKS_BEGIN = "# agentmetry hooks begin"
+KIMI_HOOKS_END = "# agentmetry hooks end"
+
+
+def _orchestrator_env_path(repo_root: Path | None = None) -> Path:
+    root = repo_root or _repo_root()
+    return root / "apps" / "orchestrator" / ".env"
+
+
+def merge_claude_hook_env(
+    settings: dict[str, Any], *, repo_root: Path | None = None
+) -> dict[str, Any]:
+    """Mirror hook-relevant keys from orchestrator .env into Claude settings env."""
+    from agentmetry.core.diagnostics.env_file import read_env_key
+
+    env_path = _orchestrator_env_path(repo_root)
+    env = settings.get("env")
+    if not isinstance(env, dict):
+        env = {}
+    for key in HOOK_ENV_KEYS:
+        val = read_env_key(env_path, key)
+        if val:
+            env[key] = val
+    if env:
+        settings["env"] = env
+    return settings
+
+
+def _claude_command(event: str, *, python: str, ingest: Path) -> str:
+    return f'"{python}" "{ingest}" claude hook {event}'
+
+
+def _family_command(source_app: str, event: str, *, python: str, ingest: Path) -> str:
+    return f'"{python}" "{ingest}" {source_app} hook {event}'
+
+
+def _is_our_hook_group(group: Any, *, source_app: str | None = None) -> bool:
+    """True if a hook group is one Agentmetry installed (idempotency marker)."""
+    if not isinstance(group, dict):
+        return False
+    for inner in group.get("hooks", []) or []:
+        cmd = str(inner.get("command", ""))
+        if "agentmetry_ingest.py" in cmd or "agentaudit_ingest.py" in cmd:
+            if source_app is None or f"{source_app} hook" in cmd:
+                return True
+    return False
+
+
+def _is_our_claude_group(group: Any) -> bool:
+    return _is_our_hook_group(group, source_app="claude")
+
+
+def merge_family_hooks(
+    settings: dict[str, Any],
+    *,
+    events: tuple[str, ...],
+    source_app: str,
+    python: str,
+    ingest: Path,
+) -> dict[str, Any]:
+    """Deep-merge Agentmetry hooks into a Claude-family settings dict."""
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        hooks = {}
+        settings["hooks"] = hooks
+
+    for event in events:
+        existing = hooks.get(event)
+        groups = existing if isinstance(existing, list) else []
+        kept = [g for g in groups if not _is_our_hook_group(g, source_app=source_app)]
+        kept.append({
+            "hooks": [{
+                "type": "command",
+                "command": _family_command(source_app, event, python=python, ingest=ingest),
+                "timeout": 10,
+            }],
+        })
+        hooks[event] = kept
+
+    return settings
+
+
+def merge_claude_hooks(
+    settings: dict[str, Any], *, python: str, ingest: Path
+) -> dict[str, Any]:
+    """Deep-merge Agentmetry hooks into a Claude settings dict, non-destructively.
+
+    Preserves every other key (theme, permissions, mcpServers, env) and any
+    user hooks; replaces only our own previously-installed entries (idempotent).
+    """
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        hooks = {}
+        settings["hooks"] = hooks
+
+    for event in CLAUDE_HOOK_EVENTS:
+        existing = hooks.get(event)
+        groups = existing if isinstance(existing, list) else []
+        # Drop our prior entries so a re-run doesn't duplicate them.
+        kept = [g for g in groups if not _is_our_claude_group(g)]
+        kept.append({
+            "hooks": [{
+                "type": "command",
+                "command": _claude_command(event, python=python, ingest=ingest),
+                "timeout": 10,
+            }],
+        })
+        hooks[event] = kept
+
+    return settings
+
+
+def install_claude_global_hooks(
+    *, repo_root: Path | None = None, python: str | None = None
+) -> Path | None:
+    """Merge Agentmetry hooks into ~/.claude/settings.json for every Claude project."""
+    root = repo_root or _repo_root()
+    ingest = _ingest_script(root)
+    if not ingest.is_file():
+        logger.warning("Claude hook bootstrap skipped: missing %s", ingest)
+        return None
+
+    py = python or sys.executable
+    settings_dir = Path.home() / ".claude"
+    settings_path = settings_dir / "settings.json"
+
+    settings: dict[str, Any] = {}
+    if settings_path.is_file():
+        try:
+            loaded = json.loads(settings_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as exc:
+            # Never clobber a config we can't parse.
+            logger.warning("Claude settings.json unreadable (%s); skipping install", exc)
+            return None
+        if not isinstance(loaded, dict):
+            logger.warning("Claude settings.json is not an object; skipping install")
+            return None
+        settings = loaded
+
+    merge_claude_hooks(settings, python=py, ingest=ingest)
+    merge_claude_hook_env(settings, repo_root=root)
+
+    settings_dir.mkdir(parents=True, exist_ok=True)
+    settings_path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+    logger.info("Installed global Claude audit hooks -> %s", settings_path)
+    return settings_path
+
+
+def _qwen_settings_dir() -> Path:
+    home = os.environ.get("QWEN_HOME", "").strip()
+    if home:
+        return Path(home).expanduser()
+    return Path.home() / ".qwen"
+
+
+def install_qwen_global_hooks(
+    *, repo_root: Path | None = None, python: str | None = None
+) -> Path | None:
+    """Merge Agentmetry hooks into ~/.qwen/settings.json for every Qwen Code project."""
+    return _install_family_settings_hooks(
+        "qwen", _qwen_settings_dir(), repo_root=repo_root, python=python
+    )
+
+
+def _qoder_settings_dir() -> Path:
+    return Path.home() / ".qoder"
+
+
+def install_qoder_global_hooks(
+    *, repo_root: Path | None = None, python: str | None = None
+) -> Path | None:
+    """Merge Agentmetry hooks into ~/.qoder/settings.json (Qoder / 通义灵码)."""
+    return _install_family_settings_hooks(
+        "qoder", _qoder_settings_dir(), repo_root=repo_root, python=python
+    )
+
+
+def _codebuddy_settings_dir() -> Path:
+    return Path.home() / ".codebuddy"
+
+
+def install_codebuddy_global_hooks(
+    *, repo_root: Path | None = None, python: str | None = None
+) -> Path | None:
+    """Merge Agentmetry hooks into ~/.codebuddy/settings.json (Tencent CodeBuddy)."""
+    return _install_family_settings_hooks(
+        "codebuddy", _codebuddy_settings_dir(), repo_root=repo_root, python=python
+    )
+
+
+def _install_family_settings_hooks(
+    source_app: str,
+    settings_dir: Path,
+    *,
+    repo_root: Path | None = None,
+    python: str | None = None,
+) -> Path | None:
+    root = repo_root or _repo_root()
+    ingest = _ingest_script(root)
+    if not ingest.is_file():
+        logger.warning("%s hook bootstrap skipped: missing %s", source_app, ingest)
+        return None
+
+    py = python or sys.executable
+    settings_path = settings_dir / "settings.json"
+
+    settings: dict[str, Any] = {}
+    if settings_path.is_file():
+        try:
+            loaded = json.loads(settings_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as exc:
+            logger.warning("%s settings.json unreadable (%s); skipping install", source_app, exc)
+            return None
+        if not isinstance(loaded, dict):
+            logger.warning("%s settings.json is not an object; skipping install", source_app)
+            return None
+        settings = loaded
+
+    merge_family_hooks(
+        settings,
+        events=FAMILY_HOOK_EVENTS,
+        source_app=source_app,
+        python=py,
+        ingest=ingest,
+    )
+
+    settings_dir.mkdir(parents=True, exist_ok=True)
+    settings_path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+    logger.info("Installed global %s audit hooks -> %s", source_app, settings_path)
+    return settings_path
+
+
+def _kimi_config_dir() -> Path:
+    home = os.environ.get("KIMI_CODE_HOME", "").strip()
+    if home:
+        return Path(home).expanduser()
+    return Path.home() / ".kimi-code"
+
+
+def kimi_hooks_toml_block(*, python: str, ingest: Path) -> str:
+    lines = [
+        KIMI_HOOKS_BEGIN,
+        "# Managed by Agentmetry — re-run scripts/install_kimi_hooks.ps1 to update",
+    ]
+    for event in FAMILY_HOOK_EVENTS:
+        cmd = _family_command("kimi", event, python=python, ingest=ingest)
+        lines.extend([
+            "[[hooks]]",
+            f'event = "{event}"',
+            'matcher = ".*"',
+            f'command = "{cmd}"',
+            "timeout = 10",
+            "",
+        ])
+    lines.append(KIMI_HOOKS_END)
+    return "\n".join(lines) + "\n"
+
+
+def merge_kimi_hooks_toml(text: str, block: str) -> str:
+    pattern = re.compile(
+        rf"{re.escape(KIMI_HOOKS_BEGIN)}.*?{re.escape(KIMI_HOOKS_END)}\n?",
+        re.DOTALL,
+    )
+    stripped = pattern.sub("", text)
+    if stripped and not stripped.endswith("\n"):
+        stripped += "\n"
+    if stripped.strip():
+        return stripped + "\n" + block
+    return block
+
+
+def install_kimi_global_hooks(
+    *, repo_root: Path | None = None, python: str | None = None
+) -> Path | None:
+    """Append Agentmetry hooks to ~/.kimi-code/config.toml (TOML [[hooks]] tables)."""
+    root = repo_root or _repo_root()
+    ingest = _ingest_script(root)
+    if not ingest.is_file():
+        logger.warning("Kimi hook bootstrap skipped: missing %s", ingest)
+        return None
+
+    py = python or sys.executable
+    config_dir = _kimi_config_dir()
+    config_path = config_dir / "config.toml"
+    block = kimi_hooks_toml_block(python=py, ingest=ingest)
+
+    existing = ""
+    if config_path.is_file():
+        existing = config_path.read_text(encoding="utf-8")
+
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(merge_kimi_hooks_toml(existing, block), encoding="utf-8")
+    logger.info("Installed global Kimi audit hooks -> %s", config_path)
+    return config_path
+
+
+def bootstrap_tier_b_hooks(*, repo_root: Path | None = None) -> dict[str, str | None]:
+    """Best-effort hook install for launch-and-forget Tier B logging."""
+    results: dict[str, str | None] = {"cursor": None, "claude": None}
+    try:
+        path = install_cursor_global_hooks(repo_root=repo_root)
+        results["cursor"] = str(path) if path else None
+    except OSError as exc:
+        logger.warning("Cursor hook bootstrap failed: %s", exc)
+    try:
+        cpath = install_claude_global_hooks(repo_root=repo_root)
+        results["claude"] = str(cpath) if cpath else None
+    except OSError as exc:
+        logger.warning("Claude hook bootstrap failed: %s", exc)
+    return results
+
+
+if __name__ == "__main__":
+    target = sys.argv[1] if len(sys.argv) > 1 else "bootstrap"
+    installers = {
+        "bootstrap": bootstrap_tier_b_hooks,
+        "qwen": install_qwen_global_hooks,
+        "kimi": install_kimi_global_hooks,
+        "qoder": install_qoder_global_hooks,
+        "codebuddy": install_codebuddy_global_hooks,
+    }
+    fn = installers.get(target, bootstrap_tier_b_hooks)
+    if target in ("qwen", "kimi", "qoder", "codebuddy"):
+        path = fn()
+        if path:
+            print(f"Installed global {target} hooks -> {path}")
+            sys.exit(0)
+        print(f"{target} hook install skipped (ingest script missing)", file=sys.stderr)
+        sys.exit(1)
+    paths = bootstrap_tier_b_hooks()
+    installed = {k: v for k, v in paths.items() if v}
+    if installed:
+        for app, path in installed.items():
+            print(f"Installed global {app} hooks -> {path}")
+        sys.exit(0)
+    print("Hook install skipped (ingest script missing)", file=sys.stderr)
+    sys.exit(1)