claude-code-tools 1.26.5__tar.gz → 1.27.1__tar.gz

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.26.5
+Version: 1.27.1
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/claude_code_tools/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Tools - Collection of utilities for Claude Code."""
 
-__version__ = "1.26.5"
+__version__ = "1.27.1"

claude_code_tools-1.27.1/claude_code_tools/amux/activity.py

@@ -0,0 +1,260 @@
+"""Read bounded, session-scoped evidence of submitted agent input.
+
+History timestamps are not pane activity: another pane can resume the same
+conversation. Missing or ambiguous evidence stays unknown. No transcript mtimes,
+launch arguments, or terminal output are used as input timestamps.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import sqlite3
+import subprocess
+import time
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+from .model import Agent
+
+_HISTORY_LIMIT = 16 * 1024 * 1024
+_UUID = r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}"
+_ROLLOUT = re.compile(rf"rollout-.*-({_UUID})\.jsonl$")
+
+
+def _homes(kind: str) -> list[Path]:
+    """Discover immediate profile directories and the explicit current home."""
+    root = Path.home()
+    paths = [root / f".{kind}"]
+    try:
+        paths.extend(p for p in root.iterdir() if p.name.startswith(f".{kind}"))
+    except OSError:
+        pass
+    variable = "CLAUDE_CONFIG_DIR" if kind == "claude" else "CODEX_HOME"
+    configured = os.environ.get(variable)
+    if configured:
+        paths.append(Path(configured).expanduser())
+    result: list[Path] = []
+    for path in paths:
+        try:
+            resolved = path.resolve()
+            if path.is_dir() and resolved not in result:
+                result.append(resolved)
+        except OSError:
+            continue
+    return result
+
+
+def _history(home: Path, kind: str) -> tuple[dict[str, float], str]:
+    """Read a bounded history tail, returning timestamps and read status."""
+    try:
+        with (home / "history.jsonl").open("rb") as stream:
+            size = stream.seek(0, 2)
+            start = max(0, size - _HISTORY_LIMIT)
+            stream.seek(start)
+            data = stream.read(_HISTORY_LIMIT)
+        if start:
+            data = data.partition(b"\n")[2]
+    except OSError:
+        return {}, "unavailable"
+    times: dict[str, float] = {}
+    for line in data.splitlines():
+        try:
+            record = json.loads(line)
+        except (ValueError, UnicodeDecodeError):
+            continue
+        if not isinstance(record, dict):
+            continue
+        submitted = record.get("display" if kind == "claude" else "text", "")
+        if isinstance(submitted, str) and submitted.lstrip().startswith(
+            ("<hook_prompt", "<task-notification", "<subagent", "<system-reminder")
+        ):
+            continue
+        sid = record.get("sessionId" if kind == "claude" else "session_id")
+        timestamp = record.get("timestamp" if kind == "claude" else "ts")
+        if not isinstance(sid, str) or not sid:
+            continue
+        if isinstance(timestamp, bool) or not isinstance(timestamp, (int, float)):
+            continue
+        try:
+            value = float(timestamp) / (1000 if kind == "claude" else 1)
+        except OverflowError:
+            continue
+        if math.isfinite(value) and 0 < value <= time.time():
+            times[sid] = max(times.get(sid, 0), value)
+    return times, "tail" if start else "complete"
+
+
+def _run(args: list[str]) -> str | None:
+    """Run a bounded read-only subprocess; failure is distinct from no records."""
+    try:
+        result = subprocess.run(
+            args, capture_output=True, text=True, timeout=5,
+            env={**os.environ, "TZ": "UTC"},
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return result.stdout if result.returncode == 0 else None
+
+
+def _starts(pids: set[int]) -> dict[int, str]:
+    """Get process start identities to reject stale PID metadata."""
+    if not pids:
+        return {}
+    output = _run(["ps", "-p", ",".join(map(str, sorted(pids))), "-o", "pid=,lstart="])
+    result: dict[int, str] = {}
+    for line in (output or "").splitlines():
+        parts = line.strip().split(None, 1)
+        if len(parts) == 2 and parts[0].isdigit():
+            result[int(parts[0])] = " ".join(parts[1].split())
+    return result
+
+
+def _claude_record(home: Path, pid: int, start: str) -> dict[str, Any] | None:
+    """Accept only runtime metadata matching a currently observed process."""
+    try:
+        with (home / "sessions" / f"{pid}.json").open("rb") as stream:
+            record = json.loads(stream.read(64 * 1024))
+    except (OSError, ValueError, UnicodeDecodeError):
+        return None
+    if not isinstance(record, dict):
+        return None
+    recorded_start = record.get("procStart")
+    sid = record.get("sessionId")
+    if (
+        record.get("pid") != pid
+        or not isinstance(recorded_start, str)
+        or " ".join(recorded_start.split()) != start
+        or not start
+        or not isinstance(sid, str)
+        or not sid
+    ):
+        return None
+    return record
+
+
+def _codex_pids(agent: Agent, tree: dict[int, list[tuple[int, str]]]) -> set[int]:
+    """Include native Codex children of the selected launcher, bounded in size."""
+    pids = {agent.pid} if agent.pid > 0 else set()
+    queue = list(pids)
+    while queue and len(pids) < 32:
+        for pid, command in tree.get(queue.pop(0), []):
+            # Follow only the launcher/native chain, never arbitrary tool workers.
+            executable = command.split()[0] if command.split() else ""
+            if pid not in pids and Path(executable).name == "codex":
+                pids.add(pid)
+                queue.append(pid)
+    return pids
+
+
+def _rollouts(pids: set[int]) -> tuple[dict[int, set[Path]], bool]:
+    """Identify open rollout descriptors in one lsof query, without reading them."""
+    if not pids:
+        return {}, True
+    output = _run(["lsof", "-nP", "-a", "-p", ",".join(map(str, sorted(pids))), "-Fn"])
+    if output is None:
+        return {}, False
+    found: dict[int, set[Path]] = {}
+    pid = 0
+    for line in output.splitlines():
+        if line.startswith("p") and line[1:].isdigit():
+            pid = int(line[1:])
+        elif pid in pids and line.startswith("n"):
+            path = Path(line[1:])
+            if _ROLLOUT.fullmatch(path.name):
+                found.setdefault(pid, set()).add(path)
+    return found, True
+
+
+def _goal_status(home: Path, sid: str) -> str:
+    """Read only the matched thread's goal status, never its objective."""
+    try:
+        uri = (home / "goals_1.sqlite").as_uri() + "?mode=ro"
+        connection = sqlite3.connect(uri, uri=True, timeout=0.1)
+        try:
+            row = connection.execute(
+                "SELECT status FROM thread_goals WHERE thread_id = ?", (sid,)
+            ).fetchone()
+        finally:
+            connection.close()
+    except (sqlite3.Error, ValueError):
+        return "unknown"
+    return str(row[0]) if row else "none"
+
+
+def enrich(agents: list[Agent], child_map: dict[int, list[tuple[int, str]]]) -> None:
+    """Add last submitted-input evidence without modifying running sessions.
+
+    Args:
+        agents: Live pane records to enrich in place.
+        child_map: Process snapshot containing launcher/native parentage.
+    """
+    homes = {kind: _homes(kind) for kind in {a.kind for a in agents}}
+    histories: dict[tuple[Path, str], tuple[dict[str, float], str]] = {}
+    starts = _starts({a.pid for a in agents if a.kind == "claude" and a.pid > 0})
+    pid_sets = {
+        a.pane: _codex_pids(a, child_map) for a in agents if a.kind == "codex"
+    }
+    paths, lsof_ok = _rollouts(set().union(*pid_sets.values()) if pid_sets else set())
+    identities: list[tuple[Agent, Path, str]] = []
+    for agent in agents:
+        agent.session_id = ""
+        agent.last_input_at = None
+        agent.input_source = "unknown"
+        agent.input_scope = "unknown"
+        matches: list[tuple[Path, str]] = []
+        runtime_records: list[dict[str, Any]] = []
+        if agent.kind == "claude":
+            for home in homes["claude"]:
+                record = _claude_record(home, agent.pid, starts.get(agent.pid, ""))
+                if record:
+                    matches.append((home, record["sessionId"]))
+                    runtime_records.append(record)
+            method = "claude-pid"
+        else:
+            open_paths = set().union(
+                *(paths.get(p, set()) for p in pid_sets[agent.pane])
+            )
+            for path in open_paths:
+                match = _ROLLOUT.fullmatch(path.name)
+                for home in homes["codex"]:
+                    if match and path.is_relative_to(home / "sessions"):
+                        matches.append((home, match.group(1)))
+            method = "codex-open-rollout"
+            agent.extra["activity_probe_ok"] = lsof_ok
+        matches = list(dict.fromkeys(matches))
+        if len(matches) != 1:
+            agent.extra["input_evidence"] = "ambiguous" if matches else "unavailable"
+            continue
+        home, sid = matches[0]
+        agent.session_id = sid
+        if agent.kind == "claude":
+            record = runtime_records[0]
+            status = record.get("status", "unknown")
+            agent.extra["runtime_status"] = status
+            if isinstance(record.get("name"), str) and record["name"]:
+                agent.name = record["name"]
+            if status in ("shell", "working", "running") and agent.state == "idle":
+                agent.state = "bg"
+        else:
+            goal = _goal_status(home, sid)
+            agent.extra["goal_status"] = goal
+            if goal == "active" and agent.state == "idle":
+                agent.state = "bg"
+        agent.input_scope = "session"
+        key = (home, agent.kind)
+        if key not in histories:
+            histories[key] = _history(home, agent.kind)
+        timestamps, status = histories[key]
+        agent.last_input_at = timestamps.get(sid)
+        agent.input_source = f"{method}/history-{status}"
+        agent.extra["activity_home"] = str(home)
+        agent.extra["input_evidence"] = "found" if sid in timestamps else "unavailable"
+        identities.append((agent, home, sid))
+    counts = Counter((home, sid) for _, home, sid in identities)
+    for agent, home, sid in identities:
+        if counts[home, sid] > 1:
+            agent.input_scope = "shared-session"

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/claude_code_tools/amux/cli.py

@@ -20,11 +20,12 @@ import subprocess
 import sys
 
 from . import cache, render, scan
+from .filters import directory_argument, select_agents
 from .model import Agent
 
 _FZF_HEADER = (
     "enter=jump  ctrl-r=refresh  esc=quit    "
-    "input=asking you  busy=working  bg=monitors  idle"
+    "input=asking you  busy=working  bg=background  age=last submitted input"
 )
 
 
@@ -44,11 +45,30 @@ def _agents_for_display(max_age: float) -> tuple[list[Agent], bool]:
     return _fresh(), False
 
 
+def _display(agents: list[Agent], args: argparse.Namespace) -> list[Agent]:
+    """Refresh ages even for cached rows, then apply the requested view."""
+    agents = select_agents(
+        agents, getattr(args, "repo", None), getattr(args, "directory", None),
+    )
+    for agent in agents:
+        agent.classify_inactivity(args.dormant_hours)
+    if args.dormant:
+        agents = [a for a in agents if a.inactivity == "dormant"]
+    if args.sort == "oldest":
+        agents = sorted(agents, key=lambda a: (
+            a.last_input_at is None,
+            a.last_input_at if a.last_input_at is not None else 0,
+            a.pane,
+        ))
+    return agents
+
+
 def cmd_list(args: argparse.Namespace) -> int:
     """Print every live agent as a table or JSON."""
     agents = cache.read(max_age=args.max_age)[0] if args.cached else _fresh()
     if not agents and args.cached:
         agents = _fresh()
+    agents = _display(agents, args)
     if args.json:
         print(render.as_json(agents))
     else:
@@ -67,7 +87,7 @@ def cmd_scan(args: argparse.Namespace) -> int:
 def cmd_rows(args: argparse.Namespace) -> int:
     """Emit picker rows (internal: used by fzf's reload binding)."""
     agents = _fresh() if args.refresh else _agents_for_display(args.max_age)[0]
-    print(render.picker_lines(agents, colour=True))
+    print(render.picker_lines(_display(agents, args), colour=True))
     return 0
 
 
@@ -81,18 +101,37 @@ def cmd_pick(args: argparse.Namespace) -> int:
         return 1
 
     agents, from_cache = _agents_for_display(args.max_age)
+    agents = _display(agents, args)
+    if not agents and from_cache:
+        agents = _display(_fresh(), args)
+        from_cache = False
     if not agents:
-        print("no agents running")
+        print("no matching agents")
         return 0
 
     # fzf runs bind commands through a shell, so the interpreter path must be
     # quoted: a venv at "/tmp/my venv/bin/python" would otherwise run "/tmp/my".
     self_cmd = f"{shlex.quote(sys.executable)} -m claude_code_tools.amux"
+    view_flags = (
+        f" --dormant-hours {args.dormant_hours} --sort {args.sort}"
+        + (" --dormant" if args.dormant else "")
+    )
+    # Keep user values out of fzf's action/placeholder parser as well as the shell.
+    reload_env = dict(os.environ)
+    if args.repo is not None:
+        reload_env["AMUX_RELOAD_REPO"] = args.repo
+        view_flags += ' --repo="$AMUX_RELOAD_REPO"'
+    if args.directory is not None:
+        reload_env["AMUX_RELOAD_DIR"] = args.directory
+        view_flags += ' --dir="$AMUX_RELOAD_DIR"'
     binds = [
-        f"ctrl-r:reload({self_cmd} rows --refresh)",
+        f"ctrl-r:reload({self_cmd} rows --refresh{view_flags})",
         # Opening on cached rows is what makes this instant; refresh the
         # moment the list is up so stale states self-correct without a keypress.
-        f"load:reload-sync({self_cmd} rows --refresh)" if from_cache else "",
+        (
+            f"load:reload-sync({self_cmd} rows --refresh{view_flags})"
+            if from_cache else ""
+        ),
     ]
     cmd = [
         "fzf",
@@ -126,6 +165,7 @@ def cmd_pick(args: argparse.Namespace) -> int:
         input=render.picker_lines(agents),
         stdout=subprocess.PIPE,
         text=True,
+        env=reload_env,
     )
     if proc.returncode != 0 or not proc.stdout.strip():
         return 0
@@ -182,6 +222,32 @@ def build_parser() -> argparse.ArgumentParser:
     rows.add_argument("--refresh", action="store_true")
     rows.set_defaults(func=cmd_rows)
 
+    for command in (pick, lst, rows, scan_cmd):
+        command.add_argument(
+            "--max-age", type=_finite_seconds, default=argparse.SUPPRESS,
+            help="seconds a cached scan stays usable (default: 30)",
+        )
+    for command in (pick, lst, rows):
+        command.add_argument(
+            "--repo", "--project", dest="repo", metavar="NAME",
+            help="exact repository name, including linked Git worktrees",
+        )
+        command.add_argument(
+            "--dir", dest="directory", type=directory_argument, metavar="PATH",
+            help="only agents in this directory or its subdirectories",
+        )
+        command.add_argument(
+            "--dormant", action="store_true",
+            help="show waiting agents with old known submitted input only",
+        )
+        command.add_argument(
+            "--dormant-hours", type=_finite_seconds, default=72.0,
+            help="input age in hours above which waiting agents are dormant (72)",
+        )
+        command.add_argument(
+            "--sort", choices=("state", "oldest"), default="state",
+            help="sort by current state or oldest known submitted input",
+        )
     return parser
 
 
@@ -193,8 +259,21 @@ def main(argv: list[str] | None = None) -> int:
     # only ["pick"] -- reparsing dropped global options, so `amux --max-age 0`
     # silently used the 30s default.
     known = {"pick", "list", "scan", "rows"}
-    if not any(tok in known for tok in raw):
-        raw.append("pick")
+    value_options = {
+        "--repo", "--project", "--dir", "--max-age", "--dormant-hours", "--sort",
+    }
+    tokens = iter(raw)
+    explicit_command = False
+    for token in tokens:
+        if token in value_options:
+            next(tokens, None)
+        elif token in known | {"-h", "--help"}:
+            explicit_command = True
+            break
+        elif not token.startswith("-"):
+            break
+    if not explicit_command:
+        raw.insert(0, "pick")
     args = parser.parse_args(raw)
     if not scan.tmux_available():
         print("amux: no tmux server running", file=sys.stderr)

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/claude_code_tools/amux/detect.py

@@ -93,7 +93,9 @@ _BUSY = re.compile(
 #: those can be used). Without this a pane with a working subagent but a free
 #: main prompt reported as idle.
 _BG = re.compile(
-    r"\b\d+\s+monitors?\b|^\s*◯\s+\S",
+    r"\b[1-9]\d*\s+monitors?\b|"
+    r"\b[1-9]\d*\s+shells? still running\b|"
+    r"^\s*⏵⏵.*·\s*[1-9]\d*\s+shells?\b|^\s*◯\s+\S",
     re.MULTILINE,
 )
 
@@ -136,7 +138,11 @@ def detect_state(screen: str, kind: Kind) -> State:
         return "busy"
     if kind == "codex" and _codex_awaiting_answer(tail):
         return "input"
-    if _BG.search(screen):
+    background_lines = "\n".join(
+        line.rstrip() for line in screen.splitlines()
+        if not re.search(r"^\s*◯.*\bidle\s*$", line)
+    )
+    if _BG.search(background_lines):
         return "bg"
     return "idle"
 

claude_code_tools-1.27.1/claude_code_tools/amux/filters.py

@@ -0,0 +1,67 @@
+"""Repository and directory selection for Amux display views."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .model import Agent
+
+
+def directory_argument(value: str) -> str:
+    """Resolve an existing directory supplied on the command line."""
+    try:
+        path = Path(value).expanduser().resolve()
+        if path.is_dir():
+            return str(path)
+    except (OSError, RuntimeError) as exc:
+        raise argparse.ArgumentTypeError(str(exc)) from exc
+    raise argparse.ArgumentTypeError(f"not a directory: {value!r}")
+
+
+def repository_name(cwd: str) -> str:
+    """Find the shared repository's directory name, including linked worktrees."""
+    if not cwd:
+        return ""
+    try:
+        path = Path(cwd).resolve()
+        for root in (path, *path.parents):
+            marker = root / ".git"
+            if marker.is_dir():
+                return root.name
+            if marker.is_file():
+                pointer = marker.read_text().strip()
+                if not pointer.startswith("gitdir: "):
+                    return ""
+                git_dir = (root / pointer.removeprefix("gitdir: ")).resolve()
+                common_file = git_dir / "commondir"
+                if not common_file.is_file():
+                    return root.name
+                common = (git_dir / common_file.read_text().strip()).resolve()
+                return common.parent.name if common.name == ".git" else common.name
+    except (OSError, RuntimeError, UnicodeError):
+        return ""
+    return ""
+
+
+def select_agents(
+    agents: list[Agent], repo: str | None, directory: str | None,
+) -> list[Agent]:
+    """Apply exact repository-name and directory-subtree filters together."""
+    selected = []
+    names: dict[str, str] = {}
+    for agent in agents:
+        if repo is not None and agent.repo != repo:
+            if agent.cwd not in names:
+                names[agent.cwd] = repository_name(agent.cwd)
+            if names[agent.cwd] != repo:
+                continue
+        if directory:
+            if not agent.cwd:
+                continue
+            try:
+                Path(agent.cwd).resolve().relative_to(directory)
+            except (ValueError, OSError, RuntimeError):
+                continue
+        selected.append(agent)
+    return selected

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/claude_code_tools/amux/model.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import math
+import time
 from dataclasses import asdict, dataclass, field
 from typing import Any, Literal
 
@@ -37,6 +39,12 @@ class Agent:
         model: Model string parsed from the harness footer, e.g. ``opus-5``.
         info: One-line context lifted from the pane's footer.
         pid: PID of the agent process itself (not the pane's shell).
+        session_id: Current conversation ID, only when reliably matched.
+        last_input_at: Last recorded submitted user input, Unix seconds.
+        input_source: Identity method and history read status, or unknown.
+        input_scope: Session-level evidence; shared-session for duplicate panes.
+        inactivity: Working, recent, dormant, or unknown input-age classification.
+        input_age_seconds: Age calculated at display time, including cached rows.
     """
 
     pane: str
@@ -50,8 +58,37 @@ class Agent:
     model: str = ""
     info: str = ""
     pid: int = 0
+    session_id: str = ""
+    last_input_at: float | None = None
+    input_source: str = "unknown"
+    input_scope: str = "unknown"
+    inactivity: str = "unknown"
+    input_age_seconds: float | None = None
     extra: dict[str, Any] = field(default_factory=dict)
 
+    def classify_inactivity(
+        self, threshold_hours: float = 72, now: float | None = None
+    ) -> None:
+        """Classify old submitted input independently of current activity."""
+        now = time.time() if now is None else now
+        self.input_age_seconds = (
+            max(0, now - self.last_input_at)
+            if self.last_input_at is not None else None
+        )
+        working = (
+            self.state in ("busy", "bg")
+            or self.extra.get("runtime_status") in ("shell", "working", "running")
+            or self.extra.get("goal_status") == "active"
+        )
+        if working:
+            self.inactivity = "working"
+        elif self.input_age_seconds is None:
+            self.inactivity = "unknown"
+        elif self.input_age_seconds > threshold_hours * 3600:
+            self.inactivity = "dormant"
+        else:
+            self.inactivity = "recent"
+
     @property
     def rank(self) -> int:
         """Urgency rank used for sorting (lower sorts first)."""
@@ -74,13 +111,23 @@ class Agent:
             value = known.get(field_name)
             if value is not None and not isinstance(value, str):
                 return None
-        for field_name in ("name", "cwd", "repo", "branch", "model", "info"):
+        for field_name in ("name", "cwd", "repo", "branch", "model", "info",
+                           "session_id", "input_source", "input_scope", "inactivity"):
             if not isinstance(known.get(field_name, ""), str):
                 return None
         if known.get("pane") is None or known.get("session") is None:
             return None
         if not isinstance(known.get("pid", 0), int):
             return None
+        for key in ("last_input_at", "input_age_seconds"):
+            value = known.get(key)
+            if value is not None and (
+                isinstance(value, bool) or not isinstance(value, (int, float))
+                or not math.isfinite(value) or value < 0
+            ):
+                return None
+        if not isinstance(known.get("extra", {}), dict):
+            return None
         # Literal[...] is a type-checker hint only; a hand-edited cache can
         # still carry kind="vim" or state="waiting" and render as an agent.
         if known.get("kind") not in ("claude", "codex"):

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/claude_code_tools/amux/render.py

@@ -29,6 +29,18 @@ def _colour(state: str, text: str, colour: bool) -> str:
     return f"\033[{STATE_COLOR.get(state, '0')}m{text}\033[0m"
 
 
+def input_age(agent: Agent) -> str:
+    """Compact age of the last submitted input, never terminal output age."""
+    age = agent.input_age_seconds
+    if age is None:
+        return "unknown"
+    if age >= 86400:
+        return f"{age / 86400:.1f}d"
+    if age >= 3600:
+        return f"{age / 3600:.1f}h"
+    return f"{int(age // 60)}m"
+
+
 def picker_row(agent: Agent, colour: bool = True) -> str:
     """The visible part of an fzf row (no key field); see :func:`picker_lines`."""
     state = _colour(agent.state, f"{agent.state:<{_W_STATE}}", colour)
@@ -36,6 +48,7 @@ def picker_row(agent: Agent, colour: bool = True) -> str:
     where = _clip(f"{agent.repo}{branch}", _W_REPO)
     return (
         f"{_clip(agent.pane, _W_PANE):<{_W_PANE}} {state} {agent.kind:<{_W_KIND}} "
+        f"{input_age(agent):>9} {agent.inactivity:<8} "
         f"{_clip(agent.name or '-', _W_NAME):<{_W_NAME}} "
         f"{where:<{_W_REPO}} {agent.info}"
     )
@@ -74,6 +87,7 @@ def table(agents: list[Agent], colour: bool = True) -> str:
 
     header = (
         f"{'PANE':<{_W_PANE}} {'STATE':<{_W_STATE}} {'KIND':<{_W_KIND}} "
+        f"{'INPUT AGE':>9} {'ACTIVITY':<8} "
         f"{'NAME':<{_W_NAME}} {'REPO@BRANCH':<{_W_REPO}} CONTEXT"
     )
     rule = "─" * min(len(header) + 20, 120)

{claude_code_tools-1.26.5 → claude_code_tools-1.27.1}/claude_code_tools/amux/scan.py

@@ -19,7 +19,7 @@ import subprocess
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
-from . import detect
+from . import activity, detect
 from .model import Agent
 
 #: Field separator for tmux -F output; chosen to not occur in paths or titles.
@@ -238,6 +238,7 @@ def scan(workers: int = 16) -> list[Agent]:
             )
         )
 
+    activity.enrich(agents, child_map)
     agents.sort(key=lambda a: (a.rank, a.pane))
     return agents