@polymorphism-tech/morph-spec 8.6.0 → 8.8.0

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

@@ -1,18 +1,37 @@
 #!/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
+# 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 time
 import re
-import hashlib
+import time
 import traceback
 from pathlib import Path
-from datetime import datetime, timezone
 
 # Ensure UTF-8 output on Windows (stdout defaults to CP1252 otherwise)
 if hasattr(sys.stdout, 'reconfigure'):
@@ -22,7 +41,6 @@ if hasattr(sys.stdout, 'reconfigure'):
 R = '\033[0m'       # Reset
 BOLD = '\033[1m'
 CYAN = '\033[36m'
-MAGENTA = '\033[35m'
 GREEN = '\033[32m'
 YELLOW = '\033[33m'
 RED = '\033[31m'
@@ -33,51 +51,79 @@ 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 (derived from phases.json / trust-manager.js) ──
 
-PHASE_POSITIONS = {
-    'proposal': 1,
-    'uiux': 2, 'design': 2,
-    'plan': 3,
-    'tasks': 4,
-    'implement': 5, 'sync': 5,
-}
+# ── MORPH framework constants ────────────────────────────────────────────────
+
+# Mirrors derivePhase() in src/core/state/state-manager.js — the first phase
+# (scanning backwards) whose CANONICAL artifact exists wins. An empty folder
+# is not enough.
+PHASE_MAP = [
+    ('4-review',    'review',    'review-report.md'),
+    ('3-implement', 'implement', 'recap.md'),
+    ('2-plan',      'plan',      'spec.md'),
+    ('1-design',    'uiux',      'design-system.md'),
+    ('0-proposal',  'proposal',  'proposal.md'),
+]
+PHASE_INDEX = {'proposal': 0, 'uiux': 1, 'plan': 2, 'implement': 3, 'review': 4}
 PHASE_LABELS = {
-    'proposal': 'proposal',
-    'uiux': 'UI/UX',
-    'design': 'design',
-    'plan': 'planning',
-    'tasks': 'tasks',
+    'proposal':  'proposal',
+    'uiux':      'UI/UX',
+    'plan':      'planning',
     'implement': 'implement',
-    'sync': 'sync',
+    'review':    'review',
 }
 PIPELINE_TOTAL = 5
 
