threadreaper.py

#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""ThreadReaper — modern TUI thread manager for shared multi-user Linux hosts.

A single-file, zero-dependency Python 3.11+ curses TUI for monitoring
thread usage, hunting ghost processes (zombies / orphans / idle hogs /
frozen / stuck-on-disk), and decisively reclaiming threads when nearing
the per-user limit on shared seedboxes and developer servers.

Run with `--help` for usage. See README.md for full documentation.
"""

from __future__ import annotations

import argparse
import curses
import io
import json
import locale
import os
import pwd
import re
import resource
import signal
import sys
import time
import unicodedata
from collections import defaultdict, deque
from dataclasses import dataclass, field, asdict
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Iterable

__version__ = "1.0.0"
APP_NAME = "ThreadReaper"

# ─── Constants ──────────────────────────────────────────────────────────────

CLK_TCK = os.sysconf(os.sysconf_names["SC_CLK_TCK"])
PAGE_SIZE = os.sysconf(os.sysconf_names["SC_PAGESIZE"])
MY_UID = os.getuid()
MY_PID = os.getpid()

DEFAULT_REFRESH = 2.0
SIGTERM_TIMEOUT = 3.0
HISTORY_LEN = 60
CONFIG_DIR = Path(os.environ.get("THREADREAPER_HOME", str(Path.home() / ".threadreaper")))
EVENTS_LOG = CONFIG_DIR / "events.log"

# Processes whose names match these are never offered for killing without an
# extra confirmation. Best-effort safety net for the inexperienced.
PROTECTED_NAMES = {
    "systemd", "init", "sshd", "agetty", "login", "logind",
    "systemd-logind", "systemd-journal", "dbus-daemon", "(sd-pam)",
}
# Binaries we treat as "user-space" — used as part of orphan classification.
KNOWN_SYSTEM_BINS = PROTECTED_NAMES | {
    "cron", "crond", "rsyslogd", "udevd", "kthreadd", "ksoftirqd",
    "kworker", "rcu_sched", "migration", "watchdog", "nginx", "apache2",
    "httpd", "redis-server", "postgres", "mysqld", "mariadbd",
}
SORT_COLUMNS = ["threads", "cpu", "rss", "pid", "name", "age"]
SORT_LABELS = {
    "threads": "Threads",
    "cpu": "CPU",
    "rss": "Memory",
    "pid": "PID",
    "name": "Name",
    "age": "Age",
}
SEVERITY_WEIGHTS = {
    "zombie": 1.6,
    "orphan": 1.3,
    "frozen": 1.1,
    "stuck": 1.0,
    "idle_hog": 0.9,
}
GHOST_TYPES = ["zombie", "orphan", "idle_hog", "frozen", "stuck"]

# ─── Color pair IDs ─────────────────────────────────────────────────────────

C_DEFAULT = 1
C_DIM = 2
C_BOLD = 3
C_ACCENT = 4
C_HEADER = 5
C_BORDER = 6
C_OK = 7
C_WARN = 8
C_CRIT = 9
C_INFO = 10
C_HOG = 11
C_ZOMBIE = 12
C_ORPHAN = 13
C_FROZEN = 14
C_STUCK = 15
C_SELECTED = 16
C_PINNED = 17
C_GAUGE_OK = 18
C_GAUGE_WARN = 19
C_GAUGE_CRIT = 20
C_SAFETY_OK = 21
C_SAFETY_WARN = 22
C_SAFETY_BAD = 23
C_SPARK_OK = 24
C_SPARK_WARN = 25
C_SPARK_CRIT = 26

# ─── Symbols ────────────────────────────────────────────────────────────────


def _build_symbols(use_emoji: bool) -> dict[str, str]:
    if use_emoji:
        return {
            "logo": "💀", "skull": "💀", "ghost": "👻", "pig": "🐷",
            "ice": "🧊", "magnet": "🧲", "thread": "🧵", "trophy": "🏆",
            "clipboard": "📋", "search": "🔍", "pin": "📌", "pinned": "📍",
            "chain": "🔗", "chart": "📊", "activity": "📈", "folder": "📂",
            "shield": "🛡️", "tree": "🌳", "fire": "🔥", "warn": "⚠️",
            "ok": "✅", "bolt": "⚡", "check": "✔", "cross": "✘",
            "bomb": "💣", "recycle": "♻️", "skip": "⏭", "play": "▶",
            "sleep": "💤", "wait": "⏳", "pause": "⏸", "diamond": "◆",
            "right": "▶", "arrow": "─▶", "refresh": "↻", "brain": "🧠",
            "clock": "⏱", "radio": "📡", "door": "🚪", "disk": "💾",
            "question": "❓", "rocket": "🚀", "star": "★", "filter": "⏷",
            "sparkle": "✨", "compass": "🧭",
            "bf": "█", "be": " ",
            "bar0": " ", "bar1": "▏", "bar2": "▎", "bar3": "▍",
            "bar4": "▌", "bar5": "▋", "bar6": "▊", "bar7": "▉",
            "bar8": "█",
            "spark": "▁▂▃▄▅▆▇█",
            "spinner": "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏",
            "safe_ok": "🟢", "safe_warn": "🟡", "safe_bad": "🔴",
            "corner_tl": "╭", "corner_tr": "╮",
            "corner_bl": "╰", "corner_br": "╯",
            "horiz": "─", "vert": "│",
            "branch_t": "├", "branch_l": "└", "branch_v": "│",
        }
    return {
        "logo": "##", "skull": "[Z]", "ghost": "[G]", "pig": "[H]",
        "ice": "[F]", "magnet": "[S]", "thread": "T", "trophy": "*",
        "clipboard": "#", "search": ">", "pin": ".", "pinned": "*",
        "chain": "->", "chart": "+", "activity": "~", "folder": "F",
        "shield": "!", "tree": "^", "fire": "!", "warn": "!",
        "ok": "v", "bolt": ">", "check": "v", "cross": "x",
        "bomb": "X", "recycle": "<>", "skip": ">", "play": ">",
        "sleep": "z", "wait": ".", "pause": "|", "diamond": ">",
        "right": ">", "arrow": "->", "refresh": "r", "brain": "M",
        "clock": "t", "radio": "~", "door": "<-", "disk": "D",
        "question": "?", "rocket": ">>", "star": "*", "filter": "v",
        "sparkle": "*", "compass": "+",
        "bf": "#", "be": ".",
        "bar0": " ", "bar1": ".", "bar2": ":", "bar3": "-",
        "bar4": "=", "bar5": "+", "bar6": "*", "bar7": "#",
        "bar8": "#",
        "spark": ".:-=+*#%",
        "spinner": "|/-\\",
        "safe_ok": "[ok]", "safe_warn": "[??]", "safe_bad": "[!!]",
        "corner_tl": "+", "corner_tr": "+",
        "corner_bl": "+", "corner_br": "+",
        "horiz": "-", "vert": "|",
        "branch_t": "+", "branch_l": "+", "branch_v": "|",
    }


SYM: dict[str, str] = {}


def state_icon(state: str) -> str:
    return {
        "R": SYM["play"], "S": SYM["sleep"], "D": SYM["wait"],
        "T": SYM["pause"], "t": SYM["pause"], "Z": SYM["skull"],
        "I": SYM["sleep"], "X": SYM["cross"],
    }.get(state, "?")


def ghost_badge(gtype: str) -> tuple[str, str, int]:
    return {
        "zombie": (SYM["skull"], "ZOMBIE", C_ZOMBIE),
        "orphan": (SYM["ghost"], "ORPHAN", C_ORPHAN),
        "idle_hog": (SYM["pig"], "IDLE HOG", C_HOG),
        "frozen": (SYM["ice"], "FROZEN", C_FROZEN),
        "stuck": (SYM["magnet"], "STUCK D", C_STUCK),
    }.get(gtype, (SYM["ghost"], "UNKNOWN", C_DIM))


# ─── Utility ────────────────────────────────────────────────────────────────


def wcswidth(s: str) -> int:
    w = 0
    for ch in s:
        if unicodedata.category(ch) == "Mn":
            continue
        if unicodedata.east_asian_width(ch) in ("W", "F"):
            w += 2
        else:
            w += 1
    return w


def wc_truncate(s: str, maxw: int, suffix: str = "…") -> str:
    if maxw <= 0:
        return ""
    if wcswidth(s) <= maxw:
        return s
    sw = wcswidth(suffix)
    w = 0
    out = []
    for ch in s:
        cw = 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
        if w + cw > maxw - sw:
            break
        out.append(ch)
        w += cw
    return "".join(out) + suffix


def wc_pad(s: str, width: int) -> str:
    return s + " " * max(0, width - wcswidth(s))


def safe_addstr(win, y: int, x: int, text: str, attr: int = 0) -> None:
    try:
        h, w = win.getmaxyx()
    except curses.error:
        return
    if y < 0 or y >= h or x >= w:
        return
    remain = w - x
    if remain <= 0:
        return
    if wcswidth(text) > remain:
        text = wc_truncate(text, remain, "")
    try:
        win.addstr(y, x, text, attr)
    except curses.error:
        pass


def smooth_bar(ratio: float, width: int) -> str:
    """Render a smooth horizontal bar using sub-cell Unicode blocks."""
    if width <= 0:
        return ""
    ratio = max(0.0, min(1.0, ratio))
    total = width * 8
    filled = int(round(ratio * total))
    full_cells = filled // 8
    remainder = filled % 8
    bar = SYM["bar8"] * full_cells
    if remainder:
        bar += SYM[f"bar{remainder}"]
    return bar + SYM["bar0"] * max(0, width - wcswidth(bar))


def sparkline(values: Iterable[float], width: int, vmax: float | None = None) -> str:
    """Generate a sparkline string from a series of numbers."""
    data = list(values)
    if not data or width <= 0:
        return " " * width
    if len(data) > width:
        # downsample by averaging chunks
        step = len(data) / width
        sampled = []
        for i in range(width):
            lo = int(i * step)
            hi = int((i + 1) * step)
            chunk = data[lo:hi] or [data[-1]]
            sampled.append(sum(chunk) / len(chunk))
        data = sampled
    if vmax is None:
        vmax = max(data) if data else 0
    if vmax <= 0:
        return " " * width
    chars = SYM["spark"]
    n = len(chars) - 1
    out = []
    for v in data:
        idx = max(0, min(n, int(round(v / vmax * n))))
        out.append(chars[idx])
    pad = max(0, width - len(out))
    return "".join(out) + " " * pad


def gauge_pair(ratio: float) -> int:
    if ratio >= 0.9:
        return C_GAUGE_CRIT
    if ratio >= 0.7:
        return C_GAUGE_WARN
    return C_GAUGE_OK


def gauge_icon(ratio: float) -> str:
    if ratio >= 0.9:
        return SYM["fire"]
    if ratio >= 0.7:
        return SYM["warn"]
    return SYM["ok"]


def format_bytes(n: int | float | None) -> str:
    if n is None:
        return "?"
    n = float(n)
    if n >= 1024 ** 3:
        return f"{n / 1024**3:.1f}G"
    if n >= 1024 ** 2:
        return f"{n / 1024**2:.0f}M"
    if n >= 1024:
        return f"{n / 1024:.0f}K"
    return f"{int(n)}B"


def format_duration(secs: float) -> str:
    if secs < 0 or secs != secs:
        return "?"
    s = int(secs)
    if s < 60:
        return f"{s}s"
    if s < 3600:
        return f"{s // 60}m"
    if s < 86400:
        return f"{s // 3600}h{(s % 3600) // 60:02d}m"
    return f"{s // 86400}d{(s % 86400) // 3600:02d}h"


def get_uptime() -> float:
    try:
        with open("/proc/uptime") as f:
            return float(f.read().split()[0])
    except (FileNotFoundError, PermissionError, ValueError):
        return 0.0


def detect_thread_limit() -> int:
    """Best-effort detection of the effective per-user thread/process limit."""
    try:
        soft, _ = resource.getrlimit(resource.RLIMIT_NPROC)
        if soft and soft != resource.RLIM_INFINITY:
            return int(soft)
    except (ValueError, OSError):
        pass
    # System-wide cap, used as a fallback
    try:
        with open("/proc/sys/kernel/threads-max") as f:
            return int(f.read().strip())
    except (FileNotFoundError, PermissionError, ValueError):
        pass
    return 2000


def proc_alive(pid: int) -> bool:
    try:
        os.kill(pid, 0)
        return True
    except ProcessLookupError:
        return False
    except PermissionError:
        return True


def user_name(uid: int | None = None) -> str:
    if uid is None:
        uid = MY_UID
    try:
        return pwd.getpwuid(uid).pw_name
    except (KeyError, OSError):
        return str(uid)


def append_event(line: str) -> None:
    """Append a line to the events log (best-effort)."""
    try:
        CONFIG_DIR.mkdir(exist_ok=True)
        with EVENTS_LOG.open("a") as f:
            f.write(f"{datetime.now().isoformat(timespec='seconds')}  {line}\n")
    except OSError:
        pass


def shorten_cmd(cmdline: str, name: str, maxw: int) -> str:
    text = cmdline.strip() or name
    return wc_truncate(text, maxw, "…")


# ─── Data classes ───────────────────────────────────────────────────────────


@dataclass
class ProcessInfo:
    pid: int
    ppid: int
    name: str
    cmdline: str
    state: str
    threads: int
    utime: int
    stime: int
    rss_bytes: int
    starttime: int
    tty: int
    vol_cs: int
    nonvol_cs: int
    io_read: int | None = None
    io_write: int | None = None
    loginuid: int | None = None
    cgroup: str = ""
    wchan: str = ""
    fd_count: int = 0
    exe: str = ""
    cpu_percent: float = 0.0
    age_secs: float = 0.0


@dataclass
class GhostInfo:
    pid: int
    ghost_type: str
    confidence: float
    reason: str
    first_seen: float = 0.0

    @property
    def safety_icon(self) -> str:
        if self.confidence >= 0.85:
            return SYM["safe_ok"]
        if self.confidence >= 0.65:
            return SYM["safe_warn"]
        return SYM["safe_bad"]

    @property
    def safety_color(self) -> int:
        if self.confidence >= 0.85:
            return C_SAFETY_OK
        if self.confidence >= 0.65:
            return C_SAFETY_WARN
        return C_SAFETY_BAD


@dataclass
class KillRecord:
    pid: int
    name: str
    ghost_type: str
    threads: int
    method: str
    success: bool
    when: float = field(default_factory=time.time)


@dataclass
class Theme:
    name: str
    use_default_bg: bool = True
    accent: int = curses.COLOR_CYAN
    border: int = curses.COLOR_WHITE
    dim: int = curses.COLOR_WHITE


# ─── Proc scanner ───────────────────────────────────────────────────────────


class ProcScanner:
    """Reads /proc and produces ProcessInfo snapshots."""

    def __init__(self, all_users: bool = False) -> None:
        self.all_users = all_users
        self.errors: dict[str, int] = defaultdict(int)

    def scan(self) -> dict[int, ProcessInfo]:
        out: dict[int, ProcessInfo] = {}
        uptime = get_uptime()
        try:
            entries = list(os.scandir("/proc"))
        except OSError:
            return out
        for entry in entries:
            if not entry.name.isdigit():
                continue
            pid = int(entry.name)
            if pid == MY_PID:
                continue
            info = self._read_one(pid, uptime)
            if info is not None:
                out[pid] = info
        return out

    # ── helpers ────────────────────────────────────────────────────────────

    def _read_file(self, path: str) -> str:
        try:
            with open(path) as f:
                return f.read()
        except FileNotFoundError:
            return ""
        except PermissionError:
            self.errors["perm"] += 1
            return ""
        except OSError:
            return ""

    def _read_one(self, pid: int, uptime: float) -> ProcessInfo | None:
        base = f"/proc/{pid}"
        stat = self._read_stat(base)
        if stat is None:
            return None
        status = self._read_status(base)
        if status is None:
            return None
        if not self.all_users and status["uid"] != MY_UID:
            return None
        cmdline = self._read_cmdline(base)
        io_d = self._read_io(base)
        loginuid = self._read_loginuid(base)
        cgroup = self._read_file(f"{base}/cgroup")
        wchan = self._read_file(f"{base}/wchan").strip()
        fd_count = self._count_fds(base)
        try:
            exe = os.readlink(f"{base}/exe")
        except OSError:
            exe = ""
        age = max(0.0, uptime - stat["starttime"] / CLK_TCK)
        return ProcessInfo(
            pid=pid,
            ppid=stat["ppid"],
            name=stat["name"],
            cmdline=cmdline,
            state=stat["state"],
            threads=status.get("threads", stat["threads"]),
            utime=stat["utime"],
            stime=stat["stime"],
            rss_bytes=stat["rss"] * PAGE_SIZE,
            starttime=stat["starttime"],
            tty=stat["tty"],
            vol_cs=status.get("vol_cs", 0),
            nonvol_cs=status.get("nonvol_cs", 0),
            io_read=io_d.get("read") if io_d else None,
            io_write=io_d.get("write") if io_d else None,
            loginuid=loginuid,
            cgroup=cgroup,
            wchan=wchan,
            fd_count=fd_count,
            exe=exe,
            age_secs=age,
        )

    def _read_stat(self, base: str) -> dict[str, Any] | None:
        raw = self._read_file(f"{base}/stat")
        if not raw:
            return None
        try:
            end = raw.rfind(")")
            name = raw[raw.index("(") + 1 : end]
            fields = raw[end + 2 :].split()
            if len(fields) < 22:
                return None
            return {
                "name": name,
                "state": fields[0],
                "ppid": int(fields[1]),
                "tty": int(fields[4]),
                "utime": int(fields[11]),
                "stime": int(fields[12]),
                "threads": int(fields[17]),
                "starttime": int(fields[19]),
                "rss": int(fields[21]),
            }
        except (ValueError, IndexError):
            return None

    def _read_status(self, base: str) -> dict[str, Any] | None:
        raw = self._read_file(f"{base}/status")
        if not raw:
            return None
        out: dict[str, Any] = {}
        try:
            for line in raw.splitlines():
                if line.startswith("Uid:"):
                    out["uid"] = int(line.split()[1])
                elif line.startswith("Threads:"):
                    out["threads"] = int(line.split()[1])
                elif line.startswith("voluntary_ctxt_switches:"):
                    out["vol_cs"] = int(line.split()[1])
                elif line.startswith("nonvoluntary_ctxt_switches:"):
                    out["nonvol_cs"] = int(line.split()[1])
        except (ValueError, IndexError):
            return None
        return out if "uid" in out else None

    def _read_cmdline(self, base: str) -> str:
        raw = self._read_file(f"{base}/cmdline")
        return raw.replace("\x00", " ").strip() if raw else ""

    def _read_io(self, base: str) -> dict[str, int] | None:
        raw = self._read_file(f"{base}/io")
        if not raw:
            return None
        out: dict[str, int] = {}
        try:
            for line in raw.splitlines():
                parts = line.split(":")
                if len(parts) != 2:
                    continue
                k, v = parts[0].strip(), parts[1].strip()
                if k == "read_bytes":
                    out["read"] = int(v)
                elif k == "write_bytes":
                    out["write"] = int(v)
        except ValueError:
            return None
        return out or None

    def _read_loginuid(self, base: str) -> int | None:
        raw = self._read_file(f"{base}/loginuid")
        try:
            v = int(raw.strip()) if raw else None
        except ValueError:
            return None
        return v if v is not None and v != 4294967295 else None

    def _count_fds(self, base: str) -> int:
        try:
            return len(os.listdir(f"{base}/fd"))
        except OSError:
            return 0

    # ── lazy lookups (called only when needed) ─────────────────────────────

    def read_fd_targets(self, pid: int, limit: int = 12) -> list[tuple[str, str]]:
        out: list[tuple[str, str]] = []
        fd_dir = f"/proc/{pid}/fd"
        try:
            fds = sorted(os.listdir(fd_dir), key=lambda x: int(x) if x.isdigit() else 0)
        except OSError:
            return out
        for fd in fds:
            if len(out) >= limit:
                break
            try:
                target = os.readlink(f"{fd_dir}/{fd}")
            except OSError:
                continue
            if target.startswith("socket:"):
                ftype = "net"
            elif target.startswith("pipe:"):
                ftype = "pipe"
            elif target.startswith("anon_inode:"):
                ftype = "anon"
            elif target.startswith("/dev/"):
                continue
            else:
                ftype = "file"
            out.append((target, ftype))
        return out

    def has_write_handles(self, pid: int) -> bool:
        fd_dir = f"/proc/{pid}/fd"
        try:
            fds = os.listdir(fd_dir)
        except OSError:
            return False
        for fd in fds:
            try:
                target = os.readlink(f"{fd_dir}/{fd}")
            except OSError:
                continue
            if not target.startswith("/") or target.startswith(("/dev/", "/proc/", "/sys/")):
                continue
            info = self._read_file(f"/proc/{pid}/fdinfo/{fd}")
            for line in info.splitlines():
                if line.startswith("flags:"):
                    try:
                        flags = int(line.split()[1], 8)
                        if flags & 3 in (1, 2):
                            return True
                    except (ValueError, IndexError):
                        continue
        return False


# ─── History ring (per-PID sparkline data) ──────────────────────────────────


class History:
    def __init__(self, capacity: int = HISTORY_LEN) -> None:
        self.cap = capacity
        self.cpu: dict[int, deque[float]] = {}
        self.threads: dict[int, deque[int]] = {}
        self.total: deque[int] = deque(maxlen=capacity)
        self.total_cpu: deque[float] = deque(maxlen=capacity)

    def push(self, procs: dict[int, ProcessInfo]) -> None:
        live = set(procs)
        for pid, p in procs.items():
            self.cpu.setdefault(pid, deque(maxlen=self.cap)).append(p.cpu_percent)
            self.threads.setdefault(pid, deque(maxlen=self.cap)).append(p.threads)
        # Drop dead PIDs to keep memory bounded
        for pid in list(self.cpu):
            if pid not in live:
                del self.cpu[pid]
                self.threads.pop(pid, None)
        self.total.append(sum(p.threads for p in procs.values()))
        self.total_cpu.append(sum(p.cpu_percent for p in procs.values()))


# ─── Ghost classifier ──────────────────────────────────────────────────────


class GhostClassifier:
    def __init__(self, scanner: ProcScanner) -> None:
        self.scanner = scanner
        self.snapshots: deque[tuple[float, dict[int, ProcessInfo]]] = deque(maxlen=30)
        self.cycle = 0
        self.first_seen: dict[tuple[int, str], float] = {}

    @property
    def warmup_msg(self) -> str | None:
        if self.cycle < 3:
            return f"warming up ({self.cycle}/3 cycles)"
        if self.cycle < 6:
            return f"sampling ({self.cycle}/6)"
        return None

    def add(self, procs: dict[int, ProcessInfo]) -> None:
        self.snapshots.append((time.time(), procs))
        self.cycle += 1

    def classify(self) -> list[GhostInfo]:
        if not self.snapshots:
            return []
        now = time.time()
        _, current = self.snapshots[-1]
        found: dict[int, GhostInfo] = {}
        for g in self._zombies(current, now):
            self._keep_best(found, g)
        for g in self._orphans(current, now):
            self._keep_best(found, g)
        if self.cycle >= 3:
            for g in self._idle_hogs(current, now):
                self._keep_best(found, g)
            for g in self._stuck(current, now):
                self._keep_best(found, g)
        if self.cycle >= 6:
            for g in self._frozen(current, now):
                self._keep_best(found, g)
        return sorted(found.values(), key=lambda g: g.confidence, reverse=True)

    def _keep_best(self, found: dict[int, GhostInfo], g: GhostInfo) -> None:
        cur = found.get(g.pid)
        if cur is None or g.confidence > cur.confidence:
            found[g.pid] = g

    def _track(self, pid: int, gtype: str, now: float) -> float:
        key = (pid, gtype)
        if key not in self.first_seen:
            self.first_seen[key] = now
        return self.first_seen[key]

    def _zombies(self, procs: dict[int, ProcessInfo], now: float) -> list[GhostInfo]:
        out = []
        for pid, p in procs.items():
            if p.state == "Z":
                fs = self._track(pid, "zombie", now)
                dur = format_duration(now - fs) if now - fs > 1 else "just now"
                out.append(GhostInfo(
                    pid=pid, ghost_type="zombie", confidence=1.0,
                    reason=f"Defunct (state Z) for {dur}. Parent PID {p.ppid} owes a wait().",
                    first_seen=fs,
                ))
        return out

    def _orphans(self, procs: dict[int, ProcessInfo], now: float) -> list[GhostInfo]:
        out = []
        home = os.path.expanduser("~")
        for pid, p in procs.items():
            if p.ppid != 1 or p.state == "Z":
                continue
            score = 0.0
            reasons = []
            if p.loginuid is not None:
                score += 0.40
                reasons.append("user-initiated")
            if "user.slice" in p.cgroup or "user@" in p.cgroup:
                score += 0.25
                reasons.append("user.slice cgroup")
            if home and home in p.cmdline:
                score += 0.20
                reasons.append("runs from $HOME")
            n = p.name.lower()
            if n not in KNOWN_SYSTEM_BINS and not n.startswith("k"):
                score += 0.15
                reasons.append("non-system binary")
            if score >= 0.60:
                fs = self._track(pid, "orphan", now)
                out.append(GhostInfo(
                    pid=pid, ghost_type="orphan", confidence=min(score, 1.0),
                    reason=(f"Reparented to init (ppid=1). {', '.join(reasons)}. "
                            f"Alive for {format_duration(p.age_secs)}."),
                    first_seen=fs,
                ))
        return out

    def _idle_hogs(self, procs: dict[int, ProcessInfo], now: float) -> list[GhostInfo]:
        out = []
        if len(self.snapshots) < 3:
            return out
        snaps = list(self.snapshots)[-3:]
        for pid, p in procs.items():
            if p.threads < 20 or p.state == "Z":
                continue
            idle = 0
            for i in range(1, len(snaps)):
                tp, pp_map = snaps[i - 1]
                tc, pc_map = snaps[i]
                if pid not in pp_map or pid not in pc_map:
                    break
                a, b = pp_map[pid], pc_map[pid]
                dt = tc - tp
                if dt <= 0:
                    continue
                cpu_d = (b.utime + b.stime) - (a.utime + a.stime)
                cpu_pct = (cpu_d / CLK_TCK) / dt * 100
                cs_d = (b.vol_cs + b.nonvol_cs) - (a.vol_cs + a.nonvol_cs)
                if cpu_pct < 0.1 and cs_d == 0:
                    idle += 1
            if idle >= 2:
                score = 0.55 + min(0.30, idle * 0.10)
                # Mitigate false positives: active sockets => probably waiting
                try:
                    for fd in os.listdir(f"/proc/{pid}/fd"):
                        try:
                            t = os.readlink(f"/proc/{pid}/fd/{fd}")
                        except OSError:
                            continue
                        if t.startswith("socket:"):
                            score -= 0.15
                            break
                except OSError:
                    pass
                score = max(0.40, min(1.0, score))
                if score >= 0.55:
                    fs = self._track(pid, "idle_hog", now)
                    out.append(GhostInfo(
                        pid=pid, ghost_type="idle_hog", confidence=score,
                        reason=(f"{p.threads} threads with ~0% CPU and zero context "
                                f"switches across {idle} cycles."),
                        first_seen=fs,
                    ))
        return out

    def _stuck(self, procs: dict[int, ProcessInfo], now: float) -> list[GhostInfo]:
        out = []
        if len(self.snapshots) < 3:
            return out
        snaps = list(self.snapshots)[-3:]
        for pid, p in procs.items():
            if p.state != "D":
                continue
            persistent = sum(1 for _, ps in snaps if pid in ps and ps[pid].state == "D")
            if persistent >= 3:
                fs = self._track(pid, "stuck", now)
                conf = 0.7 + min(0.25, (persistent - 3) * 0.05)
                out.append(GhostInfo(
                    pid=pid, ghost_type="stuck", confidence=conf,
                    reason=(f"Uninterruptible disk sleep across {persistent} cycles "
                            f"(wchan={p.wchan or 'unknown'})."),
                    first_seen=fs,
                ))
        return out

    def _frozen(self, procs: dict[int, ProcessInfo], now: float) -> list[GhostInfo]:
        out = []
        if len(self.snapshots) < 6:
            return out
        snaps = list(self.snapshots)[-6:]
        for pid, p in procs.items():
            if p.state == "Z":
                continue
            score = 0.0
            reasons = []
            first = snaps[0][1]
            last = snaps[-1][1]
            if pid not in first or pid not in last:
                continue
            pf, pl = first[pid], last[pid]
            if (pl.utime + pl.stime) - (pf.utime + pf.stime) == 0:
                score += 0.25
                reasons.append("zero CPU")
            if (pl.vol_cs + pl.nonvol_cs) - (pf.vol_cs + pf.nonvol_cs) == 0:
                score += 0.25
                reasons.append("zero ctx-switches")
            if pl.io_read is not None and pf.io_read is not None:
                if (pl.io_read + (pl.io_write or 0)) == (pf.io_read + (pf.io_write or 0)):
                    score += 0.25
                    reasons.append("zero I/O")
            if pl.fd_count == pf.fd_count and pl.fd_count > 0:
                score += 0.10
                reasons.append("stable fd count")
            if pl.wchan and pl.wchan in ("do_futex", "pipe_wait", "inode_lock"):
                score += 0.10
                reasons.append(f"blocked in {pl.wchan}")
            if p.age_secs > 86400:
                score += 0.05
                reasons.append(f"alive {format_duration(p.age_secs)}")
            if score >= 0.70 and p.threads >= 5:
                fs = self._track(pid, "frozen", now)
                out.append(GhostInfo(
                    pid=pid, ghost_type="frozen", confidence=min(score, 1.0),
                    reason="All activity metrics frozen: " + ", ".join(reasons) + ".",
                    first_seen=fs,
                ))
        return out


# ─── Process tree ──────────────────────────────────────────────────────────


class ProcessTree:
    def __init__(self, procs: dict[int, ProcessInfo]) -> None:
        self.procs = procs
        self.children: dict[int, list[int]] = defaultdict(list)
        self.parent: dict[int, int] = {}
        for pid, p in procs.items():
            self.parent[pid] = p.ppid
            self.children[p.ppid].append(pid)

    def get_children(self, pid: int) -> list[int]:
        return list(self.children.get(pid, []))

    def descendants(self, pid: int) -> list[int]:
        out, stack = [], list(self.children.get(pid, []))
        while stack:
            c = stack.pop()
            out.append(c)
            stack.extend(self.children.get(c, []))
        return out

    def chain(self, pid: int) -> list[int]:
        out, seen = [], set()
        cur = pid
        while cur and cur not in seen and cur > 0:
            seen.add(cur)
            out.append(cur)
            cur = self.parent.get(cur, 0)
        return list(reversed(out))

    def root_count(self, pids: Iterable[int]) -> int:
        pids_set = set(pids)
        roots = set()
        for pid in pids_set:
            for p in self.chain(pid):
                if p in pids_set:
                    roots.add(p)
                    break
            else:
                roots.add(pid)
        return len(roots)


def compute_cpu(snapshots: deque, current: dict[int, ProcessInfo]) -> None:
    if len(snapshots) < 2:
        return
    tp, pp_map = snapshots[-2]
    tc, _ = snapshots[-1]
    dt = tc - tp
    if dt <= 0:
        return
    for pid, p in current.items():
        if pid in pp_map:
            prev = pp_map[pid]
            ticks = (p.utime + p.stime) - (prev.utime + prev.stime)
            p.cpu_percent = max(0.0, (ticks / CLK_TCK) / dt * 100)


# ─── Reaper Mode ───────────────────────────────────────────────────────────


class ReaperMode:
    def __init__(self, app: "App", ghosts: list[GhostInfo]) -> None:
        self.app = app
        self.stdscr = app.stdscr
        self.queue = self._build_queue(ghosts)
        self.index = 0
        self.kills: list[KillRecord] = []
        self.skipped: list[GhostInfo] = []
        self.threads_before = app.total_threads
        self.threads_reclaimed = 0

    def _build_queue(self, ghosts: list[GhostInfo]) -> list[GhostInfo]:
        scored = []
        for g in ghosts:
            p = self.app.procs.get(g.pid)
            if not p:
                continue
            w = SEVERITY_WEIGHTS.get(g.ghost_type, 1.0)
            impact = g.confidence * max(1, p.threads) * w
            scored.append((impact, p.age_secs, g))
        scored.sort(key=lambda x: (x[0], x[1]), reverse=True)
        return [g for _, _, g in scored]

    def run(self) -> None:
        if not self.queue:
            self._empty_screen()
            return
        if not self._gate():
            return
        while self.index < len(self.queue):
            ghost = self.queue[self.index]
            if not proc_alive(ghost.pid):
                self.index += 1
                continue
            action = self._card(ghost)
            if action == "quit":
                break
            if action == "kill_all":
                self._kill_all()
                break
        self._summary()

    # ── screens ────────────────────────────────────────────────────────────

    def _empty_screen(self) -> None:
        self.stdscr.clear()
        h, w = self.stdscr.getmaxyx()
        cy = max(2, h // 2 - 2)
        safe_addstr(self.stdscr, cy, 4,
                    f"{SYM['ok']}  No suspects detected — system looks clean.",
                    curses.color_pair(C_SAFETY_OK) | curses.A_BOLD)
        ratio = self.app.total_threads / max(1, self.app.thread_limit)
        safe_addstr(self.stdscr, cy + 2, 4,
                    f"{SYM['thread']} Threads {self.app.total_threads:,} / "
                    f"{self.app.thread_limit:,}  [{smooth_bar(ratio, 24)}]  "
                    f"{ratio*100:.1f}%",
                    curses.color_pair(gauge_pair(ratio)))
        safe_addstr(self.stdscr, cy + 4, 4, "[Enter] return", curses.color_pair(C_DIM))
        self.stdscr.refresh()
        self.stdscr.nodelay(False)
        self.stdscr.getch()
        self.stdscr.nodelay(True)

    def _gate(self) -> bool:
        self.stdscr.clear()
        h, w = self.stdscr.getmaxyx()
        total = self.threads_before
        ratio = total / max(1, self.app.thread_limit)
        est = sum(self.app.procs[g.pid].threads for g in self.queue if g.pid in self.app.procs)
        trees = self.app.tree.root_count(g.pid for g in self.queue)
        cy = max(2, h // 2 - 7)
        title = f"{SYM['bolt']}  R E A P E R   M O D E  {SYM['bolt']}"
        safe_addstr(self.stdscr, cy, max(0, (w - wcswidth(title)) // 2), title,
                    curses.color_pair(C_CRIT) | curses.A_BOLD)
        cy += 2
        safe_addstr(self.stdscr, cy, 4,
                    f"{SYM['thread']} Threads {total:,} / {self.app.thread_limit:,}  "
                    f"[{smooth_bar(ratio, 24)}]  {ratio*100:.1f}%  {gauge_icon(ratio)}",
                    curses.color_pair(gauge_pair(ratio)))
        cy += 1
        safe_addstr(self.stdscr, cy, 4,
                    f"{SYM['ghost']} Suspects: {len(self.queue)} across {trees} tree(s)")
        cy += 1
        safe_addstr(self.stdscr, cy, 4,
                    f"{SYM['recycle']} Reclaimable estimate: ~{est} threads",
                    curses.color_pair(C_OK))
        cy += 2
        safe_addstr(self.stdscr, cy, 4,
                    "Walk through each suspect in impact order.")
        cy += 1
        safe_addstr(self.stdscr, cy, 4,
                    f"For each: {SYM['bolt']} kill · {SYM['skip']} skip · {SYM['search']} inspect")
        cy += 2
        safe_addstr(self.stdscr, cy, 4, "[Enter] begin    [q] cancel", curses.color_pair(C_DIM))
        self.stdscr.refresh()
        self.stdscr.nodelay(False)
        try:
            while True:
                k = self.stdscr.getch()
                if k in (10, 13, curses.KEY_ENTER):
                    return True
                if k in (ord("q"), 27):
                    return False
        finally:
            self.stdscr.nodelay(True)

    def _card(self, ghost: GhostInfo) -> str:
        while True:
            self.stdscr.clear()
            h, w = self.stdscr.getmaxyx()
            proc = self.app.procs.get(ghost.pid)
            if not proc:
                self.index += 1
                return "next"
            icon, label, cpair = ghost_badge(ghost.ghost_type)
            cur = self.threads_before - self.threads_reclaimed
            ratio = cur / max(1, self.app.thread_limit)
            # Header
            safe_addstr(self.stdscr, 0, 1, f"{SYM['bolt']} REAPER",
                        curses.color_pair(C_CRIT) | curses.A_BOLD)
            prog = f"[{self.index + 1}/{len(self.queue)}]"
            safe_addstr(self.stdscr, 0, max(0, (w - len(prog)) // 2), prog,
                        curses.color_pair(C_ACCENT))
            rec = f"{SYM['recycle']} reclaimed: {self.threads_reclaimed} thr"
            safe_addstr(self.stdscr, 0, max(1, w - wcswidth(rec) - 2), rec,
                        curses.color_pair(C_OK))
            gauge_text = (f"{SYM['thread']} {cur:,} / {self.app.thread_limit:,}  "
                          f"[{smooth_bar(ratio, 28)}]  {ratio*100:.1f}% {gauge_icon(ratio)}")
            safe_addstr(self.stdscr, 1, 1, gauge_text,
                        curses.color_pair(gauge_pair(ratio)))
            safe_addstr(self.stdscr, 2, 0, SYM["horiz"] * w, curses.color_pair(C_BORDER))
            row = 4
            head = f"{icon}  PID {ghost.pid}   {proc.name}"
            safe_addstr(self.stdscr, row, 3, head,
                        curses.color_pair(cpair) | curses.A_BOLD)
            safe_addstr(self.stdscr, row, max(3 + wcswidth(head) + 3, w // 2), label,
                        curses.color_pair(cpair) | curses.A_BOLD)
            row += 1
            safe_addstr(self.stdscr, row, 3, "━" * min(48, max(8, w - 6)),
                        curses.color_pair(C_DIM))
            row += 2
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['thread']} Threads: {proc.threads:<6}", curses.A_BOLD)
            safe_addstr(self.stdscr, row, 28,
                        f"{SYM['bolt']} CPU: {proc.cpu_percent:.1f}%")
            safe_addstr(self.stdscr, row, 50,
                        f"{SYM['brain']} RSS: {format_bytes(proc.rss_bytes)}")
            row += 1
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['clock']} Age:     {format_duration(proc.age_secs)}")
            safe_addstr(self.stdscr, row, 28,
                        f"State: {state_icon(proc.state)} {proc.state}")
            if proc.io_read is not None:
                row += 1
                safe_addstr(self.stdscr, row, 3,
                            f"{SYM['radio']} I/O: {format_bytes(proc.io_read)} r / "
                            f"{format_bytes(proc.io_write)} w")
            # Sparkline
            spark = self.app.history.cpu.get(ghost.pid)
            if spark and len(spark) >= 2:
                row += 1
                series = sparkline(spark, min(40, w - 20))
                safe_addstr(self.stdscr, row, 3,
                            f"{SYM['activity']} CPU trend  {series}",
                            curses.color_pair(C_ACCENT))
            row += 2
            safe_addstr(self.stdscr, row, 3, f"{SYM['question']} Why flagged:",
                        curses.A_BOLD)
            row += 1
            for line in self._wrap(ghost.reason, w - 6)[:3]:
                safe_addstr(self.stdscr, row, 3, line, curses.color_pair(C_DIM))
                row += 1
            # Spawn chain
            row += 1
            safe_addstr(self.stdscr, row, 3, f"{SYM['chain']} Spawn chain:",
                        curses.A_BOLD)
            row += 1
            parts = []
            for cpid in self.app.tree.chain(ghost.pid):
                if cpid in self.app.procs:
                    parts.append(f"{self.app.procs[cpid].name}({cpid})")
                elif cpid == 1:
                    parts.append("systemd(1)")
                else:
                    parts.append(f"[gone]({cpid})")
            chain_str = f"  {SYM['arrow']}  ".join(parts)
            safe_addstr(self.stdscr, row, 3, chain_str)
            # Children
            kids = [c for c in self.app.tree.get_children(ghost.pid)
                    if c in self.app.procs]
            if kids:
                row += 1
                safe_addstr(self.stdscr, row, 3, f"{SYM['tree']} Children:",
                            curses.A_BOLD)
                for i, cpid in enumerate(kids[:4]):
                    cp = self.app.procs[cpid]
                    row += 1
                    pre = SYM["branch_l"] if i == len(kids) - 1 else SYM["branch_t"]
                    safe_addstr(self.stdscr, row, 5,
                                f"{pre}── PID {cpid}  {cp.name}  "
                                f"{cp.threads} thr  {state_icon(cp.state)}")
            # Safety
            row += 2
            cbar = smooth_bar(ghost.confidence, 16)
            tag = ("HIGH" if ghost.confidence >= 0.85
                   else "MED" if ghost.confidence >= 0.65 else "LOW")
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['shield']} Safety  [{cbar}] {tag}  "
                        f"({ghost.confidence:.2f})  {ghost.safety_icon}",
                        curses.color_pair(ghost.safety_color) | curses.A_BOLD)
            row += 1
            has_w = self.app.scanner.has_write_handles(ghost.pid)
            risk_txt = ("MEDIUM — open write handles detected" if has_w
                        else "LOW — no open write handles")
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['disk']} Data loss risk: {risk_txt}",
                        curses.color_pair(C_SAFETY_WARN if has_w else C_SAFETY_OK))
            # Footer
            safe_addstr(self.stdscr, h - 2, 0, SYM["horiz"] * w,
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, h - 1, 2,
                        "k Kill · T Tree · s Skip · i Inspect · ! Kill all · q End",
                        curses.color_pair(C_DIM))
            self.stdscr.refresh()
            self.stdscr.nodelay(False)
            key = self.stdscr.getch()
            self.stdscr.nodelay(True)
            if key == ord("k"):
                if self._kill(ghost, tree=False):
                    self.index += 1
                    return "next"
            elif key == ord("T"):
                if self._kill(ghost, tree=True):
                    self.index += 1
                    return "next"
            elif key == ord("s"):
                self.skipped.append(ghost)
                self.index += 1
                return "next"
            elif key == ord("i"):
                self.app.run_inspector(self.app.procs[ghost.pid])
            elif key == ord("!"):
                return "kill_all"
            elif key in (ord("q"), 27):
                return "quit"

    def _kill(self, ghost: GhostInfo, tree: bool) -> bool:
        proc = self.app.procs.get(ghost.pid)
        if not proc:
            return True
        targets = [ghost.pid]
        if tree:
            targets = self.app.tree.descendants(ghost.pid) + [ghost.pid]
        thr = {t: self.app.procs[t].threads for t in targets if t in self.app.procs}
        for t in targets:
            try:
                os.kill(t, signal.SIGTERM)
            except (ProcessLookupError, PermissionError):
                pass
        h, w = self.stdscr.getmaxyx()
        start = time.time()
        spinner = SYM["spinner"]
        while time.time() - start < SIGTERM_TIMEOUT:
            alive = [t for t in targets if proc_alive(t)]
            if not alive:
                break
            elapsed = time.time() - start
            pct = elapsed / SIGTERM_TIMEOUT
            bar = smooth_bar(pct, 24)
            spin = spinner[int(elapsed * 10) % len(spinner)]
            safe_addstr(self.stdscr, h - 4, 3,
                        f"{spin} SIGTERM PID {ghost.pid}…  "
                        f"[{bar}]  {SIGTERM_TIMEOUT - elapsed:.1f}s  ",
                        curses.color_pair(C_WARN))
            self.stdscr.refresh()
            curses.napms(100)
        alive = [t for t in targets if proc_alive(t)]
        if not alive:
            reclaimed = sum(thr.get(t, 0) for t in targets)
            self.threads_reclaimed += reclaimed
            for t in targets:
                method = "SIGTERM" if t == ghost.pid else "(tree)"
                name = self.app.procs[t].name if t in self.app.procs else "?"
                self.kills.append(KillRecord(
                    pid=t, name=name, ghost_type=ghost.ghost_type,
                    threads=thr.get(t, 0), method=method, success=True))
                append_event(f"REAP {name}({t}) {ghost.ghost_type} {method} thr={thr.get(t,0)}")
            killed = set(targets)
            self.queue = [g for g in self.queue
                          if g.pid not in killed or g.pid == ghost.pid]
            safe_addstr(self.stdscr, h - 4, 3,
                        f"{SYM['check']} PID {ghost.pid} exited. "
                        f"{SYM['recycle']} reclaimed {reclaimed} thr.        ",
                        curses.color_pair(C_OK) | curses.A_BOLD)
            self.stdscr.refresh()
            curses.napms(500)
            return True
        return self._escalate(ghost, targets, alive, thr)

    def _escalate(self, ghost: GhostInfo, targets: list[int],
                  alive: list[int], thr: dict[int, int]) -> bool:
        h, w = self.stdscr.getmaxyx()
        safe_addstr(self.stdscr, h - 5, 3,
                    f"{SYM['warn']} PID {ghost.pid} survived SIGTERM.",
                    curses.color_pair(C_WARN) | curses.A_BOLD)
        safe_addstr(self.stdscr, h - 4, 3,
                    f"[9] {SYM['bomb']} SIGKILL    [w] wait 5s    [s] skip   ",
                    curses.color_pair(C_DIM))
        self.stdscr.refresh()
        self.stdscr.nodelay(False)
        key = self.stdscr.getch()
        self.stdscr.nodelay(True)
        if key == ord("9"):
            for t in alive:
                try:
                    os.kill(t, signal.SIGKILL)
                except (ProcessLookupError, PermissionError):
                    pass
            curses.napms(500)
            reclaimed = sum(thr.get(t, 0) for t in targets if not proc_alive(t))
            self.threads_reclaimed += reclaimed
            for t in targets:
                if not proc_alive(t):
                    method = "SIGKILL" if t in alive else (
                        "SIGTERM" if t == ghost.pid else "(tree)")
                    name = self.app.procs[t].name if t in self.app.procs else "?"
                    self.kills.append(KillRecord(
                        pid=t, name=name, ghost_type=ghost.ghost_type,
                        threads=thr.get(t, 0), method=method, success=True))
                    append_event(f"REAP {name}({t}) {ghost.ghost_type} {method}")
            killed = {t for t in targets if not proc_alive(t)}
            self.queue = [g for g in self.queue
                          if g.pid not in killed or g.pid == ghost.pid]
            return True
        if key == ord("w"):
            curses.napms(5000)
            still = [t for t in alive if proc_alive(t)]
            if not still:
                reclaimed = sum(thr.get(t, 0) for t in targets)
                self.threads_reclaimed += reclaimed
                for t in targets:
                    self.kills.append(KillRecord(
                        pid=t, name=self.app.procs[t].name if t in self.app.procs else "?",
                        ghost_type=ghost.ghost_type, threads=thr.get(t, 0),
                        method="SIGTERM", success=True))
                return True
            return self._escalate(ghost, targets, still, thr)
        self.skipped.append(ghost)
        return True

    def _kill_all(self) -> None:
        h, w = self.stdscr.getmaxyx()
        remaining = self.queue[self.index:]
        total_thr = sum(self.app.procs[g.pid].threads
                        for g in remaining if g.pid in self.app.procs)
        med = sum(1 for g in remaining if g.confidence < 0.85)
        high = [g for g in remaining if g.confidence >= 0.85]
        high_thr = sum(self.app.procs[g.pid].threads
                       for g in high if g.pid in self.app.procs)
        self.stdscr.clear()
        cy = max(2, h // 2 - 4)
        safe_addstr(self.stdscr, cy, 4,
                    f"{SYM['bomb']} Kill all {len(remaining)} remaining suspects?",
                    curses.color_pair(C_CRIT) | curses.A_BOLD)
        cy += 2
        safe_addstr(self.stdscr, cy, 4,
                    f"SIGTERM {len(remaining)} processes (~{total_thr} threads).")
        if med:
            cy += 1
            safe_addstr(self.stdscr, cy, 4,
                        f"{SYM['warn']} {med} have MED/LOW safety rating.",
                        curses.color_pair(C_SAFETY_WARN))
        cy += 2
        safe_addstr(self.stdscr, cy, 4, "[!] confirm — kill all",
                    curses.color_pair(C_CRIT))
        cy += 1
        safe_addstr(self.stdscr, cy, 4,
                    f"[h] HIGH-confidence only ({len(high)} procs, {high_thr} thr)",
                    curses.color_pair(C_WARN))
        cy += 1
        safe_addstr(self.stdscr, cy, 4, "[Esc] cancel", curses.color_pair(C_DIM))
        self.stdscr.refresh()
        self.stdscr.nodelay(False)
        key = self.stdscr.getch()
        self.stdscr.nodelay(True)
        if key == ord("!"):
            self._batch(remaining)
        elif key == ord("h"):
            self.skipped.extend(g for g in remaining if g.confidence < 0.85)
            self._batch(high)

    def _batch(self, ghosts: list[GhostInfo]) -> None:
        for g in ghosts:
            if g.pid in self.app.procs and proc_alive(g.pid):
                try:
                    os.kill(g.pid, signal.SIGTERM)
                except (ProcessLookupError, PermissionError):
                    pass
        curses.napms(2000)
        for g in ghosts:
            p = self.app.procs.get(g.pid)
            if not p:
                continue
            if not proc_alive(g.pid):
                self.threads_reclaimed += p.threads
                self.kills.append(KillRecord(
                    pid=g.pid, name=p.name, ghost_type=g.ghost_type,
                    threads=p.threads, method="SIGTERM", success=True))
                append_event(f"REAP {p.name}({g.pid}) {g.ghost_type} SIGTERM batch")
            else:
                self.skipped.append(g)
        self.index = len(self.queue)

    def _summary(self) -> None:
        h, w = self.stdscr.getmaxyx()
        threads_after = self.threads_before - self.threads_reclaimed
        rb = self.threads_before / max(1, self.app.thread_limit)
        ra = threads_after / max(1, self.app.thread_limit)
        scroll = 0
        while True:
            self.stdscr.clear()
            row = 1
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['ok']} REAPER MODE COMPLETE",
                        curses.color_pair(C_OK) | curses.A_BOLD)
            row += 1
            safe_addstr(self.stdscr, row, 3, "━" * min(28, w - 6),
                        curses.color_pair(C_DIM))
            row += 2
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['chart']} Reviewed:  {len(self.queue)} suspects")
            row += 1
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['bolt']} Killed:    {len(self.kills)} processes",
                        curses.color_pair(C_CRIT))
            row += 1
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['skip']} Skipped:   {len(self.skipped)} processes")
            row += 2
            safe_addstr(self.stdscr, row, 3,
                        f"BEFORE  {self.threads_before:,} / {self.app.thread_limit:,}  "
                        f"[{smooth_bar(rb, 24)}]  {rb*100:.1f}%",
                        curses.color_pair(gauge_pair(rb)))
            row += 1
            safe_addstr(self.stdscr, row, 3,
                        f"AFTER   {threads_after:,} / {self.app.thread_limit:,}  "
                        f"[{smooth_bar(ra, 24)}]  {ra*100:.1f}%",
                        curses.color_pair(gauge_pair(ra)))
            row += 1
            safe_addstr(self.stdscr, row, 3,
                        f"{SYM['recycle']} Reclaimed: {self.threads_reclaimed} threads",
                        curses.color_pair(C_OK) | curses.A_BOLD)
            row += 2
            safe_addstr(self.stdscr, row, 3, "━" * min(48, w - 6),
                        curses.color_pair(C_DIM))
            row += 2
            if self.kills:
                safe_addstr(self.stdscr, row, 3,
                            f"{SYM['bolt']} KILL LOG:", curses.A_BOLD)
                row += 1
                visible = self.kills[scroll:scroll + max(1, h - row - 4)]
                for kr in visible:
                    icon, _, cpair = ghost_badge(kr.ghost_type)
                    method = kr.method
                    if method == "SIGKILL":
                        method = f"SIGKILL {SYM['bomb']}"
                    safe_addstr(self.stdscr, row, 3,
                                f"{SYM['check']} {kr.pid:<7} {kr.name:<14} "
                                f"{icon} {kr.ghost_type:<9} "
                                f"{kr.threads:>4} thr  {method}",
                                curses.color_pair(cpair))
                    row += 1
            safe_addstr(self.stdscr, h - 2, 0, SYM["horiz"] * w,
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, h - 1, 2,
                        f"[Enter] return    [e] export log    [↑↓] scroll",
                        curses.color_pair(C_DIM))
            self.stdscr.refresh()
            self.stdscr.nodelay(False)
            key = self.stdscr.getch()
            self.stdscr.nodelay(True)
            if key in (10, 13, curses.KEY_ENTER, ord("q"), 27):
                return
            if key == ord("e"):
                path = self._export()
                safe_addstr(self.stdscr, h - 1, 2,
                            f"{SYM['check']} exported → {path}                  ",
                            curses.color_pair(C_OK))
                self.stdscr.refresh()
                curses.napms(1200)
            elif key == curses.KEY_DOWN:
                scroll = min(scroll + 1, max(0, len(self.kills) - 1))
            elif key == curses.KEY_UP:
                scroll = max(0, scroll - 1)

    def _export(self) -> Path:
        CONFIG_DIR.mkdir(exist_ok=True)
        ts = datetime.now().strftime("%Y-%m-%d-%H%M%S")
        path = CONFIG_DIR / f"reaper-{ts}.log"
        lines = [
            f"# {APP_NAME} reaper log {datetime.now().isoformat()}",
            f"# user={user_name()}  host={os.uname().nodename}",
            f"# threads_before={self.threads_before} reclaimed={self.threads_reclaimed}",
            f"# killed={len(self.kills)} skipped={len(self.skipped)}",
            "",
            "KILLS:",
        ]
        for kr in self.kills:
            lines.append(f"  {kr.pid:<7} {kr.name:<16} {kr.ghost_type:<10} "
                         f"{kr.threads:>4} thr  {kr.method}  "
                         f"{'OK' if kr.success else 'FAIL'}")
        lines.append("")
        lines.append("SKIPPED:")
        for sk in self.skipped:
            p = self.app.procs.get(sk.pid)
            name = p.name if p else "?"
            lines.append(f"  {sk.pid:<7} {name:<16} {sk.ghost_type:<10} "
                         f"conf={sk.confidence:.2f}")
        path.write_text("\n".join(lines) + "\n")
        return path

    @staticmethod
    def _wrap(text: str, width: int) -> list[str]:
        out, cur = [], ""
        for word in text.split():
            cand = f"{cur} {word}".strip()
            if wcswidth(cand) <= width:
                cur = cand
            else:
                if cur:
                    out.append(cur)
                cur = word
        if cur:
            out.append(cur)
        return out


# ─── Main TUI ──────────────────────────────────────────────────────────────


class App:
    def __init__(self, args: argparse.Namespace) -> None:
        self.args = args
        self.scanner = ProcScanner(all_users=args.all_users)
        self.classifier = GhostClassifier(self.scanner)
        self.history = History()
        self.procs: dict[int, ProcessInfo] = {}
        self.ghosts: list[GhostInfo] = []
        self.ghost_map: dict[int, GhostInfo] = {}
        self.tree = ProcessTree({})
        self.thread_limit = args.limit or detect_thread_limit()
        self.total_threads = 0
        self.refresh = args.refresh
        self.last_refresh = 0.0
        self.sort_idx = SORT_COLUMNS.index(args.sort) if args.sort in SORT_COLUMNS else 0
        self.sort_reverse = True
        self.selected = 0
        self.scroll = 0
        self.ghosts_collapsed = False
        self.filter_text = args.filter or ""
        self.filter_active = False
        self.pinned: set[int] = set()
        self.grouped = False
        self.toast = ""
        self.toast_time = 0.0
        self.toast_color = C_DIM
        self.last_kill_target = -1
        self.last_kill_time = 0.0
        self.frame = 0
        self.help_open = False
        self.use_mouse = args.mouse
        self.stdscr: Any = None

    # ── lifecycle ──────────────────────────────────────────────────────────

    def run(self, stdscr) -> None:
        self.stdscr = stdscr
        self._init_curses()
        try:
            self._refresh()
        except Exception:
            pass
        while True:
            now = time.time()
            if now - self.last_refresh >= self.refresh:
                self._refresh()
            self._render()
            self.frame += 1
            curses.napms(50)
            try:
                key = stdscr.getch()
            except KeyboardInterrupt:
                return
            if key == -1:
                continue
            if self._dispatch(key):
                return

    def _init_curses(self) -> None:
        curses.curs_set(0)
        self.stdscr.nodelay(True)
        if self.use_mouse:
            try:
                curses.mousemask(curses.ALL_MOUSE_EVENTS | curses.REPORT_MOUSE_POSITION)
            except curses.error:
                pass
        self._init_palette()

    def _init_palette(self) -> None:
        if self.args.no_color or not curses.has_colors():
            for i in range(1, 27):
                try:
                    curses.init_pair(i, -1, -1)
                except curses.error:
                    pass
            return
        curses.start_color()
        try:
            curses.use_default_colors()
            bg = -1
        except curses.error:
            bg = curses.COLOR_BLACK
        # Map color IDs → fg
        def P(idx: int, fg: int, b: int = bg) -> None:
            try:
                curses.init_pair(idx, fg, b)
            except curses.error:
                pass
        P(C_DEFAULT, curses.COLOR_WHITE)
        P(C_DIM, curses.COLOR_WHITE)
        P(C_BOLD, curses.COLOR_WHITE)
        P(C_ACCENT, curses.COLOR_CYAN)
        P(C_HEADER, curses.COLOR_MAGENTA)
        P(C_BORDER, curses.COLOR_BLUE)
        P(C_OK, curses.COLOR_GREEN)
        P(C_WARN, curses.COLOR_YELLOW)
        P(C_CRIT, curses.COLOR_RED)
        P(C_INFO, curses.COLOR_CYAN)
        P(C_HOG, curses.COLOR_RED)
        P(C_ZOMBIE, curses.COLOR_WHITE)
        P(C_ORPHAN, curses.COLOR_YELLOW)
        P(C_FROZEN, curses.COLOR_CYAN)
        P(C_STUCK, curses.COLOR_MAGENTA)
        P(C_SELECTED, curses.COLOR_BLACK, curses.COLOR_CYAN)
        P(C_PINNED, curses.COLOR_YELLOW)
        P(C_GAUGE_OK, curses.COLOR_GREEN)
        P(C_GAUGE_WARN, curses.COLOR_YELLOW)
        P(C_GAUGE_CRIT, curses.COLOR_RED)
        P(C_SAFETY_OK, curses.COLOR_GREEN)
        P(C_SAFETY_WARN, curses.COLOR_YELLOW)
        P(C_SAFETY_BAD, curses.COLOR_RED)
        P(C_SPARK_OK, curses.COLOR_GREEN)
        P(C_SPARK_WARN, curses.COLOR_YELLOW)
        P(C_SPARK_CRIT, curses.COLOR_RED)

    # ── data ───────────────────────────────────────────────────────────────

    def _refresh(self) -> None:
        self.procs = self.scanner.scan()
        self.classifier.add(self.procs)
        if len(self.classifier.snapshots) >= 2:
            compute_cpu(self.classifier.snapshots, self.procs)
        self.history.push(self.procs)
        self.ghosts = self.classifier.classify()
        self.ghost_map = {g.pid: g for g in self.ghosts}
        self.tree = ProcessTree(self.procs)
        self.total_threads = sum(p.threads for p in self.procs.values())
        self.last_refresh = time.time()

    def _sorted_procs(self) -> list[ProcessInfo]:
        items = list(self.procs.values())
        if self.filter_text:
            ft = self.filter_text.lower()
            items = [p for p in items
                     if ft in p.name.lower() or ft in p.cmdline.lower()]
        col = SORT_COLUMNS[self.sort_idx]
        key: Callable[[ProcessInfo], Any]
        if col == "threads":
            key = lambda p: p.threads
        elif col == "cpu":
            key = lambda p: p.cpu_percent
        elif col == "rss":
            key = lambda p: p.rss_bytes
        elif col == "pid":
            key = lambda p: p.pid
        elif col == "name":
            key = lambda p: p.name.lower()
        elif col == "age":
            key = lambda p: p.age_secs
        else:
            key = lambda p: p.threads
        return sorted(items, key=key, reverse=self.sort_reverse)

    def _grouped_procs(self) -> list[tuple[str, list[ProcessInfo]]]:
        groups: dict[str, list[ProcessInfo]] = defaultdict(list)
        for p in self.procs.values():
            groups[p.name].append(p)
        if self.filter_text:
            ft = self.filter_text.lower()
            groups = {n: ps for n, ps in groups.items() if ft in n.lower()}
        items = list(groups.items())
        items.sort(key=lambda kv: sum(p.threads for p in kv[1]), reverse=True)
        return items

    # ── rendering ──────────────────────────────────────────────────────────

    def _render(self) -> None:
        try:
            self.stdscr.erase()
            h, w = self.stdscr.getmaxyx()
            if h < 12 or w < 60:
                safe_addstr(self.stdscr, 0, 0,
                            "Terminal too small. Resize to ≥ 60×12.")
                self.stdscr.refresh()
                return
            row = self._render_header(w)
            row = self._render_top(row, w)
            row = self._render_ghosts(row, w, h)
            self._render_list(row, w, h)
            self._render_filter_bar(h, w)
            self._render_footer(h, w)
            if self.help_open:
                self._render_help(h, w)
            self.stdscr.refresh()
        except curses.error:
            pass

    def _render_header(self, w: int) -> int:
        ratio = self.total_threads / max(1, self.thread_limit)
        title = f" {SYM['skull']} {APP_NAME} v{__version__} "
        bar = SYM["corner_tl"] + SYM["horiz"] + title
        bar += SYM["horiz"] * max(0, w - wcswidth(bar) - 1) + SYM["corner_tr"]
        safe_addstr(self.stdscr, 0, 0, bar, curses.color_pair(C_BORDER))
        # Row 1: gauge + user + uptime
        safe_addstr(self.stdscr, 1, 0, SYM["vert"], curses.color_pair(C_BORDER))
        safe_addstr(self.stdscr, 1, w - 1, SYM["vert"], curses.color_pair(C_BORDER))
        spin = SYM["spinner"][self.frame % len(SYM["spinner"])]
        host = os.uname().nodename
        left = (f" {SYM['thread']} {self.total_threads:,}/{self.thread_limit:,} "
                f"[{smooth_bar(ratio, 24)}] {ratio*100:.1f}% {gauge_icon(ratio)}")
        safe_addstr(self.stdscr, 1, 1, left,
                    curses.color_pair(gauge_pair(ratio)) | curses.A_BOLD)
        spark = sparkline(self.history.total, 16,
                          vmax=max(1, self.thread_limit))
        spark_x = max(wcswidth(left) + 4, w // 2 - 8)
        safe_addstr(self.stdscr, 1, spark_x,
                    f"{SYM['activity']} {spark}",
                    curses.color_pair(gauge_pair(ratio)))
        right = (f" {spin} {self.refresh:.1f}s · {user_name()}@{host} "
                 f"· {len(self.procs)} procs ")
        safe_addstr(self.stdscr, 1, max(spark_x + 20, w - wcswidth(right) - 1),
                    right, curses.color_pair(C_DIM))
        return 2

    def _render_top(self, row: int, w: int) -> int:
        title = f"{SYM['trophy']} TOP THREAD HOGS"
        safe_addstr(self.stdscr, row, 0, self._section(w, title),
                    curses.color_pair(C_BORDER))
        row += 1
        top = sorted(self.procs.values(), key=lambda p: p.threads, reverse=True)[:5]
        if not top:
            return row
        max_thr = top[0].threads or 1
        for i, p in enumerate(top):
            safe_addstr(self.stdscr, row, 0, SYM["vert"], curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, row, w - 1, SYM["vert"], curses.color_pair(C_BORDER))
            ghost = self.ghost_map.get(p.pid)
            badge = ""
            if ghost:
                icon, lbl, _ = ghost_badge(ghost.ghost_type)
                badge = f" {icon} {lbl}"
            pin_mark = SYM["pinned"] if p.pid in self.pinned else " "
            line_l = (f" {i+1}. {pin_mark}{state_icon(p.state)} "
                      f"{p.name:<16} ({p.pid:>6})")
            safe_addstr(self.stdscr, row, 1, line_l)
            pct = p.threads / max(1, self.total_threads) * 100
            mid = f"{p.threads:>5} thr  {pct:>5.1f}%"
            safe_addstr(self.stdscr, row, 38, mid)
            bar_w = max(8, w - 64 - wcswidth(badge))
            ratio = p.threads / max_thr
            bar = smooth_bar(ratio, bar_w)
            bar_x = 60
            safe_addstr(self.stdscr, row, bar_x,
                        bar, curses.color_pair(gauge_pair(ratio)))
            if badge:
                safe_addstr(self.stdscr, row, bar_x + bar_w + 1, badge,
                            curses.color_pair(C_ACCENT))
            row += 1
        return row

    def _render_ghosts(self, row: int, w: int, h: int) -> int:
        count = len(self.ghosts)
        warm = self.classifier.warmup_msg
        title = f"{SYM['ghost']} GHOSTS ({count})"
        if warm:
            title += f" — {warm}"
        if self.ghosts_collapsed:
            title += " [collapsed]"
        safe_addstr(self.stdscr, row, 0, self._section(w, title),
                    curses.color_pair(C_BORDER))
        row += 1
        if self.ghosts_collapsed:
            return row
        if not self.ghosts:
            safe_addstr(self.stdscr, row, 0, SYM["vert"], curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, row, 2,
                        "No ghosts detected — clean run.",
                        curses.color_pair(C_DIM))
            safe_addstr(self.stdscr, row, w - 1, SYM["vert"],
                        curses.color_pair(C_BORDER))
            return row + 1
        budget = max(2, min(len(self.ghosts), (h - row - 12) // 2))
        for g in self.ghosts[:budget]:
            p = self.procs.get(g.pid)
            if not p:
                continue
            icon, lbl, cpair = ghost_badge(g.ghost_type)
            safe_addstr(self.stdscr, row, 0, SYM["vert"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, row, w - 1, SYM["vert"],
                        curses.color_pair(C_BORDER))
            head = f" {icon} PID {g.pid:>6}  {p.name:<14} {lbl:<9}"
            safe_addstr(self.stdscr, row, 1, head, curses.color_pair(cpair))
            detail_x = wcswidth(head) + 2
            reason = g.reason
            avail = max(8, w - detail_x - 16)
            safe_addstr(self.stdscr, row, detail_x,
                        wc_truncate(reason, avail), curses.color_pair(C_DIM))
            safety = f"{g.safety_icon} {g.confidence:.2f}"
            safe_addstr(self.stdscr, row, max(2, w - wcswidth(safety) - 2),
                        safety, curses.color_pair(g.safety_color))
            row += 1
        return row

    def _render_list(self, row: int, w: int, h: int) -> None:
        col = SORT_COLUMNS[self.sort_idx]
        arrow = "↓" if self.sort_reverse else "↑"
        title = f"{SYM['clipboard']} PROCESSES — sort: {SORT_LABELS[col]} {arrow}"
        if self.grouped:
            title += " · grouped"
        if self.filter_text:
            title += f" · filter: '{self.filter_text}'"
        safe_addstr(self.stdscr, row, 0, self._section(w, title),
                    curses.color_pair(C_BORDER))
        row += 1
        avail = h - row - 3
        if avail < 1:
            return
        if self.grouped:
            self._render_groups(row, w, avail)
            return
        items = self._sorted_procs()
        # Pin pinned PIDs to top
        if self.pinned:
            pinned = [p for p in items if p.pid in self.pinned]
            others = [p for p in items if p.pid not in self.pinned]
            items = pinned + others
        if not items:
            safe_addstr(self.stdscr, row, 0, SYM["vert"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, row, 2,
                        "No matching processes.", curses.color_pair(C_DIM))
            safe_addstr(self.stdscr, row, w - 1, SYM["vert"],
                        curses.color_pair(C_BORDER))
            return
        self.selected = max(0, min(self.selected, len(items) - 1))
        if self.selected < self.scroll:
            self.scroll = self.selected
        elif self.selected >= self.scroll + avail:
            self.scroll = self.selected - avail + 1
        visible = items[self.scroll:self.scroll + avail]
        for i, p in enumerate(visible):
            idx = self.scroll + i
            sel = idx == self.selected
            y = row + i
            ghost = self.ghost_map.get(p.pid)
            gm = ""
            gc = 0
            if ghost:
                icon, _, gc = ghost_badge(ghost.ghost_type)
                gm = f" {icon}"
            pin_mark = SYM["pinned"] if p.pid in self.pinned else " "
            cursor = SYM["diamond"] if sel else " "
            spark = ""
            if p.pid in self.history.cpu and len(self.history.cpu[p.pid]) > 2:
                spark = " " + sparkline(self.history.cpu[p.pid], 10, vmax=100.0)
            line = (f"{cursor} {pin_mark}{state_icon(p.state)} "
                    f"{p.pid:>6}  {p.name:<16} "
                    f"{p.threads:>5} thr  {p.cpu_percent:>5.1f}% "
                    f"{format_bytes(p.rss_bytes):>6} "
                    f"{format_duration(p.age_secs):>7}{spark}{gm}")
            attr = curses.color_pair(C_SELECTED) if sel else 0
            safe_addstr(self.stdscr, y, 0, SYM["vert"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, y, w - 1, SYM["vert"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, y, 1, wc_pad(line, w - 2), attr)

    def _render_groups(self, row: int, w: int, avail: int) -> None:
        groups = self._grouped_procs()
        self.selected = max(0, min(self.selected, max(0, len(groups) - 1)))
        if self.selected < self.scroll:
            self.scroll = self.selected
        elif self.selected >= self.scroll + avail:
            self.scroll = self.selected - avail + 1
        visible = groups[self.scroll:self.scroll + avail]
        for i, (name, procs) in enumerate(visible):
            idx = self.scroll + i
            sel = idx == self.selected
            y = row + i
            total_thr = sum(p.threads for p in procs)
            total_cpu = sum(p.cpu_percent for p in procs)
            total_rss = sum(p.rss_bytes for p in procs)
            ghost_count = sum(1 for p in procs if p.pid in self.ghost_map)
            gm = f" {SYM['ghost']}×{ghost_count}" if ghost_count else ""
            cursor = SYM["diamond"] if sel else " "
            line = (f"{cursor} {SYM['tree']} {name:<18} "
                    f"×{len(procs):<3}  "
                    f"{total_thr:>5} thr  {total_cpu:>5.1f}% "
                    f"{format_bytes(total_rss):>7}{gm}")
            attr = curses.color_pair(C_SELECTED) if sel else 0
            safe_addstr(self.stdscr, y, 0, SYM["vert"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, y, w - 1, SYM["vert"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, y, 1, wc_pad(line, w - 2), attr)

    def _render_filter_bar(self, h: int, w: int) -> None:
        if not self.filter_active:
            return
        bar = f" {SYM['filter']} filter: {self.filter_text}_"
        safe_addstr(self.stdscr, h - 3, 0, SYM["vert"],
                    curses.color_pair(C_BORDER))
        safe_addstr(self.stdscr, h - 3, w - 1, SYM["vert"],
                    curses.color_pair(C_BORDER))
        safe_addstr(self.stdscr, h - 3, 1, wc_pad(bar, w - 2),
                    curses.color_pair(C_ACCENT) | curses.A_BOLD)

    def _render_footer(self, h: int, w: int) -> None:
        safe_addstr(self.stdscr, h - 2, 0, SYM["horiz"] * w,
                    curses.color_pair(C_BORDER))
        # Toast (recent action message)
        if self.toast and time.time() - self.toast_time < 4:
            safe_addstr(self.stdscr, h - 1, 0, SYM["corner_bl"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, h - 1, w - 1, SYM["corner_br"],
                        curses.color_pair(C_BORDER))
            safe_addstr(self.stdscr, h - 1, 2,
                        wc_truncate(self.toast, w - 6),
                        curses.color_pair(self.toast_color) | curses.A_BOLD)
            return
        bar = (f" j/k ↑↓ nav  K kill  T tree  i inspect  / filter  s sort  S rev  "
               f"g ghosts  G group  p pin  R reaper  E export  ? help  q quit ")
        if wcswidth(bar) > w - 2:
            bar = " jk K T i / s g G R ? q "
        safe_addstr(self.stdscr, h - 1, 0, SYM["corner_bl"],
                    curses.color_pair(C_BORDER))
        safe_addstr(self.stdscr, h - 1, w - 1, SYM["corner_br"],
                    curses.color_pair(C_BORDER))
        safe_addstr(self.stdscr, h - 1, 1, wc_pad(bar, w - 2),
                    curses.color_pair(C_DIM))

    def _section(self, w: int, label: str) -> str:
        return (SYM["branch_t"] + SYM["horiz"] + " " + label + " " +
                SYM["horiz"] * max(0, w - wcswidth(label) - 5) + "┤")

    # ── help overlay ───────────────────────────────────────────────────────

    def _render_help(self, h: int, w: int) -> None:
        items = [
            ("Navigation", [
                ("↑/↓ or j/k", "move selection"),
                ("PgUp/PgDn", "page through list"),
                ("Home/End",  "jump to top/bottom"),
                ("Tab",        "next pane (process ↔ ghosts)"),
            ]),
            ("Actions", [
                ("K",     "SIGTERM selected — press again for SIGKILL"),
                ("T",     "kill selected process tree"),
                ("i",     "inspect selected process"),
                ("p",     "pin/unpin (pinned procs float to top)"),
                ("R",     "enter Reaper Mode (guided ghost cleanup)"),
                ("E",     "export current snapshot to ~/.threadreaper/"),
            ]),
            ("View", [
                ("/",     "filter process list by name/cmdline"),
                ("s",     "cycle sort column"),
                ("S",     "toggle sort direction"),
                ("g",     "toggle ghost panel"),
                ("G",     "toggle group-by-binary view"),
                ("r",     "force immediate refresh"),
            ]),
            ("Other", [
                ("?",     "this help"),
                ("q / Esc", "quit / close overlay"),
            ]),
        ]
        # Compute box
        lines: list[tuple[str, str | None]] = []
        for section, rows in items:
            lines.append((section, None))
            for k, v in rows:
                lines.append((k, v))
            lines.append(("", None))
        box_w = min(w - 4, 72)
        box_h = min(h - 4, len(lines) + 4)
        x0 = (w - box_w) // 2
        y0 = (h - box_h) // 2
        # Background blanking
        for y in range(y0, y0 + box_h):
            safe_addstr(self.stdscr, y, x0, " " * box_w,
                        curses.color_pair(C_HEADER))
        # Border
        safe_addstr(self.stdscr, y0, x0,
                    SYM["corner_tl"] + SYM["horiz"] * (box_w - 2) +
                    SYM["corner_tr"], curses.color_pair(C_ACCENT) | curses.A_BOLD)
        safe_addstr(self.stdscr, y0 + box_h - 1, x0,
                    SYM["corner_bl"] + SYM["horiz"] * (box_w - 2) +
                    SYM["corner_br"], curses.color_pair(C_ACCENT) | curses.A_BOLD)
        for y in range(y0 + 1, y0 + box_h - 1):
            safe_addstr(self.stdscr, y, x0, SYM["vert"],
                        curses.color_pair(C_ACCENT))
            safe_addstr(self.stdscr, y, x0 + box_w - 1, SYM["vert"],
                        curses.color_pair(C_ACCENT))
        title = f" {SYM['compass']} {APP_NAME} keybindings "
        safe_addstr(self.stdscr, y0, x0 + (box_w - wcswidth(title)) // 2,
                    title, curses.color_pair(C_ACCENT) | curses.A_BOLD)
        # Body
        for i, (k, v) in enumerate(lines[:box_h - 4]):
            y = y0 + 2 + i
            if v is None and k:
                safe_addstr(self.stdscr, y, x0 + 2, k,
                            curses.color_pair(C_HEADER) | curses.A_BOLD)
            elif v is None:
                pass
            else:
                safe_addstr(self.stdscr, y, x0 + 4, f"{k:<14}",
                            curses.color_pair(C_ACCENT) | curses.A_BOLD)
                safe_addstr(self.stdscr, y, x0 + 20, v,
                            curses.color_pair(C_DIM))
        safe_addstr(self.stdscr, y0 + box_h - 2, x0 + 2,
                    "press any key to dismiss",
                    curses.color_pair(C_DIM))

    # ── input ──────────────────────────────────────────────────────────────

    def _dispatch(self, key: int) -> bool:
        if self.help_open:
            self.help_open = False
            return False
        if self.filter_active:
            return self._dispatch_filter(key)
        if key == ord("q"):
            return True
        if key == curses.KEY_RESIZE:
            self.stdscr.clear()
            return False
        if key == ord("?"):
            self.help_open = True
            return False
        if key == ord("/"):
            self.filter_active = True
            return False
        if key in (curses.KEY_UP, ord("k")):
            self.selected = max(0, self.selected - 1)
        elif key in (curses.KEY_DOWN, ord("j")):
            self.selected += 1
        elif key == curses.KEY_PPAGE:
            self.selected = max(0, self.selected - 10)
        elif key == curses.KEY_NPAGE:
            self.selected += 10
        elif key == curses.KEY_HOME:
            self.selected = 0
        elif key == curses.KEY_END:
            self.selected = 9999
        elif key == ord("K"):
            self._kill_selected(tree=False)
        elif key == ord("T"):
            self._kill_selected(tree=True)
        elif key == ord("i"):
            self._open_inspector()
        elif key == ord("p"):
            self._toggle_pin()
        elif key == ord("s"):
            self.sort_idx = (self.sort_idx + 1) % len(SORT_COLUMNS)
        elif key == ord("S"):
            self.sort_reverse = not self.sort_reverse
        elif key == ord("g"):
            self.ghosts_collapsed = not self.ghosts_collapsed
        elif key == ord("G"):
            self.grouped = not self.grouped
            self.selected = 0
            self.scroll = 0
        elif key == ord("r"):
            self._refresh()
            self._set_toast("refreshed", C_OK)
        elif key == ord("R"):
            self._run_reaper()
        elif key == ord("E"):
            self._export_snapshot()
        elif key == curses.KEY_MOUSE:
            self._on_mouse()
        return False

    def _dispatch_filter(self, key: int) -> bool:
        if key in (27, curses.KEY_F2):
            self.filter_active = False
            self.filter_text = ""
        elif key in (10, 13, curses.KEY_ENTER):
            self.filter_active = False
        elif key in (curses.KEY_BACKSPACE, 127, 8):
            self.filter_text = self.filter_text[:-1]
        elif 32 <= key < 127:
            self.filter_text += chr(key)
        return False

    def _on_mouse(self) -> None:
        try:
            _, mx, my, _, bstate = curses.getmouse()
        except curses.error:
            return
        # Scroll wheel
        if bstate & curses.BUTTON4_PRESSED:
            self.selected = max(0, self.selected - 3)
        elif bstate & (1 << 21):  # BUTTON5_PRESSED (not always defined)
            self.selected += 3
        # Click: best-effort select row in list
        elif bstate & curses.BUTTON1_CLICKED:
            self.selected = max(0, my - 4 + self.scroll)

    # ── actions ────────────────────────────────────────────────────────────

    def _current_proc(self) -> ProcessInfo | None:
        if self.grouped:
            return None
        items = self._sorted_procs()
        if not items:
            return None
        idx = min(self.selected, len(items) - 1)
        return items[idx]

    def _toggle_pin(self) -> None:
        p = self._current_proc()
        if not p:
            return
        if p.pid in self.pinned:
            self.pinned.remove(p.pid)
            self._set_toast(f"unpinned PID {p.pid} ({p.name})", C_DIM)
        else:
            self.pinned.add(p.pid)
            self._set_toast(f"{SYM['pinned']} pinned PID {p.pid} ({p.name})",
                            C_INFO)

    def _kill_selected(self, tree: bool) -> None:
        p = self._current_proc()
        if not p:
            return
        if p.name.lower() in PROTECTED_NAMES:
            self._set_toast(f"{SYM['shield']} {p.name} is protected — refusing",
                            C_WARN)
            return
        if p.state == "Z":
            try:
                os.kill(p.ppid, signal.SIGCHLD)
                self._set_toast(
                    f"{SYM['bolt']} SIGCHLD → parent PID {p.ppid} (zombie {p.pid})",
                    C_INFO)
                append_event(f"SIGCHLD parent={p.ppid} zombie={p.pid}")
            except (ProcessLookupError, PermissionError) as e:
                self._set_toast(f"{SYM['cross']} cannot signal parent: {e}",
                                C_CRIT)
            return
        if tree:
            targets = self.tree.descendants(p.pid) + [p.pid]
            n = 0
            for t in targets:
                try:
                    os.kill(t, signal.SIGTERM)
                    n += 1
                except (ProcessLookupError, PermissionError):
                    pass
            self._set_toast(
                f"{SYM['tree']}{SYM['bolt']} SIGTERM × {n} (tree of {p.name})",
                C_OK)
            append_event(f"SIGTERM tree {p.name}({p.pid}) targets={n}")
            return
        # Two-press SIGTERM → SIGKILL
        if self.last_kill_target == p.pid and time.time() - self.last_kill_time < 5:
            try:
                os.kill(p.pid, signal.SIGKILL)
                self._set_toast(
                    f"{SYM['bomb']} SIGKILL → {p.name} (PID {p.pid})", C_CRIT)
                append_event(f"SIGKILL {p.name}({p.pid})")
            except (ProcessLookupError, PermissionError) as e:
                self._set_toast(f"{SYM['cross']} kill failed: {e}", C_CRIT)
            self.last_kill_target = -1
        else:
            try:
                os.kill(p.pid, signal.SIGTERM)
                self._set_toast(
                    f"{SYM['bolt']} SIGTERM → {p.name} (PID {p.pid}) — "
                    f"press K again for SIGKILL", C_WARN)
                self.last_kill_target = p.pid
                self.last_kill_time = time.time()
                append_event(f"SIGTERM {p.name}({p.pid})")
            except (ProcessLookupError, PermissionError) as e:
                self._set_toast(f"{SYM['cross']} kill failed: {e}", C_CRIT)

    def _run_reaper(self) -> None:
        rm = ReaperMode(self, self.ghosts)
        rm.run()
        self._refresh()

    def _set_toast(self, msg: str, color: int) -> None:
        self.toast = msg
        self.toast_time = time.time()
        self.toast_color = color

    def _export_snapshot(self) -> None:
        CONFIG_DIR.mkdir(exist_ok=True)
        ts = datetime.now().strftime("%Y-%m-%d-%H%M%S")
        path = CONFIG_DIR / f"snapshot-{ts}.log"
        ratio = self.total_threads / max(1, self.thread_limit)
        lines = [
            f"# {APP_NAME} snapshot {datetime.now().isoformat()}",
            f"# user={user_name()} host={os.uname().nodename}",
            f"# threads={self.total_threads}/{self.thread_limit} "
            f"({ratio*100:.1f}%)",
            f"# procs={len(self.procs)} ghosts={len(self.ghosts)}",
            "",
            "TOP HOGS:",
        ]
        for p in sorted(self.procs.values(),
                        key=lambda x: x.threads, reverse=True)[:10]:
            lines.append(f"  {p.pid:<7} {p.name:<18} "
                         f"{p.threads:>5} thr  {p.cpu_percent:>5.1f}% "
                         f"{format_bytes(p.rss_bytes):>7}")
        lines.append("")
        lines.append("GHOSTS:")
        for g in self.ghosts:
            p = self.procs.get(g.pid)
            name = p.name if p else "?"
            thr = p.threads if p else 0
            lines.append(f"  {g.pid:<7} {name:<18} {g.ghost_type:<10} "
                         f"conf={g.confidence:.2f} thr={thr}")
        path.write_text("\n".join(lines) + "\n")
        self._set_toast(f"{SYM['disk']} snapshot → {path}", C_OK)
        append_event(f"SNAPSHOT {path}")

    # ── inspector ──────────────────────────────────────────────────────────

    def run_inspector(self, proc: ProcessInfo) -> None:
        self._open_inspector(proc)

    def _open_inspector(self, proc: ProcessInfo | None = None) -> None:
        if proc is None:
            proc = self._current_proc()
        if proc is None:
            return
        scroll = 0
        while True:
            self.stdscr.clear()
            h, w = self.stdscr.getmaxyx()
            ghost = self.ghost_map.get(proc.pid)
            title = (f" {SYM['search']} Inspect: {proc.name} "
                     f"(PID {proc.pid}) ")
            safe_addstr(self.stdscr, 0, 0,
                        SYM["corner_tl"] + SYM["horiz"] + title +
                        SYM["horiz"] * max(0, w - wcswidth(title) - 3) +
                        SYM["corner_tr"],
                        curses.color_pair(C_ACCENT) | curses.A_BOLD)
            lines = self._inspector_lines(proc, ghost, w)
            avail = h - 4
            for i, item in enumerate(lines[scroll:scroll + avail]):
                y = 1 + i
                safe_addstr(self.stdscr, y, 0, SYM["vert"],
                            curses.color_pair(C_ACCENT))
                safe_addstr(self.stdscr, y, w - 1, SYM["vert"],
                            curses.color_pair(C_ACCENT))
                tag, content = item
                if tag == "hdr":
                    safe_addstr(self.stdscr, y, 2, content,
                                curses.color_pair(C_HEADER) | curses.A_BOLD)
                elif tag == "safety":
                    g = content
                    icon, lbl, _ = ghost_badge(g.ghost_type)
                    safe_addstr(self.stdscr, y, 2,
                                f"  {g.safety_icon} {lbl} — "
                                f"confidence {g.confidence:.2f}",
                                curses.color_pair(g.safety_color) | curses.A_BOLD)
                else:
                    safe_addstr(self.stdscr, y, 2, content)
            safe_addstr(self.stdscr, h - 2, 0,
                        SYM["corner_bl"] + SYM["horiz"] * (w - 2) +
                        SYM["corner_br"],
                        curses.color_pair(C_ACCENT) | curses.A_BOLD)
            safe_addstr(self.stdscr, h - 1, 2,
                        " K kill · T tree · ↑↓ scroll · Esc back ",
                        curses.color_pair(C_DIM))
            self.stdscr.refresh()
            self.stdscr.nodelay(False)
            key = self.stdscr.getch()
            self.stdscr.nodelay(True)
            if key in (27, ord("q")):
                return
            if key == ord("K"):
                self._kill_selected(tree=False)
                return
            if key == ord("T"):
                self._kill_selected(tree=True)
                return
            if key in (curses.KEY_DOWN, ord("j")):
                scroll = min(scroll + 1, max(0, len(lines) - avail))
            elif key in (curses.KEY_UP, ord("k")):
                scroll = max(0, scroll - 1)
            elif key == curses.KEY_NPAGE:
                scroll = min(scroll + avail, max(0, len(lines) - avail))
            elif key == curses.KEY_PPAGE:
                scroll = max(0, scroll - avail)

    def _inspector_lines(self, proc: ProcessInfo, ghost: GhostInfo | None,
                         w: int) -> list[tuple[str, Any]]:
        out: list[tuple[str, Any]] = []
        # Identity
        out.append(("hdr", f" {SYM['pin']} IDENTITY"))
        out.append(("txt",
                    f"  command:  {shorten_cmd(proc.cmdline, proc.name, w - 16)}"))
        if proc.exe:
            out.append(("txt", f"  exe:      {wc_truncate(proc.exe, w - 16)}"))
        started = time.time() - proc.age_secs
        ts = datetime.fromtimestamp(started).strftime("%Y-%m-%d %H:%M:%S")
        out.append(("txt", f"  started:  {ts}  ({format_duration(proc.age_secs)} ago)"))
        out.append(("txt", f"  user:     {user_name()}"))
        if proc.cgroup:
            cg = proc.cgroup.strip().splitlines()[-1] if proc.cgroup.strip() else ""
            out.append(("txt", f"  cgroup:   {wc_truncate(cg, w - 16)}"))
        out.append(("txt", ""))
        # Spawn chain
        out.append(("hdr", f" {SYM['chain']} SPAWN CHAIN"))
        parts = []
        for cpid in self.tree.chain(proc.pid):
            if cpid in self.procs:
                parts.append(f"{self.procs[cpid].name}({cpid})")
            elif cpid == 1:
                parts.append("systemd(1)")
            else:
                parts.append(f"[?]({cpid})")
        out.append(("txt", "  " + f"  {SYM['arrow']}  ".join(parts)))
        out.append(("txt", ""))
        # Resources
        out.append(("hdr", f" {SYM['chart']} RESOURCES"))
        out.append(("txt",
                    f"  {SYM['thread']} threads: {proc.threads}    "
                    f"{SYM['bolt']} cpu: {proc.cpu_percent:.1f}%    "
                    f"{SYM['brain']} rss: {format_bytes(proc.rss_bytes)}    "
                    f"state: {state_icon(proc.state)} {proc.state}"))
        out.append(("txt",
                    f"  fd count: {proc.fd_count}    "
                    f"wchan: {proc.wchan or '-'}    "
                    f"vol cs: {proc.vol_cs}    "
                    f"nonvol cs: {proc.nonvol_cs}"))
        # Sparklines
        cpu_hist = list(self.history.cpu.get(proc.pid, []))
        thr_hist = list(self.history.threads.get(proc.pid, []))
        if len(cpu_hist) >= 2 or len(thr_hist) >= 2:
            out.append(("txt", ""))
            out.append(("hdr", f" {SYM['activity']} ACTIVITY"))
            if cpu_hist:
                out.append(("txt", f"  cpu     [{sparkline(cpu_hist, 48, 100.0)}]"
                                   f"  now {proc.cpu_percent:.1f}%"))
            if thr_hist:
                vmax = max(thr_hist) or 1
                out.append(("txt", f"  threads [{sparkline(thr_hist, 48, float(vmax))}]"
                                   f"  now {proc.threads}"))
        # I/O
        if proc.io_read is not None:
            out.append(("txt", ""))
            out.append(("hdr", f" {SYM['radio']} I/O"))
            out.append(("txt",
                        f"  read:  {format_bytes(proc.io_read)}    "
                        f"write: {format_bytes(proc.io_write)}"))
        # Open files
        fds = self.scanner.read_fd_targets(proc.pid, 8)
        out.append(("txt", ""))
        out.append(("hdr", f" {SYM['folder']} OPEN FILES ({len(fds)} shown)"))
        if fds:
            for target, ftype in fds:
                out.append(("txt",
                            f"  [{ftype:<4}]  {wc_truncate(target, w - 18)}"))
        else:
            out.append(("txt", "  (none readable)"))
        # Safety
        out.append(("txt", ""))
        out.append(("hdr", f" {SYM['shield']} SAFETY"))
        if ghost:
            out.append(("safety", ghost))
            out.append(("txt", f"  reason:   {ghost.reason}"))
        else:
            if proc.cpu_percent > 1.0:
                out.append(("txt",
                            f"  {SYM['safe_ok']} ACTIVE — sustained CPU, likely working"))
            elif proc.threads > 50 and proc.cpu_percent < 0.1:
                out.append(("txt",
                            f"  {SYM['safe_warn']} IDLE — {proc.threads} threads, low CPU"))
            else:
                out.append(("txt", f"  {SYM['safe_ok']} healthy"))
        has_w = self.scanner.has_write_handles(proc.pid)
        out.append(("txt",
                    f"  data loss risk: "
                    f"{'MEDIUM (open write handles)' if has_w else 'LOW'}"))
        # Children
        kids = [c for c in self.tree.get_children(proc.pid) if c in self.procs]
        if kids:
            out.append(("txt", ""))
            out.append(("hdr", f" {SYM['tree']} CHILDREN ({len(kids)})"))
            for i, cpid in enumerate(kids[:12]):
                cp = self.procs[cpid]
                pre = "└──" if i == len(kids) - 1 else "├──"
                out.append(("txt",
                            f"  {pre} PID {cpid:<6} {cp.name:<14} "
                            f"{cp.threads:>4} thr  {state_icon(cp.state)}"))
        return out


# ─── --once / --json reporters ─────────────────────────────────────────────


def report_text(args: argparse.Namespace) -> int:
    scanner = ProcScanner(all_users=args.all_users)
    classifier = GhostClassifier(scanner)
    # Two passes for CPU & idle-hog detection
    snap1 = scanner.scan()
    classifier.add(snap1)
    time.sleep(min(args.refresh, 2.0))
    snap2 = scanner.scan()
    classifier.add(snap2)
    compute_cpu(classifier.snapshots, snap2)
    classifier.add(snap2)
    ghosts = classifier.classify()
    limit = args.limit or detect_thread_limit()
    total = sum(p.threads for p in snap2.values())
    ratio = total / max(1, limit)
    out = io.StringIO()
    out.write(f"{APP_NAME} v{__version__} — snapshot {datetime.now().isoformat(timespec='seconds')}\n")
    out.write(f"user={user_name()}  host={os.uname().nodename}  "
              f"procs={len(snap2)}  ghosts={len(ghosts)}\n")
    out.write(f"threads={total:,}/{limit:,}  [{smooth_bar(ratio, 28)}]  "
              f"{ratio*100:.1f}%\n\n")
    out.write("TOP THREAD HOGS\n")
    for p in sorted(snap2.values(), key=lambda x: x.threads, reverse=True)[:10]:
        out.write(f"  {p.pid:>7}  {p.name:<18} {p.threads:>5} thr  "
                  f"{p.cpu_percent:>5.1f}% cpu  "
                  f"{format_bytes(p.rss_bytes):>7}\n")
    out.write("\nGHOSTS\n")
    if not ghosts:
        out.write("  (none)\n")
    for g in ghosts:
        p = snap2.get(g.pid)
        name = p.name if p else "?"
        thr = p.threads if p else 0
        out.write(f"  {g.pid:>7}  {name:<18} {g.ghost_type:<10} "
                  f"conf={g.confidence:.2f} thr={thr:<4} — {g.reason}\n")
    sys.stdout.write(out.getvalue())
    return 0


def report_json(args: argparse.Namespace) -> int:
    scanner = ProcScanner(all_users=args.all_users)
    classifier = GhostClassifier(scanner)
    snap1 = scanner.scan()
    classifier.add(snap1)
    time.sleep(min(args.refresh, 2.0))
    snap2 = scanner.scan()
    classifier.add(snap2)
    compute_cpu(classifier.snapshots, snap2)
    classifier.add(snap2)
    ghosts = classifier.classify()
    limit = args.limit or detect_thread_limit()
    total = sum(p.threads for p in snap2.values())
    payload = {
        "app": APP_NAME,
        "version": __version__,
        "timestamp": datetime.now().isoformat(timespec="seconds"),
        "user": user_name(),
        "host": os.uname().nodename,
        "thread_limit": limit,
        "thread_total": total,
        "thread_ratio": total / max(1, limit),
        "processes": [
            {
                "pid": p.pid, "ppid": p.ppid, "name": p.name,
                "state": p.state, "threads": p.threads,
                "cpu_percent": round(p.cpu_percent, 2),
                "rss_bytes": p.rss_bytes,
                "age_secs": round(p.age_secs, 1),
                "cmdline": p.cmdline,
            }
            for p in sorted(snap2.values(),
                            key=lambda x: x.threads, reverse=True)
        ],
        "ghosts": [
            {
                "pid": g.pid, "type": g.ghost_type,
                "confidence": round(g.confidence, 3),
                "reason": g.reason,
            }
            for g in ghosts
        ],
    }
    json.dump(payload, sys.stdout, indent=2)
    sys.stdout.write("\n")
    return 0


# ─── CLI ───────────────────────────────────────────────────────────────────


def parse_args(argv: list[str]) -> argparse.Namespace:
    p = argparse.ArgumentParser(
        prog="threadreaper",
        description=(f"{APP_NAME} v{__version__} — modern TUI thread manager "
                     f"for shared Linux hosts. Hunt zombies, orphans, and idle "
                     f"hogs; reclaim threads before you hit the ulimit wall."),
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=(
            "examples:\n"
            "  threadreaper                  # full TUI\n"
            "  threadreaper --once           # one-shot text report\n"
            "  threadreaper --json > snap.json\n"
            "  threadreaper --ascii --refresh 3\n"
            "  threadreaper --filter rtorrent\n"
        ),
    )
    p.add_argument("--version", action="version",
                   version=f"%(prog)s {__version__}")
    p.add_argument("--refresh", type=float, default=DEFAULT_REFRESH,
                   metavar="SEC",
                   help=f"refresh interval (default {DEFAULT_REFRESH}s)")
    p.add_argument("--limit", type=int, default=0,
                   metavar="N",
                   help="override detected thread limit")
    p.add_argument("--sort", choices=SORT_COLUMNS, default="threads",
                   help="initial sort column")
    p.add_argument("--filter", type=str, default="",
                   help="initial process name/cmdline filter")
    p.add_argument("--ascii", action="store_true",
                   help="ASCII-only mode (no emoji or fancy box-drawing)")
    p.add_argument("--no-color", action="store_true",
                   help="disable colors")
    p.add_argument("--no-mouse", dest="mouse", action="store_false",
                   help="disable mouse support")
    p.add_argument("--all-users", action="store_true",
                   help="show processes from all users (best-effort; "
                        "may be permission-limited on shared hosts)")
    p.add_argument("--once", action="store_true",
                   help="print a one-shot text report and exit "
                        "(no curses, scripting-friendly)")
    p.add_argument("--json", dest="json_mode", action="store_true",
                   help="emit a JSON snapshot to stdout and exit")
    p.set_defaults(mouse=True)
    return p.parse_args(argv)


def main(argv: list[str] | None = None) -> int:
    args = parse_args(argv if argv is not None else sys.argv[1:])
    locale.setlocale(locale.LC_ALL, "")
    # Choose symbol set
    encoding = (sys.stdout.encoding or "").lower()
    use_emoji = (not args.ascii) and ("utf" in encoding)
    SYM.clear()
    SYM.update(_build_symbols(use_emoji))
    if args.json_mode:
        return report_json(args)
    if args.once:
        return report_text(args)
    if not sys.stdout.isatty():
        sys.stderr.write("threadreaper: stdout is not a TTY. "
                         "Use --once or --json for non-interactive output.\n")
        return 2
    app = App(args)
    try:
        curses.wrapper(app.run)
    except KeyboardInterrupt:
        pass
    return 0


if __name__ == "__main__":
    sys.exit(main())