anvil-dev-framework 0.1.6

package/global/tools/anvil-hud.py

@@ -0,0 +1,3622 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "textual>=0.40.0",
+#     "rich>=13.0.0",
+# ]
+# ///
+"""
+anvil-hud.py - Terminal dashboard for multi-agent Claude Code visibility
+
+Shows all active Claude Code agents across all projects in real-time.
+Run in a separate terminal pane (Warp split, tmux, etc.) alongside Claude Code.
+
+Usage:
+    uv run anvil-hud.py           # Start the dashboard
+    uv run anvil-hud.py --demo    # Start with demo data
+
+Modes:
+    Focused Mode - Tab-based navigation, one panel at a time (default)
+    Full Mode    - All panels visible simultaneously
+
+Keybindings:
+    m       Toggle Focused/Full mode
+    1-5     Switch to tab (Agents/Kanban/Quality/Costs/Coord)
+    Tab     Next tab
+    Shift+Tab Previous tab
+    q       Quit
+    r       Force refresh
+    d       Toggle detailed view
+    ?       Show help
+"""
+
+import argparse
+import json
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Dict, Any, List, Optional, Literal, Callable
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical, ScrollableContainer
+from textual.widgets import Header, Footer, Static, Label, ProgressBar, Rule
+from textual.reactive import reactive
+from textual.timer import Timer
+from rich.text import Text
+from rich.panel import Panel
+from rich.table import Table
+
+
+# Add parent directory to path for importing agent_registry
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+try:
+    from agent_registry import AgentRegistry
+except ImportError:
+    AgentRegistry = None
+
+try:
+    from linear_data_service import LinearDataService
+except ImportError:
+    LinearDataService = None
+
+try:
+    from quality_service import QualityService
+except ImportError:
+    QualityService = None
+
+try:
+    from coordination_service import CoordinationService
+except ImportError:
+    CoordinationService = None
+
+try:
+    from github_service import GitHubService
+except ImportError:
+    GitHubService = None
+
+try:
+    from coderabbit_service import CodeRabbitService
+except ImportError:
+    CodeRabbitService = None
+
+try:
+    from config_service import get_config, get_config_service, HUDConfig
+except ImportError:
+    get_config = None
+    get_config_service = None
+    HUDConfig = None
+
+try:
+    from issue_provider import get_provider, IssueProvider
+    from issue_models import Issue, IssueStatus, Priority
+except ImportError:
+    get_provider = None
+    IssueProvider = None
+    Issue = None
+    IssueStatus = None
+    Priority = None
+
+try:
+    from transcript_parser import TranscriptParser, ToolActivityState
+except ImportError:
+    TranscriptParser = None
+    ToolActivityState = None
+
+
+class CostPanel(Static):
+    """Widget displaying cost tracking and attribution (ANV-94)."""
+
+    agents: reactive[Dict[str, Any]] = reactive({})
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="cost-panel-content")
+
+    def watch_agents(self, agents: Dict[str, Any]) -> None:
+        """Update display when agents change."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the cost panel display."""
+        content = self.query_one("#cost-panel-content", Static)
+
+        text = Text()
+        text.append("COST TRACKER\n", style="bold white")
+        text.append("─" * 36 + "\n\n", style="dim")
+
+        if not self.agents:
+            text.append("No active agents\n", style="dim")
+            content.update(text)
+            return
+
+        # Calculate totals
+        total_cost = 0.0
+        total_tokens = {"input": 0, "output": 0, "cache_read": 0, "cache_write": 0}
+        issue_costs: Dict[str, float] = {}
+
+        for agent_id, agent in self.agents.items():
+            session_cost = agent.get("sessionCost", 0)
+            total_cost += session_cost
+
+            # Get detailed cost data if available
+            cost_data = agent.get("cost", {})
+            session = cost_data.get("session", {})
+            tokens = session.get("tokens", {})
+
+            total_tokens["input"] += tokens.get("input", 0)
+            total_tokens["output"] += tokens.get("output", 0)
+            total_tokens["cache_read"] += tokens.get("cache_read", 0)
+            total_tokens["cache_write"] += tokens.get("cache_write", 0)
+
+            # Aggregate issue attribution
+            attributed = cost_data.get("attributed", {})
+            for issue_id, attr in attributed.items():
+                issue_costs[issue_id] = issue_costs.get(issue_id, 0) + attr.get("cost_usd", 0)
+
+        # Session total
+        text.append("Session Total: ", style="dim")
+        cost_style = "green bold" if total_cost < 1 else ("yellow bold" if total_cost < 5 else "red bold")
+        text.append(f"${total_cost:.2f}\n\n", style=cost_style)
+
+        # Token breakdown
+        text.append("Token Usage:\n", style="dim white")
+        text.append(f"  Input:       {total_tokens['input']:>10,}\n", style="cyan")
+        text.append(f"  Output:      {total_tokens['output']:>10,}\n", style="magenta")
+        text.append(f"  Cache Read:  {total_tokens['cache_read']:>10,}\n", style="green")
+        text.append(f"  Cache Write: {total_tokens['cache_write']:>10,}\n\n", style="yellow")
+
+        # Per-agent costs
+        if len(self.agents) > 1:
+            text.append("Per Agent:\n", style="dim white")
+            for agent_id, agent in sorted(
+                self.agents.items(),
+                key=lambda x: x[1].get("sessionCost", 0),
+                reverse=True
+            ):
+                display_id = agent_id[:12] + "..." if len(agent_id) > 12 else agent_id
+                agent_cost = agent.get("sessionCost", 0)
+                model = agent.get("model", "?")
+                text.append(f"  {display_id}: ", style="cyan")
+                text.append(f"${agent_cost:.2f}", style="blue")
+                text.append(f" [{model}]\n", style="dim")
+            text.append("\n")
+
+        # Issue attribution
+        if issue_costs:
+            text.append("By Issue:\n", style="dim white")
+            for issue_id, cost in sorted(issue_costs.items(), key=lambda x: x[1], reverse=True)[:5]:
+                text.append(f"  {issue_id}: ", style="yellow")
+                text.append(f"${cost:.2f}\n", style="blue")
+
+        content.update(text)
+
+
+class TaskPanel(Static):
+    """Widget displaying Linear issue status for active agents (ANV-101/102)."""
+
+    agents: reactive[Dict[str, Any]] = reactive({})
+    issues: reactive[Dict[str, Any]] = reactive({})
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="task-panel-content")
+
+    def watch_agents(self, agents: Dict[str, Any]) -> None:
+        """Update display when agents change."""
+        self._refresh_display()
+
+    def watch_issues(self, issues: Dict[str, Any]) -> None:
+        """Update display when issues change."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the task panel display."""
+        content = self.query_one("#task-panel-content", Static)
+
+        text = Text()
+        text.append("ACTIVE ISSUES\n", style="bold white")
+        text.append("─" * 36 + "\n\n", style="dim")
+
+        if not self.agents:
+            text.append("No active agents\n", style="dim")
+            content.update(text)
+            return
+
+        # Collect unique issues from agents
+        agent_issues: Dict[str, List[str]] = {}  # issue_id -> [agent_ids]
+        for agent_id, agent in self.agents.items():
+            issue_id = agent.get("issue")
+            if issue_id:
+                if issue_id not in agent_issues:
+                    agent_issues[issue_id] = []
+                agent_issues[issue_id].append(agent_id[:10])
+
+        if not agent_issues:
+            text.append("No issues assigned\n", style="dim")
+            content.update(text)
+            return
+
+        # Display issues with Linear data if available
+        for issue_id, agent_ids in sorted(agent_issues.items()):
+            issue_data = self.issues.get(issue_id, {})
+
+            # Issue identifier
+            text.append(f" {issue_id}\n", style="bold yellow")
+
+            # Title (truncated)
+            title = issue_data.get("title", "Loading...")[:45]
+            if len(issue_data.get("title", "")) > 45:
+                title += "..."
+            text.append(f"   {title}\n", style="white")
+
+            # State with color coding
+            state = issue_data.get("state", "?")
+            state_type = issue_data.get("state_type", "")
+            if state_type == "completed":
+                state_style = "green"
+            elif state_type == "started":
+                state_style = "cyan"
+            elif state_type == "canceled":
+                state_style = "red dim"
+            else:
+                state_style = "dim"
+
+            text.append("   State: ", style="dim")
+            text.append(f"{state}\n", style=state_style)
+
+            # Agents working on this
+            text.append("   Agents: ", style="dim")
+            text.append(f"{', '.join(agent_ids)}\n", style="cyan")
+
+            # Labels if any
+            labels = issue_data.get("labels", [])
+            if labels:
+                text.append("   Labels: ", style="dim")
+                text.append(f"{', '.join(labels[:3])}\n", style="magenta")
+
+            text.append("\n")
+
+        # Summary
+        text.append("─" * 36 + "\n", style="dim")
+        in_progress = sum(1 for i in self.issues.values() if i.get("state_type") == "started")
+        completed = sum(1 for i in self.issues.values() if i.get("state_type") == "completed")
+        text.append("In Progress: ", style="dim")
+        text.append(f"{in_progress}", style="cyan bold")
+        text.append(" | Done: ", style="dim")
+        text.append(f"{completed}\n", style="green bold")
+
+        content.update(text)
+
+
+class QualityPanel(Static):
+    """Widget displaying quality gate status (ANV-103/104/105, ANV-111-115)."""
+
+    agents: reactive[Dict[str, Any]] = reactive({})
+    quality_results: reactive[Dict[str, Any]] = reactive({})
+    github_status: reactive[Dict[str, Any]] = reactive({})  # ANV-111-113
+    coderabbit_status: reactive[Dict[str, Any]] = reactive({})  # ANV-114-115
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="quality-panel-content")
+
+    def watch_agents(self, agents: Dict[str, Any]) -> None:
+        """Update display when agents change."""
+        self._refresh_display()
+
+    def watch_quality_results(self, results: Dict[str, Any]) -> None:
+        """Update display when quality results change."""
+        self._refresh_display()
+
+    def watch_github_status(self, status: Dict[str, Any]) -> None:
+        """Update display when GitHub status changes."""
+        self._refresh_display()
+
+    def watch_coderabbit_status(self, status: Dict[str, Any]) -> None:
+        """Update display when CodeRabbit status changes."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the quality panel display."""
+        content = self.query_one("#quality-panel-content", Static)
+
+        text = Text()
+        text.append("QUALITY GATES\n", style="bold white")
+        text.append("─" * 36 + "\n\n", style="dim")
+
+        if not self.agents:
+            text.append("No active agents\n", style="dim")
+            content.update(text)
+            return
+
+        # Collect projects from agents
+        projects: Dict[str, str] = {}  # path -> agent_id
+        for agent_id, agent in self.agents.items():
+            project = agent.get("project")
+            if project:
+                projects[project] = agent_id
+
+        if not projects:
+            text.append("No projects detected\n", style="dim")
+            content.update(text)
+            return
+
+        # Show results per project
+        for project_path, agent_id in projects.items():
+            results = self.quality_results.get(project_path, {})
+            branch = results.get("branch", "?")
+
+            # Project header
+            display_id = agent_id[:10] + "..." if len(agent_id) > 10 else agent_id
+            text.append(f"● {display_id}\n", style="bold cyan")
+            text.append("  Branch: ", style="dim")
+            text.append(f"{branch[:20]}\n", style="white")
+
+            # Tests
+            tests = results.get("tests", {})
+            test_status = tests.get("status", "pending")
+            if test_status == "passed":
+                text.append("  ✓ Tests: ", style="green")
+                text.append(f"{tests.get('passed', 0)} passed\n", style="green")
+            elif test_status == "failed":
+                text.append("  ✗ Tests: ", style="red")
+                text.append(f"{tests.get('failed', 0)} failed\n", style="red")
+            elif test_status == "skipped":
+                text.append("  ○ Tests: ", style="dim")
+                text.append("skipped\n", style="dim")
+            else:
+                text.append("  ⏳ Tests: ", style="yellow")
+                text.append("pending\n", style="yellow")
+
+            # Lint
+            lint = results.get("lint", {})
+            lint_status = lint.get("status", "pending")
+            errors = lint.get("errors", 0)
+            warnings = lint.get("warnings", 0)
+            if lint_status == "passed":
+                text.append("  ✓ Lint: ", style="green")
+                text.append(f"{errors} errors, {warnings} warnings\n", style="green")
+            elif lint_status == "failed":
+                text.append("  ✗ Lint: ", style="red")
+                text.append(f"{errors} errors, {warnings} warnings\n", style="red")
+            elif lint_status == "skipped":
+                text.append("  ○ Lint: ", style="dim")
+                text.append("skipped\n", style="dim")
+            else:
+                text.append("  ⏳ Lint: ", style="yellow")
+                text.append("pending\n", style="yellow")
+
+            # Types
+            types = results.get("types", {})
+            types_status = types.get("status", "pending")
+            type_errors = types.get("errors", 0)
+            if types_status == "passed":
+                text.append("  ✓ Types: ", style="green")
+                text.append(f"{type_errors} errors\n", style="green")
+            elif types_status == "failed":
+                text.append("  ✗ Types: ", style="red")
+                text.append(f"{type_errors} errors\n", style="red")
+            elif types_status == "skipped":
+                text.append("  ○ Types: ", style="dim")
+                text.append("skipped\n", style="dim")
+            else:
+                text.append("  ⏳ Types: ", style="yellow")
+                text.append("pending\n", style="yellow")
+
+            # CI Status from GitHub (ANV-111-113)
+            gh_status = self.github_status.get(project_path, {})
+            ci_status = gh_status.get("ci_status", "none")
+            if ci_status == "passed":
+                text.append("  ✓ CI: ", style="green")
+                text.append("Passed\n", style="green")
+            elif ci_status == "failed":
+                text.append("  ✗ CI: ", style="red")
+                text.append("Failed\n", style="red")
+            elif ci_status == "running":
+                text.append("  ⏳ CI: ", style="yellow")
+                text.append("Running\n", style="yellow")
+            elif ci_status == "none":
+                text.append("  ○ CI: ", style="dim")
+                text.append("None\n", style="dim")
+            else:
+                text.append("  ○ CI: ", style="dim")
+                text.append(f"{ci_status}\n", style="dim")
+
+            # PR Reviews from GitHub
+            reviews_summary = gh_status.get("reviews_summary", "")
+            if reviews_summary and reviews_summary != "No reviews":
+                if "approved" in reviews_summary.lower():
+                    text.append("  ✓ Reviews: ", style="green")
+                    text.append(f"{reviews_summary}\n", style="green")
+                elif "changes" in reviews_summary.lower():
+                    text.append("  ✗ Reviews: ", style="red")
+                    text.append(f"{reviews_summary}\n", style="red")
+                else:
+                    text.append("  ⏳ Reviews: ", style="yellow")
+                    text.append(f"{reviews_summary}\n", style="yellow")
+
+            # CodeRabbit review status (ANV-114-115)
+            cr_status = self.coderabbit_status.get(project_path, {})
+            cr_review_status = cr_status.get("review_status", "")
+            if cr_review_status and cr_review_status != "unavailable":
+                issues_count = cr_status.get("issues_count", 0)
+                suggestions_count = cr_status.get("suggestions_count", 0)
+                pending_count = cr_status.get("pending_count", 0)
+
+                if cr_review_status == "approved":
+                    text.append("  ✓ CR: ", style="green")
+                    text.append("Approved\n", style="green")
+                elif cr_review_status == "changes_requested" or issues_count > 0:
+                    text.append("  ✗ CR: ", style="red")
+                    text.append(f"{issues_count} issues", style="red")
+                    if suggestions_count > 0:
+                        text.append(f", {suggestions_count} suggestions", style="yellow")
+                    text.append("\n")
+                elif cr_review_status == "reviewing" or suggestions_count > 0:
+                    text.append("  ⏳ CR: ", style="yellow")
+                    text.append(f"{suggestions_count} suggestions", style="yellow")
+                    if pending_count > 0:
+                        text.append(f" ({pending_count} pending)", style="dim")
+                    text.append("\n")
+                elif cr_review_status == "pending":
+                    text.append("  ○ CR: ", style="dim")
+                    text.append("Pending\n", style="dim")
+
+            # Ready to merge status
+            text.append("  ─────────────\n", style="dim")
+            ready = results.get("ready_to_merge", False)
+            blocking = results.get("blocking_issues", 0)
+            if ready:
+                text.append("  Status: ", style="dim")
+                text.append("READY ✓\n", style="green bold")
+            elif blocking > 0:
+                text.append("  Status: ", style="dim")
+                text.append(f"BLOCKED ({blocking})\n", style="red bold")
+            else:
+                text.append("  Status: ", style="dim")
+                text.append("PENDING\n", style="yellow")
+
+            text.append("\n")
+
+        # Summary
+        text.append("─" * 36 + "\n", style="dim")
+        ready_count = sum(1 for r in self.quality_results.values() if r.get("ready_to_merge"))
+        blocked_count = sum(1 for r in self.quality_results.values() if r.get("blocking_issues", 0) > 0)
+        text.append("Ready: ", style="dim")
+        text.append(f"{ready_count}", style="green bold")
+        text.append(" | Blocked: ", style="dim")
+        text.append(f"{blocked_count}\n", style="red bold" if blocked_count > 0 else "dim")
+
+        content.update(text)
+
+
+class CoordinationPanel(Static):
+    """Widget displaying agent coordination and conflicts (ANV-106-110)."""
+
+    agents: reactive[Dict[str, Any]] = reactive({})
+    coordination: reactive[Dict[str, Any]] = reactive({})
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="coordination-panel-content")
+
+    def watch_agents(self, agents: Dict[str, Any]) -> None:
+        """Update display when agents change."""
+        self._refresh_display()
+
+    def watch_coordination(self, coordination: Dict[str, Any]) -> None:
+        """Update display when coordination data changes."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the coordination panel display."""
+        content = self.query_one("#coordination-panel-content", Static)
+
+        text = Text()
+        text.append("COORDINATION\n", style="bold white")
+        text.append("─" * 36 + "\n\n", style="dim")
+
+        if not self.agents:
+            text.append("No active agents\n", style="dim")
+            content.update(text)
+            return
+
+        # File locks
+        locks = self.coordination.get("file_locks", {})
+        if locks:
+            text.append("FILE LOCKS\n", style="bold cyan")
+            for pattern, lock in list(locks.items())[:5]:
+                agent = lock.get("agent_display", "?")
+                duration = lock.get("duration_seconds", 0)
+                if duration < 60:
+                    dur_str = f"{duration}s"
+                else:
+                    dur_str = f"{duration // 60}m"
+                # Truncate pattern for display
+                display_pattern = pattern[:25] + "..." if len(pattern) > 25 else pattern
+                text.append(f"  {display_pattern}\n", style="white")
+                text.append(f"    └─ {agent} ({dur_str})\n", style="dim cyan")
+            text.append("\n")
+        else:
+            text.append("FILE LOCKS\n", style="dim")
+            text.append("  None\n\n", style="dim")
+
+        # Conflicts
+        conflicts = self.coordination.get("conflicts", [])
+        if conflicts:
+            text.append("⚠️  CONFLICTS\n", style="bold red")
+            for conflict in conflicts[:3]:
+                pattern = conflict.get("pattern", "?")
+                agents = conflict.get("agents", [])
+                suggestion = conflict.get("suggestion", "")
+                # Truncate pattern
+                display_pattern = pattern[:25] + "..." if len(pattern) > 25 else pattern
+                text.append(f"  {display_pattern}\n", style="red")
+                agent_names = ", ".join(a[:10] for a in agents)
+                text.append(f"    └─ {agent_names}\n", style="yellow")
+                if suggestion:
+                    text.append(f"    └─ {suggestion}\n", style="dim")
+            text.append("\n")
+
+        # Branch age
+        branches = self.coordination.get("branches", {})
+        if branches:
+            text.append("BRANCH AGE\n", style="bold white")
+            for agent_id, branch_info in list(branches.items())[:5]:
+                agent = agent_id[:12] if len(agent_id) > 12 else agent_id
+                age = branch_info.get("age_display", "?")
+                is_stale = branch_info.get("is_stale", False)
+
+                text.append(f"  {agent}: ", style="cyan")
+                text.append(f"{age}", style="red bold" if is_stale else "green")
+                if is_stale:
+                    text.append(" (stale)", style="red")
+                text.append("\n")
+            text.append("\n")
+
+        # Summary
+        text.append("─" * 36 + "\n", style="dim")
+        lock_count = len(locks)
+        conflict_count = len(conflicts)
+        stale_count = sum(1 for b in branches.values() if b.get("is_stale", False))
+
+        text.append("Locks: ", style="dim")
+        text.append(f"{lock_count}", style="cyan")
+        text.append(" | Conflicts: ", style="dim")
+        text.append(f"{conflict_count}", style="red bold" if conflict_count > 0 else "green")
+        if stale_count > 0:
+            text.append(" | Stale: ", style="dim")
+            text.append(f"{stale_count}", style="yellow bold")
+        text.append("\n")
+
+        content.update(text)
+
+
+class ToolActivityPanel(Static):
+    """Widget displaying aggregate tool activity across all agents (ANV-125)."""
+
+    tool_activity: reactive[Dict[str, Any]] = reactive({})
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="tool-activity-content")
+
+    def watch_tool_activity(self, activity: Dict[str, Any]) -> None:
+        """Update display when tool activity changes."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the tool activity panel display."""
+        content = self.query_one("#tool-activity-content", Static)
+
+        text = Text()
+        text.append("TOOL ACTIVITY\n", style="bold white")
+        text.append("─" * 36 + "\n\n", style="dim")
+
+        running = self.tool_activity.get("running", [])
+        completed = self.tool_activity.get("completed", {})
+        error_count = self.tool_activity.get("errors", 0)
+
+        # Running tools section
+        text.append("Running:\n", style="bold cyan")
+        if running:
+            for tool in running[:2]:  # Max 2 running
+                name = tool.get("name", "Unknown")
+                target = tool.get("target", "")
+                # Spinner indicator
+                text.append("  ◐ ", style="cyan bold")
+                text.append(f"{name}", style="white bold")
+                if target:
+                    # Shorten target for display
+                    if len(target) > 25:
+                        target = "..." + target[-22:]
+                    text.append(f" {target}", style="dim")
+                text.append("\n")
+        else:
+            text.append("  (none)\n", style="dim")
+
+        text.append("\n")
+
+        # Completed tools section
+        text.append("Completed:\n", style="bold green")
+        if completed:
+            # Sort by count descending
+            sorted_tools = sorted(completed.items(), key=lambda x: x[1], reverse=True)
+            for name, count in sorted_tools[:4]:  # Max 4 completed
+                text.append("  ✓ ", style="green")
+                text.append(f"{name}", style="white")
+                if count > 1:
+                    text.append(f" ×{count}", style="cyan bold")
+                text.append("\n")
+        else:
+            text.append("  (none)\n", style="dim")
+
+        # Error summary
+        if error_count > 0:
+            text.append("\n")
+            text.append(f"Errors: {error_count}\n", style="red bold")
+
+        content.update(text)
+
+
+class TabBar(Static):
+    """Tab bar widget for Focused Mode navigation (HUD v3 - ANV-128)."""
+
+    TAB_NAMES = ["Agents", "Kanban", "Quality", "Costs", "Coord"]
+
+    active_tab: reactive[int] = reactive(0)
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="tab-bar-content")
+
+    def watch_active_tab(self, tab: int) -> None:
+        """Update display when active tab changes."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the tab bar display."""
+        content = self.query_one("#tab-bar-content", Static)
+
+        text = Text()
+        for i, name in enumerate(self.TAB_NAMES):
+            # Tab number indicator
+            num = str(i + 1)
+            if i == self.active_tab:
+                # Active tab: highlighted
+                text.append(f" [{num}]", style="cyan bold")
+                text.append(f"{name}", style="cyan bold reverse")
+                text.append(" ", style="")
+            else:
+                # Inactive tab: dimmed
+                text.append(f" [{num}]", style="dim")
+                text.append(f"{name}", style="white")
+                text.append(" ", style="")
+
+        content.update(text)
+
+    def set_tab(self, tab: int) -> None:
+        """Set active tab (0-4)."""
+        if 0 <= tab < len(self.TAB_NAMES):
+            self.active_tab = tab
+
+    def next_tab(self) -> None:
+        """Move to next tab (with wrap)."""
+        self.active_tab = (self.active_tab + 1) % len(self.TAB_NAMES)
+
+    def prev_tab(self) -> None:
+        """Move to previous tab (with wrap)."""
+        self.active_tab = (self.active_tab - 1) % len(self.TAB_NAMES)
+
+
+class HelpOverlay(Static):
+    """Modal help overlay showing all keybindings (HUD v3 - ANV-128/131).
+
+    Displays comprehensive help in a centered modal with dimmed background.
+    Toggle with '?' key, close with '?' or 'Escape'.
+    """
+
+    HELP_TEXT = """
+╔══════════════════════════════════════════════════════════════════╗
+║                        ANVIL HUD HELP                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║                                                                  ║
+║  NAVIGATION                                                      ║
+║  ──────────                                                      ║
+║  1-5         Jump to panel (Agents/Kanban/Quality/Costs/Coord)   ║
+║  Tab         Next panel                                          ║
+║  Shift+Tab   Previous panel                                      ║
+║  m           Toggle Focused/Full mode                            ║
+║                                                                  ║
+║  KANBAN (when active)                                            ║
+║  ──────────                                                      ║
+║  h / l       Move left/right between columns                     ║
+║  j / k       Move down/up within column                          ║
+║  c           Claim issue for current agent                       ║
+║  n / N       Move issue forward/backward                         ║
+║                                                                  ║
+║  GENERAL                                                         ║
+║  ──────────                                                      ║
+║  r           Force refresh                                       ║
+║  d           Toggle detailed view                                ║
+║  s           Open settings                                       ║
+║  ?           Toggle this help                                    ║
+║  Esc         Close overlay                                       ║
+║  q           Quit                                                ║
+║                                                                  ║
+║                  [ Press ? or Esc to close ]                     ║
+╚══════════════════════════════════════════════════════════════════╝
+"""
+
+    def compose(self) -> ComposeResult:
+        yield Static(self.HELP_TEXT, id="help-content")
+
+    def on_mount(self) -> None:
+        """Initially hidden."""
+        self.display = False
+
+
+# =============================================================================
+# Interactive Settings Widgets (ANV-205)
+# =============================================================================
+
+
+class SelectField(Static):
+    """Cycles through enum options with keyboard navigation."""
+
+    options: reactive[List[str]] = reactive([])
+    value: reactive[str] = reactive("")
+    focused: reactive[bool] = reactive(False)
+
+    def __init__(
+        self,
+        options: List[str],
+        value: str = "",
+        labels: Optional[Dict[str, str]] = None,
+        on_change: Optional[Callable[[str], None]] = None,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self._options = list(options)
+        self._value = value if value else (options[0] if options else "")
+        self._labels = labels or {}
+        self._on_change = on_change
+        self._last_callback_value: Optional[str] = None
+
+    def on_mount(self) -> None:
+        self.options = self._options
+        self.value = self._value
+        self._refresh_display()
+
+    def watch_value(self, value: str) -> None:
+        self._refresh_display()
+        if self._on_change:
+            # Prevent callback loops by checking if value actually changed
+            if self._last_callback_value is None or self._last_callback_value != value:
+                self._last_callback_value = value
+                self._on_change(value)
+
+    def watch_focused(self, focused: bool) -> None:
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        display_label = self._labels.get(self.value, self.value)
+        text = Text()
+        if self.focused:
+            text.append("◀ ", style="cyan")
+            text.append(display_label, style="bold white on blue")
+            text.append(" ▶", style="cyan")
+        else:
+            text.append(f"  {display_label}  ", style="white")
+        self.update(text)
+
+    def cycle_next(self) -> None:
+        if not self._options:
+            return
+        try:
+            idx = self._options.index(self.value)
+            idx = (idx + 1) % len(self._options)
+        except ValueError:
+            idx = 0
+        self.value = self._options[idx]
+
+    def cycle_prev(self) -> None:
+        if not self._options:
+            return
+        try:
+            idx = self._options.index(self.value)
+            idx = (idx - 1) % len(self._options)
+        except ValueError:
+            idx = 0
+        self.value = self._options[idx]
+
+    def handle_key(self, key: str) -> bool:
+        if key in ("right", "space", "enter"):
+            self.cycle_next()
+            return True
+        elif key == "left":
+            self.cycle_prev()
+            return True
+        return False
+
+
+class NumberField(Static):
+    """Numeric input field with validation."""
+
+    value: reactive[float] = reactive(0.0)
+    focused: reactive[bool] = reactive(False)
+    error: reactive[str] = reactive("")
+
+    def __init__(
+        self,
+        value: float = 0.0,
+        min_value: float = 0.0,
+        max_value: float = 1000.0,
+        decimal_places: int = 2,
+        prefix: str = "",
+        suffix: str = "",
+        on_change: Optional[Callable[[float], None]] = None,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self._value = value
+        self._min_value = min_value
+        self._max_value = max_value
+        self._decimal_places = decimal_places
+        self._prefix = prefix
+        self._suffix = suffix
+        self._on_change = on_change
+        self._input_buffer = ""
+        self._last_callback_value: Optional[float] = None
+
+    def on_mount(self) -> None:
+        self.value = self._value
+        self._input_buffer = self._format_value(self._value)
+        self._refresh_display()
+
+    def watch_value(self, value: float) -> None:
+        self._refresh_display()
+        if self._on_change:
+            # Prevent callback loops by checking if value actually changed
+            if self._last_callback_value is None or self._last_callback_value != value:
+                self._last_callback_value = value
+                self._on_change(value)
+
+    def watch_focused(self, focused: bool) -> None:
+        if focused:
+            self._input_buffer = self._format_value(self.value)
+        else:
+            self._commit_value()
+        self._refresh_display()
+
+    def watch_error(self, error: str) -> None:
+        self._refresh_display()
+
+    def _format_value(self, val: float) -> str:
+        return f"{val:.{self._decimal_places}f}"
+
+    def _refresh_display(self) -> None:
+        text = Text()
+        if self._prefix:
+            text.append(self._prefix, style="dim")
+        if self.focused:
+            text.append(self._input_buffer, style="bold white on blue")
+            text.append("▌", style="cyan blink")
+        else:
+            display = self._format_value(self.value)
+            style = "red bold" if self.error else "white"
+            text.append(display, style=style)
+        if self._suffix:
+            text.append(f" {self._suffix}", style="dim")
+        self.update(text)
+
+    def _validate_buffer(self) -> None:
+        try:
+            val = float(self._input_buffer) if self._input_buffer else 0.0
+            if val < self._min_value:
+                self.error = f"Min: {self._min_value}"
+            elif val > self._max_value:
+                self.error = f"Max: {self._max_value}"
+            else:
+                self.error = ""
+        except ValueError:
+            self.error = "Invalid number"
+
+    def _commit_value(self) -> None:
+        try:
+            val = float(self._input_buffer) if self._input_buffer else 0.0
+            val = max(self._min_value, min(self._max_value, val))
+            self.value = round(val, self._decimal_places)
+            self.error = ""
+        except ValueError:
+            pass
+        self._input_buffer = self._format_value(self.value)
+
+    def handle_key(self, key: str) -> bool:
+        if key in "0123456789":
+            self._input_buffer += key
+            self._validate_buffer()
+            self._refresh_display()
+            return True
+        elif key == "period" or key == ".":
+            if "." not in self._input_buffer:
+                self._input_buffer += "."
+                self._refresh_display()
+            return True
+        elif key == "backspace":
+            if self._input_buffer:
+                self._input_buffer = self._input_buffer[:-1]
+                self._validate_buffer()
+                self._refresh_display()
+            return True
+        elif key == "minus" or key == "-":
+            if not self._input_buffer and self._min_value < 0:
+                self._input_buffer = "-"
+                self._refresh_display()
+            return True
+        elif key == "enter":
+            self._commit_value()
+            return True
+        return False
+
+
+class ToggleField(Static):
+    """Boolean toggle field. Space/Enter to toggle."""
+
+    value: reactive[bool] = reactive(False)
+    focused: reactive[bool] = reactive(False)
+
+    def __init__(
+        self,
+        value: bool = False,
+        label_on: str = "Enabled",
+        label_off: str = "Disabled",
+        on_change: Optional[Callable[[bool], None]] = None,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self._value = value
+        self._label_on = label_on
+        self._label_off = label_off
+        self._on_change = on_change
+        self._last_callback_value: Optional[bool] = None
+
+    def on_mount(self) -> None:
+        self.value = self._value
+        self._refresh_display()
+
+    def watch_value(self, value: bool) -> None:
+        self._refresh_display()
+        if self._on_change:
+            # Prevent callback loops by checking if value actually changed
+            if self._last_callback_value is None or self._last_callback_value != value:
+                self._last_callback_value = value
+                self._on_change(value)
+
+    def watch_focused(self, focused: bool) -> None:
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        text = Text()
+        checkbox = "[●]" if self.value else "[ ]"
+        label = self._label_on if self.value else self._label_off
+        if self.focused:
+            text.append(checkbox, style="bold cyan")
+            text.append(f" {label}", style="bold white on blue")
+        else:
+            text.append(checkbox, style="green" if self.value else "dim")
+            text.append(f" {label}", style="white" if self.value else "dim")
+        self.update(text)
+
+    def toggle(self) -> None:
+        self.value = not self.value
+
+    def handle_key(self, key: str) -> bool:
+        if key in ("space", "enter"):
+            self.toggle()
+            return True
+        return False
+
+
+class SettingRow(Horizontal):
+    """Container for a setting: label + field + error indicator."""
+
+    focused: reactive[bool] = reactive(False)
+
+    def __init__(self, label: str, field_widget: Static, key: str, **kwargs):
+        super().__init__(**kwargs)
+        self._label = label
+        self._field = field_widget
+        self._key = key
+
+    @property
+    def key(self) -> str:
+        return self._key
+
+    @property
+    def field(self) -> Static:
+        return self._field
+
+    def compose(self) -> ComposeResult:
+        yield Static(f"{self._label}:", classes="setting-label")
+        self._field.add_class("setting-field")
+        yield self._field
+        yield Static("", classes="setting-error", id=f"error-{self._key}")
+
+    def watch_focused(self, focused: bool) -> None:
+        if hasattr(self._field, 'focused'):
+            self._field.focused = focused
+        if focused:
+            self.add_class("focused-row")
+        else:
+            self.remove_class("focused-row")
+
+    def set_error(self, message: str) -> None:
+        error_widget = self.query_one(f"#error-{self._key}", Static)
+        error_widget.update(message)
+
+    def handle_key(self, key: str) -> bool:
+        if hasattr(self._field, 'handle_key'):
+            return self._field.handle_key(key)
+        return False
+
+
+
+@dataclass
+class SettingsState:
+    """Tracks settings state for modification detection and validation (ANV-207).
+
+    Stores original values from config and current modified values,
+    enabling dirty state tracking and save/cancel functionality.
+    """
+    # Original values (from config)
+    original_billing_model: str = "api"
+    original_agent_warn: float = 5.0
+    original_agent_crit: float = 10.0
+    original_context_warn: int = 80
+    original_context_crit: int = 90
+    original_default_mode: str = "focused"
+
+    # Current (possibly modified) values
+    billing_model: str = "api"
+    agent_warn: float = 5.0
+    agent_crit: float = 10.0
+    context_warn: int = 80
+    context_crit: int = 90
+    default_mode: str = "focused"
+
+    # UI state
+    focused_index: int = 0
+    validation_errors: Dict[str, str] = field(default_factory=dict)
+
+    @property
+    def is_dirty(self) -> bool:
+        """Check if any value differs from original."""
+        return (
+            self.billing_model != self.original_billing_model or
+            self.agent_warn != self.original_agent_warn or
+            self.agent_crit != self.original_agent_crit or
+            self.context_warn != self.original_context_warn or
+            self.context_crit != self.original_context_crit or
+            self.default_mode != self.original_default_mode
+        )
+
+    def load_from_config(self, config) -> None:
+        """Load values from HUD config object."""
+        if not config:
+            return
+        self.original_billing_model = getattr(config.budget, "billing_model", "api")
+        self.original_agent_warn = config.budget.agent_warn_threshold
+        self.original_agent_crit = config.budget.agent_crit_threshold
+        self.original_context_warn = config.context.warn_threshold_pct
+        self.original_context_crit = config.context.crit_threshold_pct
+        self.original_default_mode = getattr(config.hud, "default_mode", "focused")
+        # Reset current to original
+        self.reset()
+
+    def reset(self) -> None:
+        """Reset current values to original."""
+        self.billing_model = self.original_billing_model
+        self.agent_warn = self.original_agent_warn
+        self.agent_crit = self.original_agent_crit
+        self.context_warn = self.original_context_warn
+        self.context_crit = self.original_context_crit
+        self.default_mode = self.original_default_mode
+        self.validation_errors.clear()
+
+    def validate(self) -> bool:
+        """Validate all fields. Returns True if valid."""
+        self.validation_errors.clear()
+
+        # Agent thresholds: warn must be < crit
+        if self.agent_warn >= self.agent_crit:
+            self.validation_errors["agent_warn"] = "Must be < critical"
+            self.validation_errors["agent_crit"] = "Must be > warning"
+
+        # Context thresholds: warn must be < crit
+        if self.context_warn >= self.context_crit:
+            self.validation_errors["context_warn"] = "Must be < critical"
+            self.validation_errors["context_crit"] = "Must be > warning"
+
+        return len(self.validation_errors) == 0
+
+class SettingsOverlay(Container):
+    """Interactive modal settings overlay for HUD configuration (ANV-205/ANV-207).
+
+    Displays editable settings with keyboard navigation.
+    Toggle with 's' key, close with 's' or 'Escape'.
+    Save with Ctrl+S, Cancel with Escape.
+
+    Phase 1 Fields (6 total):
+    - Budget: billing_model, agent_warn_threshold, agent_crit_threshold
+    - Context: warn_threshold_pct, crit_threshold_pct
+    - HUD: default_mode
+    """
+
+    # Field definitions for navigation order
+    FIELD_KEYS = [
+        "billing_model",
+        "agent_warn",
+        "agent_crit",
+        "context_warn",
+        "context_crit",
+        "default_mode",
+    ]
+
+    def __init__(self, config=None, **kwargs):
+        super().__init__(**kwargs)
+        self._config = config
+        self._state = SettingsState()
+        self._rows: Dict[str, SettingRow] = {}
+        self._focused_index = 0
+
+    def compose(self) -> ComposeResult:
+        """Create the interactive settings UI."""
+        yield Static(id="settings-header")
+        yield ScrollableContainer(
+            # Budget group
+            Static("BUDGET", classes="settings-group-header"),
+            SettingRow(
+                "Billing Model",
+                SelectField(
+                    options=["api", "subscription"],
+                    labels={"api": "API Key", "subscription": "Subscription (Pro/Max)"},
+                    value=self._state.billing_model,
+                    on_change=self._on_billing_change,
+                ),
+                key="billing_model",
+            ),
+            SettingRow(
+                "Agent Warning ($)",
+                NumberField(
+                    value=self._state.agent_warn,
+                    min_value=0.01,
+                    max_value=1000.0,
+                    decimal_places=2,
+                    prefix="$",
+                    on_change=self._on_agent_warn_change,
+                ),
+                key="agent_warn",
+            ),
+            SettingRow(
+                "Agent Critical ($)",
+                NumberField(
+                    value=self._state.agent_crit,
+                    min_value=0.01,
+                    max_value=1000.0,
+                    decimal_places=2,
+                    prefix="$",
+                    on_change=self._on_agent_crit_change,
+                ),
+                key="agent_crit",
+            ),
+            # Context group
+            Static("CONTEXT", classes="settings-group-header"),
+            SettingRow(
+                "Warning Threshold",
+                NumberField(
+                    value=float(self._state.context_warn),
+                    min_value=1,
+                    max_value=99,
+                    decimal_places=0,
+                    suffix="%",
+                    on_change=self._on_context_warn_change,
+                ),
+                key="context_warn",
+            ),
+            SettingRow(
+                "Critical Threshold",
+                NumberField(
+                    value=float(self._state.context_crit),
+                    min_value=1,
+                    max_value=99,
+                    decimal_places=0,
+                    suffix="%",
+                    on_change=self._on_context_crit_change,
+                ),
+                key="context_crit",
+            ),
+            # HUD group
+            Static("HUD MODE", classes="settings-group-header"),
+            SettingRow(
+                "Default Mode",
+                SelectField(
+                    options=["focused", "full"],
+                    labels={"focused": "Focused", "full": "Full"},
+                    value=self._state.default_mode,
+                    on_change=self._on_mode_change,
+                ),
+                key="default_mode",
+            ),
+            id="settings-scroll",
+        )
+        yield Static(id="settings-status")
+        yield Static(
+            "[Ctrl+S] Save  [Esc] Cancel  [↑/↓] Navigate  [←/→] Edit",
+            id="settings-footer",
+        )
+
+    def on_mount(self) -> None:
+        """Initially hidden, load config on mount."""
+        self.display = False
+        self._load_config()
+        self._cache_rows()
+        self._update_header()
+        self._update_focus()
+
+    def _cache_rows(self) -> None:
+        """Cache SettingRow references for navigation."""
+        self._rows.clear()
+        for row in self.query(SettingRow):
+            self._rows[row.key] = row
+
+    def _load_config(self) -> None:
+        """Load values from config into state."""
+        config = self._config
+        try:
+            if hasattr(self.app, 'config') and self.app.config:
+                config = self.app.config
+        except Exception:
+            pass
+        self._state.load_from_config(config)
+
+    def update_config(self, config) -> None:
+        """Update configuration and refresh display."""
+        self._config = config
+        self._load_config()
+        self._sync_widgets_from_state()
+        self._update_header()
+
+    def _sync_widgets_from_state(self) -> None:
+        """Sync widget values from state (after load/reset)."""
+        for key, row in self._rows.items():
+            if key == "billing_model":
+                row.field.value = self._state.billing_model
+            elif key == "agent_warn":
+                row.field.value = self._state.agent_warn
+            elif key == "agent_crit":
+                row.field.value = self._state.agent_crit
+            elif key == "context_warn":
+                row.field.value = float(self._state.context_warn)
+            elif key == "context_crit":
+                row.field.value = float(self._state.context_crit)
+            elif key == "default_mode":
+                row.field.value = self._state.default_mode
+
+    def _update_header(self) -> None:
+        """Update header to show dirty indicator."""
+        try:
+            header = self.query_one("#settings-header", Static)
+            dirty_marker = " *" if self._state.is_dirty else ""
+            header.update(f"ANVIL HUD SETTINGS{dirty_marker}")
+        except Exception:
+            pass
+
+    def _update_status(self, message: str = "") -> None:
+        """Update status bar with message or validation errors."""
+        try:
+            status = self.query_one("#settings-status", Static)
+            if self._state.validation_errors:
+                errors = ", ".join(
+                    f"{k}: {v}" for k, v in self._state.validation_errors.items()
+                )
+                status.update(Text(f"⚠ {errors}", style="red"))
+            elif message:
+                status.update(Text(message, style="cyan"))
+            else:
+                status.update("")
+        except Exception:
+            pass
+
+    def _update_focus(self) -> None:
+        """Update visual focus indicator on current field."""
+        for i, key in enumerate(self.FIELD_KEYS):
+            if key in self._rows:
+                self._rows[key].focused = (i == self._focused_index)
+
+    # Value change handlers (update state when widgets change)
+    def _on_billing_change(self, value: str) -> None:
+        self._state.billing_model = value
+        self._update_header()
+
+    def _on_agent_warn_change(self, value: float) -> None:
+        self._state.agent_warn = value
+        self._validate_and_update()
+
+    def _on_agent_crit_change(self, value: float) -> None:
+        self._state.agent_crit = value
+        self._validate_and_update()
+
+    def _on_context_warn_change(self, value: float) -> None:
+        self._state.context_warn = int(value)
+        self._validate_and_update()
+
+    def _on_context_crit_change(self, value: float) -> None:
+        self._state.context_crit = int(value)
+        self._validate_and_update()
+
+    def _on_mode_change(self, value: str) -> None:
+        self._state.default_mode = value
+        self._update_header()
+
+    def _validate_and_update(self) -> None:
+        """Validate state and update UI."""
+        self._state.validate()
+        self._update_header()
+        self._update_status()
+        # Show errors on individual rows
+        for key, row in self._rows.items():
+            error = self._state.validation_errors.get(key, "")
+            row.set_error(error)
+
+    # Navigation
+    def focus_next(self) -> None:
+        """Move focus to next field."""
+        self._focused_index = (self._focused_index + 1) % len(self.FIELD_KEYS)
+        self._update_focus()
+
+    def focus_prev(self) -> None:
+        """Move focus to previous field."""
+        self._focused_index = (self._focused_index - 1) % len(self.FIELD_KEYS)
+        self._update_focus()
+
+    def handle_key(self, key: str) -> bool:
+        """Handle keyboard input for navigation and field editing."""
+        # Navigation
+        if key in ("down", "tab"):
+            self.focus_next()
+            return True
+        elif key in ("up", "shift+tab"):
+            self.focus_prev()
+            return True
+
+        # Delegate to focused field
+        current_key = self.FIELD_KEYS[self._focused_index]
+        if current_key in self._rows:
+            return self._rows[current_key].handle_key(key)
+
+        return False
+
+    @property
+    def is_dirty(self) -> bool:
+        """Check if settings have been modified."""
+        return self._state.is_dirty
+
+    def save(self) -> bool:
+        """Save settings to config file. Returns True if successful (ANV-208)."""
+        if not self._state.validate():
+            self._update_status("Cannot save: validation errors")
+            return False
+
+        try:
+            # Get config and config_service from app
+            config = self._config
+            config_service = None
+            if hasattr(self.app, 'config') and self.app.config:
+                config = self.app.config
+            if hasattr(self.app, '_config_service'):
+                config_service = self.app._config_service
+
+            if config:
+                # Update in-memory config
+                config.budget.billing_model = self._state.billing_model
+                config.budget.agent_warn_threshold = self._state.agent_warn
+                config.budget.agent_crit_threshold = self._state.agent_crit
+                config.context.warn_threshold_pct = self._state.context_warn
+                config.context.crit_threshold_pct = self._state.context_crit
+                config.hud.default_mode = self._state.default_mode
+
+                # Persist to file (ANV-208)
+                if config_service:
+                    if not config_service.save_global_config(config):
+                        self._update_status("Error: Could not save to file")
+                        return False
+                    # Hot-reload to ensure changes take effect
+                    self.app.config = config_service.reload()
+
+                # Update original values (no longer dirty)
+                self._state.load_from_config(config)
+                self._update_header()
+                self._update_status("Settings saved")
+                return True
+        except Exception as e:
+            self._update_status(f"Save failed: {e}")
+            return False
+
+        return False
+
+    def cancel(self) -> None:
+        """Cancel changes and reset to original values."""
+        self._state.reset()
+        self._sync_widgets_from_state()
+        self._update_header()
+        self._update_status("Changes cancelled")
+
+
+class KanbanPanel(Static):
+    """Kanban board widget for issue tracking (ANV-76)."""
+
+    COLUMNS = [
+        ("TODO", IssueStatus.TODO if IssueStatus else None),
+        ("IN PROGRESS", IssueStatus.IN_PROGRESS if IssueStatus else None),
+        ("DONE", IssueStatus.DONE if IssueStatus else None),
+    ]
+
+    issues: reactive[list] = reactive([])
+    selected_col: reactive[int] = reactive(0)
+    selected_row: reactive[int] = reactive(0)
+    visible: reactive[bool] = reactive(True)
+
+    def __init__(self, provider=None, agent_id: str = "", **kwargs):
+        super().__init__(**kwargs)
+        self.provider = provider
+        self.agent_id = agent_id
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="kanban-content")
+
+    def watch_issues(self, issues: list) -> None:
+        """Update display when issues change."""
+        self._refresh_display()
+
+    def watch_selected_col(self, col: int) -> None:
+        """Update display when selection changes."""
+        self._refresh_display()
+
+    def watch_selected_row(self, row: int) -> None:
+        """Update display when selection changes."""
+        self._refresh_display()
+
+    def watch_visible(self, visible: bool) -> None:
+        """Update visibility."""
+        self.display = visible
+
+    def _get_issues_by_status(self, status) -> list:
+        """Get issues filtered by status."""
+        if not self.issues or status is None:
+            return []
+        return [i for i in self.issues if i.status == status]
+
+    def _get_selected_issue(self):
+        """Get currently selected issue."""
+        if not IssueStatus:
+            return None
+        _, status = self.COLUMNS[self.selected_col]
+        col_issues = self._get_issues_by_status(status)
+        if 0 <= self.selected_row < len(col_issues):
+            return col_issues[self.selected_row]
+        return None
+
+    def _refresh_display(self) -> None:
+        """Refresh the kanban board display."""
+        content = self.query_one("#kanban-content", Static)
+
+        if not IssueStatus:
+            content.update(Text("Issue tracking not available", style="dim"))
+            return
+
+        text = Text()
+        text.append("KANBAN BOARD", style="bold white")
+        if self.agent_id:
+            text.append(f" [{self.agent_id[:10]}]", style="dim cyan")
+        text.append("\n")
+        text.append("─" * 72 + "\n", style="dim")
+        text.append("Navigation: h/l=columns  j/k=issues  c=claim  m/M=move  n=new  Enter=details\n\n", style="dim")
+
+        # Get issues per column
+        columns_data = []
+        for name, status in self.COLUMNS:
+            col_issues = self._get_issues_by_status(status)
+            columns_data.append((name, col_issues))
+
+        # Calculate column width
+        col_width = 22
+
+        # Header row
+        for i, (name, col_issues) in enumerate(columns_data):
+            is_selected = (i == self.selected_col)
+            header = f" {name} ({len(col_issues)}) "
+            if is_selected:
+                text.append(f"┌{'─' * col_width}┐ ", style="cyan bold")
+            else:
+                text.append(f"┌{'─' * col_width}┐ ", style="dim")
+        text.append("\n")
+
+        # Column headers
+        for i, (name, col_issues) in enumerate(columns_data):
+            is_selected = (i == self.selected_col)
+            header = f"{name} ({len(col_issues)})"
+            header = header[:col_width].center(col_width)
+            if is_selected:
+                text.append(f"│{header}│ ", style="cyan bold")
+            else:
+                text.append(f"│{header}│ ", style="dim white")
+        text.append("\n")
+
+        # Separator
+        for i, _ in enumerate(columns_data):
+            is_selected = (i == self.selected_col)
+            if is_selected:
+                text.append(f"├{'─' * col_width}┤ ", style="cyan bold")
+            else:
+                text.append(f"├{'─' * col_width}┤ ", style="dim")
+        text.append("\n")
+
+        # Find max rows needed
+        max_rows = max(len(col[1]) for col in columns_data) if columns_data else 0
+        max_rows = max(max_rows, 3)  # Show at least 3 rows
+
+        # Issue rows
+        for row in range(min(max_rows, 8)):  # Limit to 8 rows
+            for col_idx, (name, col_issues) in enumerate(columns_data):
+                is_col_selected = (col_idx == self.selected_col)
+                is_row_selected = (row == self.selected_row)
+                is_selected = is_col_selected and is_row_selected
+
+                if row < len(col_issues):
+                    issue = col_issues[row]
+                    # Format issue card
+                    identifier = issue.identifier[:10]
+                    title = issue.title[:col_width - 4]
+
+                    # Priority indicator
+                    pri = "!" if issue.priority.value <= 1 else " "
+
+                    # Agent indicator
+                    agent = "🤖" if issue.assigned_agent else "  "
+
+                    # Build card content
+                    line1 = f"{pri}{identifier} {agent}"
+                    line1 = line1[:col_width].ljust(col_width)
+
+                    if is_selected:
+                        text.append(f"│", style="cyan bold")
+                        text.append(f"▸{line1[1:]}", style="cyan bold reverse")
+                        text.append(f"│ ", style="cyan bold")
+                    elif is_col_selected:
+                        text.append(f"│{line1}│ ", style="white")
+                    else:
+                        text.append(f"│{line1}│ ", style="dim")
+                else:
+                    # Empty cell
+                    empty = " " * col_width
+                    if is_col_selected:
+                        text.append(f"│{empty}│ ", style="cyan")
+                    else:
+                        text.append(f"│{empty}│ ", style="dim")
+            text.append("\n")
+
+        # Bottom border
+        for i, _ in enumerate(columns_data):
+            is_selected = (i == self.selected_col)
+            if is_selected:
+                text.append(f"└{'─' * col_width}┘ ", style="cyan bold")
+            else:
+                text.append(f"└{'─' * col_width}┘ ", style="dim")
+        text.append("\n")
+
+        # Show selected issue details
+        selected = self._get_selected_issue()
+        if selected:
+            text.append("\n")
+            text.append("─" * 72 + "\n", style="dim")
+            text.append(f"Selected: ", style="dim")
+            text.append(f"{selected.identifier}", style="yellow bold")
+            text.append(f" - {selected.title[:50]}\n", style="white")
+            if selected.description:
+                desc = selected.description[:100].replace("\n", " ")
+                text.append(f"  {desc}...\n", style="dim")
+            if selected.assigned_agent:
+                text.append(f"  Agent: ", style="dim")
+                text.append(f"{selected.assigned_agent}\n", style="cyan")
+            text.append(f"  Priority: ", style="dim")
+            text.append(f"{selected.priority.to_display()}\n", style="magenta")
+
+        content.update(text)
+
+    def move_left(self) -> None:
+        """Move selection left."""
+        if self.selected_col > 0:
+            self.selected_col -= 1
+            self.selected_row = 0
+
+    def move_right(self) -> None:
+        """Move selection right."""
+        if self.selected_col < len(self.COLUMNS) - 1:
+            self.selected_col += 1
+            self.selected_row = 0
+
+    def move_up(self) -> None:
+        """Move selection up."""
+        if self.selected_row > 0:
+            self.selected_row -= 1
+
+    def move_down(self) -> None:
+        """Move selection down."""
+        _, status = self.COLUMNS[self.selected_col]
+        col_issues = self._get_issues_by_status(status)
+        if self.selected_row < len(col_issues) - 1:
+            self.selected_row += 1
+
+    def claim_issue(self) -> bool:
+        """Claim selected issue for current agent."""
+        if not self.provider or not self.agent_id:
+            return False
+        issue = self._get_selected_issue()
+        if issue:
+            try:
+                self.provider.assign_to_agent(issue.identifier, self.agent_id)
+                return True
+            except Exception:
+                pass
+        return False
+
+    def move_issue_forward(self) -> bool:
+        """Move selected issue to next status."""
+        if not self.provider:
+            return False
+        issue = self._get_selected_issue()
+        if not issue:
+            return False
+
+        # Status progression
+        next_status = {
+            IssueStatus.BACKLOG: IssueStatus.TODO,
+            IssueStatus.TODO: IssueStatus.IN_PROGRESS,
+            IssueStatus.IN_PROGRESS: IssueStatus.IN_REVIEW,
+            IssueStatus.IN_REVIEW: IssueStatus.DONE,
+        }
+
+        new_status = next_status.get(issue.status)
+        if new_status:
+            try:
+                self.provider.update_issue(issue.identifier, status=new_status)
+                return True
+            except Exception:
+                pass
+        return False
+
+    def move_issue_backward(self) -> bool:
+        """Move selected issue to previous status."""
+        if not self.provider:
+            return False
+        issue = self._get_selected_issue()
+        if not issue:
+            return False
+
+        # Status regression
+        prev_status = {
+            IssueStatus.DONE: IssueStatus.IN_REVIEW,
+            IssueStatus.IN_REVIEW: IssueStatus.IN_PROGRESS,
+            IssueStatus.IN_PROGRESS: IssueStatus.TODO,
+            IssueStatus.TODO: IssueStatus.BACKLOG,
+        }
+
+        new_status = prev_status.get(issue.status)
+        if new_status:
+            try:
+                self.provider.update_issue(issue.identifier, status=new_status)
+                return True
+            except Exception:
+                pass
+        return False
+
+
+class AgentCard(Static):
+    """Widget displaying a single agent's status."""
+
+    def __init__(self, agent_data: Dict[str, Any], **kwargs):
+        super().__init__(**kwargs)
+        self.agent_data = agent_data
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._render_card())
+
+    def _render_card(self) -> Text:
+        """Render the agent card as Rich Text."""
+        agent = self.agent_data
+        text = Text()
+
+        # Status indicator
+        status = agent.get("status", "active")
+        status_icon = "[green]●[/]" if status == "active" else "[yellow]○[/]"
+
+        # Agent ID and project
+        agent_id = agent.get("id", "unknown")[:20]
+        project_name = agent.get("projectName", "unknown")
+        issue = agent.get("issue", "")
+
+        text.append(f" {status_icon} ", style="bold")
+        text.append(f"{agent_id}\n", style="bold cyan")
+        text.append(f"   {project_name}", style="dim")
+        if issue:
+            text.append(f" → {issue}", style="yellow")
+        text.append("\n")
+
+        # Model and context
+        model = agent.get("model", "Claude")
+        context_usage = agent.get("contextUsage", 0)
+        context_limit = agent.get("contextLimit", 200000)
+        context_pct = int((context_usage / context_limit) * 100) if context_limit > 0 else 0
+
+        # Context bar
+        bar_width = 15
+        filled = int(bar_width * context_pct / 100)
+        bar = "█" * filled + "░" * (bar_width - filled)
+
+        # Color based on usage
+        if context_pct < 50:
+            bar_style = "green"
+        elif context_pct < 80:
+            bar_style = "yellow"
+        else:
+            bar_style = "red"
+
+        text.append(f"   [{model}] ", style="bold blue")
+        text.append(bar, style=bar_style)
+        text.append(f" {context_pct}%\n", style=bar_style)
+
+        # Phase and cost
+        phase = agent.get("phase", "unknown")
+        cost = agent.get("sessionCost", 0.0)
+
+        text.append(f"   Phase: ", style="dim")
+        text.append(f"{phase.upper()}", style="magenta bold")
+        text.append(f" | ${cost:.2f}\n", style="blue")
+
+        # Last activity
+        last_activity = agent.get("lastActivity", "")
+        if last_activity:
+            try:
+                last_dt = datetime.fromisoformat(last_activity.replace('Z', '+00:00'))
+                now = datetime.now(timezone.utc)
+                age_seconds = (now - last_dt).total_seconds()
+
+                if age_seconds < 60:
+                    age_str = f"{int(age_seconds)}s ago"
+                elif age_seconds < 3600:
+                    age_str = f"{int(age_seconds / 60)}m ago"
+                else:
+                    age_str = f"{int(age_seconds / 3600)}h ago"
+
+                text.append(f"   Last active: {age_str}\n", style="dim")
+            except (ValueError, TypeError):
+                pass
+
+        return text
+
+
+class AgentList(ScrollableContainer):
+    """Scrollable list of agent cards."""
+
+    agents: reactive[Dict[str, Any]] = reactive({})
+    show_details: reactive[bool] = reactive(False)
+    detailed_states: reactive[Dict[str, Any]] = reactive({})
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="agent-list-content")
+
+    def watch_agents(self, agents: Dict[str, Any]) -> None:
+        """Update display when agents change."""
+        self._refresh_display()
+
+    def watch_show_details(self, show_details: bool) -> None:
+        """Update display when detail mode changes."""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the agent list display."""
+        content = self.query_one("#agent-list-content", Static)
+
+        if not self.agents:
+            content.update(Text("No active agents\n\nStart a Claude Code session to see it here.", style="dim"))
+            return
+
+        text = Text()
+        text.append(f"ACTIVE AGENTS ({len(self.agents)})\n", style="bold white")
+        text.append("─" * 36 + "\n\n", style="dim")
+
+        for agent_id, agent in self.agents.items():
+            # Status indicator
+            status = agent.get("status", "active")
+            status_icon = "●" if status == "active" else "○"
+            status_style = "green" if status == "active" else "yellow"
+
+            # Agent ID and project
+            display_id = agent_id[:16] + "..." if len(agent_id) > 16 else agent_id
+            project_name = agent.get("projectName", "unknown")
+            issue = agent.get("issue", "")
+
+            text.append(f" {status_icon} ", style=status_style)
+            text.append(f"{display_id}\n", style="bold cyan")
+            text.append(f"   {project_name}", style="dim white")
+            if issue:
+                text.append(f" → {issue}", style="yellow")
+            text.append("\n")
+
+            # Model and context bar
+            model = agent.get("model", "Claude")
+            context_usage = agent.get("contextUsage", 0)
+            context_limit = agent.get("contextLimit", 200000)
+            context_pct = int((context_usage / context_limit) * 100) if context_limit > 0 else 0
+
+            bar_width = 15
+            filled = int(bar_width * context_pct / 100)
+            bar = "█" * filled + "░" * (bar_width - filled)
+
+            if context_pct < 50:
+                bar_style = "green"
+            elif context_pct < 80:
+                bar_style = "yellow"
+            else:
+                bar_style = "red"
+
+            text.append(f"   [{model}] ", style="bold blue")
+            text.append(bar, style=bar_style)
+            text.append(f" {context_pct}%", style=bar_style)
+
+            # Show estimated turns until compaction (ANV-98)
+            estimated_turns = agent.get("estimatedTurns")
+            if estimated_turns is not None:
+                if estimated_turns <= 5:
+                    text.append(f" (~{estimated_turns}t)", style="red bold")
+                elif estimated_turns <= 15:
+                    text.append(f" (~{estimated_turns}t)", style="yellow")
+                else:
+                    text.append(f" (~{estimated_turns}t)", style="dim")
+            text.append("\n")
+
+            # Phase and cost
+            phase = agent.get("phase") or "idle"
+            cost = agent.get("sessionCost", 0.0)
+
+            text.append(f"   Phase: ", style="dim")
+            text.append(f"{phase.upper()}", style="magenta bold")
+            text.append(f" | ${cost:.2f}\n", style="blue")
+
+            # Last activity
+            last_activity = agent.get("lastActivity", "")
+            if last_activity:
+                try:
+                    last_dt = datetime.fromisoformat(last_activity.replace('Z', '+00:00'))
+                    now = datetime.now(timezone.utc)
+                    age_seconds = (now - last_dt).total_seconds()
+
+                    if age_seconds < 60:
+                        age_str = f"{int(age_seconds)}s ago"
+                    elif age_seconds < 3600:
+                        age_str = f"{int(age_seconds / 60)}m ago"
+                    else:
+                        age_str = f"{int(age_seconds / 3600)}h ago"
+
+                    text.append(f"   Last: {age_str}\n", style="dim")
+                except (ValueError, TypeError):
+                    pass
+
+            # Detailed view: show tool activity from transcript (ANV-126)
+            if self.show_details:
+                self._render_agent_tools(text, agent_id, agent)
+
+            text.append("\n")
+
+        # Aggregate stats
+        text.append("─" * 36 + "\n", style="dim")
+        text.append("AGGREGATE\n", style="bold white")
+
+        total_cost = sum(a.get("sessionCost", 0) for a in self.agents.values())
+        avg_context = (
+            sum(a.get("contextUsage", 0) / a.get("contextLimit", 200000) * 100
+                for a in self.agents.values()) / len(self.agents)
+            if self.agents else 0
+        )
+
+        # Count agents by status
+        active_count = sum(1 for a in self.agents.values() if a.get("status") == "active")
+
+        # Count agents at risk (>80% context)
+        at_risk = sum(1 for a in self.agents.values()
+                      if (a.get("contextUsage", 0) / a.get("contextLimit", 200000) * 100) > 80)
+
+        # Phases breakdown
+        phases = {}
+        for a in self.agents.values():
+            phase = a.get("phase") or "idle"
+            phases[phase] = phases.get(phase, 0) + 1
+
+        text.append(f"Active: ", style="dim")
+        text.append(f"{active_count}", style="green bold")
+        if at_risk > 0:
+            text.append(f" | At Risk: ", style="dim")
+            text.append(f"{at_risk}", style="red bold")
+        text.append("\n")
+
+        text.append(f"Total Cost: ", style="dim")
+        text.append(f"${total_cost:.2f}\n", style="blue bold")
+        text.append(f"Avg Context: ", style="dim")
+        text.append(f"{avg_context:.0f}%\n", style="green" if avg_context < 50 else ("yellow" if avg_context < 80 else "red"))
+
+        # Show phases if more than one agent
+        if len(phases) > 0 and len(self.agents) > 1:
+            text.append("Phases: ", style="dim")
+            phase_parts = []
+            for phase, count in sorted(phases.items()):
+                phase_parts.append(f"{phase}:{count}")
+            text.append(" ".join(phase_parts) + "\n", style="magenta")
+
+        content.update(text)
+
+    def _render_agent_tools(self, text: Text, agent_id: str, agent: Dict[str, Any]) -> None:
+        """Render per-agent tool activity from transcript (ANV-126).
+
+        Args:
+            text: Rich Text object to append to
+            agent_id: Agent identifier
+            agent: Agent data dictionary
+        """
+        # Get transcript path from agent data
+        transcript_path = agent.get("transcriptPath", "")
+
+        if not transcript_path or not TranscriptParser:
+            # Fallback to recentTools from detailed_states
+            detailed = self.detailed_states.get(agent_id, {})
+            recent_tools = detailed.get("recentTools", [])
+            if recent_tools:
+                text.append("   ┌─ Recent Tools ─────────\n", style="dim cyan")
+                for tool in recent_tools[:5]:
+                    tool_name = tool.get("name", "?")[:12]
+                    duration = tool.get("duration")
+                    duration_str = f" ({duration}ms)" if duration else ""
+                    text.append(f"   │ {tool_name}{duration_str}\n", style="dim")
+                text.append("   └─────────────────────────\n", style="dim cyan")
+            return
+
+        try:
+            parser = TranscriptParser(cache_ttl=1.0)
+            activity = parser.parse(transcript_path)
+
+            has_tools = activity.running or activity.tool_counts
+
+            if has_tools:
+                text.append("   ┌─ Tool Activity ────────\n", style="dim cyan")
+
+                # Show running tools
+                for tool in activity.running[:2]:
+                    target = tool.target or ""
+                    if len(target) > 20:
+                        target = "..." + target[-17:]
+                    text.append("   │ ", style="dim cyan")
+                    text.append("◐ ", style="cyan bold")
+                    text.append(f"{tool.name[:10]}", style="white bold")
+                    if target:
+                        text.append(f" {target}", style="dim")
+                    text.append("\n")
+
+                # Show completed tools with counts
+                top_tools = activity.get_top_completed(limit=3)
+                for name, count in top_tools:
+                    text.append("   │ ", style="dim cyan")
+                    text.append("✓ ", style="green")
+                    text.append(f"{name[:10]}", style="white")
+                    if count > 1:
+                        text.append(f" ×{count}", style="cyan")
+                    text.append("\n")
+
+                # Show error count if any
+                if activity.error_count > 0:
+                    text.append("   │ ", style="dim cyan")
+                    text.append(f"⚠ {activity.error_count} errors\n", style="red")
+
+                text.append("   └─────────────────────────\n", style="dim cyan")
+
+        except Exception:
+            # Graceful degradation - show nothing on error
+            pass
+
+
+class AnvilHUD(App):
+    """Main TUI application for Anvil HUD."""
+
+    # Track which agents we've already warned about
+    warned_agents: set = set()
+
+    # HUD v3: Mode state (ANV-128)
+    mode: reactive[Literal["focused", "full"]] = reactive("focused")
+    active_tab: reactive[int] = reactive(0)
+    show_help: reactive[bool] = reactive(False)  # ANV-131: Help overlay state
+    show_settings: reactive[bool] = reactive(False)  # ANV-136: Settings overlay state
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+
+    #main-container {
+        width: 100%;
+        height: 100%;
+        padding: 0;  /* Removed padding to eliminate empty space at top */
+    }
+
+    #title-row {
+        width: 100%;
+        height: 1;
+    }
+
+    #header-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        padding: 0 1;
+    }
+
+    #timestamp {
+        text-align: right;
+        color: $text-muted;
+        padding: 0 1;
+    }
+
+    #panels-container {
+        width: 100%;
+        height: 1fr;
+    }
+
+    AgentList {
+        width: 2fr;
+        height: 100%;
+        border: solid $primary;
+        padding: 1;
+    }
+
+    CostPanel {
+        width: 1fr;
+        height: 100%;
+        border: solid $secondary;
+        padding: 1;
+    }
+
+    TaskPanel {
+        width: 1fr;
+        height: 100%;
+        border: solid $warning;
+        padding: 1;
+    }
+
+    QualityPanel {
+        width: 1fr;
+        height: 100%;
+        border: solid $success;
+        padding: 1;
+    }
+
+    CoordinationPanel {
+        width: 1fr;
+        height: 100%;
+        border: solid $error;
+        padding: 1;
+    }
+
+    ToolActivityPanel {
+        width: 1fr;
+        height: 100%;
+        border: solid $accent;
+        padding: 1;
+    }
+
+    KanbanPanel {
+        width: 100%;
+        height: auto;
+        min-height: 20;
+        border: solid $primary;
+        padding: 1;
+        margin-bottom: 1;
+    }
+
+    TabBar {
+        width: 100%;
+        height: 1;
+        background: $primary-background;
+        padding: 0 1;
+    }
+
+    #mode-indicator {
+        text-align: right;
+        color: $text-muted;
+        padding: 0 1;
+    }
+
+    #upper-panel {
+        width: 100%;
+        height: auto;
+        max-height: 50%;
+    }
+
+    /* Upper panel starts hidden - shown when Kanban tab active */
+    #upper-panel.initially-hidden {
+        display: none;
+        height: 0;
+        max-height: 0;
+    }
+
+    /* Also hide with focused-hidden class */
+    #upper-panel.focused-hidden {
+        display: none;
+        height: 0;
+        max-height: 0;
+    }
+
+    #status-bar {
+        dock: bottom;
+        height: 1;
+        background: $primary-background;
+        color: $text;
+        padding: 0 1;
+    }
+
+    /* HUD v3: Focused Mode layout (ANV-128/130) */
+    /* Constraint-based: TitleRow (1) → TabBar (1) → Content (flex) → Footer (1) */
+
+    .focused-mode #panels-container {
+        width: 100%;
+        height: 1fr;
+    }
+
+    .focused-mode #upper-panel {
+        width: 100%;
+        height: 1fr;
+        max-height: 100%;
+    }
+
+    /* Full-width panel styling in Focused Mode */
+    .focused-mode AgentList,
+    .focused-mode CostPanel,
+    .focused-mode QualityPanel,
+    .focused-mode CoordinationPanel,
+    .focused-mode KanbanPanel {
+        width: 100%;
+        height: 100%;
+    }
+
+    /* Active panel gets full viewport in Focused Mode */
+    .focused-panel {
+        width: 100% !important;
+        height: 1fr !important;
+    }
+
+    /* Hidden panels in Focused Mode - use display: none */
+    .focused-hidden {
+        display: none;
+    }
+
+    /* HUD v3: Help Overlay modal styling (ANV-128/131) */
+    HelpOverlay {
+        layer: overlay;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.7);
+        align: center middle;
+    }
+
+    HelpOverlay #help-content {
+        width: auto;
+        height: auto;
+        background: $surface;
+        border: heavy $primary;
+        padding: 1 2;
+        color: $text;
+    }
+
+    /* Settings overlay (ANV-136) */
+    SettingsOverlay {
+        dock: top;
+        layer: overlay;
+        width: 100%;
+        height: 100%;
+        align: center middle;
+        display: none;
+    }
+
+    SettingsOverlay #settings-content {
+        width: auto;
+        height: auto;
+        background: $surface;
+        border: heavy $secondary;
+        padding: 1 2;
+        color: $text;
+    }
+
+    /* Dim main content when help is shown */
+    .help-active #main-container {
+        opacity: 0.3;
+    }
+
+    /* Dim main content when settings is shown */
+    .settings-active #main-container {
+        opacity: 0.3;
+    }
+
+    /* Settings Overlay Layout (ANV-205 Phase 2) */
+    #settings-title {
+        width: 100%;
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+
+    #settings-scroll {
+        width: 100%;
+        height: auto;
+        max-height: 20;
+        padding: 0 1;
+    }
+
+    #settings-status {
+        width: 100%;
+        text-align: center;
+        height: 1;
+        margin-top: 1;
+    }
+
+    #settings-footer {
+        width: 100%;
+        text-align: center;
+        color: $text-muted;
+        margin-top: 1;
+    }
+
+    .settings-section-header {
+        width: 100%;
+        text-style: bold;
+        color: $secondary;
+        margin-top: 1;
+        margin-bottom: 0;
+    }
+
+    /* Interactive Settings Widgets (ANV-205) */
+    SettingRow {
+        width: 100%;
+        height: auto;
+        padding: 0 1;
+        margin: 0 0 1 0;
+    }
+
+    SettingRow.focused-row {
+        background: $surface-darken-1;
+    }
+
+    .setting-label {
+        width: 22;
+        color: $text-muted;
+    }
+
+    .setting-field {
+        width: 1fr;
+        min-width: 20;
+    }
+
+    .setting-error {
+        width: auto;
+        color: $error;
+        padding-left: 1;
+    }
+
+    SelectField {
+        width: auto;
+        min-width: 15;
+    }
+
+    NumberField {
+        width: auto;
+        min-width: 10;
+    }
+
+    ToggleField {
+        width: auto;
+        min-width: 12;
+    }
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("r", "refresh", "Refresh"),
+        ("d", "toggle_details", "Details"),
+        ("s", "toggle_settings", "Settings"),  # ANV-136: Settings overlay
+        ("?", "toggle_help", "Help"),  # ANV-131: Changed to toggle_help
+        ("escape", "close_overlays", ""),  # ANV-136: Close any overlay
+        ("ctrl+s", "save_settings", ""),  # ANV-205: Save settings
+        # HUD v3: Mode and tab navigation (ANV-128)
+        ("m", "toggle_mode", "Mode"),
+        ("1", "tab_1", ""),
+        ("2", "tab_2", ""),
+        ("3", "tab_3", ""),
+        ("4", "tab_4", ""),
+        ("5", "tab_5", ""),
+        ("tab", "next_tab", ""),
+        ("shift+tab", "prev_tab", ""),
+        # Kanban navigation (when visible)
+        ("h", "kanban_left", ""),
+        ("l", "kanban_right", ""),
+        ("j", "kanban_down", ""),
+        ("ctrl+k", "kanban_up", ""),
+        ("c", "kanban_claim", ""),
+        ("n", "kanban_forward", ""),
+        ("shift+n", "kanban_backward", ""),
+    ]
+
+    def __init__(self, demo_mode: bool = False, project_path: Optional[str] = None, **kwargs):
+        super().__init__(**kwargs)
+
+        # Load configuration (ANV-116-118)
+        # Store config service for hot-reload support (ANV-136)
+        self._config_service = get_config_service(project_path) if get_config_service else None
+        self.config = self._config_service.config if self._config_service else None
+        self._config_reload_counter = 0  # Reload config every N refresh cycles
+        self._pending_settings_close = False  # ANV-208: Track if user confirmed discard
+        self.demo_mode = demo_mode or (self.config.demo_mode if self.config else False)
+        self.project_path = project_path
+
+        self.registry: Optional[AgentRegistry] = None
+        self.linear_service: Optional["LinearDataService"] = None
+        self.quality_services: Dict[str, "QualityService"] = {}  # project_path -> service
+        self.coordination_service: Optional["CoordinationService"] = None
+        self.github_service: Optional["GitHubService"] = None  # ANV-111-113
+        self.coderabbit_service: Optional["CodeRabbitService"] = None  # ANV-114-115
+        self.issue_provider = None  # ANV-76: Issue provider for Kanban
+        self.refresh_timer: Optional[Timer] = None
+
+        if not self.demo_mode and AgentRegistry:
+            self.registry = AgentRegistry()
+        if not self.demo_mode and LinearDataService:
+            if not self.config or self.config.integrations.enable_linear:
+                self.linear_service = LinearDataService()
+        if not self.demo_mode and CoordinationService:
+            self.coordination_service = CoordinationService()
+        if not self.demo_mode and GitHubService:
+            if not self.config or self.config.integrations.enable_github:
+                self.github_service = GitHubService()
+        if not self.demo_mode and CodeRabbitService:
+            if not self.config or self.config.integrations.enable_coderabbit:
+                self.coderabbit_service = CodeRabbitService()
+        # ANV-76: Initialize issue provider
+        if not self.demo_mode and get_provider:
+            try:
+                self.issue_provider = get_provider(Path(project_path) if project_path else None)
+            except Exception:
+                self.issue_provider = None
+
+    def compose(self) -> ComposeResult:
+        # Removed Header() widget - redundant with title-row and wastes 1-2 lines of vertical space
+        with Container(id="main-container"):
+            with Horizontal(id="title-row"):
+                yield Static("🔧 Anvil HUD", id="header-title")
+                yield Static("", id="timestamp")
+                yield Static("Mode:Focused", id="mode-indicator")
+            # HUD v3: Tab bar for Focused Mode (ANV-128)
+            yield TabBar(id="tab-bar")
+            # ANV-76: Kanban panel (toggled with 'k' in Full Mode, or tab 2 in Focused)
+            with Container(id="upper-panel", classes="initially-hidden"):
+                yield KanbanPanel(
+                    provider=self.issue_provider,
+                    agent_id=self._get_current_agent_id(),
+                    id="kanban-panel"
+                )
+            with Horizontal(id="panels-container"):
+                yield AgentList(id="agent-list")
+                yield CostPanel(id="cost-panel")
+                yield TaskPanel(id="task-panel")
+                yield QualityPanel(id="quality-panel")
+                yield CoordinationPanel(id="coordination-panel")
+                yield ToolActivityPanel(id="tool-activity-panel")
+        # HUD v3: Overlays (ANV-131, ANV-136) - must be last for z-order
+        yield HelpOverlay(id="help-overlay")
+        yield SettingsOverlay(config=self.config, id="settings-overlay")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Called when app is mounted."""
+        self.title = "Anvil HUD"
+        self.sub_title = "Multi-Agent Dashboard"
+
+        # HUD v3: Load default mode from config (ANV-128)
+        if self.config and hasattr(self.config, 'hud') and hasattr(self.config.hud, 'default_mode'):
+            self.mode = self.config.hud.default_mode
+        else:
+            self.mode = "focused"  # Default to focused mode
+
+        # Initial UI state
+        self._update_mode_ui()
+
+        # Initial refresh
+        self.action_refresh()
+
+        # Start auto-refresh timer (configurable via ANV-116-118)
+        refresh_seconds = 2.0
+        if self.config:
+            refresh_seconds = self.config.refresh.agent_refresh_seconds
+        self.refresh_timer = self.set_interval(refresh_seconds, self.action_refresh)
+
+    def on_key(self, event) -> None:
+        """Forward keys to settings overlay when active (ANV-205)."""
+        if self.show_settings:
+            try:
+                settings = self.query_one("#settings-overlay", SettingsOverlay)
+                if settings.handle_key(event.key):
+                    event.stop()
+                    event.prevent_default()
+            except Exception:
+                pass
+
+    def watch_mode(self, mode: str) -> None:
+        """Update UI when mode changes (HUD v3 - ANV-128)."""
+        self._update_mode_ui()
+
+    def watch_active_tab(self, tab: int) -> None:
+        """Update UI when active tab changes (HUD v3 - ANV-128)."""
+        if self.mode == "focused":
+            self._update_focused_panels()
+            # Sync TabBar widget
+            try:
+                tab_bar = self.query_one("#tab-bar", TabBar)
+                tab_bar.active_tab = tab
+            except Exception:
+                pass
+
+    def watch_show_help(self, show: bool) -> None:
+        """Update UI when help overlay state changes (HUD v3 - ANV-131)."""
+        try:
+            help_overlay = self.query_one("#help-overlay", HelpOverlay)
+            help_overlay.display = show
+
+            # Add/remove help-active class for dimming effect
+            if show:
+                self.add_class("help-active")
+            else:
+                self.remove_class("help-active")
+        except Exception:
+            pass
+
+    def watch_show_settings(self, show: bool) -> None:
+        """Update UI when settings overlay state changes (ANV-136)."""
+        try:
+            settings_overlay = self.query_one("#settings-overlay", SettingsOverlay)
+            settings_overlay.display = show
+
+            # Refresh config when opening
+            if show:
+                settings_overlay.update_config(self.config)
+
+            # Add/remove settings-active class for dimming effect
+            if show:
+                self.add_class("settings-active")
+            else:
+                self.remove_class("settings-active")
+        except Exception:
+            pass
+
+    def _update_mode_ui(self) -> None:
+        """Update UI elements based on current mode (HUD v3 - ANV-128/130)."""
+        try:
+            # Update mode indicator
+            indicator = self.query_one("#mode-indicator", Static)
+            if self.mode == "focused":
+                indicator.update("Mode:Focused")
+            else:
+                indicator.update("[FULL]")
+
+            # Show/hide TabBar based on mode
+            tab_bar = self.query_one("#tab-bar", TabBar)
+            if self.mode == "focused":
+                tab_bar.display = True
+                tab_bar.styles.height = "1"
+            else:
+                tab_bar.display = False
+                tab_bar.styles.height = "0"
+
+            # Add/remove focused-mode class on Screen for CSS targeting (ANV-130)
+            main_container = self.query_one("#main-container", Container)
+            if self.mode == "focused":
+                main_container.add_class("focused-mode")
+            else:
+                main_container.remove_class("focused-mode")
+
+            # Update panel visibility
+            if self.mode == "focused":
+                self._update_focused_panels()
+            else:
+                self._show_all_panels()
+
+        except Exception:
+            pass  # Graceful degradation during initial mount
+
+    def _update_focused_panels(self) -> None:
+        """Show only the active panel in Focused Mode (HUD v3 - ANV-128/130).
+
+        Uses CSS classes for smooth transitions:
+        - .focused-panel: Applied to the active panel for full-width styling
+        - .focused-hidden: Applied to inactive panels to hide them
+
+        Panel mapping:
+        - Tab 0: Agents (AgentList)
+        - Tab 1: Kanban (KanbanPanel)
+        - Tab 2: Quality (QualityPanel)
+        - Tab 3: Costs (CostPanel)
+        - Tab 4: Coordination (CoordinationPanel)
+        """
+        try:
+            # Panel configuration: (id, widget_class, container)
+            # container: "panels" = in panels-container, "upper" = in upper-panel
+            panel_config = [
+                ("agent-list", AgentList, "panels"),
+                ("kanban-panel", KanbanPanel, "upper"),
+                ("quality-panel", QualityPanel, "panels"),
+                ("cost-panel", CostPanel, "panels"),
+                ("coordination-panel", CoordinationPanel, "panels"),
+            ]
+
+            # Update each panel's visibility and CSS classes
+            for i, (panel_id, widget_class, container) in enumerate(panel_config):
+                try:
+                    panel = self.query_one(f"#{panel_id}", widget_class)
+                    is_active = (i == self.active_tab)
+
+                    # Set display and CSS classes
+                    panel.display = is_active
+                    if is_active:
+                        panel.add_class("focused-panel")
+                        panel.remove_class("focused-hidden")
+                    else:
+                        panel.remove_class("focused-panel")
+                        panel.add_class("focused-hidden")
+                except Exception:
+                    pass
+
+            # Show the appropriate container based on active tab
+            panels_container = self.query_one("#panels-container", Horizontal)
+            upper_panel = self.query_one("#upper-panel", Container)
+
+            if self.active_tab == 1:  # Kanban uses upper-panel
+                panels_container.display = False
+                panels_container.add_class("focused-hidden")
+                upper_panel.display = True
+                upper_panel.styles.height = "1fr"
+                upper_panel.styles.max_height = "100%"
+                upper_panel.remove_class("focused-hidden")
+                upper_panel.remove_class("initially-hidden")
+            else:  # All other panels use panels-container
+                panels_container.display = True
+                panels_container.remove_class("focused-hidden")
+                upper_panel.display = False
+                upper_panel.styles.height = "0"
+                upper_panel.styles.max_height = "0"
+                upper_panel.add_class("focused-hidden")
+
+            # Always hide auxiliary panels in Focused Mode (they're not in tab list)
+            try:
+                task_panel = self.query_one("#task-panel", TaskPanel)
+                task_panel.display = False
+                task_panel.add_class("focused-hidden")
+            except Exception:
+                pass
+
+            try:
+                tool_panel = self.query_one("#tool-activity-panel", ToolActivityPanel)
+                tool_panel.display = False
+                tool_panel.add_class("focused-hidden")
+            except Exception:
+                pass
+
+        except Exception:
+            pass
+
+    def _show_all_panels(self) -> None:
+        """Show all panels in Full Mode (HUD v3 - ANV-128/130).
+
+        Removes focused-mode CSS classes and restores normal panel visibility.
+        """
+        try:
+            # All panels in the horizontal container
+            panels = [
+                ("#agent-list", AgentList),
+                ("#cost-panel", CostPanel),
+                ("#task-panel", TaskPanel),
+                ("#quality-panel", QualityPanel),
+                ("#coordination-panel", CoordinationPanel),
+                ("#tool-activity-panel", ToolActivityPanel),
+            ]
+
+            for panel_id, widget_class in panels:
+                try:
+                    panel = self.query_one(panel_id, widget_class)
+                    panel.display = True
+                    # Remove focused mode classes
+                    panel.remove_class("focused-panel")
+                    panel.remove_class("focused-hidden")
+                except Exception:
+                    pass
+
+            # Show containers
+            self.query_one("#panels-container", Horizontal).display = True
+
+            # Completely remove upper-panel from DOM in Full Mode
+            # This is the only reliable way to prevent it from taking space
+            try:
+                upper_panel = self.query_one("#upper-panel", Container)
+                upper_panel.remove()
+            except Exception:
+                pass  # Already removed
+        except Exception:
+            pass
+
+    def action_refresh(self) -> None:
+        """Refresh agent data."""
+        # Hot-reload config every 5 refresh cycles (~10 seconds) for billing_model changes (ANV-136)
+        self._config_reload_counter += 1
+        if self._config_reload_counter >= 5 and self._config_service:
+            self._config_reload_counter = 0
+            self.config = self._config_service.reload()
+
+        # Update timestamp
+        timestamp = self.query_one("#timestamp", Static)
+        timestamp.update(datetime.now().strftime("%H:%M:%S"))
+
+        # Get agents
+        if self.demo_mode:
+            agents = self._get_demo_agents()
+        elif self.registry:
+            agents = self.registry.get_all()
+        else:
+            agents = {}
+
+        # Update agent list
+        agent_list = self.query_one("#agent-list", AgentList)
+        agent_list.agents = agents
+
+        # Update cost panel (ANV-94)
+        cost_panel = self.query_one("#cost-panel", CostPanel)
+        cost_panel.agents = agents
+
+        # Update task panel with Linear issue data (ANV-100/101/102)
+        task_panel = self.query_one("#task-panel", TaskPanel)
+        task_panel.agents = agents
+        if self.demo_mode:
+            task_panel.issues = self._get_demo_issues()
+        elif self.linear_service:
+            task_panel.issues = self.linear_service.get_issues_for_agents(agents)
+
+        # Update quality panel (ANV-103/104/105)
+        quality_panel = self.query_one("#quality-panel", QualityPanel)
+        quality_panel.agents = agents
+        if self.demo_mode:
+            quality_panel.quality_results = self._get_demo_quality()
+        elif QualityService:
+            quality_results = {}
+            for agent_id, agent in agents.items():
+                project = agent.get("project")
+                if project and project not in quality_results:
+                    # Get or create quality service for this project
+                    if project not in self.quality_services:
+                        self.quality_services[project] = QualityService(project)
+                    # Get cached results (runs checks if cache expired)
+                    quality_results[project] = self.quality_services[project].get_results()
+            quality_panel.quality_results = quality_results
+
+        # Update GitHub/CI status (ANV-111-113)
+        if self.demo_mode:
+            quality_panel.github_status = self._get_demo_github_status()
+        elif self.github_service:
+            quality_panel.github_status = self.github_service.get_status_for_agents(agents)
+
+        # Update CodeRabbit status (ANV-114-115)
+        if self.demo_mode:
+            quality_panel.coderabbit_status = self._get_demo_coderabbit_status()
+        elif self.coderabbit_service and quality_panel.github_status:
+            # Get CodeRabbit status for PRs (uses GitHub PR numbers)
+            quality_panel.coderabbit_status = self.coderabbit_service.get_status_for_prs(
+                quality_panel.github_status
+            )
+
+        # Update coordination panel (ANV-106-110)
+        coordination_panel = self.query_one("#coordination-panel", CoordinationPanel)
+        coordination_panel.agents = agents
+        if self.demo_mode:
+            coordination_panel.coordination = self._get_demo_coordination()
+        elif self.coordination_service:
+            # Update coordination service with agent data including detailed states
+            agents_with_details = {}
+            for agent_id, agent in agents.items():
+                agent_copy = dict(agent)
+                if self.registry:
+                    detailed = self.registry.get_detailed_state(agent_id)
+                    if detailed:
+                        agent_copy["detailed"] = detailed
+                agents_with_details[agent_id] = agent_copy
+            coordination_panel.coordination = self.coordination_service.update_from_registry(agents_with_details)
+
+        # Also refresh detailed states if in detailed view
+        if agent_list.show_details and self.registry:
+            detailed_states = {}
+            for agent_id in agents.keys():
+                state = self.registry.get_detailed_state(agent_id)
+                if state:
+                    detailed_states[agent_id] = state
+            agent_list.detailed_states = detailed_states
+
+        # Update tool activity panel (ANV-125)
+        tool_panel = self.query_one("#tool-activity-panel", ToolActivityPanel)
+        if self.demo_mode:
+            tool_panel.tool_activity = self._get_demo_tool_activity()
+        elif TranscriptParser:
+            # Aggregate tool activity from all agents' transcripts
+            tool_activity = self._aggregate_tool_activity(agents)
+            tool_panel.tool_activity = tool_activity
+
+        # ANV-76: Refresh Kanban panel if visible
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                self._refresh_kanban()
+        except Exception:
+            pass
+
+        # Check for context warnings (only notify once per agent)
+        self._check_context_warnings(agents)
+
+        # Check for cost/budget alerts (ANV-95)
+        self._check_budget_alerts(agents)
+
+    def _cleanup_warned_agents(self, agents: Dict[str, Any]) -> None:
+        """Clean up warnings for agents no longer present.
+
+        Handles all warning suffixes:
+        - Context warnings: agent_id_warn, agent_id_crit
+        - Cost warnings: agent_id_cost_warn, agent_id_cost_crit
+        - Total warnings: total_cost_warn, total_cost_crit
+        """
+        current_ids = set(agents.keys())
+
+        # Known suffixes to strip (order matters - longest first)
+        suffixes = ['_cost_crit', '_cost_warn', '_crit', '_warn']
+
+        def extract_agent_id(warning_key: str) -> str:
+            """Extract agent ID from warning key by stripping known suffixes."""
+            for suffix in suffixes:
+                if warning_key.endswith(suffix):
+                    return warning_key[:-len(suffix)]
+            return warning_key
+
+        # Keep warnings if:
+        # 1. It's a "total" warning (applies to all agents collectively)
+        # 2. The extracted agent_id is still in current_ids
+        self.warned_agents = {
+            w for w in self.warned_agents
+            if w.startswith('total_') or extract_agent_id(w) in current_ids
+        }
+
+    def _check_context_warnings(self, agents: Dict[str, Any]) -> None:
+        """Check for high context agents and notify (configurable via ANV-116-118)."""
+        # Context thresholds from config or defaults
+        if self.config:
+            CONTEXT_WARN_PCT = self.config.context.warn_threshold_pct
+            CONTEXT_CRIT_PCT = self.config.context.crit_threshold_pct
+        else:
+            CONTEXT_WARN_PCT = 80
+            CONTEXT_CRIT_PCT = 90
+
+        for agent_id, agent in agents.items():
+            context_usage = agent.get("contextUsage", 0)
+            context_limit = agent.get("contextLimit", 200000)
+            context_pct = (context_usage / context_limit * 100) if context_limit > 0 else 0
+
+            # Warn at configurable thresholds
+            if context_pct >= CONTEXT_CRIT_PCT and f"{agent_id}_crit" not in self.warned_agents:
+                project = agent.get("projectName", "unknown")
+                self.notify(
+                    f"⚠️ {project} at {context_pct:.0f}% context!",
+                    title="Critical Context",
+                    severity="error",
+                    timeout=10
+                )
+                self.warned_agents.add(f"{agent_id}_crit")
+            elif context_pct >= CONTEXT_WARN_PCT and f"{agent_id}_warn" not in self.warned_agents:
+                project = agent.get("projectName", "unknown")
+                self.notify(
+                    f"{project} at {context_pct:.0f}% context",
+                    title="High Context",
+                    severity="warning",
+                    timeout=5
+                )
+                self.warned_agents.add(f"{agent_id}_warn")
+
+        # Clean up warnings for agents no longer present
+        # Note: This also cleans up cost warnings which use double suffixes
+        # (e.g., agent123_cost_warn, agent123_cost_crit)
+        self._cleanup_warned_agents(agents)
+
+    def _check_budget_alerts(self, agents: Dict[str, Any]) -> None:
+        """Check for cost threshold warnings (ANV-95, configurable via ANV-116-118).
+
+        Respects billing_model config:
+        - "api": Show cost alerts (pay-per-use API billing)
+        - "subscription": Skip cost alerts (Pro/Max flat-rate subscription)
+        """
+        # Skip cost alerts for subscription users (Pro/Max flat rate)
+        # Costs are still tracked and displayed, just no alerts
+        billing_model = "api"
+        if self.config:
+            billing_model = getattr(self.config.budget, "billing_model", "api")
+
+        if billing_model == "subscription":
+            return  # No cost alerts for subscription users
+
+        # Budget thresholds from config or defaults
+        if self.config:
+            AGENT_WARN_THRESHOLD = self.config.budget.agent_warn_threshold
+            AGENT_CRIT_THRESHOLD = self.config.budget.agent_crit_threshold
+            TOTAL_WARN_THRESHOLD = self.config.budget.total_warn_threshold
+            TOTAL_CRIT_THRESHOLD = self.config.budget.total_crit_threshold
+        else:
+            AGENT_WARN_THRESHOLD = 5.0   # Warn when single agent exceeds $5
+            AGENT_CRIT_THRESHOLD = 10.0  # Critical when single agent exceeds $10
+            TOTAL_WARN_THRESHOLD = 15.0  # Warn when total exceeds $15
+            TOTAL_CRIT_THRESHOLD = 25.0  # Critical when total exceeds $25
+
+        # Check individual agent costs
+        for agent_id, agent in agents.items():
+            cost = agent.get("sessionCost", 0)
+            project = agent.get("projectName", "unknown")
+
+            if cost >= AGENT_CRIT_THRESHOLD and f"{agent_id}_cost_crit" not in self.warned_agents:
+                self.notify(
+                    f"💰 {project}: ${cost:.2f} spent!",
+                    title="High Cost Alert",
+                    severity="error",
+                    timeout=10
+                )
+                self.warned_agents.add(f"{agent_id}_cost_crit")
+            elif cost >= AGENT_WARN_THRESHOLD and f"{agent_id}_cost_warn" not in self.warned_agents:
+                self.notify(
+                    f"{project}: ${cost:.2f} session cost",
+                    title="Cost Warning",
+                    severity="warning",
+                    timeout=5
+                )
+                self.warned_agents.add(f"{agent_id}_cost_warn")
+
+        # Check total cost across all agents
+        total_cost = sum(a.get("sessionCost", 0) for a in agents.values())
+
+        if total_cost >= TOTAL_CRIT_THRESHOLD and "total_cost_crit" not in self.warned_agents:
+            self.notify(
+                f"💰 Total spend: ${total_cost:.2f}!",
+                title="Budget Critical",
+                severity="error",
+                timeout=15
+            )
+            self.warned_agents.add("total_cost_crit")
+        elif total_cost >= TOTAL_WARN_THRESHOLD and "total_cost_warn" not in self.warned_agents:
+            self.notify(
+                f"Total spend: ${total_cost:.2f}",
+                title="Budget Warning",
+                severity="warning",
+                timeout=10
+            )
+            self.warned_agents.add("total_cost_warn")
+
+    def action_toggle_details(self) -> None:
+        """Toggle detailed view - shows tool activity per agent."""
+        try:
+            agent_list = self.query_one("#agent-list", AgentList)
+            agent_list.show_details = not agent_list.show_details
+
+            if agent_list.show_details:
+                # Load detailed states for all agents
+                if self.registry:
+                    detailed_states = {}
+                    for agent_id in agent_list.agents.keys():
+                        state = self.registry.get_detailed_state(agent_id)
+                        if state:
+                            detailed_states[agent_id] = state
+                    agent_list.detailed_states = detailed_states
+                self.notify("Details ON - tool activity shown", title="Details", severity="information", timeout=3)
+            else:
+                agent_list.detailed_states = {}
+                self.notify("Details OFF", title="Details", timeout=2)
+        except Exception as e:
+            self.notify(f"Details error: {e}", title="Error", severity="error")
+
+    def action_toggle_help(self) -> None:
+        """Toggle help overlay (HUD v3 - ANV-131)."""
+        # Close settings if open
+        if self.show_settings:
+            self.show_settings = False
+        self.show_help = not self.show_help
+
+    def action_toggle_settings(self) -> None:
+        """Toggle settings overlay (ANV-136)."""
+        # Close help if open
+        if self.show_help:
+            self.show_help = False
+        self.show_settings = not self.show_settings
+
+    def action_close_overlays(self) -> None:
+        """Close any open overlay (ANV-136, ANV-208: confirm discard on dirty settings)."""
+        if self.show_help:
+            self.show_help = False
+            return
+        if self.show_settings:
+            try:
+                settings = self.query_one("#settings-overlay", SettingsOverlay)
+                if settings.is_dirty:
+                    # ANV-208: Require confirmation before discarding changes
+                    if not self._pending_settings_close:
+                        # First Escape: warn user, set pending flag
+                        self._pending_settings_close = True
+                        self.notify(
+                            "Press Escape again to discard changes, or Ctrl+S to save",
+                            title="Unsaved Changes",
+                            severity="warning",
+                        )
+                        return  # Don't close yet
+                    else:
+                        # Second Escape: actually discard
+                        settings.cancel()
+                        self.notify("Changes discarded", title="Settings")
+                        self._pending_settings_close = False
+            except Exception:
+                pass
+            self._pending_settings_close = False
+            self.show_settings = False
+
+    def action_save_settings(self) -> None:
+        """Save settings from overlay (ANV-208)."""
+        if self.show_settings:
+            try:
+                settings = self.query_one("#settings-overlay", SettingsOverlay)
+                if settings.save():
+                    self._pending_settings_close = False  # Reset confirmation state
+                    self.notify("Settings saved!", title="Settings")
+            except Exception as e:
+                self.notify(f"Save failed: {e}", title="Error", severity="error")
+
+    # HUD v3: Mode and tab navigation actions (ANV-128)
+    def action_toggle_mode(self) -> None:
+        """Toggle between Focused and Full mode."""
+        if self.mode == "focused":
+            self.mode = "full"
+            self.notify("Full Mode - all panels visible", title="Mode")
+        else:
+            self.mode = "focused"
+            self.notify("Focused Mode - use 1-5 or Tab to switch", title="Mode")
+
+    def action_tab_1(self) -> None:
+        """Switch to tab 1 (Agents)."""
+        self._switch_to_tab(0)
+
+    def action_tab_2(self) -> None:
+        """Switch to tab 2 (Kanban)."""
+        self._switch_to_tab(1)
+
+    def action_tab_3(self) -> None:
+        """Switch to tab 3 (Quality)."""
+        self._switch_to_tab(2)
+
+    def action_tab_4(self) -> None:
+        """Switch to tab 4 (Costs)."""
+        self._switch_to_tab(3)
+
+    def action_tab_5(self) -> None:
+        """Switch to tab 5 (Coordination)."""
+        self._switch_to_tab(4)
+
+    def action_next_tab(self) -> None:
+        """Move to next tab."""
+        if self.mode == "focused":
+            self.active_tab = (self.active_tab + 1) % 5
+        else:
+            # In Full Mode, pressing Tab switches to Focused Mode on next tab
+            self.active_tab = (self.active_tab + 1) % 5
+            self.mode = "focused"
+
+    def action_prev_tab(self) -> None:
+        """Move to previous tab."""
+        if self.mode == "focused":
+            self.active_tab = (self.active_tab - 1) % 5
+        else:
+            # In Full Mode, pressing Shift+Tab switches to Focused Mode on prev tab
+            self.active_tab = (self.active_tab - 1) % 5
+            self.mode = "focused"
+
+    def _switch_to_tab(self, tab: int) -> None:
+        """Switch to a specific tab (0-4)."""
+        if self.mode == "full":
+            # In Full Mode, pressing 1-5 switches to Focused Mode on that tab
+            self.mode = "focused"
+        self.active_tab = tab
+
+        # Refresh Kanban data if switching to Kanban tab
+        if tab == 1:
+            self._refresh_kanban()
+
+    def _get_current_agent_id(self) -> str:
+        """Get current agent ID from registry or generate one."""
+        if self.registry:
+            agents = self.registry.get_all()
+            if agents:
+                # Return first active agent
+                return next(iter(agents.keys()), "")
+        return ""
+
+    def action_toggle_kanban(self) -> None:
+        """Toggle Kanban panel visibility."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            kanban.visible = not kanban.visible
+            if kanban.visible:
+                self.notify("Kanban ON (h/l/j/k to navigate)", title="Kanban")
+                # Refresh issues when showing
+                self._refresh_kanban()
+            else:
+                self.notify("Kanban OFF", title="Kanban")
+        except Exception:
+            pass
+
+    def _refresh_kanban(self) -> None:
+        """Refresh Kanban panel issues."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if self.demo_mode:
+                kanban.issues = self._get_demo_kanban_issues()
+            elif self.issue_provider:
+                try:
+                    kanban.issues = self.issue_provider.list_issues(limit=50)
+                except Exception:
+                    kanban.issues = []
+        except Exception:
+            pass
+
+    def _get_demo_kanban_issues(self) -> list:
+        """Generate demo issues for Kanban board."""
+        if not Issue or not IssueStatus or not Priority:
+            return []
+
+        from datetime import datetime, timezone
+        now = datetime.now(timezone.utc)
+
+        return [
+            Issue(
+                id="demo-1", identifier="ANV-42", title="Implement OAuth flow",
+                description="Add OAuth2 authentication", status=IssueStatus.IN_PROGRESS,
+                priority=Priority.HIGH, created_at=now, updated_at=now,
+                provider="demo", assigned_agent="agent-alpha"
+            ),
+            Issue(
+                id="demo-2", identifier="ANV-43", title="Add unit tests",
+                description="Test payment module", status=IssueStatus.TODO,
+                priority=Priority.MEDIUM, created_at=now, updated_at=now,
+                provider="demo"
+            ),
+            Issue(
+                id="demo-3", identifier="ANV-44", title="Fix login bug",
+                description="Users can't log in", status=IssueStatus.TODO,
+                priority=Priority.URGENT, created_at=now, updated_at=now,
+                provider="demo"
+            ),
+            Issue(
+                id="demo-4", identifier="ANV-41", title="Update docs",
+                description="API documentation", status=IssueStatus.DONE,
+                priority=Priority.LOW, created_at=now, updated_at=now,
+                provider="demo"
+            ),
+            Issue(
+                id="demo-5", identifier="ANV-40", title="Refactor utils",
+                description="Clean up utility functions", status=IssueStatus.IN_PROGRESS,
+                priority=Priority.MEDIUM, created_at=now, updated_at=now,
+                provider="demo", assigned_agent="agent-beta"
+            ),
+        ]
+
+    def action_kanban_left(self) -> None:
+        """Move Kanban selection left."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                kanban.move_left()
+        except Exception:
+            pass
+
+    def action_kanban_right(self) -> None:
+        """Move Kanban selection right."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                kanban.move_right()
+        except Exception:
+            pass
+
+    def action_kanban_up(self) -> None:
+        """Move Kanban selection up."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                kanban.move_up()
+        except Exception:
+            pass
+
+    def action_kanban_down(self) -> None:
+        """Move Kanban selection down."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                kanban.move_down()
+        except Exception:
+            pass
+
+    def action_kanban_claim(self) -> None:
+        """Claim selected issue."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                if kanban.claim_issue():
+                    self.notify("Issue claimed!", title="Kanban")
+                    self._refresh_kanban()
+                else:
+                    self.notify("Could not claim issue", title="Kanban", severity="warning")
+        except Exception:
+            pass
+
+    def action_kanban_forward(self) -> None:
+        """Move selected issue forward."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                if kanban.move_issue_forward():
+                    self.notify("Issue moved forward", title="Kanban")
+                    self._refresh_kanban()
+                else:
+                    self.notify("Could not move issue", title="Kanban", severity="warning")
+        except Exception:
+            pass
+
+    def action_kanban_backward(self) -> None:
+        """Move selected issue backward."""
+        try:
+            kanban = self.query_one("#kanban-panel", KanbanPanel)
+            if kanban.visible:
+                if kanban.move_issue_backward():
+                    self.notify("Issue moved back", title="Kanban")
+                    self._refresh_kanban()
+                else:
+                    self.notify("Could not move issue", title="Kanban", severity="warning")
+        except Exception:
+            pass
+
+    def _get_demo_issues(self) -> Dict[str, Any]:
+        """Generate demo issue data for testing."""
+        return {
+            "ANV-42": {
+                "id": "demo-42",
+                "identifier": "ANV-42",
+                "title": "Implement user authentication with OAuth",
+                "state": "In Progress",
+                "state_type": "started",
+                "assignee": "Demo User",
+                "priority": 1,
+                "labels": ["feature", "auth"],
+            },
+            "ANV-43": {
+                "id": "demo-43",
+                "identifier": "ANV-43",
+                "title": "Add unit tests for payment module",
+                "state": "In Progress",
+                "state_type": "started",
+                "assignee": None,
+                "priority": 2,
+                "labels": ["testing"],
+            },
+        }
+
+    def _get_demo_quality(self) -> Dict[str, Any]:
+        """Generate demo quality gate data for testing."""
+        return {
+            "/Users/demo/projects/auth-service": {
+                "project_path": "/Users/demo/projects/auth-service",
+                "branch": "feature/oauth-flow",
+                "tests": {
+                    "status": "passed",
+                    "passed": 156,
+                    "failed": 0,
+                    "warnings": 0,
+                    "errors": 0,
+                    "message": "156 passed",
+                },
+                "lint": {
+                    "status": "passed",
+                    "errors": 0,
+                    "warnings": 2,
+                    "message": "0 errors, 2 warnings",
+                },
+                "types": {
+                    "status": "passed",
+                    "errors": 0,
+                    "message": "No errors",
+                },
+                "ready_to_merge": True,
+                "blocking_issues": 0,
+            },
+            "/Users/demo/projects/payment-api": {
+                "project_path": "/Users/demo/projects/payment-api",
+                "branch": "feature/unit-tests",
+                "tests": {
+                    "status": "failed",
+                    "passed": 47,
+                    "failed": 3,
+                    "warnings": 0,
+                    "errors": 3,
+                    "message": "47 passed, 3 failed",
+                },
+                "lint": {
+                    "status": "passed",
+                    "errors": 0,
+                    "warnings": 0,
+                    "message": "0 errors, 0 warnings",
+                },
+                "types": {
+                    "status": "failed",
+                    "errors": 2,
+                    "message": "2 errors",
+                },
+                "ready_to_merge": False,
+                "blocking_issues": 5,
+            },
+        }
+
+    def _get_demo_coordination(self) -> Dict[str, Any]:
+        """Generate demo coordination data for testing."""
+        now = datetime.now(timezone.utc).isoformat()
+        return {
+            "file_locks": {
+                "src/auth/*": {
+                    "agent_id": "agent-alpha-demo",
+                    "agent_display": "agent-alpha",
+                    "file_path": "/Users/demo/projects/auth-service/src/auth/oauth.ts",
+                    "pattern": "src/auth/*",
+                    "since": now,
+                    "operation": "Edit",
+                    "duration_seconds": 900,  # 15 minutes
+                },
+                "src/payments/*": {
+                    "agent_id": "agent-beta-demo",
+                    "agent_display": "agent-beta",
+                    "file_path": "/Users/demo/projects/payment-api/src/payments/stripe.ts",
+                    "pattern": "src/payments/*",
+                    "since": now,
+                    "operation": "Edit",
+                    "duration_seconds": 480,  # 8 minutes
+                },
+            },
+            "conflicts": [
+                {
+                    "file_path": "/Users/demo/projects/shared/src/utils.ts",
+                    "pattern": "src/utils/*",
+                    "agents": ["agent-alpha-demo", "agent-beta-demo"],
+                    "detected": now,
+                    "suggestion": "Coordinate via /handoff",
+                },
+            ],
+            "branches": {
+                "agent-alpha-demo": {
+                    "agent_id": "agent-alpha-demo",
+                    "branch": "feature/oauth-flow",
+                    "age_seconds": 8100,  # 2h 15m
+                    "age_display": "2h 15m",
+                    "is_stale": False,
+                },
+                "agent-beta-demo": {
+                    "agent_id": "agent-beta-demo",
+                    "branch": "feature/unit-tests",
+                    "age_seconds": 2700,  # 45m
+                    "age_display": "45m",
+                    "is_stale": False,
+                },
+                "agent-gamma-demo": {
+                    "agent_id": "agent-gamma-demo",
+                    "branch": "feature/stale-branch",
+                    "age_seconds": 16200,  # 4h 30m
+                    "age_display": "4h 30m",
+                    "is_stale": True,
+                },
+            },
+            "last_update": time.time(),
+        }
+
+    def _get_demo_github_status(self) -> Dict[str, Any]:
+        """Generate demo GitHub/CI status data for testing (ANV-111-113)."""
+        return {
+            "/Users/demo/projects/auth-service": {
+                "project_path": "/Users/demo/projects/auth-service",
+                "branch": "feature/oauth-flow",
+                "pr_number": 45,
+                "pr_url": "https://github.com/demo/auth-service/pull/45",
+                "pr_state": "OPEN",
+                "pr_title": "Implement OAuth2 authentication flow",
+                "ci_status": "passed",
+                "ci_conclusion": "success",
+                "reviews": [
+                    {"state": "APPROVED", "author": "reviewer1"},
+                    {"state": "APPROVED", "author": "reviewer2"},
+                ],
+                "reviews_summary": "2 approved",
+                "check_runs": [
+                    {"name": "test", "status": "completed", "conclusion": "success"},
+                    {"name": "lint", "status": "completed", "conclusion": "success"},
+                    {"name": "build", "status": "completed", "conclusion": "success"},
+                ],
+                "merge_queue": {"position": 2, "estimated_time_to_merge": 300},
+            },
+            "/Users/demo/projects/payment-api": {
+                "project_path": "/Users/demo/projects/payment-api",
+                "branch": "feature/unit-tests",
+                "pr_number": 44,
+                "pr_url": "https://github.com/demo/payment-api/pull/44",
+                "pr_state": "OPEN",
+                "pr_title": "Add unit tests for payment module",
+                "ci_status": "failed",
+                "ci_conclusion": "failure",
+                "reviews": [
+                    {"state": "CHANGES_REQUESTED", "author": "reviewer1"},
+                ],
+                "reviews_summary": "1 changes requested",
+                "check_runs": [
+                    {"name": "test", "status": "completed", "conclusion": "failure"},
+                    {"name": "lint", "status": "completed", "conclusion": "success"},
+                ],
+                "merge_queue": None,
+            },
+        }
+
+    def _get_demo_coderabbit_status(self) -> Dict[str, Any]:
+        """Generate demo CodeRabbit status data for testing (ANV-114-115)."""
+        now = time.time()
+        return {
+            "/Users/demo/projects/auth-service": {
+                "pr_number": 45,
+                "review_status": "approved",
+                "issues_count": 0,
+                "suggestions_count": 2,
+                "resolved_count": 2,
+                "pending_count": 0,
+                "review_url": "https://coderabbit.ai/review/45",
+                "issues": [],
+                "last_updated": now,
+            },
+            "/Users/demo/projects/payment-api": {
+                "pr_number": 44,
+                "review_status": "changes_requested",
+                "issues_count": 3,
+                "suggestions_count": 5,
+                "resolved_count": 2,
+                "pending_count": 6,
+                "review_url": "https://coderabbit.ai/review/44",
+                "issues": [
+                    {"severity": "error", "file": "src/payment.ts", "line": 42, "message": "Potential SQL injection", "resolved": False},
+                    {"severity": "warning", "file": "src/utils.ts", "line": 15, "message": "Unused import", "resolved": False},
+                    {"severity": "suggestion", "file": "src/api.ts", "line": 88, "message": "Consider error handling", "resolved": True},
+                ],
+                "last_updated": now,
+            },
+        }
+
+    def _get_demo_agents(self) -> Dict[str, Any]:
+        """Generate demo agent data for testing."""
+        now = datetime.now(timezone.utc).isoformat()
+
+        return {
+            "agent-alpha-demo": {
+                "id": "agent-alpha-demo",
+                "project": "/Users/demo/projects/auth-service",
+                "projectName": "auth-service",
+                "issue": "ANV-42",
+                "phase": "implement",
+                "model": "Opus",
+                "contextUsage": 64000,
+                "contextLimit": 200000,
+                "estimatedTurns": 23,  # ANV-98
+                "sessionCost": 2.45,
+                "cost": {
+                    "session": {
+                        "tokens": {"input": 80000, "output": 25000, "cache_read": 120000, "cache_write": 8000},
+                        "cost_usd": 2.45,
+                        "last_updated": now,
+                    },
+                    "attributed": {
+                        "ANV-42": {"issue_id": "ANV-42", "cost_usd": 1.85, "tokens": 180000, "started_at": now},
+                        "ANV-41": {"issue_id": "ANV-41", "cost_usd": 0.60, "tokens": 53000, "started_at": now},
+                    },
+                    "daily_total": 2.45,
+                    "weekly_total": 12.30,
+                    "last_issue": "ANV-42",
+                },
+                "lastActivity": now,
+                "startedAt": now,
+                "status": "active"
+            },
+            "agent-beta-demo": {
+                "id": "agent-beta-demo",
+                "project": "/Users/demo/projects/payment-api",
+                "projectName": "payment-api",
+                "issue": "ANV-43",
+                "phase": "spec",
+                "model": "Sonnet",
+                "contextUsage": 36000,
+                "contextLimit": 200000,
+                "estimatedTurns": 42,  # ANV-98
+                "sessionCost": 0.42,
+                "cost": {
+                    "session": {
+                        "tokens": {"input": 45000, "output": 18000, "cache_read": 80000, "cache_write": 5000},
+                        "cost_usd": 0.42,
+                        "last_updated": now,
+                    },
+                    "attributed": {
+                        "ANV-43": {"issue_id": "ANV-43", "cost_usd": 0.42, "tokens": 148000, "started_at": now},
+                    },
+                    "daily_total": 0.42,
+                    "weekly_total": 3.15,
+                    "last_issue": "ANV-43",
+                },
+                "lastActivity": now,
+                "startedAt": now,
+                "status": "active"
+            },
+            "agent-gamma-demo": {
+                "id": "agent-gamma-demo",
+                "project": "/Users/demo/Projects/api-service",
+                "projectName": "api-service",
+                "issue": None,
+                "phase": "explore",
+                "model": "Haiku",
+                "contextUsage": 8000,
+                "contextLimit": 200000,
+                "estimatedTurns": None,  # ANV-98: New session, calculating...
+                "sessionCost": 0.02,
+                "cost": {
+                    "session": {
+                        "tokens": {"input": 12000, "output": 4000, "cache_read": 0, "cache_write": 2000},
+                        "cost_usd": 0.02,
+                        "last_updated": now,
+                    },
+                    "attributed": {},
+                    "daily_total": 0.02,
+                    "weekly_total": 0.08,
+                    "last_issue": None,
+                },
+                "lastActivity": now,
+                "startedAt": now,
+                "status": "active"
+            }
+        }
+
+    def _get_demo_tool_activity(self) -> Dict[str, Any]:
+        """Generate demo tool activity data for testing (ANV-125)."""
+        return {
+            "running": [
+                {"name": "Edit", "target": ".../components/Auth.tsx"},
+                {"name": "Bash", "target": "npm run test"},
+            ],
+            "completed": {
+                "Read": 12,
+                "Edit": 8,
+                "Grep": 5,
+                "Glob": 4,
+            },
+            "errors": 1,
+        }
+
+    def _aggregate_tool_activity(self, agents: Dict[str, Any]) -> Dict[str, Any]:
+        """Aggregate tool activity from all agent transcripts (ANV-125).
+
+        Args:
+            agents: Dictionary of agent data keyed by agent ID
+
+        Returns:
+            Aggregated tool activity with running, completed, and error counts
+        """
+        if not TranscriptParser:
+            return {"running": [], "completed": {}, "errors": 0}
+
+        parser = TranscriptParser(cache_ttl=1.0)
+
+        all_running = []
+        all_completed: Dict[str, int] = {}
+        total_errors = 0
+
+        for agent_id, agent in agents.items():
+            # Get transcript path from agent data
+            transcript_path = agent.get("transcriptPath", "")
+            if not transcript_path:
+                continue
+
+            try:
+                activity = parser.parse(transcript_path)
+
+                # Collect running tools
+                for tool in activity.running:
+                    all_running.append({
+                        "name": tool.name,
+                        "target": tool.target or "",
+                        "agent": agent_id,
+                    })
+
+                # Aggregate completed tool counts
+                for name, count in activity.tool_counts.items():
+                    all_completed[name] = all_completed.get(name, 0) + count
+
+                # Sum errors
+                total_errors += activity.error_count
+
+            except Exception:
+                # Graceful degradation - continue with other agents
+                pass
+
+        # Limit running tools to 2 (most recent)
+        running_limited = all_running[:2]
+
+        return {
+            "running": running_limited,
+            "completed": all_completed,
+            "errors": total_errors,
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Anvil HUD - Multi-agent Claude Code dashboard"
+    )
+    parser.add_argument(
+        "--demo",
+        action="store_true",
+        help="Run with demo data"
+    )
+    parser.add_argument(
+        "--project",
+        type=str,
+        help="Project path for project-specific config"
+    )
+    parser.add_argument(
+        "--generate-config",
+        action="store_true",
+        help="Generate default config file and exit"
+    )
+    args = parser.parse_args()
+
+    # Handle config generation
+    if args.generate_config:
+        try:
+            from config_service import generate_default_config
+            print(generate_default_config())
+        except ImportError:
+            print("# Config service not available. Install pyyaml.")
+        return
+
+    app = AnvilHUD(demo_mode=args.demo, project_path=args.project)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()