@polymorphism-tech/morph-spec 4.5.0 → 4.6.0

package/framework/{skills/level-2-domains → agents}/integrations/resend-email.md

@@ -1,14 +1,11 @@
 ---
 name: resend-email
-description: >
-  Resend Email specialist for transactional email, email templates, and Resend API integration. Activates for keywords: email, resend, smtp, transactional, notifications, email templates.
+description: Resend Email specialist for transactional email, HTML/React email templates, Resend API integration, and notification systems in .NET and Next.js. Use when implementing email notifications, integrating Resend API, creating transactional email templates, or configuring email delivery in MORPH-SPEC projects.
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Resend Email
 
-> **Layer:** 2 | **Load:** on-keyword | **Keywords:** resend, email, envio, transactional, notification, send email, template
-
 Transactional email via Resend for .NET. REST API, no official SDK. Simple, developer-friendly.
 
 ## Setup

package/framework/{skills/level-2-domains → agents}/quality/code-analyzer.md

@@ -1,14 +1,11 @@
 ---
 name: code-analyzer
-description: >
-  Code Analyzer specialist for refactoring, complexity analysis, code review, and technical debt assessment. Activates for keywords: refactor, analysis, code review, complexity, technical debt.
+description: Code Analyzer specialist for refactoring, complexity analysis, technical debt assessment, and identifying code smells in .NET/TypeScript codebases. Use when analyzing code quality, identifying refactoring opportunities, assessing technical debt, or reviewing code for duplication and architecture violations.
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Code Analyzer
 
-> **Layer:** 2 | **Load:** on-keyword | **Keywords:** analyze, review, refactor, clean, smell, duplicate, architecture, quality, debt, unused, dead code, code review, code quality
-
 Deep code analysis specialist. Automates architecture review, clean code checks, and duplication detection.
 
 > **Ref:** `framework/standards/core/coding.md` for naming conventions.

package/framework/{skills/level-2-domains → agents}/quality/testing-specialist.md

@@ -1,14 +1,11 @@
 ---
 name: testing-specialist
-description: >
-  Testing Specialist for test strategy, coverage, TDD/BDD, xUnit, Vitest, Jest, and quality assurance. Activates for keywords: tests, coverage, tdd, bdd, vitest, jest, xunit, testing.
+description: Testing Specialist for test strategy, TDD/BDD implementation, unit and integration tests using xUnit, Vitest, and Jest, and quality assurance automation. Use when designing test strategies, implementing TDD cycles, writing unit/integration tests, or improving test coverage in .NET and TypeScript projects.
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep
 ---
 
 # Testing Specialist
 
-> **Layer:** 2 | **Load:** on-keyword | **Keywords:** test, testing, mock, fake, simulation, unit test, integration test
-
 Especialista em testes, mocking e simulação para projetos .NET.
 
 ## Strategy

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

@@ -8,7 +8,10 @@ import json
 import os
 import subprocess
 import time
+import re
+import hashlib
 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'):
@@ -27,10 +30,52 @@ GRAY = '\033[90m'
 WHITE = '\033[97m'
 
 
+# ── MORPH framework constants (derived from phases.json / trust-manager.js) ──
+
+# Ordered core phases for pipeline mini-map (5 positions, optional phases mapped)
+# uiux maps to position 2 (same slot as design — they're mutually exclusive in practice)
+PHASE_POSITIONS = {
+    'proposal': 1, 'setup': 1,
+    'uiux': 2, 'design': 2,
+    'clarify': 3,
+    'tasks': 4,
+    'implement': 5, 'sync': 5,
+}
+PHASE_ABBREV = {
+    'proposal': 'prop', 'setup': 'setup',
+    'uiux': 'ui', 'design': 'design',
+    'clarify': 'clarify', 'tasks': 'tasks',
+    'implement': 'impl', 'sync': 'sync',
+}
+PIPELINE_TOTAL = 5
+
+# Approval gates per phase (from phases.json pausePoints)
+PHASE_GATES = {
+    'proposal': 'proposal',
+    'uiux':     'uiux',
+    'design':   'design',
+    'tasks':    'tasks',
+}
+
+# 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 ctx_color(pct):
-    if pct < 70:
+    """Color based on context usage. 80% = Claude's auto-compact threshold."""
+    if pct < 60:
         return GREEN