-# Approval gates per phase (from phases.json pausePoints)
-PHASE_GATES = {
-    'proposal': 'proposal',
-    'uiux':     'uiux',
-    'design':   'design',
-    'tasks':    'tasks',
-}
+# Gates that can block; `implement` has none. Mirrors feature.schema.json.
+GATE_PHASES = ('proposal', 'uiux', 'plan', '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
 
-# Trust level thresholds and badges (from trust-manager.js)
-# passRate >= threshold → level
-TRUST_LEVELS = [
-    (0.95, 'maximum', GREEN + BOLD, '◆◆◆◆'),
-    (0.90, 'high',    GREEN,        '◆◆◆○'),
-    (0.80, 'medium',  YELLOW,       '◆◆○○'),
-    (0.00, 'low',     RED,          '◆○○○'),
-]
 
-CHECKPOINT_FREQUENCY = 3  # matches llm-interaction.json default
+# ── 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
 
-# ── General helpers ──────────────────────────────────────────────────────────
 
-def ctx_color(pct):
-    """Color based on context usage. Thresholds from Claude Code docs: 70% / 90%."""
+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:
@@ -85,165 +131,115 @@ def ctx_color(pct):
     return RED
 
 
+_EIGHTHS = '▏▎▍▌▋▊▉'
+
+
 def progress_bar(pct, width=8):
-    filled = int(pct / 100 * width)
-    empty = width - filled
-    return f"{'█' * filled}{'░' * empty}"
+    """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:
-        return f"{n / 1_000_000:.1f}m"
+        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 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 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"
 
 
-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
+# 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('⚡⛔⬛⬜✅❌⏳')
 
-# ── MORPH feature helpers ────────────────────────────────────────────────────
 
-def calculate_trust(checkpoints):
-    """Return (level_str, color, pass_rate) from checkpoint array."""
-    if not checkpoints:
-        return 'none', GRAY, None  # no data — silent
-    total = len(checkpoints)
-    passed = sum(1 for c in checkpoints if c.get('passed'))
-    rate = passed / total
-    for threshold, level, color, _badge in TRUST_LEVELS:
-        if rate >= threshold:
-            return level, color, rate
-    return 'low', RED, 0.0
+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 get_checkpoint_countdown(tasks_done):
-    """Tasks remaining until next checkpoint fires (frequency=3)."""
-    if tasks_done <= 0:
-        return None
-    remaining = CHECKPOINT_FREQUENCY - (tasks_done % CHECKPOINT_FREQUENCY)
-    return 0 if remaining == CHECKPOINT_FREQUENCY else remaining
+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 get_session_feature_names(features_dict, entries):
-    """Return only feature names mentioned in the current session's transcript.
-    If a feature name appears in the transcript (tool calls, messages, results),
-    this session is actively working on it. Prevents showing features from other sessions.
-    """
-    if not features_dict or not entries:
-        return set()
-    # Serialize last 500 entries for search (avoids cost on long sessions)
-    recent = entries[-500:] if len(entries) > 500 else entries
-    transcript_text = json.dumps(recent, ensure_ascii=False)
-    return {name for name in features_dict if name in transcript_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 get_all_active_features(cwd, entries):
-    """Return in_progress features that are active in the current session.
+    def total(items):
+        return (sum(visible_width(text) for _, text in items)
+                + sep_width * max(0, len(items) - 1))
 
-    Caller is responsible for only calling this when inside a secondary worktree.
-    """
-    state_path = Path(cwd) / '.morph' / 'state.json'
-    if not state_path.exists():
-        return []
-    try:
-        state = json.loads(state_path.read_text(encoding='utf-8'))
-        features = state.get('features', {})
-
-        # Filter to features belonging to this session (mentioned in transcript)
-        session_names = get_session_feature_names(features, entries)
-
-        if not session_names:
-            return []
-
-        result = []
-        for name, feat in features.items():
-            if feat.get('status') != 'in_progress':
-                continue
-            if name not in session_names:
-                continue
-            phase    = feat.get('phase', '?')
-            tasks    = feat.get('tasks') or {}
-            done     = safe_int(tasks.get('completed'))
-            total    = safe_int(tasks.get('total'))
-            gates    = feat.get('approvalGates') or {}
-            checkpts = feat.get('checkpoints') or []
-
-            pending   = [g for g, v in gates.items() if not v.get('approved')]
-            trust_lvl, trust_color, trust_rate = calculate_trust(checkpts)
-            countdown = get_checkpoint_countdown(done)
-
-            result.append({
-                'name':        name,
-                'phase':       phase,
-                'tasks_done':  done,
-                'tasks_total': total,
-                'pending':     pending[0] if pending else None,
-                'trust_level': trust_lvl,
-                'trust_color': trust_color,
-                'countdown':   countdown,
-            })
-        return result
-    except Exception:
-        return []
+    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)
 
 
-# ── Activity log helpers ──────────────────────────────────────────────────────
+def read_user_settings():
+    """Read the user settings (for autoCompactWindow). Never raises.
 
-def get_activity_info(cwd):
-    """Read .morph/logs/activity.json and return compact summary dict.
-    Returns None if file is missing or unreadable.
+    Honours CLAUDE_CONFIG_DIR, the same override Claude Code itself uses to
+    relocate ~/.claude.
     """
-    activity_path = Path(cwd) / '.morph' / 'logs' / 'activity.json'
-    if not activity_path.exists():
-        return None
     try:
-        data = json.loads(activity_path.read_text(encoding='utf-8'))
-        hooks = data.get('hooks') or []
-        skills = data.get('skills') or []
-
-        last_hook = None
-        last_hook_age = None
-        if hooks:
-            last = hooks[-1]
-            last_hook = last.get('name', '')
-            # Try to compute age from timestamp (HH:MM:SS)
-            try:
-                ts = last.get('ts', '')
-                if ts and len(ts) == 8:
-                    now = datetime.now()
-                    hook_t = datetime.strptime(ts, '%H:%M:%S').replace(
-                        year=now.year, month=now.month, day=now.day
-                    )
-                    diff_s = (now - hook_t).total_seconds()
-                    if diff_s < 0:
-                        diff_s = 0
-                    if diff_s < 60:
-                        last_hook_age = f"{int(diff_s)}s"
-                    else:
-                        last_hook_age = f"{int(diff_s // 60)}m"
-            except Exception:
-                pass
-
-        return {
-            'hook_count': len(hooks),
-            'skill_count': len(skills),
-            'last_hook': last_hook,
-            'last_hook_age': last_hook_age,
-        }
+        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 None
+        return {}
 
 
 # ── Git helpers ───────────────────────────────────────────────────────────────
@@ -254,266 +250,413 @@ def _run_git(args, cwd):
         ['git'] + args,
         cwd=cwd, stderr=subprocess.DEVNULL, timeout=3,
         creationflags=_CREATE_NO_WINDOW,
-    ).decode().strip()
+    ).decode('utf-8', 'replace').strip()
 
 
 def get_git_info(cwd):
