@andespindola/crow-skills 0.1.0 → 0.4.0

package/crow_skills/progress.py

@@ -0,0 +1,667 @@
+"""Run ledger reader and progress panel for crow-behaviour runs.
+
+Self-contained on purpose (standard library only, no package-relative
+imports): the host integrations copy this file next to the CLI state and run
+it as a script from a status line or a tmux segment, so it keeps working even
+when the npm cache path of the CLI changes.
+
+The ledger is written by the agent that follows crow-behaviour; this module
+only reads it. Token usage comes from each host's own local session logs and
+is matched to a run by host, session id or working directory, and the run's
+time window. Only numeric usage fields are read and printed: message
+contents, prompts and credentials are never output.
+"""
+from datetime import datetime, timezone
+import glob
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import sqlite3
+import subprocess
+import sys
+import time
+
+SCHEMA = "crow-run/1"
+STATUSES = ("pending", "running", "done", "failed", "skipped")
+FINISHED = ("done", "failed", "cancelled")
+MAX_LEDGER = 2 * 1024 * 1024
+MAX_LOG_LINE = 8 * 1024 * 1024
+RECENT_DONE = 300  # seconds a finished run stays visible in compact views
+STALE = 2 * 3600  # a "running" ledger untouched for this long is treated as abandoned
+
+
+# --- ledger -------------------------------------------------------------------------
+
+def parse_time(value):
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        moment = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if moment.tzinfo is None:
+        moment = moment.replace(tzinfo=timezone.utc)
+    return moment.timestamp()
+
+
+def safe(text, limit=200):
+    """Printable, single-line text: ledger content is agent-written data."""
+    text = "".join(c if c.isprintable() else " " for c in str(text if text is not None else ""))
+    text = " ".join(text.split())
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+def validate(data):
+    """Normalise a ledger; raise ValueError when it is not a crow run."""
+    if not isinstance(data, dict) or data.get("schema", SCHEMA) != SCHEMA:
+        raise ValueError("schema")
+    if not isinstance(data.get("id"), str) or not data["id"]:
+        raise ValueError("id")
+    units = data.get("units", [])
+    phases = data.get("phases", [])
+    if not isinstance(units, list) or not isinstance(phases, list):
+        raise ValueError("units/phases")
+    run = {"id": safe(data["id"], 80), "title": safe(data.get("title") or data["id"]),
+           "host": safe(data.get("host") or "other", 20).lower(), "cwd": data.get("cwd") if isinstance(data.get("cwd"), str) else None,
+           "status": data.get("status") if data.get("status") in ("running",) + FINISHED else "running",
+           "startedAt": data.get("startedAt"), "updatedAt": data.get("updatedAt"), "endedAt": data.get("endedAt"),
+           "session": data.get("session") if isinstance(data.get("session"), dict) else {},
+           "phases": [], "units": []}
+    for phase in phases:
+        if isinstance(phase, dict) and isinstance(phase.get("id"), str):
+            run["phases"].append({"id": phase["id"], "title": safe(phase.get("title") or phase["id"]),
+                                  "status": phase.get("status") if phase.get("status") in STATUSES else None})
+    for unit in units:
+        if not isinstance(unit, dict) or not isinstance(unit.get("id"), str):
+            continue
+        status = unit.get("status") if unit.get("status") in STATUSES else "pending"
+        try:
+            progress = float(unit.get("progress", 1.0 if status in ("done", "skipped") else 0.0))
+        except (TypeError, ValueError):
+            progress = 0.0
+        if status in ("done", "skipped"):
+            progress = 1.0
+        run["units"].append({"id": safe(unit["id"], 40), "title": safe(unit.get("title") or unit["id"]),
+                             "phase": unit.get("phase") if isinstance(unit.get("phase"), str) else None,
+                             "owner": safe(unit.get("owner") or "", 40), "status": status,
+                             "progress": min(1.0, max(0.0, progress)),
+                             "startedAt": unit.get("startedAt"), "endedAt": unit.get("endedAt"),
+                             "summary": safe(unit.get("summary") or "", 160)})
+    return run
+
+
+def load(path):
+    path = Path(path)
+    if path.is_symlink() or not path.is_file() or path.stat().st_size > MAX_LEDGER:
+        raise ValueError("ledger file")
+    run = validate(json.loads(path.read_text(encoding="utf-8")))
+    run["path"] = str(path)
+    run["mtime"] = path.stat().st_mtime
+    return run
+
+
+def ledger_dirs(cwd, home):
+    """Where runs live: <dir>/.crow/runs from cwd up to the filesystem root, then ~/.crow/runs."""
+    cwd = Path(cwd).absolute()
+    dirs = [d / ".crow" / "runs" for d in (cwd, *cwd.parents)]
+    dirs.append(Path(home) / ".crow" / "runs")
+    seen, result = set(), []
+    for d in dirs:
+        if str(d) not in seen:
+            seen.add(str(d))
+            result.append(d)
+    return result
+
+
+def discover(cwd, home, env=None):
+    env = os.environ if env is None else env
+    runs, seen = [], set()
+    candidates = []
+    if env.get("CROW_LEDGER"):
+        candidates.append(Path(env["CROW_LEDGER"]).expanduser())
+    for d in ledger_dirs(cwd, home):
+        if d.is_dir() and not d.is_symlink():
+            candidates += sorted(d.glob("*.json"))
+    for path in candidates:
+        key = os.path.abspath(path)
+        if key in seen:
+            continue
+        seen.add(key)
+        try:
+            runs.append(load(path))
+        except (OSError, ValueError, TypeError, AttributeError):
+            continue  # Not a crow run or unreadable: ignore, never fail the panel.
+    return runs
+
+
+def related(run, cwd):
+    """The run belongs to this directory: same path, an ancestor or a descendant."""
+    cwd = os.path.abspath(cwd)
+    base = run.get("cwd")
+    if not base:
+        return False
+    return cwd == base or cwd.startswith(base.rstrip("/") + "/") or base.startswith(cwd.rstrip("/") + "/")
+
+
+def last_touch(run):
+    return max(parse_time(run.get("updatedAt")) or 0, run.get("mtime") or 0)
+
+
+def stale(run, now=None):
+    """A ledger left "running" (no finish) and not updated for STALE seconds."""
+    return run["status"] == "running" and (now or time.time()) - last_touch(run) > STALE
+
+
+def select(runs, cwd, run_id=None, strict=False, session=None, now=None):
+    """Pick the run to show.
+
+    The full panel prefers runs of this directory, then live runs, then the
+    newest. strict (status line, tmux segment) shows only live or recently
+    finished runs of this directory, and when the host's session id is known,
+    never a run recorded for another session.
+    """
+    if run_id:
+        matches = [r for r in runs if r["id"] == run_id]
+        return matches[0] if matches else None
+    if strict:
+        runs = [r for r in runs if related(r, cwd) and not stale(r, now)]
+        if session:
+            runs = [r for r in runs if not r["session"].get("id") or r["session"].get("id") == session]
+    if not runs:
+        return None
+
+    def key(run):
+        return (related(run, cwd), run["status"] == "running" and not stale(run, now),
+                bool(session) and run["session"].get("id") == session, run["mtime"])
+    return max(runs, key=key)
+
+
+def active(run, now=None):
+    """Worth showing in a compact view: running (not stale), or finished in the last minutes."""
+    if run is None:
+        return False
+    if run["status"] == "running":
+        return not stale(run, now)
+    ended = parse_time(run.get("endedAt")) or run.get("mtime", 0)
+    return (now or time.time()) - ended <= RECENT_DONE
+
+
+def summary(run):
+    units = run["units"]
+    counted = [u for u in units if u["status"] != "skipped"]
+    done = sum(u["status"] == "done" for u in counted)
+    failed = sum(u["status"] == "failed" for u in counted)
+    overall = sum(u["progress"] for u in units) / len(units) if units else (1.0 if run["status"] == "done" else 0.0)
+    return {"done": done, "failed": failed, "total": len(counted), "running": sum(u["status"] == "running" for u in units),
+            "progress": round(overall, 4)}
+
+
+def window(run, now=None):
+    start = parse_time(run.get("startedAt")) or run.get("mtime")
+    end = parse_time(run.get("endedAt")) if run["status"] in FINISHED else None
+    return start, (end or (now or time.time())) + 5
+
+
+# --- token usage from host logs ---------------------------------------------------------
+
+def _empty(host, source):
+    return {"host": host, "source": source, "input": 0, "output": 0, "cache_read": 0, "cache_write": 0,
+            "total": 0, "sessions": 0, "approximate": False}
+
+
+def _lines(path):
+    try:
+        with open(path, "rb") as handle:
+            for raw in handle:
+                if len(raw) <= MAX_LOG_LINE:
+                    yield raw
+    except OSError:
+        return
+
+
+def claude_project_dir(cwd):
+    return re.sub(r"[^A-Za-z0-9]", "-", cwd)
+
+
+def claude_tokens(run, home, start, end):
+    root = Path(home) / ".claude" / "projects"
+    if not root.is_dir():
+        return None
+    session = run["session"].get("id") if isinstance(run["session"].get("id"), str) else None
+    if session and re.fullmatch(r"[A-Za-z0-9-]{8,80}", session):
+        files = glob.glob(str(root / "*" / (session + ".jsonl"))) + glob.glob(str(root / "*" / session / "subagents" / "*.jsonl"))
+    elif run["cwd"]:
+        base = root / claude_project_dir(run["cwd"])
+        files = glob.glob(str(base / "*.jsonl")) + glob.glob(str(base / "*" / "subagents" / "*.jsonl"))
+    else:
+        return None
+    files = [f for f in files if os.path.getmtime(f) >= start - 60]
+    result = _empty("claude", "~/.claude/projects (message.usage)")
+    result["approximate"] = not session
+    seen, sessions = set(), set()
+    for path in files:
+        for raw in _lines(path):
+            if b'"usage"' not in raw or b'"assistant"' not in raw:
+                continue
+            try:
+                record = json.loads(raw)
+            except ValueError:
+                continue
+            if record.get("type") != "assistant":
+                continue
+            moment = parse_time(record.get("timestamp"))
+            if moment is None or not (start <= moment <= end):
+                continue
+            message = record.get("message") or {}
+            usage = message.get("usage") or {}
+            key = (message.get("id"), record.get("requestId"))
+            if key in seen and key != (None, None):
+                continue
+            seen.add(key)
+            sessions.add(record.get("sessionId") or path)
+            result["input"] += int(usage.get("input_tokens") or 0)
+            result["output"] += int(usage.get("output_tokens") or 0)
+            result["cache_read"] += int(usage.get("cache_read_input_tokens") or 0)
+            result["cache_write"] += int(usage.get("cache_creation_input_tokens") or 0)
+    result["total"] = result["input"] + result["output"] + result["cache_read"] + result["cache_write"]
+    result["sessions"] = len(sessions)
+    return result if sessions else None
+
+
+def codex_tokens(run, home, start, end):
+    root = Path(home) / ".codex" / "sessions"
+    if not root.is_dir():
+        return None
+    session = run["session"].get("id") if isinstance(run["session"].get("id"), str) else None
+    result = _empty("codex", "~/.codex/sessions (token_count)")
+    result["approximate"] = not session
+    for path in glob.glob(str(root / "**" / "rollout-*.jsonl"), recursive=True):
+        if os.path.getmtime(path) < start - 60:
+            continue
+        before = after = None
+        matched = False
+        for index, raw in enumerate(_lines(path)):
+            if index == 0:
+                try:
+                    meta = json.loads(raw).get("payload") or {}
+                except ValueError:
+                    break
+                matched = (session and session in (meta.get("id"), meta.get("session_id"))) or \
+                          (not session and run["cwd"] and meta.get("cwd") == run["cwd"])
+                if not matched:
+                    break
+                continue
+            if b'"token_count"' not in raw:
+                continue
+            try:
+                record = json.loads(raw)
+            except ValueError:
+                continue
+            payload = record.get("payload") or {}
+            usage = (payload.get("info") or {}).get("total_token_usage") if payload.get("type") == "token_count" else None
+            moment = parse_time(record.get("timestamp"))
+            if not usage or moment is None:
+                continue
+            if moment < start:
+                before = usage
+            elif moment <= end:
+                after = usage
+        if not matched or after is None:
+            continue
+        before = before or {}
+        delta = {k: int(after.get(k) or 0) - int(before.get(k) or 0) for k in
+                 ("input_tokens", "cached_input_tokens", "cache_write_input_tokens", "output_tokens", "total_tokens")}
+        result["cache_read"] += delta["cached_input_tokens"]
+        result["cache_write"] += delta["cache_write_input_tokens"]
+        result["input"] += delta["input_tokens"] - delta["cached_input_tokens"]
+        result["output"] += delta["output_tokens"]
+        result["total"] += delta["total_tokens"]
+        result["sessions"] += 1
+    return result if result["sessions"] else None
+
+
+def gemini_tokens(run, home, start, end):
+    root = Path(home) / ".gemini" / "tmp"
+    if not root.is_dir():
+        return None
+    session = run["session"].get("id") if isinstance(run["session"].get("id"), str) else None
+    project = hashlib.sha256(run["cwd"].encode("utf-8")).hexdigest() if run["cwd"] else None
+    result = _empty("gemini", "~/.gemini/tmp/*/chats (tokens)")
+    result["approximate"] = not session
+    for path in glob.glob(str(root / "*" / "chats" / "session-*.json*")):
+        if os.path.getmtime(path) < start - 60:
+            continue
+        try:
+            if path.endswith(".jsonl"):
+                records = [json.loads(raw) for raw in _lines(path) if raw.strip()]
+                header = records[0] if records else {}
+                messages = records[1:]
+            else:
+                header = json.loads(Path(path).read_text(encoding="utf-8"))
+                messages = header.get("messages", [])
+        except (ValueError, OSError, AttributeError):
+            continue
+        if not isinstance(header, dict):
+            continue
+        if not ((session and header.get("sessionId") == session) or (not session and project and header.get("projectHash") == project)):
+            continue
+        latest = {}
+        for message in messages:
+            if isinstance(message, dict) and message.get("type") == "gemini" and isinstance(message.get("tokens"), dict):
+                moment = parse_time(message.get("timestamp"))
+                if moment is not None and start <= moment <= end:
+                    latest[message.get("id") or id(message)] = message["tokens"]
+        if not latest:
+            continue
+        result["sessions"] += 1
+        for tokens in latest.values():
+            cached = int(tokens.get("cached") or 0)
+            result["input"] += int(tokens.get("input") or 0) - cached
+            result["cache_read"] += cached
+            result["output"] += int(tokens.get("output") or 0) + int(tokens.get("thoughts") or 0)
+            result["total"] += int(tokens.get("total") or 0)
+    return result if result["sessions"] else None
+
+
+def devin_tokens(run, home, start, end):
+    path = Path(home) / ".local" / "share" / "devin" / "cli" / "sessions.db"
+    if not path.is_file():
+        return None
+    session = run["session"].get("id") if isinstance(run["session"].get("id"), str) else None
+    result = _empty("devin", "~/.local/share/devin/cli/sessions.db (metrics)")
+    result["approximate"] = not session
+    try:
+        db = sqlite3.connect("file:" + str(path) + "?mode=ro", uri=True, timeout=1)
+    except sqlite3.Error:
+        return None
+    try:
+        if session:
+            ids = [r[0] for r in db.execute("SELECT id FROM sessions WHERE id = ?", (session,))]
+        elif run["cwd"]:
+            ids = [r[0] for r in db.execute("SELECT id FROM sessions WHERE working_directory = ? AND last_activity_at >= ?",
+                                            (run["cwd"], int(start)))]
+        else:
+            ids = []
+        for sid in ids:
+            counted = False
+            for (raw,) in db.execute("SELECT chat_message FROM message_nodes WHERE session_id = ? AND created_at BETWEEN ? AND ?",
+                                     (sid, int(start), int(end) + 1)):
+                try:
+                    metrics = ((json.loads(raw).get("metadata") or {}).get("metrics") or {})
+                except (ValueError, AttributeError):
+                    continue
+                if not metrics:
+                    continue
+                counted = True
+                result["input"] += int(metrics.get("input_tokens") or 0)
+                result["output"] += int(metrics.get("output_tokens") or 0)
+                result["cache_read"] += int(metrics.get("cache_read_tokens") or 0)
+                result["cache_write"] += int(metrics.get("cache_creation_tokens") or 0)
+            result["sessions"] += counted
+    except sqlite3.Error:
+        return None
+    finally:
+        db.close()
+    result["total"] = result["input"] + result["output"] + result["cache_read"] + result["cache_write"]
+    return result if result["sessions"] else None
+
+
+READERS = {"claude": claude_tokens, "codex": codex_tokens, "gemini": gemini_tokens, "gemini-cli": gemini_tokens,
+           "devin": devin_tokens}
+
+
+def tokens(run, home, now=None):
+    """Usage for the run's host and window, or None ("n/d") when the host keeps no readable usage."""
+    reader = READERS.get(run["host"])
+    if reader is None:
+        return None
+    start, end = window(run, now)
+    if start is None:
+        return None
+    try:
+        return reader(run, Path(home), start, end)
+    except (OSError, ValueError, TypeError, sqlite3.Error):
+        return None
+
+
+# --- rendering --------------------------------------------------------------------------
+
+def human(n):
+    n = int(n)
+    for size, suffix in ((1_000_000_000, "B"), (1_000_000, "M"), (1_000, "k")):
+        if n >= size:
+            value = n / size
+            return ("%.2f" % value if value < 10 else "%.1f" % value).rstrip("0").rstrip(".") + suffix
+    return str(n)
+
+
+def duration(seconds):
+    seconds = max(0, int(seconds))
+    hours, rest = divmod(seconds, 3600)
+    minutes, secs = divmod(rest, 60)
+    return "%dh%02dm" % (hours, minutes) if hours else ("%dm%02ds" % (minutes, secs) if minutes else "%ds" % secs)
+
+
+def unicode_ok(stream=None):
+    encoding = (getattr(stream or sys.stdout, "encoding", None) or "").lower()
+    return "utf" in encoding
+
+
+def bar(fraction, width=20, unicode=True):
+    filled = int(round(min(1.0, max(0.0, fraction)) * width))
+    if unicode:
+        return "█" * filled + "░" * (width - filled)
+    return "[" + "#" * filled + "-" * (width - filled) + "]"
+
+
+class Palette:
+    CODES = {"done": "32", "running": "36", "failed": "31", "pending": "90", "skipped": "90", "bold": "1", "dim": "2",
+             "cancelled": "33"}
+
+    def __init__(self, enabled):
+        self.enabled = enabled
+
+    def __call__(self, kind, text):
+        return "\x1b[" + self.CODES[kind] + "m" + text + "\x1b[0m" if self.enabled and kind in self.CODES else text
+
+
+def color_enabled(stream=None):
+    stream = stream or sys.stdout
+    return bool(getattr(stream, "isatty", lambda: False)()) and not os.environ.get("NO_COLOR") and os.environ.get("TERM") != "dumb"
+
+
+ICONS = {"done": ("✓", "x"), "running": ("▸", ">"), "failed": ("✗", "!"), "pending": ("·", "."), "skipped": ("–", "-")}
+
+
+def token_text(usage, unicode=True):
+    if not usage:
+        return "tokens n/d"
+    dot = " · " if unicode else ", "
+    text = "tokens " + human(usage["total"]) + " (in " + human(usage["input"]) + dot + "out " + human(usage["output"])
+    if usage["cache_read"] or usage["cache_write"]:
+        text += dot + "cache " + human(usage["cache_read"] + usage["cache_write"])
+    text += ")"
+    if usage["approximate"]:
+        text += " ~" + str(usage["sessions"]) + " sessão(ões) do host no diretório"
+    return text
+
+
+def render(run, usage=None, now=None, color=False, unicode=True, width=20):
+    now = now or time.time()
+    paint = Palette(color)
+    info = summary(run)
+    start, _ = window(run, now)
+    end = parse_time(run.get("endedAt")) if run["status"] in FINISHED else None
+    elapsed = duration((end or now) - start) if start else "n/d"
+    lines = [paint("bold", "crow ▸ " if unicode else "crow > ") + paint("bold", run["title"]) +
+             "  [" + (" · " if unicode else " - ").join((run["host"], run["status"], elapsed)) + "]",
+             bar(info["progress"], width, unicode) + " " + str(int(info["progress"] * 100)).rjust(3) + "%  " +
+             str(info["done"]) + "/" + str(info["total"]) + " unidades" +
+             (" - " + str(info["failed"]) + " falha(s)" if info["failed"] else "") + "  " + token_text(usage, unicode)]
+    phase_ids = [p["id"] for p in run["phases"]]
+    groups = [(p, [u for u in run["units"] if u["phase"] == p["id"]]) for p in run["phases"]]
+    loose = [u for u in run["units"] if u["phase"] not in phase_ids]
+    if loose:
+        groups.append(({"id": None, "title": "(sem fase)", "status": None}, loose))
+    for index, (phase, units) in enumerate(groups):
+        last_phase = index == len(groups) - 1
+        done = sum(u["status"] in ("done", "skipped") for u in units)
+        branch = ("└─ " if last_phase else "├─ ") if unicode else ("`- " if last_phase else "|- ")
+        lines.append(branch + paint("bold", phase["title"]) + "  " + str(done) + "/" + str(len(units)))
+        for position, unit in enumerate(units):
+            stem = ("   " if last_phase else ("│  " if unicode else "|  "))
+            twig = ("└─ " if position == len(units) - 1 else "├─ ") if unicode else ("`- " if position == len(units) - 1 else "|- ")
+            icon = ICONS[unit["status"]][0 if unicode else 1]
+            took = ""
+            if parse_time(unit["startedAt"]):
+                took = " " + duration((parse_time(unit["endedAt"]) or now) - parse_time(unit["startedAt"]))
+            owner = " @" + unit["owner"] if unit["owner"] else ""
+            line = (stem + twig + paint(unit["status"], icon + " " + unit["title"]) + "  " +
+                    bar(unit["progress"], 10, unicode) + " " + str(int(unit["progress"] * 100)).rjust(3) + "%" + owner + took)
+            lines.append(line)
+            if unit["summary"] and unit["status"] in ("done", "failed"):
+                lines.append(stem + "   " + paint("dim", unit["summary"]))
+    return "\n".join(lines)
+
+
+def compact(run, usage=None, unicode=True, width=10):
+    info = summary(run)
+    mark = "✓" if run["status"] == "done" else ("✗" if run["status"] in ("failed", "cancelled") else "▸")
+    if not unicode:
+        mark = {"✓": "ok", "✗": "x", "▸": ">"}[mark]
+    text = "crow " + mark + " " + safe(run["title"], 32) + " " + str(info["done"]) + "/" + str(info["total"]) + " " + \
+        bar(info["progress"], width, unicode) + " " + str(int(info["progress"] * 100)) + "%"
+    if usage:
+        text += (" · " if unicode else " - ") + ("~" if usage.get("approximate") else "") + human(usage["total"]) + " tok"
+    return text
+
+
+# --- entry points -------------------------------------------------------------------------
+
+def snapshot(cwd, home, run_id=None, now=None):
+    run = select(discover(cwd, home), cwd, run_id)
+    if run is None:
+        return None, None
+    return run, tokens(run, home, now)
+
+
+def as_json(run, usage):
+    if run is None:
+        return {"run": None, "tokens": None}
+    view = {k: v for k, v in run.items() if k not in ("mtime",)}
+    return {"run": view, "summary": summary(run), "tokens": usage}
+
+
+def watch(cwd, home, run_id=None, interval=1.0, stream=None, linger=5.0, max_frames=None):
+    """Redraw with ANSI until interrupted, or shortly after the run finishes."""
+    stream = stream or sys.stdout
+    color, uni = color_enabled(stream), unicode_ok(stream)
+    finished_at, frames, usage, last_tokens = None, 0, None, 0.0
+    try:
+        while True:
+            run = select(discover(cwd, home), cwd, run_id)
+            if run is not None and time.time() - last_tokens >= 5:
+                usage, last_tokens = tokens(run, home), time.time()
+            text = render(run, usage, color=color, unicode=uni) if run else "crow: nenhuma execução registrada neste diretório."
+            stream.write("\x1b[H\x1b[2J" + text + "\n")
+            stream.flush()
+            frames += 1
+            if max_frames is not None and frames >= max_frames:
+                return 0
+            if run is not None and run["status"] in FINISHED:
+                finished_at = finished_at or time.time()
+                if time.time() - finished_at >= linger:
+                    return 0
+            time.sleep(interval)
+    except KeyboardInterrupt:
+        return 0
+
+
+def statusline(home, stdin_text, chain=None):
+    """Claude Code statusLine: one line; the previous status line (if chained) comes first."""
+    try:
+        payload = json.loads(stdin_text) if stdin_text.strip() else {}
+    except ValueError:
+        payload = {}
+    if not isinstance(payload, dict):
+        payload = {}
+    cwd = (payload.get("workspace") or {}).get("current_dir") or payload.get("cwd") or os.getcwd()
+    transcript = payload.get("transcript_path")
+    session = payload.get("session_id")
+    if not (isinstance(session, str) and session):
+        session = Path(transcript).stem if isinstance(transcript, str) and transcript.endswith(".jsonl") else None
+    previous = ""
+    if chain:
+        try:
+            done = subprocess.run(chain, shell=True, input=stdin_text, capture_output=True, text=True, timeout=5)
+            # Keep the user's status line as it printed it (every line, inner spacing); only the
+            # trailing newline goes, so the crow segment joins its last line.
+            previous = done.stdout.rstrip("\r\n")
+        except (OSError, subprocess.SubprocessError):
+            previous = ""
+    run = select(discover(cwd, home), cwd, strict=True, session=session)
+    ours = ""
+    if active(run):
+        if run["host"] == "claude" and not run["session"].get("id") and session:
+            # The status line knows its own session: exact usage instead of every session in the directory.
+            try:
+                usage = claude_tokens(dict(run, session={"id": session}), Path(home), *window(run))
+            except (OSError, ValueError, TypeError):
+                usage = None
+        else:
+            usage = tokens(run, home)
+        ours = compact(run, usage)
+    if not previous.strip():
+        return ours
+    if not ours:
+        return previous
+    return previous + " │ " + ours
+
+
+def tmux_segment(home, cwd):
+    run = select(discover(cwd, home), cwd, strict=True)
+    if not active(run):
+        return ""
+    return compact(run, tokens(run, home), unicode=True, width=8).replace("#", "##")
+
+
+def main(argv=None):
+    import argparse
+    p = argparse.ArgumentParser(prog="crow_progress", description="Painel de progresso de execuções crow-behaviour.")
+    p.add_argument("mode", nargs="?", default="show", choices=("show", "watch", "json", "statusline", "tmux"))
+    p.add_argument("--run")
+    p.add_argument("--cwd", default=None)
+    p.add_argument("--home", default=None)
+    p.add_argument("--chain-file", default=None, help="JSON com o comando de status line anterior, encadeado antes do crow")
+    args = p.parse_args(argv)
+    home = Path(args.home).expanduser() if args.home else Path.home()
+    cwd = args.cwd or os.getcwd()
+    if args.mode == "statusline":
+        chain = None
+        if args.chain_file:
+            try:
+                chain = json.loads(Path(args.chain_file).read_text(encoding="utf-8")).get("command")
+            except (OSError, ValueError, AttributeError):
+                chain = None
+        print(statusline(home, sys.stdin.read() if not sys.stdin.isatty() else "", chain))
+        return 0
+    if args.mode == "tmux":
+        print(tmux_segment(home, cwd))
+        return 0
+    if args.mode == "watch":
+        return watch(cwd, home, args.run)
+    run, usage = snapshot(cwd, home, args.run)
+    if args.mode == "json":
+        print(json.dumps(as_json(run, usage), ensure_ascii=False))
+    elif run is None:
+        print("crow: nenhuma execução registrada neste diretório.")
+    else:
+        print(render(run, usage, color=color_enabled(), unicode=unicode_ok()))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())