-    if pct < 90:
+    if pct < 80:
         return YELLOW
     return RED
 
@@ -42,13 +87,113 @@ def progress_bar(pct, width=8):
 
 
 def format_tokens(n):
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}m"
     if n >= 1000:
         return f"{n // 1000}k"
     return str(n)
 
 
+# ── MORPH feature helpers ────────────────────────────────────────────────────
+
+def calculate_trust(checkpoints):
+    """Return (level_str, color, badge, pass_rate) from checkpoint array."""
+    if not checkpoints:
+        return 'low', RED, '○○○○', 0.0
+    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, badge, rate
+    return 'low', RED, '○○○○', rate
+
+
+def get_phase_minimap(phase):
+    """Return colored dot strip + phase abbrev, e.g. '●►○○○ design'."""
+    pos = PHASE_POSITIONS.get(phase)
+    if pos is None:
+        return None
+    dots = ''
+    for i in range(1, PIPELINE_TOTAL + 1):
+        if i < pos:
+            dots += f"{GREEN}●{R}"
+        elif i == pos:
+            dots += f"{CYAN}►{R}"
+        else:
+            dots += f"{GRAY}○{R}"
+    abbrev = PHASE_ABBREV.get(phase, phase)
+    return f"{dots} {CYAN}{abbrev}{R}"
+
+
+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 get_next_gate(phase, approval_gates):
+    """Return the upcoming gate for this phase if not yet triggered in state."""
+    gate_id = PHASE_GATES.get(phase)
+    if not gate_id:
+        return None
+    # If the gate already appears in approvalGates (approved or pending),
+    # it's either done or already shown as pending — don't duplicate.
+    if gate_id in (approval_gates or {}):
+        return None
+    return gate_id
+
+
+def get_all_active_features(cwd):
+    """Return list of all in_progress features with enriched MORPH metadata."""
+    state_path = Path(cwd) / '.morph' / 'state.json'
+    if not state_path.exists():
+        return []
+    try:
+        state = json.loads(state_path.read_text())
+        features = state.get('features', {})
+        result = []
+        for name, feat in features.items():
+            if feat.get('status') != 'in_progress':
+                continue
+            phase      = feat.get('phase', '?')
+            tasks      = feat.get('tasks', {})
+            done       = tasks.get('completed', 0)
+            total      = tasks.get('total', 0)
+            gates      = feat.get('approvalGates', {})
+            checkpts   = feat.get('checkpoints', [])
+
+            pending    = [g for g, v in gates.items() if not v.get('approved')]
+            trust_lvl, trust_color, trust_badge, trust_rate = calculate_trust(checkpts)
+            countdown  = get_checkpoint_countdown(done)
+            next_gate  = get_next_gate(phase, gates)
+            minimap    = get_phase_minimap(phase)
+
+            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,
+                'trust_badge':  trust_badge,
+                'trust_rate':   trust_rate,
+                'countdown':    countdown,
+                'next_gate':    next_gate,
+                'minimap':      minimap,
+            })
+        return result
+    except Exception:
+        return []
+
+
+# ── Git helpers ───────────────────────────────────────────────────────────────
+
 def get_git_info(cwd):
-    """Get git branch and file stats. Uses a 5s file cache to avoid lag."""
+    """Get git branch and diff stats. Uses a 5s file cache to avoid lag."""
     try:
         cache_file = Path(cwd) / '.morph' / '.git-cache'
         try:
@@ -64,31 +209,32 @@ def get_git_info(cwd):
             cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
         ).decode().strip()
 