-    """Get git branch, files changed, line diff, and ahead/behind remote."""
-    try:
-        branch = _run_git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd)
+    """Branch, ahead/behind, changed files and line diff.
 
-        # Files with changes (staged + unstaged, no untracked)
-        files = 0
+    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:
-            status_out = _run_git(['status', '--porcelain', '--untracked-files=no'], cwd)
-            files = len([l for l in status_out.splitlines() if l.strip()])
+            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
 
-        # Lines inserted/removed vs HEAD
-        ins, dels = 0, 0
-        try:
-            out = _run_git(['diff', 'HEAD', '--shortstat'], cwd)
-            m = re.search(r'(\d+) insertion', out)
-            if m:
-                ins = int(m.group(1))
-            m = re.search(r'(\d+) deletion', out)
-            if m:
-                dels = int(m.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']
 
-        # Commits ahead/behind remote
-        ahead, behind = 0, 0
+    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:
-            ab = _run_git(['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'], cwd)
-            ahead, behind = (int(x) for x in ab.split('\t'))
+            cwd_resolved = str(Path(cwd).resolve())
         except Exception:
-            pass
+            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
 
-        parts = [f"{BLUE} {branch}{R}"]
-        if ahead or behind:
-            ab_str = ''
-            if ahead:  ab_str += f"{GREEN}↑{ahead}{R}"
-            if behind: ab_str += f"{RED}↓{behind}{R}"
-            parts.append(ab_str)
-        if files:
-            parts.append(f"{GRAY}{files} files{R}")
-        if ins or dels:
-            parts.append(f"{GREEN}+{ins}{R}{GRAY},{R}{RED}-{dels}{R}")
-
-        return ' '.join(parts)
-    except Exception:
-        return ""
+
+def _gate_implied_phase(gates):
+    """Phase implied purely by approved gates (mirrors state-manager.js)."""
+    def approved(gate):
+        return (gates.get(gate) or {}).get('approved') is True
+    if approved('review'):
+        return 'review'
+    if approved('plan'):
+        return 'implement'
+    if approved('uiux'):
+        return 'plan'
+    return 'proposal'
+
+
+def derive_phase(feature_dir, gates):
+    """Phase from the filesystem, bumped by approved gates."""
+    artifact_phase = 'proposal'
+    for folder, phase, canonical in PHASE_MAP:
+        if (feature_dir / folder / canonical).exists():
+            artifact_phase = phase
+            break
+    implied = _gate_implied_phase(gates)
+    if PHASE_INDEX[implied] > PHASE_INDEX[artifact_phase]:
+        return implied
+    return artifact_phase
 
 
-def get_worktree_data(cwd):
-    """Detect worktree status for cwd.
+def count_tasks(feature_dir, feature_json):
+    """(done, total) from 2-plan/tasks.json — the declared source of truth.
 
-    Returns (is_secondary: bool, display_str: str).
-    is_secondary is True only when cwd is a non-primary git worktree.
-    display_str is the formatted label (non-empty only when is_secondary).
-    Called once in main() to avoid duplicate git subprocess.
+    `skipped` counts as resolved: it will never be worked on, and leaving it
+    out would pin the bar below 100%. Falls back to feature.json's aggregate
+    counters, which the schema marks as informational.
     """
     try:
-        out = _run_git(['worktree', 'list', '--porcelain'], cwd)
-        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:
-            cwd_r = str(Path(cwd).resolve())
-            for entry in entries[1:]:
-                if str(Path(entry.get('path', '')).resolve()) == cwd_r:
-                    branch = entry.get('branch', '').replace('refs/heads/', '')
-                    return True, f"{MAGENTA}worktree:{branch}{R}"
+        raw = (feature_dir / '2-plan' / 'tasks.json').read_text(encoding='utf-8')
+        tasks = json.loads(raw).get('tasks')
+        if isinstance(tasks, list) and tasks:
+            done = sum(1 for task in tasks if task.get('status') in ('done', 'skipped'))
+            return done, len(tasks)
     except Exception:
         pass
-    return False, ""
+    aggregate = feature_json.get('tasks') or {}
+    return safe_int(aggregate.get('completed')), safe_int(aggregate.get('total'))
 
 
-def get_recent_tool_calls(entries):
-    """Scan the last 50 transcript entries for the most recent Skill and Agent tool calls.
+def get_active_features(cwd):
+    """in_progress features from the authoritative per-feature state.
 
-    Returns (last_skill_name, last_agent_name) — either may be None.
-    Looks at assistant messages containing tool_use blocks.
+    Reads .morph/features/*/feature.json. The root .morph/state.json is a thin,
+    gitignored, derivable index and must not be trusted here.
     """
-    last_skill = None
-    last_agent = None
-    recent = entries[-50:] if len(entries) > 50 else entries
-    for entry in reversed(recent):
-        if entry.get('isSidechain') or entry.get('isApiErrorMessage'):
-            continue
-        msg = entry.get('message') or {}
-        content = msg.get('content') or []
-        if not isinstance(content, list):
-            continue
-        # Within each entry, scan content from last to first to get most-recent call
-        for item in reversed(content):
-            if not isinstance(item, dict) or item.get('type') != 'tool_use':
-                continue
-            tool = item.get('name', '')
-            inp = item.get('input') or {}
-            if tool == 'Skill' and last_skill is None:
-                last_skill = inp.get('skill') or ''
-            elif tool == 'Agent' and last_agent is None:
-                agent_name = inp.get('subagent_type') or ''
-                if not agent_name:
-                    desc = inp.get('description') or inp.get('prompt') or ''
-                    agent_name = (desc[:22] + '…') if len(desc) > 25 else desc
-                last_agent = agent_name
-        if last_skill is not None and last_agent is not None:
-            break
-    return last_skill or None, last_agent or None
-
-
-# ── Transcript / JSONL helpers ────────────────────────────────────────────────
-
-def read_transcript_jsonl(path):
-    """Read and parse JSONL transcript file. Returns list of parsed entries."""
-    entries = []
+    base = Path(cwd) / '.morph' / 'features'
+    if not base.is_dir():
+        return []
     try:
-        with open(path, 'r', encoding='utf-8') as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    entries.append(json.loads(line))
-                except Exception:
-                    pass
+        feature_files = sorted(base.glob('*/feature.json'))
     except Exception:
-        pass
-    return entries
-
+        return []
 
-def get_token_metrics(entries):
-    """Sum token usage from all non-sidechain JSONL entries."""
-    total_input, total_output, total_cached = 0, 0, 0
-    for entry in entries:
-        if entry.get('isSidechain') or entry.get('isApiErrorMessage'):
+    result = []
+    for path in feature_files:
+        try:
+            data = json.loads(path.read_text(encoding='utf-8'))
+        except Exception:
             continue
-        usage = (entry.get('message') or {}).get('usage') or {}
-        if not usage:
+        if not isinstance(data, dict) or data.get('status') != 'in_progress':
             continue
