@polymorphism-tech/morph-spec 9.7.0 → 10.0.0

package/framework/hooks/claude-code/statusline.py

@@ -1,699 +0,0 @@
-#!/usr/bin/env python3
-# framework/hooks/claude-code/statusline.py
-# Claude Code statusline for morph-spec.
-# Receives JSON via stdin from Claude Code after each response.
-#
-# DESIGN RULE — the payload is the source of truth.
-# Anything Claude Code already computes (context %, rate limits, worktree,
-# repo, PR) is READ from stdin, never recomputed. Recomputing is what made
-# previous versions drift away from /context and /usage. Only two things come
-# from outside the payload: git diff stats and the MORPH feature state.
-#
-# ONE LINE — the layout is deliberately a single row:
-#
-#   <model·effort> │ <context bar ↻ tokens-to-compact> │ <5h> │ <7d> │ <branch> │ <PR>
-#
-# The only second line is the MORPH block, and only inside a secondary
-# worktree. Everything else that used to occupy rows — the session name, the
-# session clock, the last Skill/Agent, the output style — was cut as noise.
-# Dropping the Skill/Agent widgets is also what lets this script stop parsing
-# the transcript entirely.
-#
-# The statusline is STATELESS — it never writes to disk. An earlier version
-# cached session start times per-cwd and per-transcript; the cwd cache leaked
-# start times between concurrent windows and the directory grew to thousands
-# of files. Removing the clock removed the need for any of it.
-
-import sys
-import json
-import os
-import subprocess
-import re
-import time
-import traceback
-from pathlib import Path
-
-# Ensure UTF-8 output on Windows (stdout defaults to CP1252 otherwise)
-if hasattr(sys.stdout, 'reconfigure'):
-    sys.stdout.reconfigure(encoding='utf-8')
-
-# ANSI colors
-R = '\033[0m'       # Reset
-BOLD = '\033[1m'
-CYAN = '\033[36m'
-GREEN = '\033[32m'
-YELLOW = '\033[33m'
-RED = '\033[31m'
-BLUE = '\033[34m'
-GRAY = '\033[90m'
-WHITE = '\033[97m'
-
-# Windows: flag to hide console window when spawning subprocesses
-_CREATE_NO_WINDOW = 0x08000000 if os.name == 'nt' else 0
-
-SEP = f" {GRAY}│{R} "
-
-
-# ── MORPH framework constants ────────────────────────────────────────────────
-
-# Mirrors derivePhaseFrom() in framework/hooks/shared/state-reader.js — the
-# first phase (scanning backwards) whose CANONICAL artifact exists wins. An
-# empty folder is not enough; a canonical ending in '/' is any .md under it.
-PHASE_MAP = [
-    ('4-review',    'review',    'verifier.md'),
-    ('3-implement', 'implement', 'reports/'),
-    ('1-design',    'uiux',      'design-system.md'),
-    ('2-plan',      'plan',      'plan.md'),
-]
-PHASE_INDEX = {'plan': 0, 'uiux': 1, 'implement': 2, 'review': 3}
-PHASE_LABELS = {
-    'plan':      'planning',
-    'uiux':      'UI/UX',
-    'implement': 'implement',
-    'review':    'review',
-}
-PIPELINE_TOTAL = 4
-
-# Gates that can block; `implement` has none. Mirrors feature.schema.json.
-GATE_PHASES = ('plan', 'uiux', 'review')
-
-
-# ── Auto-compact threshold ───────────────────────────────────────────────────
-#
-# Mirrors claude.exe v2.1.220. The context bar's headline number is the
-# payload's own `used_percentage` (a fraction of the MODEL window), but
-# auto-compact fires much earlier, against a different budget:
-#
-#   l7(model, cfg).window = min(modelWindow, autoCompactWindow)   [settings]
-#   HSe(model, cfg)       = window - min(maxOutputTokens, 20000)
-#   wfo(e)                = e - 13000
-#   threshold             = wfo(HSe(...))
-#
-# maxOutputTokens is >= 20000 on every current model, so the output reserve is
-# a flat 20000. This is only reproducible when `autoCompactWindow` is set
-# explicitly in settings (source "settings"); every other source (clientdata,
-# experiment, model-default, auto) is server-driven and cannot be mirrored
-# here, so the widget hides itself instead of guessing.
-COMPACT_OUTPUT_RESERVE = 20000
-COMPACT_HEADROOM = 13000
-
-
-# ── General helpers ──────────────────────────────────────────────────────────
-
-def safe_int(val, default=0):
-    """Safely convert value to int, handling None from JSON null."""
-    if val is None:
-        return default
-    try:
-        return int(val)
-    except (TypeError, ValueError):
-        return default
-
-
-def safe_float(val, default=0.0):
-    """Safely convert value to float, handling None from JSON null."""
-    if val is None:
-        return default
-    try:
-        return float(val)
-    except (TypeError, ValueError):
-        return default
-
-
-def usage_color(pct):
-    """Color for a 0-100 usage gauge. Thresholds from the Claude Code docs."""
-    if pct < 70:
-        return GREEN
-    if pct < 90:
-        return YELLOW
-    return RED
-
-
-_EIGHTHS = '▏▎▍▌▋▊▉'
-
-
-def progress_bar(pct, width=8):
-    """Gauge with sub-cell resolution.
-
-    Whole blocks alone are too coarse for the 5-wide rate-limit gauges: at
-    width 5 a real 13% would render completely empty. The eighth-block glyphs
-    keep small-but-nonzero values visible.
-    """
-    pct = max(0.0, min(100.0, pct))
-    exact = pct / 100 * width
-    filled = int(exact)
-    bar = '█' * filled
-    if filled < width:
-        remainder = int((exact - filled) * 8)
-        if remainder:
-            bar += _EIGHTHS[remainder - 1]
-    return bar + '░' * (width - len(bar))
-
-
-def format_tokens(n):
-    if n >= 1_000_000:
-        value = f"{n / 1_000_000:.1f}"
-        return f"{value[:-2] if value.endswith('.0') else value}M"
-    if n >= 1000:
-        return f"{n // 1000}k"
-    return str(n)
-
-
-def format_countdown(epoch):
-    """Time until a Unix epoch: 47m, 1h48, 6d16. None when already past."""
-    remaining = epoch - time.time()
-    if remaining <= 0:
-        return None
-    days, rest = int(remaining // 86400), int(remaining % 86400)
-    hours, minutes = rest // 3600, (rest % 3600) // 60
-    if days:
-        return f"{days}d{hours:02d}"
-    if hours:
-        return f"{hours}h{minutes:02d}"
-    return f"{minutes}m"
-
-
-# Both CSI colour codes and OSC sequences. The OSC branch matters: an OSC 8
-# hyperlink carries the whole URL as an invisible payload, and counting it
-# would make a 9-character PR badge measure the length of its GitHub URL.
-_ANSI_RE = re.compile(r'\033\][^\a\033]*(?:\a|\033\\)|\033\[[0-9;]*m')
-
-# Glyphs terminals render double-width. Deliberately narrow: the block and
-# arrow glyphs this script draws gauges with (█ ░ ▏▎▍▌▋▊▉ ↑ ↓ ↻ ► ✓ ✗) are all
-# SINGLE width, and treating the whole U+2100+ range as wide overcounted the
-# budget line by ~20 columns, dropping widgets that would have fit.
-#
-# Any new glyph below U+1F300 must be listed here or it is measured as 1.
-# ⏳ (U+23F3) is the live case: it has Emoji_Presentation=Yes so it renders
-# double, unlike its lookalike ⏱ (U+23F1), which renders as narrow text.
-_WIDE_SINGLES = frozenset('⚡⛔⬛⬜✅❌⏳')
-
-
-def char_width(ch):
-    code = ord(ch)
-    if 0x1F300 <= code <= 0x1FAFF:   # emoji planes
-        return 2
-    return 2 if ch in _WIDE_SINGLES else 1
-
-
-def visible_width(text):
-    """Rendered width: escape sequences stripped, emoji counted double."""
-    return sum(char_width(ch) for ch in _ANSI_RE.sub('', text))
-
-
-def join_to_width(parts, columns):
-    """Join `parts` with SEP, dropping the lowest-priority ones until it fits.
-
-    `parts` is a list of (priority, text); lower priority number = keep longer.
-    `columns` comes from the COLUMNS env var Claude Code exports before running
-    the status line (tput does not work — stdout is captured, not a terminal).
-    """
-    kept = [p for p in parts if p[1]]
-    if not kept:
-        return ''
-    sep_width = visible_width(SEP)
-
-    def total(items):
-        return (sum(visible_width(text) for _, text in items)
-                + sep_width * max(0, len(items) - 1))
-
-    if columns:
-        # Drop the worst priority first, but never drop the single best item.
-        while len(kept) > 1 and total(kept) > columns:
-            worst = max(range(len(kept)), key=lambda i: kept[i][0])
-            kept.pop(worst)
-    return SEP.join(text for _, text in kept)
-
-
-def read_user_settings():
-    """Read the user settings (for autoCompactWindow). Never raises.
-
-    Honours CLAUDE_CONFIG_DIR, the same override Claude Code itself uses to
-    relocate ~/.claude.
-    """
-    try:
-        base = os.environ.get('CLAUDE_CONFIG_DIR')
-        path = (Path(base) if base else Path.home() / '.claude') / 'settings.json'
-        data = json.loads(path.read_text(encoding='utf-8'))
-        return data if isinstance(data, dict) else {}
-    except Exception:
-        return {}
-
-
-# ── Git helpers ───────────────────────────────────────────────────────────────
-
-def _run_git(args, cwd):
-    """Run a git command safely on Windows (no console popup, with timeout)."""
-    return subprocess.check_output(
-        ['git'] + args,
-        cwd=cwd, stderr=subprocess.DEVNULL, timeout=3,
-        creationflags=_CREATE_NO_WINDOW,
-    ).decode('utf-8', 'replace').strip()
-
-
-def get_git_info(cwd):
-    """Branch, ahead/behind, changed files and line diff.
-
-    A single `status --porcelain=v2 --branch -uno` covers branch, upstream
-    divergence and the file count. `-uno` matters: v2 lists untracked entries
-    by default, which would silently change what the file count means. The
-    shortstat call is skipped entirely on a clean tree.
-    """
-    try:
-        out = _run_git(['status', '--porcelain=v2', '--branch', '-uno'], cwd)
-    except Exception:
-        return ''
-
-    branch, ahead, behind, files = '', 0, 0, 0
-    for line in out.splitlines():
-        if line.startswith('# branch.head '):
-            branch = line[len('# branch.head '):].strip()
-        elif line.startswith('# branch.ab '):
-            # Only present when an upstream is configured.
-            match = re.match(r'# branch\.ab \+(\d+) -(\d+)', line)
-            if match:
-                ahead, behind = int(match.group(1)), int(match.group(2))
-        elif line[:1] in ('1', '2', 'u'):
-            files += 1
-
-    if not branch:
-        return ''
-
-    ins, dels = 0, 0
-    if files:
-        try:
-            stat = _run_git(['diff', 'HEAD', '--shortstat'], cwd)
-            match = re.search(r'(\d+) insertion', stat)
-            if match:
-                ins = int(match.group(1))
-            match = re.search(r'(\d+) deletion', stat)
-            if match:
-                dels = int(match.group(1))
-        except Exception:
-            pass
-
-    parts = [f"{BLUE} {branch}{R}"]
-    if ahead or behind:
-        divergence = ''
-        if ahead:
-            divergence += f"{GREEN}↑{ahead}{R}"
-        if behind:
-            divergence += f"{RED}↓{behind}{R}"
-        parts.append(divergence)
-    if ins or dels:
-        parts.append(f"{GREEN}+{ins}{RED}-{dels}{R}")
-    return ' '.join(parts)
-
-
-# ── Transcript helpers ────────────────────────────────────────────────────────
-
-def get_worktree_label(payload, cwd):
-    """Worktree name for this session, or None when in the primary worktree.
-
-    Cascade: the payload's own `worktree` (--worktree sessions), then
-    `workspace.git_worktree` (any linked worktree), then — only when both are
-    absent AND this looks like a morph project — the git subprocess earlier
-    versions always paid for. The fallback keeps behaviour identical on builds
-    or worktree layouts where those fields do not appear.
-    """
-    worktree = payload.get('worktree') or {}
-    if worktree.get('name'):
-        branch = (worktree.get('branch') or '').replace('refs/heads/', '')
-        return branch or worktree['name']
-
-    git_worktree = (payload.get('workspace') or {}).get('git_worktree')
-    if git_worktree:
-        return git_worktree
-
-    if not (Path(cwd) / '.morph' / 'features').is_dir():
-        return None
-    try:
-        out = _run_git(['worktree', 'list', '--porcelain'], cwd)
-    except Exception:
-        return None
-    entries, current = [], {}
-    for line in out.splitlines():
-        if line.startswith('worktree '):
-            if current:
-                entries.append(current)
-            current = {'path': line.split(' ', 1)[1]}
-        elif line.startswith('branch '):
-            current['branch'] = line.split(' ', 1)[1]
-    if current:
-        entries.append(current)
-    if len(entries) > 1:
-        try:
-            cwd_resolved = str(Path(cwd).resolve())
-        except Exception:
-            return None
-        for entry in entries[1:]:  # entry 0 is always the primary worktree
-            try:
-                same = str(Path(entry.get('path', '')).resolve()) == cwd_resolved
-            except Exception:
-                same = False
-            if same:
-                return entry.get('branch', '').replace('refs/heads/', '') or None
-    return None
-
-
-def _gate_implied_phase(gates, design_started):
-    """Phase implied purely by approved gates (mirrors state-reader.js)."""
-    def approved(gate):
-        return (gates.get(gate) or {}).get('approved') is True
-    if approved('review'):
-        return 'review'
-    if approved('plan'):
-        return 'uiux' if design_started and not approved('uiux') else 'implement'
-    return 'plan'
-
-
-def _has_artifact(folder, canonical):
-    if not canonical.endswith('/'):
-        return (folder / canonical).exists()
-    try:
-        return any(p.is_file() for p in (folder / canonical).glob('*.md'))
-    except OSError:
-        return False
-
-
-def derive_phase(feature_dir, gates):
-    """Phase from the filesystem, bumped by approved gates."""
-    artifact_phase = 'plan'
-    for folder, phase, canonical in PHASE_MAP:
-        if _has_artifact(feature_dir / folder, canonical):
-            artifact_phase = phase
-            break
-    implied = _gate_implied_phase(gates, (feature_dir / '1-design').exists())
-    if PHASE_INDEX[implied] > PHASE_INDEX[artifact_phase]:
-        return implied
-    return artifact_phase
-
-
-PARTIAL_MARKER = re.compile(r'^[\s#>*_]*PARCIAL\b')
-BLOCKED_MARKER = re.compile(r'^[\s#>*_]*BLOQUEADO\b')
-
-
-def count_slices(feature_dir):
-    """(done, total) of the slices in 2-plan/checks.json.
-
-    Same rule as framework/hooks/shared/slice-progress.js: a slice is done when
-    3-implement/reports/{id}.md exists and its first line is neither PARCIAL nor BLOQUEADO.
-    """
-    try:
-        slices = json.loads((feature_dir / '2-plan' / 'checks.json').read_text(encoding='utf-8')).get('slices')
-    except Exception:
-        return 0, 0
-    if not isinstance(slices, list):
-        return 0, 0
-    ids = [s.get('id') for s in slices if isinstance(s, dict) and isinstance(s.get('id'), str)]
-    done = 0
-    for slice_id in ids:
-        try:
-            text = (feature_dir / '3-implement' / 'reports' / f'{slice_id}.md').read_text(encoding='utf-8')
-        except Exception:
-            continue
-        first = next((line for line in text.splitlines() if line.strip()), '')
-        if not PARTIAL_MARKER.match(first) and not BLOCKED_MARKER.match(first):
-            done += 1
-    return done, len(ids)
-
-
-def get_active_features(cwd):
-    """in_progress features from the authoritative per-feature state.
-
-    Reads .morph/features/*/feature.json. The root .morph/state.json is a thin,
-    gitignored, derivable index and must not be trusted here.
-    """
-    base = Path(cwd) / '.morph' / 'features'
-    if not base.is_dir():
-        return []
-    try:
-        feature_files = sorted(base.glob('*/feature.json'))
-    except Exception:
-        return []
-
-    result = []
-    for path in feature_files:
-        try:
-            data = json.loads(path.read_text(encoding='utf-8'))
-        except Exception:
-            continue
-        if not isinstance(data, dict) or data.get('status') != 'in_progress':
-            continue
-        feature_dir = path.parent
-        gates = data.get('approvalGates') or {}
-        phase = derive_phase(feature_dir, gates)
-        done, total = count_slices(feature_dir)
-        pending = None
-        if phase in GATE_PHASES and (gates.get(phase) or {}).get('approved') is not True:
-            pending = phase
-        result.append({
-            'name':        feature_dir.name,
-            'phase':       phase,
-            'slices_done':  done,
-            'slices_total': total,
-            'pending':     pending,
-        })
-    return result
-
-
-# ── Line renderers ────────────────────────────────────────────────────────────
-
-def render_morph_line(feature, columns):
-    """Line 0 — the active MORPH feature.
-
-    Goes through join_to_width like the status line: a feature name plus phase,
-    slice bar and gate is the longest thing this script prints, and a
-    wrapping line 0 would defeat the whole point of the single-row layout.
-    """
-    parts = [(0, f"{CYAN}{BOLD}► {feature['name']}{R}")]
-
-    phase = feature['phase']
-    label = PHASE_LABELS.get(phase, phase)
-    position = PHASE_INDEX.get(phase)
-    if position is None:
-        parts.append((1, f"{CYAN}{label}{R}"))
-    else:
-        parts.append((1, f"{CYAN}{label} {position + 1}/{PIPELINE_TOTAL}{R}"))
-
-    if feature['slices_total'] > 0:
-        pct = feature['slices_done'] / feature['slices_total'] * 100
-        parts.append((
-            3,
-            f"{GREEN}{progress_bar(pct, 6)} "
-            f"{feature['slices_done']}/{feature['slices_total']} fatias{R}"
-        ))
-
-    if feature['pending']:
-        parts.append((2, f"{RED}⛔ gate: {feature['pending']}{R}"))
-
-    return join_to_width(parts, columns)
-
-
-def effective_window(payload, settings):
-    """The window /context measures against, or None when not reproducible.
-
-    NOT the model window. Measured against Claude Code 2.1.220 with
-    `autoCompactWindow: 680000`:
-
-        payload   total_input_tokens 289681, context_window_size 1000000,
-                  used_percentage 29        (= 289681 / 1000000)
-        /context  "289.7k/680k tokens (43%)" (= 289681 / 680000)
-
-    So the payload's own `used_percentage` divides by the MODEL window while
-    the app divides by the effective one. Taking `used_percentage` verbatim —
-    which is what this script did — is a 1.47x understatement at these
-    settings, and it is the divergence the whole rewrite set out to kill.
-    """
-    model_window = safe_int((payload.get('context_window') or {}).get('context_window_size'))
-    if model_window <= 0:
-        return None
-    if settings.get('autoCompactEnabled') is False:
-        return model_window
-    configured = safe_int(settings.get('autoCompactWindow'))
-    # Every other source of the window (clientdata, experiment, model-default,
-    # auto) is server-driven and cannot be mirrored here.
-    return min(model_window, configured) if configured > 0 else None
-
-
-def compact_threshold(payload, settings):
-    """Tokens at which auto-compact fires, or None when not reproducible."""
-    if settings.get('autoCompactEnabled') is False:
-        return None
-    if safe_int(settings.get('autoCompactWindow')) <= 0:
-        return None
-    window = effective_window(payload, settings)
-    if not window:
-        return None
-    # /context calls this the "Autocompact buffer" and reports it as 33k —
-    # exactly COMPACT_OUTPUT_RESERVE + COMPACT_HEADROOM.
-    threshold = window - COMPACT_OUTPUT_RESERVE - COMPACT_HEADROOM
-    return threshold if threshold > 0 else None
-
-
-def render_status_line(payload, cwd, settings, columns):
-    """The single status line — where you are and what you have left.
-
-    One bar only, on the context: it is the budget that moves fastest and the
-    one you act on. The account windows are numbers, coloured by the same
-    thresholds. Priority governs what a narrow terminal drops — the context
-    never goes, the weekly window goes first.
-
-    Deliberately NOT rendered, by the user's call: the session name, the
-    session clock, the last Skill/Agent, and the output style. Dropping the
-    last two is also what lets this script stop reading the transcript at all.
-    """
-    parts = []  # (priority, text) — the highest priority number is dropped first
-
-    model = payload.get('model') or {}
-    model_name = (model.get('display_name') or model.get('id') or ''
-                  if isinstance(model, dict) else str(model or ''))
-    if model_name:
-        short = (model_name
-                 .replace('Claude ', '')
-                 .replace('claude-', '')
-                 .replace(' (1M context)', ' 1M')
-                 .replace(' (claude.ai)', ''))
-        # Only surface state that is NOT the default: thinking is normally on,
-        # fast mode normally off. `permission_mode` is deliberately absent —
-        # Claude Code never sends it to the status line, only to hooks.
-        state = []
-        effort = (payload.get('effort') or {}).get('level')
-        if effort:
-            state.append(effort)
-        if (payload.get('thinking') or {}).get('enabled') is False:
-            state.append('no-think')
-        if payload.get('fast_mode'):
-            state.append('fast')
-        suffix = f"{GRAY}·{chr(183).join(state)}{R}" if state else ''
-        parts.append((3, f"{WHITE}{short}{R}{suffix}"))
-
-    context = payload.get('context_window') or {}
-    if context:
-        model_window = safe_int(context.get('context_window_size'))
-        tokens = safe_int(context.get('total_input_tokens'))
-        if not tokens:
-            # Null right after /compact and before the first API response.
-            # Recompute with the app's own input-only formula — output_tokens
-            # is NOT part of it, and adding it is how earlier versions drifted.
-            usage = context.get('current_usage')
-            if isinstance(usage, dict):
-                tokens = (safe_int(usage.get('input_tokens'))
-                          + safe_int(usage.get('cache_creation_input_tokens'))
-                          + safe_int(usage.get('cache_read_input_tokens')))
-
-        # Divide by the same window /context does. Only when that window is
-        # not reproducible do we fall back to the payload's own percentage,
-        # which is measured against the model window instead.
-        window = effective_window(payload, settings)
-        pct = None
-        if window and tokens:
-            pct = tokens / window * 100
-        elif context.get('used_percentage') is not None:
-            pct = safe_float(context.get('used_percentage'))
-        elif model_window and tokens:
-            pct = tokens / model_window * 100
-
-        if pct is not None:
-            chunk = f"{usage_color(pct)}{progress_bar(pct, 8)} {pct:.0f}%{R}"
-            # How much still fits before auto-compact fires — /context reports
-            # the same number as "Free space". Same ↻ as the account windows:
-            # "how much is left until the next reset", each in its own unit —
-            # tokens here, time there.
-            threshold = compact_threshold(payload, settings)
-            if threshold and tokens:
-                left = threshold - tokens
-                if left <= 0:
-                    chunk += f" {RED}⚠ compactando{R}"
-                else:
-                    left_pct = left / threshold * 100
-                    color = GRAY if left_pct > 25 else (YELLOW if left_pct > 10 else RED)
-                    chunk += f" {color}↻ {format_tokens(left)}{R}"
-            parts.append((0, chunk))
-
-    # Claude.ai subscription windows. Present only for Pro/Max subscribers
-    # after the first API response; each window may be absent on its own.
-    #
-    # ⏳ is /usage's "Current session" and 📅 its "Current week (all models)".
-    # The icons cost the same two columns the "5h"/"7d" labels did, and they
-    # sidestep a real ambiguity: the app calls the short one a "session", but
-    # it is a 5-hour billing window that resets on its own clock, unrelated to
-    # the Claude Code session.
-    rate_limits = payload.get('rate_limits') or {}
-    for key, label, priority, countdown in (('five_hour', '⏳', 2, True),
-                                            ('seven_day', '📅', 5, False)):
-        window = rate_limits.get(key) or {}
-        raw_pct = window.get('used_percentage')
-        if raw_pct is None:
-            continue
-        pct = safe_float(raw_pct)
-        chunk = f"{GRAY}{label}{R} {usage_color(pct)}{pct:.0f}%{R}"
-        resets_at = window.get('resets_at') if countdown else None
-        if resets_at:
-            until = format_countdown(safe_float(resets_at))
-            if until:
-                chunk += f" {GRAY}↻ {until}{R}"
-        parts.append((priority, chunk))
-
-    git_info = get_git_info(cwd)
-    if git_info:
-        parts.append((1, git_info))
-
-    pull_request = payload.get('pr') or {}
-    if pull_request.get('number'):
-        review_state = pull_request.get('review_state')
-        mark = {'approved': '✓', 'changes_requested': '✗',
-                'draft': '·', 'pending': '…'}.get(review_state, '')
-        color = {'approved': GREEN, 'changes_requested': RED,
-                 'draft': GRAY}.get(review_state, YELLOW)
-        label = f"PR #{pull_request['number']} {mark}".strip()
-        url = pull_request.get('url')
-        if url:
-            # OSC 8 hyperlink — honoured by Windows Terminal, iTerm2, Kitty.
-            # visible_width() strips the OSC payload, so the URL costs no columns.
-            label = f"\033]8;;{url}\033\\{label}\033]8;;\033\\"
-        parts.append((4, f"{color}{label}{R}"))
-
-    return join_to_width(parts, columns)
-
-
-# ── Main ──────────────────────────────────────────────────────────────────────
-
-def main():
-    try:
-        raw = sys.stdin.read()
-        if not raw.strip():
-            sys.exit(0)
-        payload = json.loads(raw)
-        if not isinstance(payload, dict):
-            sys.exit(0)
-    except Exception:
-        sys.exit(0)
-
-    try:
-        workspace = payload.get('workspace') or {}
-        cwd = workspace.get('current_dir') or payload.get('cwd') or os.getcwd()
-        settings = read_user_settings()
-
-        # Claude Code exports COLUMNS before running the command; `tput cols`
-        # does not work here because stdout is captured, not a terminal.
-        columns = safe_int(os.environ.get('COLUMNS'), 0)
-
-        # The MORPH line is the ONLY second line, and only inside a secondary
-        # worktree. In the primary tree it resurrects stale feature names
-        # during unrelated work, so there the status line is a single row.
-        if get_worktree_label(payload, cwd):
-            for feature in get_active_features(cwd):
-                print(render_morph_line(feature, columns))
-
-        status_line = render_status_line(payload, cwd, settings, columns)
-        if status_line:
-            print(status_line)
-
-    except Exception:
-        err = traceback.format_exc().splitlines()[-1]
-        print(f"{RED}ERRO: {err}{R}")
-
-
-if __name__ == '__main__':
-    main()