-        status_out = subprocess.check_output(
-            ['git', 'status', '--porcelain'],
-            cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
-        ).decode()
-
-        staged = sum(1 for l in status_out.splitlines() if l and l[0] in 'MADRC')
-        modified = sum(1 for l in status_out.splitlines() if l and l[1] in 'MD')
-        untracked = sum(1 for l in status_out.splitlines() if l.startswith('??'))
+        # Diff stats: insertions/deletions from staged + unstaged changes
+        ins, dels = 0, 0
+        for cmd in [['diff', '--shortstat'], ['diff', '--cached', '--shortstat']]:
+            try:
+                out = subprocess.check_output(
+                    ['git'] + cmd, cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
+                ).decode()
+                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 staged:
-            parts.append(f"{GREEN}+{staged}{R}")
-        if modified:
-            parts.append(f"{YELLOW}~{modified}{R}")
-        if untracked:
-            parts.append(f"{GRAY}?{untracked}{R}")
+        if ins or dels:
+            parts.append(f"{GREEN}+{ins}{R}{GRAY},{R}{RED}-{dels}{R}")
 
         result = ' '.join(parts)
-
         try:
             cache_file.parent.mkdir(parents=True, exist_ok=True)
             cache_file.write_text(result)
         except Exception:
             pass
-
         return result
     except Exception:
         return ""
@@ -97,71 +243,164 @@ def get_git_info(cwd):
 def get_worktree_info(cwd):
     """Detect if running in a git worktree (not the main worktree)."""
     try:
-        worktrees_out = subprocess.check_output(
+        out = subprocess.check_output(
             ['git', 'worktree', 'list', '--porcelain'],
             cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
         ).decode()
-
-        entries = []
-        current = {}
-        for line in worktrees_out.splitlines():
+        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_resolved = str(Path(cwd).resolve())
+            cwd_r = str(Path(cwd).resolve())
             for entry in entries[1:]:
-                entry_path = str(Path(entry.get('path', '')).resolve())
-                if cwd_resolved == entry_path:
-                    branch_ref = entry.get('branch', '')
-                    branch = branch_ref.replace('refs/heads/', '')
+                if str(Path(entry.get('path', '')).resolve()) == cwd_r:
+                    branch = entry.get('branch', '').replace('refs/heads/', '')
                     return f"{MAGENTA}worktree:{branch}{R}"
     except Exception:
         pass
     return ""
 
 
-def get_morph_info(cwd):
-    """Read active feature info from .morph/state.json."""
-    state_path = Path(cwd) / '.morph' / 'state.json'
-    if not state_path.exists():
+# ── Transcript / JSONL helpers ────────────────────────────────────────────────
+
+def read_transcript_jsonl(path):
+    """Read and parse JSONL transcript file. Returns list of parsed entries."""
+    entries = []
+    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
+    except Exception:
+        pass
+    return entries
+
+
+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'):
+            continue
+        usage = (entry.get('message') or {}).get('usage') or {}
+        if not usage:
+            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."""
+    try:
+        return datetime.fromisoformat(ts.replace('Z', '+00:00')).timestamp()
+    except Exception:
         return None
+
+
+def get_session_duration(entries):
+    """Elapsed time since first message. Returns 'Xhr Ym' or None."""
+    now = time.time()
+    for entry in entries:
+        ts = entry.get('timestamp')
+        if not ts:
+            continue
+        t = parse_timestamp(ts)
+        if t is None:
+            continue
+        elapsed_s = now - t
+        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"
+    return 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 get_block_start(transcript_path, entries):
+    """Find start of current 5-hour billing block. Cached per transcript."""
+    h = hashlib.sha256(transcript_path.encode()).hexdigest()[:16]
+    cache_dir  = Path.home() / '.cache' / 'morph-spec'
+    cache_file = cache_dir / f'block-{h}.json'
+    now        = time.time()
+    block_s    = 5 * 3600
+
     try:
-        state = json.loads(state_path.read_text())
-        features = state.get('features', {})
-        active = [
-            (name, feat)
-            for name, feat in features.items()
-            if feat.get('status') == 'in_progress'
-        ]
-        if not active:
-            return None
-
-        name, feat = active[0]
-        phase = feat.get('phase', '?')
-        tasks = feat.get('tasks', {})
-        done = tasks.get('completed', 0)
-        total = tasks.get('total', 0)
-        gates = feat.get('approvalGates', {})
-        pending = [g for g, v in gates.items() if not v.get('approved')]
-
-        return {
-            'name': name,
-            'phase': phase,
-            'tasks_done': done,
-            'tasks_total': total,
-            'pending_approval': pending[0] if pending else None,
-        }
+        if cache_file.exists():
+            cached = json.loads(cache_file.read_text())
+            start  = cached.get('block_start')
+            if start and (now - start) < block_s:
+                return start
     except Exception:
+        pass
+
+    start = None
+    for entry in entries:
+        ts = entry.get('timestamp')
+        if not ts:
+            continue
+        t = parse_timestamp(ts)
+        if t is None:
+            continue
+        if (now - t) <= block_s:
+            start = t
+            break
+
+    if start is None:
         return None
 
+    try:
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_file.write_text(json.dumps({'block_start': start}))
+    except Exception:
+        pass
+    return start
+
+
+def format_block_timer(block_start):
+    """Format block timer as 'bar Xhr Ym' relative to 5-hour window."""
+    now       = time.time()
+    elapsed_s = max(0.0, now - block_start)
+    pct       = min(elapsed_s / (5 * 3600) * 100, 100)
+    hours     = int(elapsed_s // 3600)
+    minutes   = int((elapsed_s % 3600) // 60)
+    if hours == 0:
+        time_str = f"{minutes}m"
+    elif minutes == 0:
+        time_str = f"{hours}hr"
+    else:
+        time_str = f"{hours}hr {minutes}m"
+    return f"{progress_bar(pct, 6)} {time_str}"
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
 
 def main():
     try:
@@ -172,43 +411,103 @@ def main():
     except Exception:
         sys.exit(0)
 
-    cwd = data.get('cwd', os.getcwd())
-
-    # === LINE 1: Morph status (only if morph project has active feature) ===
-    morph = get_morph_info(cwd)
-    if morph:
-        parts1 = [
-            f"{CYAN}{BOLD}{morph['name']}{R}",
-            f"{MAGENTA}phase:{morph['phase']}{R}",
-        ]
-        if morph['tasks_total'] > 0:
-            pct = morph['tasks_done'] / morph['tasks_total'] * 100
+    cwd             = data.get('cwd', os.getcwd())
+    transcript_path = data.get('transcript_path')
+
+    # Read JSONL transcript once — shared by session clock, block timer,
+    # token metrics, and session name.
+    entries = read_transcript_jsonl(transcript_path) if transcript_path else []
+
+    # ── MORPH feature lines (one line per active feature) ────────────────────
+    features = get_all_active_features(cwd)
+    for feat in features:
+        parts = [f"{CYAN}{BOLD}{feat['name']}{R}"]
+
+        # Phase pipeline mini-map: ●●►○○ design
+        if feat['minimap']:
+            parts.append(feat['minimap'])
+
+        # Task progress bar
+        if feat['tasks_total'] > 0:
+            pct = feat['tasks_done'] / feat['tasks_total'] * 100
             bar = progress_bar(pct, 6)
-            parts1.append(f"{GREEN}{bar} {morph['tasks_done']}/{morph['tasks_total']}{R}")
-        if morph['pending_approval']:
-            parts1.append(f"{YELLOW}⏳ {morph['pending_approval']} pending{R}")
-        print('  |  '.join(parts1))
+            parts.append(f"{GREEN}{bar} {feat['tasks_done']}/{feat['tasks_total']}{R}")
 
-    # === LINE 2: Session info (always shown) ===
+        # Checkpoint countdown: how many tasks until next validation fires
+        if feat['countdown'] is not None:
+            if feat['countdown'] == 0:
+                parts.append(f"{GREEN}ckpt!{R}")          # just hit checkpoint
+            elif feat['countdown'] == 1:
+                parts.append(f"{YELLOW}ckpt:1{R}")        # 1 task away — heads up
+            else:
+                parts.append(f"{GRAY}ckpt:{feat['countdown']}{R}")
+
+        # Trust level badge: ◆◆◆○ high
+        tc = feat['trust_color']
+        parts.append(f"{tc}{feat['trust_badge']}{R}")
+
+        # Pending approval gate (blocking — already triggered, not yet approved)
+        if feat['pending']:
+            parts.append(f"{YELLOW}⏳ {feat['pending']} pending{R}")
+
+        # Upcoming gate (not yet triggered — reminds what comes at end of phase)
+        if feat['next_gate']:
+            parts.append(f"{GRAY}→gate:{feat['next_gate']}{R}")
+
+        print('  |  '.join(parts))
+
+    # ── 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', {})
+    model      = data.get('model', {})
     model_name = model.get('display_name', model.get('id', ''))
     if model_name:
         short = model_name.replace('Claude ', '').replace(' (claude.ai)', '')
         parts2.append(f"{WHITE}{BOLD}🤖 {short}{R}")
 
-    # Context window
+    # Session clock (elapsed time since first message)
+    if entries:
+        duration = get_session_duration(entries)
+        if duration:
+            parts2.append(f"{YELLOW}⏱ {duration}{R}")
+
+    # Block timer (progress through current 5-hour billing window)
+    if entries and transcript_path:
+        block_start = get_block_start(transcript_path, entries)
+        if block_start is not None:
+            parts2.append(f"{YELLOW}blk:{format_block_timer(block_start)}{R}")
+
+    # Context window (60% = yellow, 80% = red/auto-compact threshold)
     ctx = data.get('context_window', {})
     if ctx:
-        used_pct = ctx.get('used_percentage', 0)
-        cur = ctx.get('current_usage', 0)
+        used_pct  = ctx.get('used_percentage', 0)
+        cur       = ctx.get('current_usage', 0)
         total_ctx = ctx.get('context_window_size', 0)
-        color = ctx_color(used_pct)
-        bar = progress_bar(used_pct, 8)
-        toks = f"{format_tokens(cur)}/{format_tokens(total_ctx)}"
-        parts2.append(f"{color}{bar} {used_pct:.0f}% ({toks} tok){R}")
+        color     = ctx_color(used_pct)
+        bar       = progress_bar(used_pct, 8)
+        toks      = f"{format_tokens(cur)}/{format_tokens(total_ctx)}"
+        suffix    = f" {RED}~cmpct{R}" if used_pct >= 80 else ""
+        parts2.append(f"{color}{bar} {used_pct:.0f}%{R} ({toks}){suffix}")
+
+    # Token breakdown from JSONL (session totals: input / output / cached)
+    if entries:
+        tok = get_token_metrics(entries)
+        tok_parts = []
+        if tok['input']:
+            tok_parts.append(f"in:{format_tokens(tok['input'])}")
+        if tok['output']:
+            tok_parts.append(f"out:{format_tokens(tok['output'])}")
+        if tok['cached']:
+            tok_parts.append(f"↩{format_tokens(tok['cached'])}")
+        if tok_parts:
+            parts2.append(f"{GRAY}{' '.join(tok_parts)}{R}")
 
     # Cost
     cost = data.get('cost', {})
@@ -221,7 +520,7 @@ def main():
     if agent.get('name'):
         parts2.append(f"{BLUE}agent:{agent['name']}{R}")
 
-    # Git info (cached, non-blocking)
+    # Git info (branch + diff stats, 5s cached)
     git = get_git_info(cwd)
     if git:
         parts2.append(git)