-        total_input  += usage.get('input_tokens', 0)
-        total_output += usage.get('output_tokens', 0)
-        total_cached += (
-            usage.get('cache_creation_input_tokens', 0) +
-            usage.get('cache_read_input_tokens', 0)
-        )
-    return {'input': total_input, 'output': total_output, 'cached': total_cached}
-
-
-def parse_timestamp(ts):
-    """Parse ISO 8601 timestamp to Unix float. Returns None on error."""
+        feature_dir = path.parent
+        gates = data.get('approvalGates') or {}
+        phase = derive_phase(feature_dir, gates)
+        done, total = count_tasks(feature_dir, data)
+        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,
+            'tasks_done':  done,
+            'tasks_total': total,
+            'pending':     pending,
+        })
+    return result
+
+
+def get_last_hook(cwd):
+    """Name of the most recent hook from .morph/logs/activity.json.
+
+    The age is deliberately not shown: activity-logger.js only records
+    HH:MM:SS, so any age computed from it is wrong across midnight.
+    """
     try:
-        return datetime.fromisoformat(ts.replace('Z', '+00:00')).timestamp()
+        raw = (Path(cwd) / '.morph' / 'logs' / 'activity.json').read_text(encoding='utf-8')
+        hooks = json.loads(raw).get('hooks') or []
+        return hooks[-1].get('name') or None if hooks else None
     except Exception:
         return None
 
 
-def get_session_start(cwd, transcript_path, entries):
-    """Return Unix timestamp for the start of the current session.
+# ── Line renderers ────────────────────────────────────────────────────────────
 
-    Uses two caches:
-    - sess-tp-*  : keyed by transcript_path — persists the start for this
-                   session even after long absences (wall-clock elapsed)
-    - sess-cwd-* : keyed by cwd, 2-min window — detects plan→accept
-                   (new transcript created seconds after the previous one)
+def render_morph_line(feature, hook_name, columns):
+    """Line 0 — the active MORPH feature.
 
-    Each Claude Code window gets its own timer (per transcript).
+    Goes through join_to_width like the status line: a feature name plus phase,
+    task bar, gate and hook is the longest thing this script prints, and a
+    wrapping line 0 would defeat the whole point of the single-row layout.
     """
-    if os.name == 'nt':
-        base = Path(os.environ.get('LOCALAPPDATA', str(Path.home() / 'AppData' / 'Local')))
-        cache_dir = base / 'morph-spec' / 'cache'
+    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:
-        cache_dir = Path.home() / '.cache' / 'morph-spec'
+        parts.append((1, f"{CYAN}{label} {position + 1}/{PIPELINE_TOTAL}{R}"))
 
-    now = time.time()
+    if feature['tasks_total'] > 0:
+        pct = feature['tasks_done'] / feature['tasks_total'] * 100
+        parts.append((
+            3,
+            f"{GREEN}{progress_bar(pct, 6)} "
+            f"{feature['tasks_done']}/{feature['tasks_total']} tasks{R}"
+        ))
 
-    if transcript_path:
-        tp_h     = hashlib.sha256(transcript_path.encode()).hexdigest()[:16]
-        tp_cache = cache_dir / f'sess-tp-{tp_h}.json'
-    else:
-        tp_cache = None
+    if feature['pending']:
+        parts.append((2, f"{RED}⛔ gate: {feature['pending']}{R}"))
 
-    cwd_h     = hashlib.sha256(cwd.encode()).hexdigest()[:16]
-    cwd_cache = cache_dir / f'sess-cwd-{cwd_h}.json'
+    if hook_name:
+        parts.append((4, f"{GRAY}🪝 {hook_name}{R}"))
 
-    # 1. This transcript already has a recorded start?
-    session_start = None
-    try:
-        if tp_cache and tp_cache.exists():
-            session_start = json.loads(tp_cache.read_text()).get('session_start')
-    except Exception:
-        pass
+    return join_to_width(parts, columns)
 
-    # 2. New transcript — continuation from plan→accept? (cwd gap < 2 min)
-    if session_start is None:
-        try:
-            if cwd_cache.exists():
-                cwd_data = json.loads(cwd_cache.read_text())
-                if (now - cwd_data.get('last_seen', 0)) < 120:
-                    session_start = cwd_data.get('session_start')
-        except Exception:
-            pass
 
-    # 3. Genuinely new session — use first entry from current transcript
-    if session_start is None:
-        for entry in entries:
-            ts = entry.get('timestamp')
-            if not ts:
-                continue
-            t = parse_timestamp(ts)
-            if t is not None:
-                session_start = t
-                break
-
-    if session_start is None:
-        return None
+def effective_window(payload, settings):
+    """The window /context measures against, or None when not reproducible.
 
