zeno-cli 0.3.4__py3-none-any.whl

zeno_cli/hud/hud_install.py

@@ -0,0 +1,652 @@
+"""`zeno hud install`: stack the zeno cognition bar UNDER the user's existing HUD.
+
+Claude Code exposes exactly one ``statusLine`` slot, so two HUDs cannot register
+natively. The supported composition is to ride whatever popular HUD the user runs:
+
+  * **ccstatusline** (sirmalloc/ccstatusline): a native ``custom-command`` widget on
+    a dedicated extra line. Update-proof, no fork. Config lives at
+    ``~/.config/ccstatusline/settings.json`` (read-merge-write, preserve the user's
+    widgets/lines).
+  * **claude-hud** (jarrodwatts/claude-hud): a thin ``zeno-hud-wrapper`` shell script
+    set as the ``statusLine`` that runs the real claude-hud then ``zeno-hud-bar`` and
+    concatenates their stdout, so Claude Code stacks the rows. (Built in Phase 3.)
+
+Every edit is timestamped-backed-up and reversible (``zeno hud uninstall`` does a
+surgical removal of only zeno-owned entries, or ``--restore`` copies the latest
+backup back byte-for-byte). Nothing here ever runs the host HUD; it only wires the
+plumbing, and the bar itself is crash-safe (an empty line on any error).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+# A zeno-owned ccstatusline widget carries this metadata flag (metadata is a
+# Record<string,string> in ccstatusline's schema), so re-install is idempotent and
+# uninstall removes exactly our widget without touching the user's other widgets.
+ZENO_META_KEY = "zeno-managed"
+ZENO_META_VALUE = "hud-bar"
+# ccstatusline's custom-command widget type id (its WidgetItem.type). The widget
+# runs WidgetItem.commandPath via execSync, feeding it the session JSON on stdin.
+CC_WIDGET_TYPE = "custom-command"
+CC_WIDGET_ID = "zeno-hud-bar"
+# ccstatusline SettingsSchema version at the time of writing (used only when we have
+# to stamp a version onto an existing config that somehow lacks one; an existing
+# config always already carries its own version, which we never rewrite).
+CC_SETTINGS_VERSION = 2
+
+
+class HudInstallError(Exception):
+    """Raised when a HUD config is unsafe to edit (malformed / wrong shape)."""
+
+
+# ---------------------------------------------------------------------------
+# shared helpers
+# ---------------------------------------------------------------------------
+def _timestamp() -> str:
+    # microseconds so a rapid re-install never collides on the backup stamp.
+    return datetime.now().strftime("%Y%m%dT%H%M%S%f")
+
+
+def _backup(path: Path, stamp: str) -> Path | None:
+    if not path.exists():
+        return None
+    bak = path.with_name(f"{path.name}.zeno-bak.{stamp}")
+    shutil.copy2(path, bak)
+    return bak
+
+
+def _latest_backup(path: Path) -> Path | None:
+    baks = sorted(path.parent.glob(f"{path.name}.zeno-bak.*"))
+    return baks[-1] if baks else None
+
+
+def _write_json(path: Path, data: dict) -> None:
+    # Atomic: temp sibling then os.replace, so a crash mid-write can never truncate
+    # the user's live config (the exact failure this guards against).
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(f"{path.name}.zeno-tmp.{os.getpid()}")
+    tmp.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def resolve_bar_command() -> str:
+    """The command a host HUD should run to render the zeno line.
+
+    Prefers an absolute path to the ``zeno-hud-bar`` console_script (most robust:
+    works regardless of the PATH Claude Code spawns the statusLine with), then the
+    ``zeno`` console_script's ``hud bar`` subcommand, then the bare name as a last
+    resort. The bar reads the session JSON on stdin and prints exactly one line."""
+    direct = shutil.which("zeno-hud-bar")
+    if direct:
+        return direct
+    zeno = shutil.which("zeno")
+    if zeno:
+        return f"{zeno} hud bar"
+    return "zeno-hud-bar"
+
+
+# ---------------------------------------------------------------------------
+# ccstatusline adapter
+# ---------------------------------------------------------------------------
+def default_ccstatusline_path() -> Path:
+    """``$XDG_CONFIG_HOME/ccstatusline/settings.json`` (default ``~/.config``)."""
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base).expanduser() / "ccstatusline" / "settings.json"
+
+
+def ccstatusline_present(path: Path | None = None) -> bool:
+    """ccstatusline is considered present iff its settings.json exists."""
+    path = path or default_ccstatusline_path()
+    return path.exists()
+
+
+def _is_zeno_widget(widget: object) -> bool:
+    if not isinstance(widget, dict):
+        return False
+    meta = widget.get("metadata")
+    return isinstance(meta, dict) and meta.get(ZENO_META_KEY) == ZENO_META_VALUE
+
+
+def _zeno_widget(command: str) -> dict:
+    return {
+        "id": CC_WIDGET_ID,
+        "type": CC_WIDGET_TYPE,
+        "commandPath": command,
+        "preserveColors": True,  # keep the bar's ANSI colors (no strip)
+        "metadata": {ZENO_META_KEY: ZENO_META_VALUE},
+    }
+
+
+def _load_ccstatusline(path: Path, stamp: str) -> dict:
+    """Parse the config; on malformed JSON, back it up and refuse to edit (never
+    destroy the user's file). Returns {} only when the file is genuinely absent."""
+    if not path.exists():
+        return {}
+    raw = path.read_text(encoding="utf-8")
+    if not raw.strip():
+        return {}
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        _backup(path, stamp)  # preserve the malformed file, then refuse
+        raise HudInstallError(
+            f"{path} is not valid JSON ({exc}). Backed it up and refusing to edit so "
+            "your ccstatusline config is never destroyed. Fix or remove it, then retry."
+        ) from exc
+    if not isinstance(data, dict):
+        raise HudInstallError(f"{path}: top-level JSON is not an object; refusing to edit.")
+    return data
+
+
+def install_ccstatusline(
+    path: Path | None = None,
+    *,
+    command: str | None = None,
+    dry_run: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Add a dedicated extra line holding the zeno custom-command widget.
+
+    Read-merge-write: every existing line, widget, and top-level key is preserved;
+    we only append one new line ``[<zeno widget>]`` at the end so the cognition bar
+    renders as its own row UNDER the user's HUD line(s). Idempotent (detected via the
+    zeno metadata flag), backed up, and reversible. Returns a result dict; with
+    ``dry_run`` nothing is written and the planned config is returned under ``preview``.
+    """
+    path = path or default_ccstatusline_path()
+    stamp = stamp or _timestamp()
+    command = command or resolve_bar_command()
+
+    if not path.exists():
+        return {"action": "not-found", "config": str(path), "command": command, "backup": None}
+
+    data = _load_ccstatusline(path, stamp)
+    lines = data.get("lines", [])
+    if not isinstance(lines, list):
+        raise HudInstallError(f"{path}: 'lines' is not a list; refusing to edit.")
+
+    already = any(_is_zeno_widget(w) for line in lines if isinstance(line, list) for w in line)
+    action = "unchanged"
+    new_data = dict(data)
+    if not already:
+        new_data["lines"] = list(lines) + [[_zeno_widget(command)]]
+        if "version" not in new_data:
+            new_data["version"] = CC_SETTINGS_VERSION
+        action = "added"
+
+    if dry_run:
+        return {
+            "action": action,
+            "config": str(path),
+            "command": command,
+            "backup": None,
+            "preview": json.dumps(new_data, indent=2),
+        }
+    if action == "unchanged":
+        return {"action": action, "config": str(path), "command": command, "backup": None}
+
+    backup = _backup(path, stamp)
+    _write_json(path, new_data)
+    return {
+        "action": action,
+        "config": str(path),
+        "command": command,
+        "backup": str(backup) if backup else None,
+    }
+
+
+def uninstall_ccstatusline(
+    path: Path | None = None,
+    *,
+    restore: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Remove only the zeno-owned widget/line (or ``restore`` the latest backup
+    byte-for-byte). Surgical removal preserves every other line, widget, and key;
+    a line that held only the zeno widget is dropped, a line that also held the
+    user's widgets keeps them."""
+    path = path or default_ccstatusline_path()
+    stamp = stamp or _timestamp()
+
+    if restore:
+        latest = _latest_backup(path)
+        if latest is None:
+            raise HudInstallError(f"no zeno backup found next to {path} to restore.")
+        shutil.copy2(latest, path)
+        return {"restored_from": str(latest)}
+
+    if not path.exists():
+        return {"removed": False, "config": str(path), "backup": None}
+
+    data = _load_ccstatusline(path, stamp)
+    lines = data.get("lines")
+    removed = False
+    if isinstance(lines, list):
+        new_lines: list = []
+        for line in lines:
+            if isinstance(line, list):
+                kept = [w for w in line if not _is_zeno_widget(w)]
+                if len(kept) != len(line):
+                    removed = True
+                    if kept:
+                        new_lines.append(kept)
+                    continue  # drop a line that was zeno-only
+            new_lines.append(line)
+        # ccstatusline's schema requires at least one line; never leave it empty.
+        data["lines"] = new_lines or [[]]
+
+    if not removed:
+        return {"removed": False, "config": str(path), "backup": None}
+    backup = _backup(path, stamp)
+    _write_json(path, data)
+    return {"removed": True, "config": str(path), "backup": str(backup) if backup else None}
+
+
+# ---------------------------------------------------------------------------
+# claude-hud wrapper adapter
+# ---------------------------------------------------------------------------
+# The wrapper IS the statusLine: it reads the session JSON from stdin ONCE, feeds it
+# to the real claude-hud (discovered at runtime - newest install, so claude-hud
+# auto-updates keep flowing) and then to zeno-hud-bar, and concatenates the rows.
+# Discovery is version-agnostic (newest mtime match of *claude-hud*/dist/index.js),
+# never a hardcoded version path, mirroring claude-hud's own setup. If claude-hud or
+# node is unavailable the wrapper emits just the zeno bar (no error to stdout).
+_WRAPPER_TEMPLATE = r"""#!/usr/bin/env bash
+# zeno-hud-wrapper - generated by `zeno hud install --target claude-hud`. Do not edit;
+# re-run `zeno hud install` to regenerate. Stacks the zeno cognition bar UNDER the
+# host claude-hud HUD. Reads the session JSON on stdin ONCE and feeds it to both.
+
+input="$(cat)"
+
+# Discover the newest installed claude-hud dist/index.js (version-agnostic, so
+# claude-hud auto-updates keep flowing). Only if node is on PATH.
+hud_js=""
+if command -v node >/dev/null 2>&1; then
+  for root in "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/plugins" "$HOME/.claude/plugins"; do
+    [ -d "$root" ] || continue
+    matches="$(find "$root" -type f -path '*claude-hud*/dist/index.js' \
+      -not -path '*/node_modules/*' 2>/dev/null)"
+    if [ -n "$matches" ]; then
+      hud_js="$(printf '%s\n' "$matches" | tr '\n' '\0' | xargs -0 ls -t 2>/dev/null | head -n1)"
+      [ -n "$hud_js" ] && break
+    fi
+  done
+fi
+
+# Line(s) 1..n: the host claude-hud HUD (unchanged, keeps its own updates). Pass
+# COLUMNS through so claude-hud renders at the right width. stderr is suppressed so a
+# claude-hud hiccup never pollutes the statusLine.
+hud_out=""
+if [ -n "$hud_js" ]; then
+  hud_out="$(printf '%s' "$input" | COLUMNS="${COLUMNS:-}" node "$hud_js" 2>/dev/null)"
+fi
+
+# Final line: the zeno cognition bar (crash-safe; empty line on any error).
+bar_out="$(printf '%s' "$input" | __ZENO_BAR_COMMAND__)"
+
+if [ -n "$hud_out" ]; then
+  printf '%s\n%s\n' "$hud_out" "$bar_out"
+else
+  printf '%s\n' "$bar_out"
+fi
+"""
+
+
+def _zeno_home() -> Path:
+    return Path(os.environ.get("ZENO_HOME") or (Path.home() / ".zeno")).expanduser()
+
+
+def wrapper_path() -> Path:
+    """Where the generated ``zeno-hud-wrapper.sh`` lives (under ZENO_HOME, host-local
+    and zeno-owned, so it never collides with the user's own scripts)."""
+    return _zeno_home() / "zeno-hud-wrapper.sh"
+
+
+def find_claude_hud() -> Path | None:
+    """The newest installed claude-hud ``dist/index.js`` (version-agnostic, newest
+    mtime), or None. Mirrors the wrapper's runtime discovery so dry-run reports the
+    exact file the wrapper will run. Never a hardcoded version path."""
+    roots: list[Path] = []
+    ccd = os.environ.get("CLAUDE_CONFIG_DIR")
+    if ccd:
+        roots.append(Path(ccd).expanduser() / "plugins")
+    roots.append(Path.home() / ".claude" / "plugins")
+    cands: list[Path] = []
+    seen: set[str] = set()
+    for root in roots:
+        key = str(root)
+        if key in seen or not root.exists():
+            continue
+        seen.add(key)
+        for p in root.rglob("dist/index.js"):
+            sp = str(p)
+            # match claude-hud's OWN entry, never a bundled dep's dist/index.js
+            # (e.g. .../claude-hud/<ver>/node_modules/escalade/dist/index.js).
+            if "claude-hud" in sp and "node_modules" not in sp:
+                cands.append(p)
+    if not cands:
+        return None
+    return max(cands, key=lambda p: p.stat().st_mtime)
+
+
+def claude_hud_present() -> bool:
+    """claude-hud is present iff its executable can be discovered."""
+    return find_claude_hud() is not None
+
+
+def build_wrapper_script(bar_command: str) -> str:
+    """Render the wrapper shell script with the resolved bar command baked in."""
+    return _WRAPPER_TEMPLATE.replace("__ZENO_BAR_COMMAND__", bar_command)
+
+
+def write_wrapper(bar_command: str | None = None) -> Path:
+    """Write (or refresh) the wrapper script and mark it executable. Returns its path."""
+    bar_command = bar_command or resolve_bar_command()
+    path = wrapper_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(f"{path.name}.zeno-tmp.{os.getpid()}")
+    tmp.write_text(build_wrapper_script(bar_command), encoding="utf-8")
+    os.replace(tmp, path)
+    path.chmod(0o755)
+    return path
+
+
+def set_statusline(
+    settings_path: Path,
+    command: str,
+    *,
+    force: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Set settings.json ``statusLine`` to ``command``, reusing the hook_install
+    machinery (ZENO_MARKER, backup, zeno-owned detection, ``--force`` semantics) but
+    WITHOUT touching the capture hook (decision 3: leave the cc-bridge hook alone).
+
+    An existing NON-zeno statusLine is kept unless ``force`` (statusLine allows one
+    value); a zeno-owned one is always replaced (idempotent re-apply)."""
+    from .. import hook_install as HI  # noqa: PLC0415
+
+    stamp = stamp or _timestamp()
+    data = HI._load_settings(settings_path)
+    existing = data.get("statusLine")
+    if existing and not HI._is_zeno_handler(existing) and not force:
+        return {"statusline": "skipped-existing", "backup": None, "command": command}
+    data["statusLine"] = {"type": "command", "command": f"{command}  # {HI.ZENO_MARKER}"}
+    backup = HI._backup(settings_path, stamp)
+    HI._write(settings_path, data)
+    return {
+        "statusline": "set",
+        "backup": str(backup) if backup else None,
+        "command": command,
+    }
+
+
+def remove_statusline(
+    settings_path: Path,
+    *,
+    restore: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Remove only a zeno-owned ``statusLine`` (or ``restore`` the latest backup
+    byte-for-byte). Never touches the capture hook."""
+    from .. import hook_install as HI  # noqa: PLC0415
+
+    stamp = stamp or _timestamp()
+    if restore:
+        latest = _latest_backup(settings_path)
+        if latest is None:
+            raise HudInstallError(f"no zeno backup found next to {settings_path} to restore.")
+        shutil.copy2(latest, settings_path)
+        return {"restored_from": str(latest)}
+
+    if not settings_path.exists():
+        return {"statusline_removed": False, "backup": None}
+    data = HI._load_settings(settings_path)
+    removed = False
+    if HI._is_zeno_handler(data.get("statusLine")):
+        data.pop("statusLine", None)
+        removed = True
+    if not removed:
+        return {"statusline_removed": False, "backup": None}
+    backup = HI._backup(settings_path, stamp)
+    HI._write(settings_path, data)
+    return {"statusline_removed": True, "backup": str(backup) if backup else None}
+
+
+def install_claudehud(
+    settings_path: Path,
+    *,
+    bar_command: str | None = None,
+    dry_run: bool = False,
+    force: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Generate the wrapper and point settings.json ``statusLine`` at it.
+
+    Works whether or not claude-hud is currently installed: the wrapper discovers it
+    at runtime and degrades to bar-only if absent (so install is safe to run early).
+    ``node_missing`` / ``claude_hud_found`` are surfaced for a one-line install note;
+    they never affect the statusLine output."""
+    bar_command = bar_command or resolve_bar_command()
+    stamp = stamp or _timestamp()
+    found = find_claude_hud()
+    node = shutil.which("node")
+    command = str(wrapper_path())
+
+    if dry_run:
+        return {
+            "action": "dry-run",
+            "wrapper": command,
+            "settings_path": str(settings_path),
+            "bar_command": bar_command,
+            "claude_hud_found": str(found) if found else None,
+            "node_missing": node is None,
+            "preview": build_wrapper_script(bar_command),
+        }
+
+    write_wrapper(bar_command)
+    sl = set_statusline(settings_path, command, force=force, stamp=stamp)
+    return {
+        "action": "installed" if sl["statusline"] == "set" else sl["statusline"],
+        "wrapper": command,
+        "settings_path": str(settings_path),
+        "bar_command": bar_command,
+        "statusline": sl["statusline"],
+        "backup": sl["backup"],
+        "claude_hud_found": str(found) if found else None,
+        "node_missing": node is None,
+    }
+
+
+def uninstall_claudehud(
+    settings_path: Path,
+    *,
+    restore: bool = False,
+    stamp: str | None = None,
+    remove_wrapper: bool = True,
+) -> dict:
+    """Remove the zeno statusLine (or ``restore`` the backup) and delete the wrapper."""
+    stamp = stamp or _timestamp()
+    sl = remove_statusline(settings_path, restore=restore, stamp=stamp)
+    wrapper_removed = False
+    if remove_wrapper and not restore:
+        wp = wrapper_path()
+        if wp.exists():
+            wp.unlink()
+            wrapper_removed = True
+    return {**sl, "wrapper_removed": wrapper_removed}
+
+
+# ---------------------------------------------------------------------------
+# auto-detect orchestrator (zeno hud install / uninstall / status)
+# ---------------------------------------------------------------------------
+def resolve_settings_path(explicit: str | None = None) -> Path:
+    """The settings.json to write the claude-hud statusLine into.
+
+    Honors an explicit path. Otherwise defaults to ``~/.claude/settings.json`` (via
+    hook_install, so CLAUDE_CONFIG_DIR is respected), BUT if that file is a SYMLINK
+    (e.g. a shared dotfiles checkout) it redirects to the sibling
+    ``settings.local.json`` host-local override - so a shared/symlinked config is
+    never modified. This is the laptop-safe default the Mini install relies on."""
+    if explicit:
+        return Path(explicit).expanduser()
+    from .. import hook_install as HI  # noqa: PLC0415
+
+    base = HI.default_settings_path()
+    if base.is_symlink():
+        return base.with_name("settings.local.json")
+    return base
+
+
+def capture_hook_present(settings_path: str | None = None) -> bool:
+    """True if the zeno capture hook is installed (in settings.json or its sibling
+    settings.local.json). The cognition line is read-only, so it shows real att/eff/drv
+    only once the cc-bridge hook is writing cognition_samples; the installer warns when
+    the hook is absent."""
+    from .. import hook_install as HI  # noqa: PLC0415
+
+    candidates: list[Path] = []
+    if settings_path:
+        candidates.append(Path(settings_path).expanduser())
+    base = HI.default_settings_path()
+    candidates += [base, base.with_name("settings.local.json")]
+    for p in candidates:
+        try:
+            if p.exists() and HI.status(p)["events_installed"]:
+                return True
+        except HI.HookInstallError:
+            continue
+    return False
+
+
+def detect_target(*, ccstatusline_path: Path | None = None) -> str:
+    """Auto-detect the adapter: ``ccstatusline`` if its config exists (cleanest, a
+    native segment), else ``claude-hud`` if the plugin is installed (a wrapper), else
+    ``none``. ccstatusline wins when both are present (per the locked decision)."""
+    if ccstatusline_present(ccstatusline_path):
+        return "ccstatusline"
+    if claude_hud_present():
+        return "claude-hud"
+    return "none"
+
+
+def detect_status(
+    *, ccstatusline_path: Path | None = None, settings_path: str | None = None
+) -> dict:
+    """Report what is present + whether zeno is already wired into each adapter."""
+    from .. import hook_install as HI  # noqa: PLC0415
+
+    ccstatusline_path = ccstatusline_path or default_ccstatusline_path()
+    sp = resolve_settings_path(settings_path)
+    cc_installed = False
+    if ccstatusline_path.exists():
+        try:
+            data = json.loads(ccstatusline_path.read_text(encoding="utf-8") or "{}")
+            cc_installed = any(
+                _is_zeno_widget(w)
+                for line in (data.get("lines") or [])
+                if isinstance(line, list)
+                for w in line
+            )
+        except (json.JSONDecodeError, OSError):
+            cc_installed = False
+    ch_statusline = False
+    if sp.exists():
+        try:
+            ch_statusline = HI._is_zeno_handler(HI._load_settings(sp).get("statusLine"))
+        except HI.HookInstallError:
+            ch_statusline = False
+    return {
+        "ccstatusline_present": ccstatusline_present(ccstatusline_path),
+        "ccstatusline_config": str(ccstatusline_path),
+        "ccstatusline_installed": cc_installed,
+        "claude_hud_present": claude_hud_present(),
+        "claude_hud_path": (str(find_claude_hud()) if claude_hud_present() else None),
+        "settings_path": str(sp),
+        "claude_hud_installed": ch_statusline,
+        "wrapper_present": wrapper_path().exists(),
+        "capture_hook_present": capture_hook_present(settings_path),
+        "recommended": detect_target(ccstatusline_path=ccstatusline_path),
+    }
+
+
+def install(
+    target: str = "auto",
+    *,
+    settings_path: str | None = None,
+    ccstatusline_path: Path | None = None,
+    bar_command: str | None = None,
+    dry_run: bool = False,
+    force: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Pick the adapter (or honor an explicit ``target``) and wire the bar in.
+
+    ``auto`` chooses ccstatusline if configured, else claude-hud if installed, else a
+    friendly no-op (``target='none'``). An explicit ``ccstatusline`` target with no
+    config is reported as ``action='not-found'`` (the CLI exits non-zero); the
+    ``claude-hud`` target always succeeds (the wrapper degrades to bar-only)."""
+    ccstatusline_path = ccstatusline_path or default_ccstatusline_path()
+    stamp = stamp or _timestamp()
+    chosen = detect_target(ccstatusline_path=ccstatusline_path) if target == "auto" else target
+
+    if chosen == "ccstatusline":
+        res = install_ccstatusline(
+            ccstatusline_path, command=bar_command, dry_run=dry_run, stamp=stamp
+        )
+        return {"target": "ccstatusline", "auto": target == "auto", **res}
+    if chosen == "claude-hud":
+        sp = resolve_settings_path(settings_path)
+        res = install_claudehud(
+            sp, bar_command=bar_command, dry_run=dry_run, force=force, stamp=stamp
+        )
+        return {
+            "target": "claude-hud",
+            "auto": target == "auto",
+            "settings_resolved": str(sp),
+            **res,
+        }
+    return {
+        "target": "none",
+        "action": "none",
+        "auto": target == "auto",
+        "ccstatusline_present": ccstatusline_present(ccstatusline_path),
+        "claude_hud_present": claude_hud_present(),
+    }
+
+
+def uninstall(
+    *,
+    settings_path: str | None = None,
+    ccstatusline_path: Path | None = None,
+    restore: bool = False,
+    stamp: str | None = None,
+) -> dict:
+    """Remove zeno from BOTH adapters (idempotent + safe regardless of which was
+    installed). ``restore`` brings each config back from its latest backup byte-for-
+    byte, skipping any adapter that has no zeno backup."""
+    ccstatusline_path = ccstatusline_path or default_ccstatusline_path()
+    sp = resolve_settings_path(settings_path)
+    stamp = stamp or _timestamp()
+    if restore:
+        cc = (
+            uninstall_ccstatusline(ccstatusline_path, restore=True, stamp=stamp)
+            if _latest_backup(ccstatusline_path)
+            else {"restored_from": None}
+        )
+        ch = (
+            uninstall_claudehud(sp, restore=True, stamp=stamp)
+            if _latest_backup(sp)
+            else {"restored_from": None, "wrapper_removed": False}
+        )
+        return {"ccstatusline": cc, "claude_hud": ch, "settings_path": str(sp)}
+    return {
+        "ccstatusline": uninstall_ccstatusline(ccstatusline_path, stamp=stamp),
+        "claude_hud": uninstall_claudehud(sp, stamp=stamp),
+        "settings_path": str(sp),
+    }