-    # Persist both caches
-    try:
-        cache_dir.mkdir(parents=True, exist_ok=True)
-        payload = json.dumps({'session_start': session_start, 'last_seen': now})
-        if tp_cache:
-            tp_cache.write_text(payload)
-        cwd_cache.write_text(payload)
-    except Exception:
-        pass
+    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)
 
-    return session_start
+    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 get_session_duration(session_start):
-    """Format elapsed time since session_start. Returns string or None."""
-    if session_start is 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
-    elapsed_s = time.time() - session_start
-    hours   = int(elapsed_s // 3600)
-    minutes = int((elapsed_s % 3600) // 60)
-    if hours == 0:
-        return f"{minutes}m"
-    elif minutes == 0:
-        return f"{hours}hr"
-    else:
-        return f"{hours}hr {minutes}m"
+    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 get_session_name(entries):
-    """Find the most recent /rename title. Returns string or None."""
-    for entry in reversed(entries):
-        if entry.get('type') == 'custom-title' and entry.get('customTitle'):
-            return entry['customTitle']
-    return 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 ──────────────────────────────────────────────────────────────────────
@@ -523,152 +666,33 @@ def main():
         raw = sys.stdin.read()
         if not raw.strip():
             sys.exit(0)
-        data = json.loads(raw)
+        payload = json.loads(raw)
+        if not isinstance(payload, dict):
+            sys.exit(0)
     except Exception:
         sys.exit(0)
 
     try:
-        cwd             = data.get('cwd', os.getcwd())
-        transcript_path = data.get('transcript_path')
-
-        # Read JSONL transcript once — shared by session clock, token metrics,
-        # session name, and skill/agent detection.
-        entries = read_transcript_jsonl(transcript_path) if transcript_path else []
-
-        # ── Worktree detection (single git call) ─────────────────────────────────
-        # Feature lines are only shown when inside a secondary git worktree.
-        # This prevents stale feature names showing up during unrelated work
-        # in the main worktree.
-        is_worktree, wt_display = get_worktree_data(cwd)
-
-        # ── MORPH feature lines (one line per active feature) ────────────────────
-        features = get_all_active_features(cwd, entries) if is_worktree else []
-        for feat in features:
-            # Feature name with visual prefix
-            parts = [f"{CYAN}{BOLD}► {feat['name']}{R}"]
-
-            # Phase: human-readable label + position in pipeline (e.g. "implement 4/5")
-            phase = feat['phase']
-            pos   = PHASE_POSITIONS.get(phase)
-            label = PHASE_LABELS.get(phase, phase)
-            if pos:
-                parts.append(f"{CYAN}{label} {pos}/{PIPELINE_TOTAL}{R}")
-            elif phase != '?':
-                parts.append(f"{CYAN}{label}{R}")
-
-            # Task progress (only if tasks exist)
-            if feat['tasks_total'] > 0:
-                pct = feat['tasks_done'] / feat['tasks_total'] * 100
-                bar = progress_bar(pct, 6)
-                parts.append(f"{GREEN}{bar} {feat['tasks_done']}/{feat['tasks_total']} tasks{R}")
-
-            # Checkpoint: only show when imminent (0 = now, 1 = next task)
-            if feat['countdown'] == 0:
-                parts.append(f"{GREEN}💾 checkpoint!{R}")
-            elif feat['countdown'] == 1:
-                parts.append(f"{YELLOW}💾 in 1 task{R}")
-
-            # Trust: silent when good, alert only if problematic
-            if feat['trust_level'] == 'low':
-                parts.append(f"{RED}⚠ low trust{R}")
-            elif feat['trust_level'] == 'medium':
-                parts.append(f"{YELLOW}⚠ medium trust{R}")
-
-            # Blocking approval gate
-            if feat['pending']:
-                parts.append(f"{RED}⛔ approval required{R}")
-
-            print('  |  '.join(parts))
-
-        # ── Activity info line (hooks; only shown when a feature is active) ───────
-        if features:
-            activity = get_activity_info(cwd)
-            if activity and activity['hook_count'] > 0:
-                hook_label = activity['last_hook'] or '?'
-                age_str = f"({activity['last_hook_age']})" if activity['last_hook_age'] else ''
-                hook_str = f"{BLUE}🪝 {hook_label} {age_str}{R}".strip()
-                print(f"  {GRAY}└{R} {hook_str}")
-
-        # ── Session info line (always shown) ─────────────────────────────────────
-        parts2 = []
-
-        # Session name (set via /rename)
-        if entries:
-            session_name = get_session_name(entries)
-            if session_name:
-                parts2.append(f"{CYAN}{BOLD}📌 {session_name}{R}")
-
-        # Model
-        model = data.get('model') or ''
-        if isinstance(model, dict):
-            model_name = model.get('display_name') or model.get('id') or ''
-        else:
-            model_name = str(model) if model else ''
-        if model_name:
-            short = model_name.replace('Claude ', '').replace('claude-', '').replace(' (claude.ai)', '')
-            parts2.append(f"{WHITE}{BOLD}🤖 {short}{R}")
-
-        # Permission mode (only shown when non-default)
-        perm = data.get('permission_mode') or ''
-        if perm and perm != 'default':
-            _perm_labels = {
-                'plan':               '📋 plan',
-                'acceptEdits':        '✏ accept edits',
-                'bypassPermissions':  '⚠ bypass',
-                'dontAsk':            '🔕 auto',
-            }
-            parts2.append(f"{YELLOW}{_perm_labels.get(perm, perm)}{R}")
-
-        # Last skill and agent invoked (parsed from transcript tool_use blocks)
-        if entries:
-            last_skill, last_agent = get_recent_tool_calls(entries)
-            if last_skill:
-                parts2.append(f"{YELLOW}🎯 {last_skill}{R}")
-            if last_agent:
-                parts2.append(f"{MAGENTA}⚡ {last_agent}{R}")
-
-        # Session clock (elapsed time since session start, survives transcript transitions)
-        session_start = get_session_start(cwd, transcript_path, entries)
-        duration = get_session_duration(session_start)
-        if duration:
-            parts2.append(f"{YELLOW}⏱ {duration}{R}")
-
-        # Context window
-        # used_percentage excludes output_tokens — underestimates real usage in long sessions.
-        # Compute (input + cache_creation + cache_read + output) / context_window_size,
-        # which reflects true context consumption for the next turn.
-        ctx = data.get('context_window', {})
-        if ctx:
-            cur_usage = ctx.get('current_usage') or {}
-            total_ctx = safe_int(ctx.get('context_window_size'))
-            if isinstance(cur_usage, dict) and total_ctx > 0:
-                tokens = (safe_int(cur_usage.get('input_tokens'))
-                        + safe_int(cur_usage.get('cache_creation_input_tokens'))
-                        + safe_int(cur_usage.get('cache_read_input_tokens'))
-                        + safe_int(cur_usage.get('output_tokens')))
-                used_pct = tokens / total_ctx * 100 if tokens > 0 else safe_float(ctx.get('used_percentage'))
-            else:
-                used_pct = safe_float(ctx.get('used_percentage'))
-            color  = ctx_color(used_pct)
-            bar    = progress_bar(used_pct, 8)
-            toks   = f"{format_tokens(tokens)}/{format_tokens(total_ctx)}" if total_ctx and isinstance(cur_usage, dict) else ""
-            suffix = f" {RED}~cmpct{R}" if used_pct >= 90 else ""
-            line   = f"{color}{bar} {used_pct:.0f}%{R}"
-            if toks:
-                line += f" ({toks})"
-            parts2.append(line + suffix)
-
-        # Git info (branch + diff stats)
-        git = get_git_info(cwd)
-        if git:
-            parts2.append(git)
-
-        # Worktree label (already computed above — reuse result)
-        if wt_display:
-            parts2.append(wt_display)
-
-        if parts2:
-            print('  |  '.join(parts2))
+        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):
+            hook_name = get_last_hook(cwd)
+            for feature in get_active_features(cwd):
+                print(render_morph_line(feature, hook_name, columns))
+                hook_name = None  # annotate the first line only
+
+        status_line = render_status_line(payload, cwd, settings, columns)
+        if status_line:
+            print(status_line)
 
     except Exception:
         err = traceback.format_exc().splitlines()[-1]