diff --git a/bin/bugs b/bin/bugs
new file mode 100755
index 0000000..921592e
--- /dev/null
+++ b/bin/bugs
@@ -0,0 +1,81 @@
+#!/bin/bash
+# Bug Tracking CLI
+# Usage: bugs <command> [options]
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WATCHER_SCRIPT="/opt/agent-governance/testing/oversight/bug_watcher.py"
+
+show_help() {
+    echo "Bug Tracking CLI"
+    echo ""
+    echo "Usage: bugs <command> [options]"
+    echo ""
+    echo "Commands:"
+    echo "  list                List all bugs"
+    echo "  list --status open  Filter by status (open/in_progress/resolved)"
+    echo "  list --severity high  Filter by severity (critical/high/medium/low)"
+    echo "  get <id>            Get details of a specific bug"
+    echo "  log <message>       Log a new bug"
+    echo "  update <id> <status>  Update bug status"
+    echo "  scan                Scan for anomalies"
+    echo "  status              Show bug summary"
+    echo ""
+    echo "Examples:"
+    echo "  bugs list --status open"
+    echo "  bugs log -m 'API timeout in pipeline' --severity high"
+    echo "  bugs update anom-abc123 resolved --notes 'Fixed in commit xyz'"
+    echo "  bugs get anom-abc123"
+    echo ""
+}
+
+case "$1" in
+    list)
+        shift
+        python3 "$WATCHER_SCRIPT" list "$@"
+        ;;
+    get)
+        shift
+        if [ -z "$1" ]; then
+            echo "Error: Bug ID required"
+            echo "Usage: bugs get <bug-id>"
+            exit 1
+        fi
+        python3 "$WATCHER_SCRIPT" get --id "$1"
+        ;;
+    log)
+        shift
+        python3 "$WATCHER_SCRIPT" log "$@"
+        ;;
+    update)
+        shift
+        if [ -z "$1" ] || [ -z "$2" ]; then
+            echo "Error: Bug ID and status required"
+            echo "Usage: bugs update <bug-id> <status> [--notes 'note']"
+            exit 1
+        fi
+        BUG_ID="$1"
+        STATUS="$2"
+        shift 2
+        python3 "$WATCHER_SCRIPT" update --id "$BUG_ID" --set-status "$STATUS" "$@"
+        ;;
+    scan)
+        shift
+        python3 "$WATCHER_SCRIPT" scan "$@"
+        ;;
+    status|summary)
+        shift
+        python3 "$WATCHER_SCRIPT" status "$@"
+        ;;
+    help|--help|-h)
+        show_help
+        ;;
+    *)
+        if [ -z "$1" ]; then
+            show_help
+        else
+            echo "Unknown command: $1"
+            echo "Run 'bugs help' for usage"
+            exit 1
+        fi
+        ;;
+esac
diff --git a/testing/oversight/bug_watcher.py b/testing/oversight/bug_watcher.py
index b160962..f24fc40 100644
--- a/testing/oversight/bug_watcher.py
+++ b/testing/oversight/bug_watcher.py
@@ -45,6 +45,13 @@ class Severity(str, Enum):
     INFO = "info"          # Tracking only
 
 
+class BugStatus(str, Enum):
+    """Status tracking for bugs/anomalies"""
+    OPEN = "open"              # Newly detected, not yet addressed
+    IN_PROGRESS = "in_progress"  # Being worked on
+    RESOLVED = "resolved"      # Fixed and verified
+
+
 @dataclass
 class Anomaly:
     """Represents a detected anomaly"""
@@ -60,14 +67,23 @@ class Anomaly:
     checkpoint_id: Optional[str] = None
     status_file: Optional[str] = None
     detected_at: str = ""
-    resolved: bool = False
+    # Status tracking
+    status: BugStatus = BugStatus.OPEN
+    resolved: bool = False  # Kept for backwards compatibility
     resolution_notes: Optional[str] = None
+    assigned_to: Optional[str] = None
+    updated_at: Optional[str] = None
 
     def __post_init__(self):
         if not self.detected_at:
             self.detected_at = datetime.now(timezone.utc).isoformat()
         if not self.id:
             self.id = f"anom-{hashlib.sha256(f'{self.type}{self.phase}{self.message}{self.detected_at}'.encode()).hexdigest()[:12]}"
+        # Sync resolved with status for backwards compatibility
+        if self.resolved and self.status == BugStatus.OPEN:
+            self.status = BugStatus.RESOLVED
+        elif self.status == BugStatus.RESOLVED:
+            self.resolved = True
 
 
 @dataclass
@@ -129,11 +145,13 @@ class BugWindowWatcher:
     def __init__(self, base_path: str = "/opt/agent-governance"):
         self.base_path = Path(base_path)
         self.ledger_db = self.base_path / "ledger" / "governance.db"
+        self.bug_db = self.base_path / "testing" / "oversight" / "bug_watcher.db"
         self.checkpoint_dir = self.base_path / "checkpoint" / "storage"
         self.state = WatcherState()
         self.anomalies: list[Anomaly] = []
         self._redis: Optional[redis.Redis] = None
         self._setup_redis()
+        self._setup_bug_db()
 
     def _setup_redis(self):
         """Connect to DragonflyDB for real-time state"""
@@ -148,6 +166,43 @@ class BugWindowWatcher:
         except Exception:
             self._redis = None
 
+    def _setup_bug_db(self):
+        """Initialize SQLite database for bug tracking"""
+        conn = sqlite3.connect(self.bug_db)
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS bugs (
+                id TEXT PRIMARY KEY,
+                type TEXT NOT NULL,
+                severity TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'open',
+                phase INTEGER NOT NULL,
+                phase_name TEXT NOT NULL,
+                directory TEXT NOT NULL,
+                message TEXT NOT NULL,
+                details TEXT,
+                stack_trace TEXT,
+                checkpoint_id TEXT,
+                status_file TEXT,
+                detected_at TEXT NOT NULL,
+                updated_at TEXT,
+                resolved_at TEXT,
+                resolution_notes TEXT,
+                assigned_to TEXT
+            )
+        """)
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_bugs_status ON bugs(status)
+        """)
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_bugs_severity ON bugs(severity)
+        """)
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_bugs_phase ON bugs(phase)
+        """)
+        conn.commit()
+        conn.close()
+
     def _now(self) -> str:
         return datetime.now(timezone.utc).isoformat()
 
@@ -545,7 +600,46 @@ class BugWindowWatcher:
         return anomalies
 
     def _persist_anomalies(self, anomalies: list[Anomaly]):
-        """Persist anomalies to storage"""
+        """Persist anomalies to storage (Redis + SQLite)"""
+        # Persist to SQLite
+        conn = sqlite3.connect(self.bug_db)
+        cursor = conn.cursor()
+
+        for anomaly in anomalies:
+            # Convert enum values to strings for storage
+            type_val = anomaly.type.value if hasattr(anomaly.type, 'value') else anomaly.type
+            sev_val = anomaly.severity.value if hasattr(anomaly.severity, 'value') else anomaly.severity
+            status_val = anomaly.status.value if hasattr(anomaly.status, 'value') else anomaly.status
+
+            cursor.execute("""
+                INSERT OR REPLACE INTO bugs
+                (id, type, severity, status, phase, phase_name, directory, message,
+                 details, stack_trace, checkpoint_id, status_file, detected_at,
+                 updated_at, resolution_notes, assigned_to)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                anomaly.id,
+                type_val,
+                sev_val,
+                status_val,
+                anomaly.phase,
+                anomaly.phase_name,
+                anomaly.directory,
+                anomaly.message,
+                json.dumps(anomaly.details) if anomaly.details else None,
+                anomaly.stack_trace,
+                anomaly.checkpoint_id,
+                anomaly.status_file,
+                anomaly.detected_at,
+                anomaly.updated_at,
+                anomaly.resolution_notes,
+                anomaly.assigned_to
+            ))
+
+        conn.commit()
+        conn.close()
+
+        # Also persist to Redis for real-time access
         if not self._redis:
             return
 
@@ -560,65 +654,201 @@ class BugWindowWatcher:
             self._redis.ltrim("oversight:anomalies", 0, 999)
 
             # Index by severity
-            self._redis.sadd(f"oversight:anomalies:{anomaly.severity.value}", anomaly.id)
+            sev_val = anomaly.severity.value if hasattr(anomaly.severity, 'value') else anomaly.severity
+            self._redis.sadd(f"oversight:anomalies:{sev_val}", anomaly.id)
 
             # Index by phase
             self._redis.sadd(f"oversight:anomalies:phase:{anomaly.phase}", anomaly.id)
 
+            # Index by status
+            status_val = anomaly.status.value if hasattr(anomaly.status, 'value') else anomaly.status
+            self._redis.sadd(f"oversight:anomalies:status:{status_val}", anomaly.id)
+
     def get_anomalies(
         self,
         severity: Optional[Severity] = None,
         phase: Optional[int] = None,
+        status: Optional[BugStatus] = None,
         limit: int = 50
     ) -> list[Anomaly]:
-        """Retrieve anomalies with optional filters"""
-        if not self._redis:
-            # Return in-memory anomalies
-            filtered = self.anomalies
-            if severity:
-                filtered = [a for a in filtered if a.severity == severity]
-            if phase:
-                filtered = [a for a in filtered if a.phase == phase]
-            return filtered[:limit]
+        """Retrieve anomalies with optional filters from SQLite"""
+        conn = sqlite3.connect(self.bug_db)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        query = "SELECT * FROM bugs WHERE 1=1"
+        params = []
+
+        if severity:
+            sev_val = severity.value if hasattr(severity, 'value') else severity
+            query += " AND severity = ?"
+            params.append(sev_val)
+
+        if phase:
+            query += " AND phase = ?"
+            params.append(phase)
+
+        if status:
+            status_val = status.value if hasattr(status, 'value') else status
+            query += " AND status = ?"
+            params.append(status_val)
+
+        query += " ORDER BY detected_at DESC LIMIT ?"
+        params.append(limit)
+
+        cursor.execute(query, params)
+        rows = cursor.fetchall()
+        conn.close()
 
-        # Get from Redis
-        raw = self._redis.lrange("oversight:anomalies", 0, limit - 1)
         anomalies = []
-
-        for item in raw:
+        for row in rows:
             try:
-                data = json.loads(item)
-                anomaly = Anomaly(**data)
-
-                if severity and anomaly.severity != severity:
-                    continue
-                if phase and anomaly.phase != phase:
-                    continue
-
+                anomaly = Anomaly(
+                    id=row['id'],
+                    type=AnomalyType(row['type']),
+                    severity=Severity(row['severity']),
+                    status=BugStatus(row['status']),
+                    phase=row['phase'],
+                    phase_name=row['phase_name'],
+                    directory=row['directory'],
+                    message=row['message'],
+                    details=json.loads(row['details']) if row['details'] else {},
+                    stack_trace=row['stack_trace'],
+                    checkpoint_id=row['checkpoint_id'],
+                    status_file=row['status_file'],
+                    detected_at=row['detected_at'],
+                    updated_at=row['updated_at'],
+                    resolution_notes=row['resolution_notes'],
+                    assigned_to=row['assigned_to'],
+                    resolved=row['status'] == 'resolved'
+                )
                 anomalies.append(anomaly)
             except Exception:
                 continue
 
         return anomalies
 
+    def update_bug_status(
+        self,
+        bug_id: str,
+        new_status: BugStatus,
+        notes: Optional[str] = None,
+        assigned_to: Optional[str] = None
+    ) -> bool:
+        """Update bug status with optional notes and assignment"""
+        conn = sqlite3.connect(self.bug_db)
+        cursor = conn.cursor()
+
+        now = self._now()
+        status_val = new_status.value if hasattr(new_status, 'value') else new_status
+
+        # Build update query
+        updates = ["status = ?", "updated_at = ?"]
+        params = [status_val, now]
+
+        if notes is not None:
+            updates.append("resolution_notes = ?")
+            params.append(notes)
+
+        if assigned_to is not None:
+            updates.append("assigned_to = ?")
+            params.append(assigned_to)
+
+        if new_status == BugStatus.RESOLVED:
+            updates.append("resolved_at = ?")
+            params.append(now)
+
+        params.append(bug_id)
+
+        cursor.execute(f"""
+            UPDATE bugs SET {', '.join(updates)} WHERE id = ?
+        """, params)
+
+        updated = cursor.rowcount > 0
+        conn.commit()
+        conn.close()
+
+        # Update Redis index if available
+        if self._redis and updated:
+            # Remove from old status sets, add to new
+            for s in BugStatus:
+                self._redis.srem(f"oversight:anomalies:status:{s.value}", bug_id)
+            self._redis.sadd(f"oversight:anomalies:status:{status_val}", bug_id)
+
+            self._redis.hset(f"oversight:anomaly:{bug_id}", mapping={
+                "status": status_val,
+                "updated_at": now,
+                "resolution_notes": notes or "",
+                "assigned_to": assigned_to or ""
+            })
+
+        return updated
+
     def acknowledge_anomaly(self, anomaly_id: str, notes: str = "") -> bool:
-        """Mark an anomaly as resolved"""
-        if not self._redis:
-            for anomaly in self.anomalies:
-                if anomaly.id == anomaly_id:
-                    anomaly.resolved = True
-                    anomaly.resolution_notes = notes
-                    return True
-            return False
+        """Mark an anomaly as resolved (backwards compatible)"""
+        return self.update_bug_status(anomaly_id, BugStatus.RESOLVED, notes)
 
-        # Update in Redis
-        self._redis.hset(f"oversight:anomaly:{anomaly_id}", mapping={
-            "resolved": "true",
-            "resolution_notes": notes,
-            "resolved_at": self._now()
-        })
+    def get_bug(self, bug_id: str) -> Optional[Anomaly]:
+        """Get a single bug by ID"""
+        conn = sqlite3.connect(self.bug_db)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
 
-        return True
+        cursor.execute("SELECT * FROM bugs WHERE id = ?", (bug_id,))
+        row = cursor.fetchone()
+        conn.close()
+
+        if not row:
+            return None
+
+        return Anomaly(
+            id=row['id'],
+            type=AnomalyType(row['type']),
+            severity=Severity(row['severity']),
+            status=BugStatus(row['status']),
+            phase=row['phase'],
+            phase_name=row['phase_name'],
+            directory=row['directory'],
+            message=row['message'],
+            details=json.loads(row['details']) if row['details'] else {},
+            stack_trace=row['stack_trace'],
+            checkpoint_id=row['checkpoint_id'],
+            status_file=row['status_file'],
+            detected_at=row['detected_at'],
+            updated_at=row['updated_at'],
+            resolution_notes=row['resolution_notes'],
+            assigned_to=row['assigned_to'],
+            resolved=row['status'] == 'resolved'
+        )
+
+    def log_bug(
+        self,
+        message: str,
+        severity: Severity = Severity.MEDIUM,
+        bug_type: AnomalyType = AnomalyType.UNHANDLED_ERROR,
+        phase: int = 0,
+        directory: str = "unknown",
+        details: Optional[dict] = None,
+        stack_trace: Optional[str] = None
+    ) -> Anomaly:
+        """Manually log a bug (for API/CLI use)"""
+        anomaly = Anomaly(
+            id="",
+            type=bug_type,
+            severity=severity,
+            status=BugStatus.OPEN,
+            phase=phase,
+            phase_name=self.PHASES.get(phase, f"Phase {phase}"),
+            directory=directory,
+            message=message,
+            details=details or {},
+            stack_trace=stack_trace
+        )
+
+        self._persist_anomalies([anomaly])
+        self.anomalies.append(anomaly)
+
+        return anomaly
 
     def get_summary(self) -> dict:
         """Get summary of watcher state and anomalies"""
@@ -627,23 +857,29 @@ class BugWindowWatcher:
         by_severity = {s.value: 0 for s in Severity}
         by_phase = {p: 0 for p in self.PHASES}
         by_type = {t.value: 0 for t in AnomalyType}
+        by_status = {s.value: 0 for s in BugStatus}
 
         for a in anomalies:
             # Handle both enum and string values
             sev_val = a.severity.value if hasattr(a.severity, 'value') else a.severity
             type_val = a.type.value if hasattr(a.type, 'value') else a.type
+            status_val = a.status.value if hasattr(a.status, 'value') else a.status
 
             by_severity[sev_val] = by_severity.get(sev_val, 0) + 1
             by_phase[a.phase] = by_phase.get(a.phase, 0) + 1
             by_type[type_val] = by_type.get(type_val, 0) + 1
+            by_status[status_val] = by_status.get(status_val, 0) + 1
 
         return {
             "state": asdict(self.state),
             "total_anomalies": len(anomalies),
-            "unresolved": len([a for a in anomalies if not a.resolved]),
+            "open": by_status.get("open", 0),
+            "in_progress": by_status.get("in_progress", 0),
+            "resolved": by_status.get("resolved", 0),
             "by_severity": by_severity,
             "by_phase": by_phase,
             "by_type": by_type,
+            "by_status": by_status,
             "phases": self.PHASES
         }
 
@@ -652,10 +888,20 @@ if __name__ == "__main__":
     import argparse
 
     parser = argparse.ArgumentParser(description="Bug Window Watcher")
-    parser.add_argument("command", choices=["scan", "status", "list"], help="Command to run")
+    parser.add_argument("command", choices=["scan", "status", "list", "update", "log", "get"], help="Command to run")
     parser.add_argument("--phase", type=int, help="Specific phase to scan")
     parser.add_argument("--severity", choices=["critical", "high", "medium", "low", "info"])
+    parser.add_argument("--bug-status", dest="bug_status", choices=["open", "in_progress", "resolved"], help="Filter by bug status")
     parser.add_argument("--json", action="store_true", help="Output as JSON")
+    # For update command
+    parser.add_argument("--id", help="Bug ID to update or get")
+    parser.add_argument("--set-status", dest="set_status", choices=["open", "in_progress", "resolved"], help="New status to set")
+    parser.add_argument("--notes", help="Resolution or status notes")
+    parser.add_argument("--assign", help="Assign bug to person/team")
+    # For log command
+    parser.add_argument("--message", "-m", help="Bug message (for log command)")
+    parser.add_argument("--directory", "-d", default="unknown", help="Directory (for log command)")
+    parser.add_argument("--type", dest="bug_type", choices=[t.value for t in AnomalyType], default="unhandled_error")
 
     args = parser.parse_args()
 
@@ -678,8 +924,12 @@ if __name__ == "__main__":
             print()
 
             for a in anomalies:
-                icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵", "info": "⚪"}.get(a.severity.value, "⚪")
-                print(f"{icon} [{a.severity.value.upper()}] Phase {a.phase}: {a.message}")
+                sev_val = a.severity.value if hasattr(a.severity, 'value') else a.severity
+                status_val = a.status.value if hasattr(a.status, 'value') else a.status
+                icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵", "info": "⚪"}.get(sev_val, "⚪")
+                status_icon = {"open": "📋", "in_progress": "🔧", "resolved": "✅"}.get(status_val, "❓")
+                print(f"{icon} [{sev_val.upper()}] {status_icon} {status_val.upper()} | Phase {a.phase}: {a.message}")
+                print(f"   ID: {a.id}")
                 print(f"   Directory: {a.directory}")
                 if a.status_file:
                     print(f"   Status: {a.status_file}")
@@ -694,20 +944,123 @@ if __name__ == "__main__":
             print(f"BUG WINDOW WATCHER - Status")
             print(f"{'='*60}")
             print(f"Active: {summary['state']['active']}")
-            print(f"Total Anomalies: {summary['total_anomalies']}")
-            print(f"Unresolved: {summary['unresolved']}")
+            print(f"Total Bugs: {summary['total_anomalies']}")
+            print()
+            print("By Status:")
+            print(f"  📋 Open:        {summary['open']}")
+            print(f"  🔧 In Progress: {summary['in_progress']}")
+            print(f"  ✅ Resolved:    {summary['resolved']}")
             print()
             print("By Severity:")
             for sev, count in summary['by_severity'].items():
                 if count > 0:
-                    print(f"  {sev}: {count}")
+                    icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵", "info": "⚪"}.get(sev, "⚪")
+                    print(f"  {icon} {sev}: {count}")
 
     elif args.command == "list":
         severity = Severity(args.severity) if args.severity else None
-        anomalies = watcher.get_anomalies(severity=severity, phase=args.phase)
+        status = BugStatus(args.bug_status) if args.bug_status else None
+        anomalies = watcher.get_anomalies(severity=severity, phase=args.phase, status=status)
 
         if args.json:
             print(json.dumps([asdict(a) for a in anomalies], indent=2))
         else:
-            for a in anomalies:
-                print(f"[{a.id}] {a.severity.value}: {a.message}")
+            if not anomalies:
+                print("No bugs found matching criteria.")
+            else:
+                print(f"\n{'='*70}")
+                print(f"{'ID':<20} {'Status':<12} {'Severity':<10} {'Message'}")
+                print(f"{'='*70}")
+                for a in anomalies:
+                    sev_val = a.severity.value if hasattr(a.severity, 'value') else a.severity
+                    status_val = a.status.value if hasattr(a.status, 'value') else a.status
+                    msg = a.message[:40] + "..." if len(a.message) > 40 else a.message
+                    print(f"{a.id:<20} {status_val:<12} {sev_val:<10} {msg}")
+
+    elif args.command == "update":
+        if not args.id:
+            print("Error: --id is required for update command")
+            exit(1)
+        if not args.set_status:
+            print("Error: --set-status is required for update command")
+            exit(1)
+
+        new_status = BugStatus(args.set_status)
+        success = watcher.update_bug_status(
+            args.id,
+            new_status,
+            notes=args.notes,
+            assigned_to=args.assign
+        )
+
+        if success:
+            bug = watcher.get_bug(args.id)
+            if args.json:
+                print(json.dumps(asdict(bug), indent=2))
+            else:
+                print(f"✅ Bug {args.id} updated to {args.set_status}")
+                if args.notes:
+                    print(f"   Notes: {args.notes}")
+                if args.assign:
+                    print(f"   Assigned to: {args.assign}")
+        else:
+            print(f"❌ Failed to update bug {args.id} - not found")
+            exit(1)
+
+    elif args.command == "get":
+        if not args.id:
+            print("Error: --id is required for get command")
+            exit(1)
+
+        bug = watcher.get_bug(args.id)
+        if bug:
+            if args.json:
+                print(json.dumps(asdict(bug), indent=2))
+            else:
+                sev_val = bug.severity.value if hasattr(bug.severity, 'value') else bug.severity
+                status_val = bug.status.value if hasattr(bug.status, 'value') else bug.status
+                type_val = bug.type.value if hasattr(bug.type, 'value') else bug.type
+                print(f"\n{'='*60}")
+                print(f"Bug: {bug.id}")
+                print(f"{'='*60}")
+                print(f"Status:      {status_val}")
+                print(f"Severity:    {sev_val}")
+                print(f"Type:        {type_val}")
+                print(f"Phase:       {bug.phase} - {bug.phase_name}")
+                print(f"Directory:   {bug.directory}")
+                print(f"Message:     {bug.message}")
+                print(f"Detected:    {bug.detected_at}")
+                if bug.updated_at:
+                    print(f"Updated:     {bug.updated_at}")
+                if bug.assigned_to:
+                    print(f"Assigned to: {bug.assigned_to}")
+                if bug.resolution_notes:
+                    print(f"Notes:       {bug.resolution_notes}")
+        else:
+            print(f"❌ Bug {args.id} not found")
+            exit(1)
+
+    elif args.command == "log":
+        if not args.message:
+            print("Error: --message/-m is required for log command")
+            exit(1)
+
+        severity = Severity(args.severity) if args.severity else Severity.MEDIUM
+        bug_type = AnomalyType(args.bug_type)
+        phase = args.phase or 0
+
+        bug = watcher.log_bug(
+            message=args.message,
+            severity=severity,
+            bug_type=bug_type,
+            phase=phase,
+            directory=args.directory
+        )
+
+        if args.json:
+            print(json.dumps(asdict(bug), indent=2))
+        else:
+            print(f"✅ Bug logged: {bug.id}")
+            print(f"   Severity: {severity.value}")
+            print(f"   Status: open")
+            print(f"   Message: {args.message}")
diff --git a/ui/server.ts b/ui/server.ts
index 125d7a6..0c3889a 100644
--- a/ui/server.ts
+++ b/ui/server.ts
@@ -199,6 +199,196 @@ async function getViolations(limit: number = 50): Promise<any[]> {
   }
 }
 
+// Bug Tracking Functions
+const BUG_DB_PATH = "/opt/agent-governance/testing/oversight/bug_watcher.db";
+
+async function getBugs(params: URLSearchParams): Promise<any[]> {
+  try {
+    const db = new Database(BUG_DB_PATH, { readonly: true });
+    const limit = parseInt(params.get("limit") || "50");
+    const status = params.get("status");
+    const severity = params.get("severity");
+    const phase = params.get("phase");
+
+    let query = "SELECT * FROM bugs WHERE 1=1";
+    const queryParams: any[] = [];
+
+    if (status) {
+      query += " AND status = ?";
+      queryParams.push(status);
+    }
+    if (severity) {
+      query += " AND severity = ?";
+      queryParams.push(severity);
+    }
+    if (phase) {
+      query += " AND phase = ?";
+      queryParams.push(parseInt(phase));
+    }
+
+    query += " ORDER BY detected_at DESC LIMIT ?";
+    queryParams.push(limit);
+
+    const rows = db.query(query).all(...queryParams);
+    db.close();
+
+    return (rows as any[]).map(row => ({
+      ...row,
+      details: row.details ? JSON.parse(row.details) : {}
+    }));
+  } catch (e) {
+    console.error("[BUGS] Error fetching bugs:", e);
+    return [];
+  }
+}
+
+async function getBug(bugId: string): Promise<any | null> {
+  try {
+    const db = new Database(BUG_DB_PATH, { readonly: true });
+    const row = db.query("SELECT * FROM bugs WHERE id = ?").get(bugId) as any;
+    db.close();
+
+    if (!row) return null;
+    return {
+      ...row,
+      details: row.details ? JSON.parse(row.details) : {}
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function getBugSummary(): Promise<any> {
+  try {
+    const db = new Database(BUG_DB_PATH, { readonly: true });
+
+    const total = (db.query("SELECT COUNT(*) as count FROM bugs").get() as any)?.count || 0;
+    const byStatus = db.query(`
+      SELECT status, COUNT(*) as count FROM bugs GROUP BY status
+    `).all() as any[];
+    const bySeverity = db.query(`
+      SELECT severity, COUNT(*) as count FROM bugs GROUP BY severity ORDER BY
+        CASE severity WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 WHEN 'low' THEN 4 ELSE 5 END
+    `).all() as any[];
+    const byPhase = db.query(`
+      SELECT phase, phase_name, COUNT(*) as count FROM bugs GROUP BY phase ORDER BY phase
+    `).all() as any[];
+    const recent = db.query(`
+      SELECT * FROM bugs ORDER BY detected_at DESC LIMIT 5
+    `).all() as any[];
+
+    db.close();
+
+    const statusMap: Record<string, number> = { open: 0, in_progress: 0, resolved: 0 };
+    byStatus.forEach(r => { statusMap[r.status] = r.count; });
+
+    return {
+      total,
+      open: statusMap.open || 0,
+      in_progress: statusMap.in_progress || 0,
+      resolved: statusMap.resolved || 0,
+      by_severity: bySeverity,
+      by_phase: byPhase,
+      recent: recent.map(r => ({ ...r, details: r.details ? JSON.parse(r.details) : {} }))
+    };
+  } catch (e) {
+    console.error("[BUGS] Error getting summary:", e);
+    return { total: 0, open: 0, in_progress: 0, resolved: 0, by_severity: [], by_phase: [], recent: [] };
+  }
+}
+
+async function logBug(params: {
+  message: string;
+  severity?: string;
+  type?: string;
+  phase?: number;
+  directory?: string;
+  details?: Record<string, any>;
+}): Promise<any> {
+  const db = new Database(BUG_DB_PATH);
+
+  const id = `anom-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  const now = new Date().toISOString();
+  const severity = params.severity || "medium";
+  const type = params.type || "unhandled_error";
+  const phase = params.phase || 0;
+  const phaseNames: Record<number, string> = {
+    1: "Foundation", 2: "Vault Policy", 3: "Execution", 4: "Promotion/Revocation",
+    5: "Agent Bootstrap", 6: "Pipeline DSL", 7: "Teams & Learning", 8: "Production Hardening",
+    9: "Integrations", 10: "Multi-Tenant", 11: "Marketplace", 12: "Observability", 0: "Unknown"
+  };
+
+  db.query(`
+    INSERT INTO bugs (id, type, severity, status, phase, phase_name, directory, message, details, detected_at)
+    VALUES (?, ?, ?, 'open', ?, ?, ?, ?, ?, ?)
+  `).run(
+    id, type, severity, phase, phaseNames[phase] || `Phase ${phase}`,
+    params.directory || "unknown", params.message,
+    params.details ? JSON.stringify(params.details) : null, now
+  );
+
+  db.close();
+
+  return {
+    id,
+    type,
+    severity,
+    status: "open",
+    phase,
+    phase_name: phaseNames[phase] || `Phase ${phase}`,
+    directory: params.directory || "unknown",
+    message: params.message,
+    details: params.details || {},
+    detected_at: now
+  };
+}
+
+async function updateBugStatus(bugId: string, params: {
+  status?: string;
+  notes?: string;
+  assigned_to?: string;
+}): Promise<{ success: boolean; message: string }> {
+  try {
+    const db = new Database(BUG_DB_PATH);
+
+    // Check if bug exists
+    const existing = db.query("SELECT id FROM bugs WHERE id = ?").get(bugId);
+    if (!existing) {
+      db.close();
+      return { success: false, message: "Bug not found" };
+    }
+
+    const now = new Date().toISOString();
+    const updates: string[] = ["updated_at = ?"];
+    const values: any[] = [now];
+
+    if (params.status) {
+      updates.push("status = ?");
+      values.push(params.status);
+      if (params.status === "resolved") {
+        updates.push("resolved_at = ?");
+        values.push(now);
+      }
+    }
+    if (params.notes !== undefined) {
+      updates.push("resolution_notes = ?");
+      values.push(params.notes);
+    }
+    if (params.assigned_to !== undefined) {
+      updates.push("assigned_to = ?");
+      values.push(params.assigned_to);
+    }
+
+    values.push(bugId);
+    db.query(`UPDATE bugs SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+    db.close();
+
+    return { success: true, message: `Bug ${bugId} updated` };
+  } catch (e: any) {
+    return { success: false, message: e.message };
+  }
+}
+
 async function getPromotions(limit: number = 20): Promise<any[]> {
   try {
     const db = new Database("/opt/agent-governance/ledger/governance.db", { readonly: true });
@@ -278,6 +468,340 @@ async function getAgentMetrics(): Promise<any[]> {
   }
 }
 
+// =============================================================================
+// New UI Tab Data Fetchers
+// =============================================================================
+
+const CHECKPOINT_VENV = "python3";  // Use system python with redis installed
+const CHECKPOINT_PY = "/opt/agent-governance/checkpoint/checkpoint.py";
+const MEMORY_DB_PATH = "/opt/agent-governance/memory/memory.db";
+const MEMORY_PY = "/opt/agent-governance/memory/memory.py";
+
+async function runPythonCommand(args: string[]): Promise<any> {
+  try {
+    const proc = Bun.spawn(args, {
+      cwd: "/opt/agent-governance",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      console.error(`[Python] Command failed: ${args.join(" ")}\n${stderr}`);
+      return null;
+    }
+    try {
+      return JSON.parse(output);
+    } catch {
+      return output.trim();
+    }
+  } catch (e: any) {
+    console.error(`[Python] Error: ${e.message}`);
+    return null;
+  }
+}
+
+// Checkpoint Fetchers
+async function getCheckpointList(limit: number = 20): Promise<any[]> {
+  const result = await runPythonCommand([
+    CHECKPOINT_VENV, CHECKPOINT_PY, "list", "--limit", String(limit), "--json"
+  ]);
+  return Array.isArray(result) ? result : [];
+}
+
+async function getCheckpointDetail(checkpointId?: string): Promise<any> {
+  const args = [CHECKPOINT_VENV, CHECKPOINT_PY, "load", "--json"];
+  if (checkpointId) args.splice(3, 0, checkpointId);
+  return await runPythonCommand(args);
+}
+
+async function getCheckpointDiff(fromId?: string, toId?: string): Promise<any> {
+  const args = [CHECKPOINT_VENV, CHECKPOINT_PY, "diff", "--json"];
+  if (fromId) args.push("--from", fromId);
+  if (toId) args.push("--to", toId);
+  return await runPythonCommand(args);
+}
+
+async function getCheckpointSummary(level: string = "compact"): Promise<string> {
+  const args = [CHECKPOINT_VENV, CHECKPOINT_PY, "summary", "--level", level];
+  const result = await runPythonCommand(args);
+  return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+}
+
+async function createCheckpointNow(notes?: string): Promise<any> {
+  const args = [CHECKPOINT_VENV, CHECKPOINT_PY, "now", "--json"];
+  if (notes) args.push("--notes", notes);
+  return await runPythonCommand(args);
+}
+
+async function getCheckpointReport(): Promise<any> {
+  return await runPythonCommand([CHECKPOINT_VENV, CHECKPOINT_PY, "report", "--json"]);
+}
+
+async function getCheckpointTimeline(limit: number = 10): Promise<any> {
+  return await runPythonCommand([
+    CHECKPOINT_VENV, CHECKPOINT_PY, "timeline", "--limit", String(limit), "--json"
+  ]);
+}
+
+// Memory Fetchers
+async function getMemoryList(type?: string, limit: number = 50): Promise<any[]> {
+  try {
+    const db = new Database(MEMORY_DB_PATH, { readonly: true });
+    // Query from memory_entries table (real data) with mapped column names
+    let query = `SELECT
+      id,
+      type as entry_type,
+      directory as source_agent,
+      summary,
+      tokens_estimate as total_size,
+      created_at,
+      status,
+      tags
+    FROM memory_entries WHERE status = 'active'`;
+    const params: any[] = [];
+    if (type) {
+      query += " AND type = ?";
+      params.push(type);
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit);
+    const rows = db.query(query).all(...params);
+    db.close();
+    return rows as any[];
+  } catch (e: any) {
+    console.error(`[Memory] Error listing: ${e.message}`);
+    return [];
+  }
+}
+
+async function getMemoryEntry(id: string): Promise<any> {
+  try {
+    const db = new Database(MEMORY_DB_PATH, { readonly: true });
+    const row = db.query(`
+      SELECT id, type as entry_type, content, content_path, summary,
+             tokens_estimate as total_size, created_at, status, tags,
+             directory, checkpoint_id, context
+      FROM memory_entries WHERE id = ?
+    `).get(id) as any;
+    db.close();
+
+    if (!row) return { error: "Entry not found" };
+
+    // If content_path exists and content is empty, try to read from file
+    if (row.content_path && !row.content) {
+      try {
+        const file = Bun.file(row.content_path);
+        if (await file.exists()) {
+          // Handle gzipped files
+          if (row.content_path.endsWith('.gz')) {
+            const gzipped = await file.arrayBuffer();
+            const decompressed = Bun.gunzipSync(new Uint8Array(gzipped));
+            row.content = new TextDecoder().decode(decompressed);
+          } else {
+            row.content = await file.text();
+          }
+        }
+      } catch (e) {
+        row.content = `[Error reading content: ${e}]`;
+      }
+    }
+
+    return row;
+  } catch (e: any) {
+    console.error(`[Memory] Error fetching entry: ${e.message}`);
+    return { error: e.message };
+  }
+}
+
+async function searchMemory(query: string): Promise<any[]> {
+  const result = await runPythonCommand(["python3", MEMORY_PY, "search", query, "--json"]);
+  return Array.isArray(result) ? result : [];
+}
+
+async function getMemoryStats(): Promise<any> {
+  return await runPythonCommand(["python3", MEMORY_PY, "stats", "--json"]);
+}
+
+// Status Grid Fetcher (64 directories)
+async function getStatusGrid(): Promise<any> {
+  // Use checkpoint report which includes directory statuses
+  const report = await getCheckpointReport();
+  if (!report) return { directories: [], summary: {} };
+
+  const directories = report.directory_statuses || [];
+  const summary = {
+    total: directories.length,
+    complete: directories.filter((d: any) => d.phase === "complete").length,
+    in_progress: directories.filter((d: any) => d.phase === "in_progress").length,
+    blocked: directories.filter((d: any) => d.phase === "blocked").length,
+    not_started: directories.filter((d: any) => d.phase === "not_started").length,
+  };
+  return { directories, summary, checkpoint: report.checkpoint };
+}
+
+// Integration Status Fetchers
+// NOTE: External integrations (Slack, GitHub, PagerDuty) have been deprecated.
+// Code archived to .archive/integrations/. Framework retained in integrations/common/.
+async function getIntegrationStatus(): Promise<any> {
+  const timestamp = new Date().toISOString();
+  return {
+    slack: {
+      name: "Slack",
+      status: "deprecated",
+      last_checked: timestamp,
+      details: "Archived - not required for core functionality"
+    },
+    github: {
+      name: "GitHub",
+      status: "deprecated",
+      last_checked: timestamp,
+      details: "Archived - not required for core functionality"
+    },
+    pagerduty: {
+      name: "PagerDuty",
+      status: "deprecated",
+      last_checked: timestamp,
+      details: "Archived - not required for core functionality"
+    },
+    _note: "External integrations deprecated. See .archive/integrations/ to restore."
+  };
+}
+
+async function testIntegration(name: string): Promise<any> {
+  // External integrations have been deprecated
+  const timestamp = new Date().toISOString();
+  return {
+    success: false,
+    message: `${name} integration deprecated - archived to .archive/integrations/`,
+    timestamp,
+    deprecated: true
+  };
+}
+
+// Analytics Fetchers (Direct SQLite)
+async function getViolationsByType(): Promise<any[]> {
+  try {
+    const db = new Database("/opt/agent-governance/ledger/governance.db", { readonly: true });
+    const rows = db.query(`
+      SELECT violation_type as type, COUNT(*) as count
+      FROM violations
+      GROUP BY violation_type
+      ORDER BY count DESC
+    `).all();
+    db.close();
+    return rows as any[];
+  } catch { return []; }
+}
+
+async function getViolationsBySeverity(): Promise<any[]> {
+  try {
+    const db = new Database("/opt/agent-governance/ledger/governance.db", { readonly: true });
+    const rows = db.query(`
+      SELECT severity, COUNT(*) as count
+      FROM violations
+      GROUP BY severity
+      ORDER BY
+        CASE severity
+          WHEN 'critical' THEN 1
+          WHEN 'high' THEN 2
+          WHEN 'medium' THEN 3
+          WHEN 'low' THEN 4
+          ELSE 5
+        END
+    `).all();
+    db.close();
+    return rows as any[];
+  } catch { return []; }
+}
+
+async function getViolationsByTime(days: number = 7): Promise<any[]> {
+  try {
+    const db = new Database("/opt/agent-governance/ledger/governance.db", { readonly: true });
+    const rows = db.query(`
+      SELECT
+        strftime('%Y-%m-%d %H:00', timestamp) as hour,
+        COUNT(*) as count
+      FROM violations
+      WHERE timestamp >= datetime('now', '-${days} days')
+      GROUP BY hour
+      ORDER BY hour ASC
+    `).all();
+    db.close();
+    return rows as any[];
+  } catch { return []; }
+}
+
+async function getAnalyticsSummary(): Promise<any> {
+  try {
+    const db = new Database("/opt/agent-governance/ledger/governance.db", { readonly: true });
+    const totalViolations = db.query("SELECT COUNT(*) as count FROM violations").get() as any;
+    const last24h = db.query(`
+      SELECT COUNT(*) as count FROM violations
+      WHERE timestamp >= datetime('now', '-1 day')
+    `).get() as any;
+    const byAgent = db.query(`
+      SELECT agent_id, COUNT(*) as count
+      FROM violations
+      GROUP BY agent_id
+      ORDER BY count DESC
+      LIMIT 5
+    `).all();
+    db.close();
+    return {
+      total_violations: totalViolations?.count || 0,
+      last_24h: last24h?.count || 0,
+      top_agents: byAgent,
+    };
+  } catch { return { total_violations: 0, last_24h: 0, top_agents: [] }; }
+}
+
+// Tier Progression Fetchers
+async function getTierSummary(): Promise<any> {
+  try {
+    // Get agents by tier from Redis
+    const keys = await redis.keys("agent:*:state");
+    const tiers: Record<string, number> = { T0: 0, T1: 0, T2: 0, T3: 0, T4: 0 };
+
+    for (const key of keys) {
+      try {
+        const packetKey = key.replace(":state", ":packet");
+        const packetData = await safeRedisGet(packetKey);
+        if (packetData) {
+          const packet = JSON.parse(packetData);
+          const tier = `T${packet.tier || 0}`;
+          if (tier in tiers) tiers[tier]++;
+        }
+      } catch {}
+    }
+    return tiers;
+  } catch { return { T0: 0, T1: 0, T2: 0, T3: 0, T4: 0 }; }
+}
+
+async function getTierPromotions(limit: number = 20): Promise<any[]> {
+  try {
+    const db = new Database("/opt/agent-governance/ledger/governance.db", { readonly: true });
+    const rows = db.query(`
+      SELECT * FROM promotions
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `).all(limit);
+    db.close();
+    return rows as any[];
+  } catch { return []; }
+}
+
+async function getTierDefinitions(): Promise<any[]> {
+  return [
+    { tier: "T0", name: "Sandboxed", description: "No external access, local operations only", color: "#6b7280" },
+    { tier: "T1", name: "Read-Only", description: "Can read external resources, no writes", color: "#3b82f6" },
+    { tier: "T2", name: "Limited Write", description: "Can write to approved destinations", color: "#8b5cf6" },
+    { tier: "T3", name: "Full Access", description: "Full API access with audit logging", color: "#f59e0b" },
+    { tier: "T4", name: "Autonomous", description: "Self-managing with minimal oversight", color: "#10b981" },
+  ];
+}
+
 // =============================================================================
 // Pipeline & Multi-Agent Data Fetchers
 // =============================================================================
@@ -467,6 +991,9 @@ interface PipelineConfig {
   task_id: string;
   objective: string;
   spawn_diagnostic: boolean;
+  auto_continue?: boolean;  // Auto-trigger OpenRouter orchestration after report
+  model?: string;           // OpenRouter model (default: anthropic/claude-sonnet-4)
+  timeout?: number;         // Orchestration timeout in seconds (default: 120)
 }
 
 async function spawnPipeline(config: PipelineConfig): Promise<{ success: boolean; pipeline_id: string; message: string }> {
@@ -482,6 +1009,9 @@ async function spawnPipeline(config: PipelineConfig): Promise<{ success: boolean
       status: "STARTING",
       created_at: new Date().toISOString(),
       agents: JSON.stringify([]),
+      auto_continue: config.auto_continue ? "true" : "false",
+      model: config.model || "anthropic/claude-sonnet-4",
+      timeout: String(config.timeout || 120),
     });
 
     // Add to live log
@@ -702,20 +1232,183 @@ async function checkPipelineCompletion(pipelineId: string) {
 
     if (allDone) {
       const anySuccess = agents.some((a: any) => a.status === "COMPLETED");
-      const status = anySuccess ? "COMPLETED" : "FAILED";
+      const phase1Status = anySuccess ? "REPORT" : "FAILED";
 
-      await redis.hSet(pipelineKey, "status", status);
-      await redis.hSet(pipelineKey, "completed_at", new Date().toISOString());
+      // Set to REPORT phase first (before orchestration)
+      await redis.hSet(pipelineKey, "status", phase1Status);
+      await redis.hSet(pipelineKey, "phase1_completed_at", new Date().toISOString());
 
-      await appendPipelineLog(pipelineId, "SYSTEM", `Pipeline ${status}`, anySuccess ? "SUCCESS" : "ERROR");
-      broadcastUpdate("pipeline_completed", { pipeline_id: pipelineId, status });
+      await appendPipelineLog(pipelineId, "SYSTEM", `Phase 1 ${phase1Status}`, anySuccess ? "SUCCESS" : "ERROR");
+      broadcastUpdate("pipeline_report", { pipeline_id: pipelineId, status: phase1Status });
 
       // Trigger auto-execution check for any pending plans
       await checkAutoExecution(pipelineId);
+
+      // Check for auto-continue to OpenRouter orchestration
+      const autoContinue = await redis.hGet(pipelineKey, "auto_continue");
+      if (autoContinue === "true" && anySuccess) {
+        await appendPipelineLog(pipelineId, "SYSTEM", "Auto-continuing to OpenRouter orchestration...", "INFO");
+
+        const objective = await redis.hGet(pipelineKey, "objective") || "";
+        const taskId = await redis.hGet(pipelineKey, "task_id") || "";
+        const model = await redis.hGet(pipelineKey, "model") || "anthropic/claude-sonnet-4";
+        const timeout = parseInt(await redis.hGet(pipelineKey, "timeout") || "120");
+
+        // Trigger orchestration asynchronously
+        triggerOrchestration(pipelineId, taskId, objective, model, timeout);
+      } else if (!anySuccess) {
+        // Pipeline failed, mark as final
+        await redis.hSet(pipelineKey, "status", "FAILED");
+        await redis.hSet(pipelineKey, "completed_at", new Date().toISOString());
+        broadcastUpdate("pipeline_completed", { pipeline_id: pipelineId, status: "FAILED" });
+      }
     }
   }
 }
 
+// =============================================================================
+// OpenRouter Orchestration (Multi-Agent)
+// =============================================================================
+
+async function triggerOrchestration(
+  pipelineId: string,
+  taskId: string,
+  objective: string,
+  model: string,
+  timeout: number
+): Promise<void> {
+  const pipelineKey = `pipeline:${pipelineId}`;
+
+  try {
+    // Update pipeline status to ORCHESTRATING
+    await redis.hSet(pipelineKey, "status", "ORCHESTRATING");
+    await redis.hSet(pipelineKey, "orchestration_started_at", new Date().toISOString());
+
+    await appendPipelineLog(pipelineId, "ORCHESTRATOR", `Starting OpenRouter orchestration with model: ${model}`);
+    broadcastUpdate("orchestration_started", {
+      pipeline_id: pipelineId,
+      model,
+      timeout,
+      agents: ["ALPHA", "BETA"]
+    });
+
+    // Spawn the multi-agent orchestrator process
+    const proc = Bun.spawn([
+      "bun", "run", "orchestrator.ts",
+      objective,
+      "--timeout", String(timeout),
+      "--model", model
+    ], {
+      cwd: "/opt/agent-governance/agents/multi-agent",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        PIPELINE_ID: pipelineId,
+        TASK_ID: taskId,
+      },
+    });
+
+    // Stream orchestrator output
+    const reader = proc.stdout.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value, { stream: true });
+      buffer += chunk;
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.trim()) {
+          await appendPipelineLog(pipelineId, "ORCHESTRATOR", line.trim());
+
+          // Detect agent spawns and consensus events
+          if (line.includes("[ALPHA]") || line.includes("[BETA]") || line.includes("[GAMMA]")) {
+            broadcastUpdate("agent_message", {
+              pipeline_id: pipelineId,
+              message: line.trim()
+            });
+          }
+          if (line.includes("CONSENSUS") || line.includes("ACCEPTED") || line.includes("REJECTED")) {
+            broadcastUpdate("consensus_event", {
+              pipeline_id: pipelineId,
+              message: line.trim()
+            });
+          }
+        }
+      }
+    }
+
+    // Check exit code
+    const exitCode = await proc.exited;
+
+    if (exitCode === 0) {
+      await redis.hSet(pipelineKey, "status", "COMPLETED");
+      await redis.hSet(pipelineKey, "completed_at", new Date().toISOString());
+      await appendPipelineLog(pipelineId, "ORCHESTRATOR", "Orchestration completed successfully", "SUCCESS");
+      broadcastUpdate("orchestration_complete", {
+        pipeline_id: pipelineId,
+        status: "COMPLETED"
+      });
+    } else {
+      await redis.hSet(pipelineKey, "status", "ORCHESTRATION_FAILED");
+      await redis.hSet(pipelineKey, "completed_at", new Date().toISOString());
+      await appendPipelineLog(pipelineId, "ORCHESTRATOR", `Orchestration failed with exit code ${exitCode}`, "ERROR");
+      broadcastUpdate("orchestration_complete", {
+        pipeline_id: pipelineId,
+        status: "FAILED",
+        exit_code: exitCode
+      });
+    }
+
+    // Create checkpoint with final state
+    await createCheckpointNow(`Pipeline ${pipelineId} orchestration ${exitCode === 0 ? "completed" : "failed"}`);
+
+  } catch (e: any) {
+    await redis.hSet(pipelineKey, "status", "ORCHESTRATION_ERROR");
+    await redis.hSet(pipelineKey, "completed_at", new Date().toISOString());
+    await appendPipelineLog(pipelineId, "ORCHESTRATOR", `Orchestration error: ${e.message}`, "ERROR");
+    broadcastUpdate("orchestration_complete", {
+      pipeline_id: pipelineId,
+      status: "ERROR",
+      error: e.message
+    });
+  }
+}
+
+async function continueOrchestration(
+  pipelineId: string,
+  model?: string,
+  timeout?: number
+): Promise<{ success: boolean; message: string }> {
+  const pipelineKey = `pipeline:${pipelineId}`;
+
+  // Get pipeline data
+  const data = await redis.hGetAll(pipelineKey);
+  if (!data || !data.task_id) {
+    return { success: false, message: "Pipeline not found" };
+  }
+
+  // Check current status
+  if (!["REPORT", "COMPLETED", "FAILED"].includes(data.status)) {
+    return { success: false, message: `Cannot continue from status: ${data.status}` };
+  }
+
+  const finalModel = model || data.model || "anthropic/claude-sonnet-4";
+  const finalTimeout = timeout || parseInt(data.timeout || "120");
+
+  // Trigger orchestration
+  triggerOrchestration(pipelineId, data.task_id, data.objective, finalModel, finalTimeout);
+
+  return { success: true, message: "Orchestration started" };
+}
+
 // =============================================================================
 // Auto-Execution & Approval Workflow
 // =============================================================================
@@ -1410,12 +2103,17 @@ async function verifyPlan(planId: string): Promise<{
     timestamp: new Date().toISOString()
   };
 
-  const evidenceKey = `evidence:${planId}`;
-  const evidenceExists = await redis.exists(evidenceKey);
-  if (!evidenceExists) {
+  // Evidence is stored with pattern evidence:evidence-{planId}-{timestamp}
+  const evidenceKeys = await redis.keys(`evidence:evidence-${planId}-*`);
+  const evidenceIdFromPlan = await redis.hGet(`plan:${planId}`, "evidence_id");
+
+  if (evidenceKeys.length === 0 && !evidenceIdFromPlan) {
     evidenceCheck.status = "FAIL";
     evidenceCheck.details = "Missing evidence package - execution audit incomplete";
     allPassed = false;
+  } else {
+    const evidenceCount = evidenceKeys.length || (evidenceIdFromPlan ? 1 : 0);
+    evidenceCheck.details = `Evidence package verified (${evidenceCount} artifact(s) found)`;
   }
   checks.push(evidenceCheck);
   await appendPipelineLog(pipelineId, verifierId,
@@ -2682,6 +3380,846 @@ function renderDashboard(): string {
     ::-webkit-scrollbar-track { background: var(--bg-primary); }
     ::-webkit-scrollbar-thumb { background: var(--border-color); border-radius: 4px; }
     ::-webkit-scrollbar-thumb:hover { background: var(--text-muted); }
+
+    /* ========== Tab Navigation ========== */
+    .tab-bar {
+      display: flex;
+      gap: 2px;
+      padding: 0 12px;
+      background: var(--bg-secondary);
+      border-bottom: 1px solid var(--border-color);
+      overflow-x: auto;
+    }
+
+    .tab-btn {
+      padding: 10px 16px;
+      background: transparent;
+      border: none;
+      color: var(--text-secondary);
+      font-size: 11px;
+      font-weight: 600;
+      font-family: inherit;
+      cursor: pointer;
+      white-space: nowrap;
+      border-bottom: 2px solid transparent;
+      transition: all 0.15s;
+    }
+
+    .tab-btn:hover {
+      color: var(--text-primary);
+      background: var(--bg-tertiary);
+    }
+
+    .tab-btn.active {
+      color: var(--accent-cyan);
+      border-bottom-color: var(--accent-cyan);
+    }
+
+    .tab-content {
+      display: none;
+      height: calc(100vh - 100px);
+      overflow: hidden;
+    }
+
+    .tab-content.active {
+      display: flex;
+    }
+
+    /* ========== Checkpoint Manager ========== */
+    .checkpoint-container {
+      display: flex;
+      gap: 12px;
+      padding: 12px;
+      height: 100%;
+      width: 100%;
+    }
+
+    .checkpoint-timeline {
+      width: 280px;
+      flex-shrink: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
+
+    .checkpoint-item {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      padding: 10px;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+
+    .checkpoint-item:hover, .checkpoint-item.active {
+      border-color: var(--accent-cyan);
+    }
+
+    .checkpoint-item.active {
+      background: rgba(0, 255, 255, 0.05);
+    }
+
+    .checkpoint-id {
+      font-size: 10px;
+      color: var(--accent-cyan);
+      font-family: monospace;
+    }
+
+    .checkpoint-time {
+      font-size: 10px;
+      color: var(--text-muted);
+    }
+
+    .checkpoint-notes {
+      font-size: 11px;
+      color: var(--text-secondary);
+      margin-top: 4px;
+    }
+
+    .checkpoint-detail {
+      flex: 1;
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      overflow: auto;
+      padding: 12px;
+    }
+
+    .summary-level-btns {
+      display: flex;
+      gap: 4px;
+      margin-bottom: 12px;
+    }
+
+    .summary-level-btn {
+      padding: 4px 10px;
+      background: var(--bg-tertiary);
+      border: 1px solid var(--border-color);
+      border-radius: 3px;
+      color: var(--text-secondary);
+      font-size: 10px;
+      cursor: pointer;
+    }
+
+    .summary-level-btn.active {
+      background: var(--accent-cyan);
+      color: #0a0e14;
+      border-color: var(--accent-cyan);
+    }
+
+    /* ========== Memory Browser ========== */
+    .memory-container {
+      display: flex;
+      gap: 12px;
+      padding: 12px;
+      height: 100%;
+      width: 100%;
+    }
+
+    .memory-sidebar {
+      width: 300px;
+      flex-shrink: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
+
+    .memory-search {
+      display: flex;
+      gap: 4px;
+    }
+
+    .memory-search input {
+      flex: 1;
+      padding: 8px 10px;
+      background: var(--bg-tertiary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      color: var(--text-primary);
+      font-size: 11px;
+    }
+
+    .memory-list {
+      flex: 1;
+      overflow-y: auto;
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+
+    .memory-item {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      padding: 8px;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+
+    .memory-item:hover, .memory-item.active {
+      border-color: var(--accent-purple);
+    }
+
+    .memory-item.active {
+      background: rgba(139, 92, 246, 0.05);
+    }
+
+    .memory-type {
+      display: inline-block;
+      padding: 2px 6px;
+      background: var(--accent-purple);
+      color: #0a0e14;
+      font-size: 9px;
+      font-weight: 600;
+      border-radius: 2px;
+    }
+
+    .memory-content {
+      flex: 1;
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      overflow: auto;
+      padding: 12px;
+    }
+
+    .chunk-nav {
+      display: flex;
+      gap: 8px;
+      align-items: center;
+      margin-bottom: 12px;
+      padding-bottom: 12px;
+      border-bottom: 1px solid var(--border-color);
+    }
+
+    .chunk-nav button {
+      padding: 4px 10px;
+      background: var(--bg-tertiary);
+      border: 1px solid var(--border-color);
+      border-radius: 3px;
+      color: var(--text-secondary);
+      font-size: 10px;
+      cursor: pointer;
+    }
+
+    .chunk-nav button:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+
+    /* ========== Status Grid ========== */
+    .status-grid-container {
+      padding: 12px;
+      width: 100%;
+      overflow: auto;
+    }
+
+    .status-summary {
+      display: flex;
+      gap: 12px;
+      margin-bottom: 16px;
+      flex-wrap: wrap;
+    }
+
+    .status-stat {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      padding: 12px 16px;
+      text-align: center;
+    }
+
+    .status-stat-value {
+      font-size: 24px;
+      font-weight: 700;
+      color: var(--text-primary);
+    }
+
+    .status-stat-label {
+      font-size: 10px;
+      color: var(--text-muted);
+      text-transform: uppercase;
+    }
+
+    .status-grid {
+      display: grid;
+      grid-template-columns: repeat(8, 1fr);
+      gap: 6px;
+    }
+
+    .status-cell {
+      aspect-ratio: 1;
+      min-width: 80px;
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      padding: 8px;
+      display: flex;
+      flex-direction: column;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+
+    .status-cell:hover {
+      border-color: var(--text-muted);
+      transform: scale(1.02);
+    }
+
+    .status-cell.complete { border-left: 3px solid var(--accent-green); }
+    .status-cell.in_progress { border-left: 3px solid var(--accent-cyan); }
+    .status-cell.blocked { border-left: 3px solid var(--accent-red); }
+    .status-cell.needs_review { border-left: 3px solid var(--accent-orange); }
+    .status-cell.not_started { border-left: 3px solid var(--text-muted); }
+
+    .status-cell-name {
+      font-size: 9px;
+      font-weight: 600;
+      color: var(--text-primary);
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .status-cell-phase {
+      font-size: 8px;
+      color: var(--text-muted);
+      margin-top: auto;
+    }
+
+    .status-cell-icon {
+      font-size: 16px;
+      margin-bottom: 4px;
+    }
+
+    /* ========== Integration Panel ========== */
+    .integration-container {
+      display: flex;
+      gap: 16px;
+      padding: 16px;
+      flex-wrap: wrap;
+    }
+
+    .integration-card {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 20px;
+      width: 300px;
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+    }
+
+    .integration-header {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+    }
+
+    .integration-icon {
+      width: 40px;
+      height: 40px;
+      background: var(--bg-tertiary);
+      border-radius: 8px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 20px;
+    }
+
+    .integration-name {
+      font-size: 14px;
+      font-weight: 600;
+      color: var(--text-primary);
+    }
+
+    .integration-status {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 10px;
+      border-radius: 12px;
+      font-size: 10px;
+      font-weight: 600;
+    }
+
+    .integration-status.configured {
+      background: rgba(16, 185, 129, 0.15);
+      color: var(--accent-green);
+    }
+
+    .integration-status.not_configured {
+      background: rgba(107, 114, 128, 0.15);
+      color: var(--text-muted);
+    }
+
+    .integration-status.error {
+      background: rgba(239, 68, 68, 0.15);
+      color: var(--accent-red);
+    }
+
+    .integration-status.deprecated {
+      background: rgba(107, 114, 128, 0.25);
+      color: var(--text-muted);
+      text-decoration: line-through;
+    }
+
+    .integration-card.deprecated {
+      opacity: 0.6;
+    }
+
+    .integration-test-btn {
+      padding: 8px 12px;
+      background: var(--bg-tertiary);
+      border: 1px solid var(--border-color);
+      border-radius: 4px;
+      color: var(--text-secondary);
+      font-size: 11px;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+
+    .integration-test-btn:hover {
+      background: var(--accent-cyan);
+      color: #0a0e14;
+      border-color: var(--accent-cyan);
+    }
+
+    .integration-result {
+      font-size: 10px;
+      color: var(--text-muted);
+      padding: 8px;
+      background: var(--bg-tertiary);
+      border-radius: 4px;
+    }
+
+    /* ========== Analytics Charts ========== */
+    .analytics-container {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 16px;
+      padding: 16px;
+      overflow: auto;
+      width: 100%;
+    }
+
+    .chart-container {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 16px;
+      min-width: 350px;
+      flex: 1;
+    }
+
+    .chart-title {
+      font-size: 12px;
+      font-weight: 600;
+      color: var(--text-primary);
+      margin-bottom: 16px;
+    }
+
+    .chart-svg {
+      width: 100%;
+      height: 200px;
+    }
+
+    .bar-chart-bar {
+      fill: var(--accent-cyan);
+      transition: fill 0.15s;
+    }
+
+    .bar-chart-bar:hover {
+      fill: var(--accent-blue);
+    }
+
+    .bar-chart-label {
+      fill: var(--text-secondary);
+      font-size: 10px;
+    }
+
+    .bar-chart-value {
+      fill: var(--text-primary);
+      font-size: 10px;
+      font-weight: 600;
+    }
+
+    .pie-chart-segment {
+      transition: opacity 0.15s;
+    }
+
+    .pie-chart-segment:hover {
+      opacity: 0.8;
+    }
+
+    .chart-legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+      margin-top: 12px;
+    }
+
+    .legend-item {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 10px;
+      color: var(--text-secondary);
+    }
+
+    .legend-dot {
+      width: 10px;
+      height: 10px;
+      border-radius: 2px;
+    }
+
+    .analytics-summary-cards {
+      display: flex;
+      gap: 12px;
+      width: 100%;
+      margin-bottom: 16px;
+    }
+
+    .analytics-card {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 16px 20px;
+      text-align: center;
+    }
+
+    .analytics-card-value {
+      font-size: 28px;
+      font-weight: 700;
+      color: var(--accent-cyan);
+    }
+
+    .analytics-card-label {
+      font-size: 10px;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      margin-top: 4px;
+    }
+
+    /* ========== Bug Tracking ========== */
+    .bugs-container {
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+      overflow: auto;
+      width: 100%;
+      flex: 1;
+    }
+
+    .bugs-summary {
+      display: flex;
+      gap: 12px;
+    }
+
+    .bug-stat-card {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 16px 24px;
+      text-align: center;
+      min-width: 100px;
+    }
+
+    .bug-stat-card.open { border-left: 3px solid #f59e0b; }
+    .bug-stat-card.in-progress { border-left: 3px solid #3b82f6; }
+    .bug-stat-card.resolved { border-left: 3px solid #10b981; }
+
+    .bug-stat-value {
+      font-size: 28px;
+      font-weight: 700;
+      color: var(--text-primary);
+    }
+
+    .bug-stat-card.open .bug-stat-value { color: #f59e0b; }
+    .bug-stat-card.in-progress .bug-stat-value { color: #3b82f6; }
+    .bug-stat-card.resolved .bug-stat-value { color: #10b981; }
+
+    .bug-stat-label {
+      font-size: 10px;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      margin-top: 4px;
+    }
+
+    .bugs-filters {
+      display: flex;
+      gap: 12px;
+      align-items: center;
+    }
+
+    .bugs-filters select {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      color: var(--text-primary);
+      padding: 6px 10px;
+      border-radius: 4px;
+      font-size: 12px;
+    }
+
+    .bug-action-btn {
+      background: var(--accent-cyan);
+      border: none;
+      color: var(--bg-primary);
+      padding: 6px 12px;
+      border-radius: 4px;
+      font-size: 12px;
+      font-weight: 600;
+      cursor: pointer;
+      margin-left: auto;
+    }
+
+    .bug-action-btn:hover { opacity: 0.9; }
+
+    .bugs-list {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      flex: 1;
+      overflow: auto;
+    }
+
+    .bug-item {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 6px;
+      padding: 12px 16px;
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      cursor: pointer;
+      transition: border-color 0.15s;
+    }
+
+    .bug-item:hover { border-color: var(--accent-cyan); }
+
+    .bug-severity {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      flex-shrink: 0;
+    }
+
+    .bug-severity.critical { background: #ef4444; }
+    .bug-severity.high { background: #f59e0b; }
+    .bug-severity.medium { background: #fbbf24; }
+    .bug-severity.low { background: #10b981; }
+    .bug-severity.info { background: #6b7280; }
+
+    .bug-status-badge {
+      font-size: 9px;
+      padding: 2px 6px;
+      border-radius: 3px;
+      text-transform: uppercase;
+      font-weight: 600;
+    }
+
+    .bug-status-badge.open { background: rgba(245, 158, 11, 0.2); color: #f59e0b; }
+    .bug-status-badge.in_progress { background: rgba(59, 130, 246, 0.2); color: #3b82f6; }
+    .bug-status-badge.resolved { background: rgba(16, 185, 129, 0.2); color: #10b981; }
+
+    .bug-message {
+      flex: 1;
+      font-size: 12px;
+      color: var(--text-primary);
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .bug-meta {
+      font-size: 10px;
+      color: var(--text-muted);
+      white-space: nowrap;
+    }
+
+    .bug-detail-panel {
+      width: 400px;
+      background: var(--bg-secondary);
+      border-left: 1px solid var(--border-color);
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+      overflow: auto;
+    }
+
+    .bug-detail-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      font-size: 12px;
+      font-weight: 600;
+      color: var(--accent-cyan);
+    }
+
+    .bug-detail-content {
+      font-size: 12px;
+      color: var(--text-secondary);
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+    }
+
+    .bug-detail-row {
+      display: flex;
+      gap: 8px;
+    }
+
+    .bug-detail-label {
+      color: var(--text-muted);
+      min-width: 80px;
+    }
+
+    .bug-detail-value {
+      color: var(--text-primary);
+      flex: 1;
+    }
+
+    .bug-detail-actions {
+      display: flex;
+      gap: 8px;
+      margin-top: auto;
+      padding-top: 16px;
+      border-top: 1px solid var(--border-color);
+    }
+
+    .bug-detail-actions button {
+      flex: 1;
+      padding: 8px 12px;
+      border-radius: 4px;
+      font-size: 11px;
+      font-weight: 600;
+      cursor: pointer;
+      border: 1px solid var(--border-color);
+      background: var(--bg-primary);
+      color: var(--text-primary);
+    }
+
+    .bug-detail-actions button.primary {
+      background: var(--accent-cyan);
+      color: var(--bg-primary);
+      border: none;
+    }
+
+    .bug-detail-actions button:hover { opacity: 0.9; }
+
+    /* ========== Tier Progression ========== */
+    .tier-container {
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 20px;
+      overflow: auto;
+      width: 100%;
+    }
+
+    .tier-cards {
+      display: flex;
+      gap: 12px;
+      flex-wrap: wrap;
+    }
+
+    .tier-card {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 16px;
+      min-width: 150px;
+      flex: 1;
+      text-align: center;
+      position: relative;
+      overflow: hidden;
+    }
+
+    .tier-card::before {
+      content: '';
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      height: 3px;
+    }
+
+    .tier-card.t0::before { background: #6b7280; }
+    .tier-card.t1::before { background: #3b82f6; }
+    .tier-card.t2::before { background: #8b5cf6; }
+    .tier-card.t3::before { background: #f59e0b; }
+    .tier-card.t4::before { background: #10b981; }
+
+    .tier-label {
+      font-size: 11px;
+      font-weight: 600;
+      color: var(--text-muted);
+      text-transform: uppercase;
+    }
+
+    .tier-count {
+      font-size: 32px;
+      font-weight: 700;
+      color: var(--text-primary);
+      margin: 8px 0;
+    }
+
+    .tier-name {
+      font-size: 10px;
+      color: var(--text-secondary);
+    }
+
+    .tier-history {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 16px;
+    }
+
+    .tier-history-title {
+      font-size: 12px;
+      font-weight: 600;
+      color: var(--text-primary);
+      margin-bottom: 12px;
+    }
+
+    .tier-history-list {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      max-height: 300px;
+      overflow-y: auto;
+    }
+
+    .tier-history-item {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 8px;
+      background: var(--bg-tertiary);
+      border-radius: 4px;
+      font-size: 11px;
+    }
+
+    .tier-badge {
+      padding: 2px 8px;
+      border-radius: 3px;
+      font-size: 10px;
+      font-weight: 600;
+    }
+
+    .tier-badge.t0 { background: #6b7280; color: white; }
+    .tier-badge.t1 { background: #3b82f6; color: white; }
+    .tier-badge.t2 { background: #8b5cf6; color: white; }
+    .tier-badge.t3 { background: #f59e0b; color: #0a0e14; }
+    .tier-badge.t4 { background: #10b981; color: #0a0e14; }
+
+    .promotion-arrow {
+      color: var(--accent-green);
+      font-weight: bold;
+    }
   </style>
 </head>
 <body>
@@ -2714,8 +4252,20 @@ function renderDashboard(): string {
       </div>
     </div>
 
-    <!-- Main Content -->
-    <div class="main-content">
+    <!-- Tab Navigation -->
+    <div class="tab-bar">
+      <button class="tab-btn active" data-tab="pipelines" onclick="switchTab('pipelines')">Pipelines</button>
+      <button class="tab-btn" data-tab="checkpoint" onclick="switchTab('checkpoint')">Checkpoints</button>
+      <button class="tab-btn" data-tab="memory" onclick="switchTab('memory')">Memory</button>
+      <button class="tab-btn" data-tab="status" onclick="switchTab('status')">Status Grid</button>
+      <button class="tab-btn" data-tab="integrations" onclick="switchTab('integrations')">Integrations</button>
+      <button class="tab-btn" data-tab="analytics" onclick="switchTab('analytics')">Analytics</button>
+      <button class="tab-btn" data-tab="bugs" onclick="switchTab('bugs')">Bugs</button>
+      <button class="tab-btn" data-tab="tiers" onclick="switchTab('tiers')">Tiers</button>
+    </div>
+
+    <!-- Tab: Pipelines (Original Main Content) -->
+    <div class="tab-content active" id="tab-pipelines">
       <!-- Left: Pipelines -->
       <div class="panel">
         <div class="panel-header">
@@ -2768,6 +4318,154 @@ function renderDashboard(): string {
         </div>
       </div>
     </div>
+
+    <!-- Tab: Checkpoints -->
+    <div class="tab-content" id="tab-checkpoint">
+      <div class="checkpoint-container">
+        <div class="checkpoint-timeline">
+          <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
+            <span style="font-size: 12px; font-weight: 600; color: var(--text-primary);">TIMELINE</span>
+            <button onclick="createCheckpoint()" style="padding: 4px 10px; background: var(--accent-cyan); border: none; border-radius: 3px; color: #0a0e14; font-size: 10px; font-weight: 600; cursor: pointer;">+ New</button>
+          </div>
+          <div id="checkpoint-list" style="overflow-y: auto; flex: 1;"></div>
+        </div>
+        <div class="checkpoint-detail">
+          <div class="summary-level-btns">
+            <button class="summary-level-btn active" onclick="setSummaryLevel('minimal')">Minimal</button>
+            <button class="summary-level-btn" onclick="setSummaryLevel('compact')">Compact</button>
+            <button class="summary-level-btn" onclick="setSummaryLevel('standard')">Standard</button>
+            <button class="summary-level-btn" onclick="setSummaryLevel('full')">Full</button>
+          </div>
+          <div id="checkpoint-detail-content" style="font-size: 11px; color: var(--text-secondary); white-space: pre-wrap; font-family: monospace;">
+            Select a checkpoint to view details
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Tab: Memory -->
+    <div class="tab-content" id="tab-memory">
+      <div class="memory-container">
+        <div class="memory-sidebar">
+          <div class="memory-search">
+            <input type="text" id="memory-search-input" placeholder="Search memory..." onkeydown="if(event.key==='Enter') searchMemoryEntries()">
+            <button onclick="searchMemoryEntries()" style="padding: 8px 12px; background: var(--accent-purple); border: none; border-radius: 4px; color: white; cursor: pointer;">Search</button>
+          </div>
+          <div style="display: flex; gap: 4px; margin-top: 8px;">
+            <select id="memory-type-filter" onchange="loadMemoryEntries()" style="flex: 1; padding: 6px; background: var(--bg-tertiary); border: 1px solid var(--border-color); border-radius: 4px; color: var(--text-primary); font-size: 11px;">
+              <option value="">All Types</option>
+              <option value="output">Output</option>
+              <option value="result">Result</option>
+              <option value="artifact">Artifact</option>
+              <option value="log">Log</option>
+            </select>
+          </div>
+          <div class="memory-list" id="memory-list"></div>
+        </div>
+        <div class="memory-content">
+          <div class="chunk-nav" id="chunk-nav" style="display: none;">
+            <button onclick="loadChunk(-1)" id="chunk-prev">Prev</button>
+            <span id="chunk-indicator">Chunk 1 / 1</span>
+            <button onclick="loadChunk(1)" id="chunk-next">Next</button>
+          </div>
+          <div id="memory-content-display" style="font-size: 11px; color: var(--text-secondary); white-space: pre-wrap; font-family: monospace;">
+            Select a memory entry to view content
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Tab: Status Grid -->
+    <div class="tab-content" id="tab-status">
+      <div class="status-grid-container">
+        <div class="status-summary" id="status-summary"></div>
+        <div class="status-grid" id="status-grid-display"></div>
+      </div>
+    </div>
+
+    <!-- Tab: Integrations -->
+    <div class="tab-content" id="tab-integrations">
+      <div class="integration-container" id="integration-cards"></div>
+    </div>
+
+    <!-- Tab: Analytics -->
+    <div class="tab-content" id="tab-analytics">
+      <div class="analytics-container">
+        <div class="analytics-summary-cards" id="analytics-summary"></div>
+        <div class="chart-container" id="chart-by-type">
+          <div class="chart-title">Violations by Type</div>
+          <svg class="chart-svg" id="chart-svg-type"></svg>
+        </div>
+        <div class="chart-container" id="chart-by-severity">
+          <div class="chart-title">Violations by Severity</div>
+          <svg class="chart-svg" id="chart-svg-severity"></svg>
+        </div>
+        <div class="chart-container" style="flex-basis: 100%;" id="chart-by-time">
+          <div class="chart-title">Violations Over Time (Last 7 Days)</div>
+          <svg class="chart-svg" id="chart-svg-time" style="height: 150px;"></svg>
+        </div>
+      </div>
+    </div>
+
+    <!-- Tab: Bugs -->
+    <div class="tab-content" id="tab-bugs">
+      <div class="bugs-container">
+        <div class="bugs-summary">
+          <div class="bug-stat-card">
+            <div class="bug-stat-value" id="bugs-total">0</div>
+            <div class="bug-stat-label">Total</div>
+          </div>
+          <div class="bug-stat-card open">
+            <div class="bug-stat-value" id="bugs-open">0</div>
+            <div class="bug-stat-label">Open</div>
+          </div>
+          <div class="bug-stat-card in-progress">
+            <div class="bug-stat-value" id="bugs-in-progress">0</div>
+            <div class="bug-stat-label">In Progress</div>
+          </div>
+          <div class="bug-stat-card resolved">
+            <div class="bug-stat-value" id="bugs-resolved">0</div>
+            <div class="bug-stat-label">Resolved</div>
+          </div>
+        </div>
+        <div class="bugs-filters">
+          <select id="bug-filter-status" onchange="loadBugs()">
+            <option value="">All Statuses</option>
+            <option value="open">Open</option>
+            <option value="in_progress">In Progress</option>
+            <option value="resolved">Resolved</option>
+          </select>
+          <select id="bug-filter-severity" onchange="loadBugs()">
+            <option value="">All Severities</option>
+            <option value="critical">Critical</option>
+            <option value="high">High</option>
+            <option value="medium">Medium</option>
+            <option value="low">Low</option>
+          </select>
+          <button class="bug-action-btn" onclick="showLogBugModal()">+ Log Bug</button>
+        </div>
+        <div class="bugs-list" id="bugs-list"></div>
+      </div>
+      <div class="bug-detail-panel" id="bug-detail-panel" style="display: none;">
+        <div class="bug-detail-header">
+          <span id="bug-detail-id"></span>
+          <button onclick="closeBugDetail()" style="background: none; border: none; color: var(--text-muted); cursor: pointer;">&times;</button>
+        </div>
+        <div class="bug-detail-content" id="bug-detail-content"></div>
+        <div class="bug-detail-actions" id="bug-detail-actions"></div>
+      </div>
+    </div>
+
+    <!-- Tab: Tiers -->
+    <div class="tab-content" id="tab-tiers">
+      <div class="tier-container">
+        <div class="tier-cards" id="tier-cards"></div>
+        <div class="tier-history">
+          <div class="tier-history-title">Recent Promotions</div>
+          <div class="tier-history-list" id="tier-history-list"></div>
+        </div>
+      </div>
+    </div>
   </div>
 
   <script>
@@ -2827,6 +4525,42 @@ function renderDashboard(): string {
         if (msg.type === 'orchestration_run' || msg.type === 'orchestration_completed') {
           loadOrchestration();
         }
+
+        // New tab events
+        if (msg.type === 'checkpoint_created') {
+          if (currentTab === 'checkpoint') {
+            loadCheckpoints();
+          }
+          tabDataLoaded['checkpoint'] = false; // Force reload on next visit
+        }
+
+        if (msg.type === 'memory_stored') {
+          if (currentTab === 'memory') {
+            loadMemoryEntries();
+          }
+          tabDataLoaded['memory'] = false;
+        }
+
+        if (msg.type === 'status_changed') {
+          if (currentTab === 'status') {
+            loadStatusGrid();
+          }
+          tabDataLoaded['status'] = false;
+        }
+
+        if (msg.type === 'violation_recorded') {
+          if (currentTab === 'analytics') {
+            loadAnalytics();
+          }
+          tabDataLoaded['analytics'] = false;
+        }
+
+        if (msg.type === 'tier_promoted') {
+          if (currentTab === 'tiers') {
+            loadTierProgression();
+          }
+          tabDataLoaded['tiers'] = false;
+        }
       };
 
       ws.onclose = () => {
@@ -3006,8 +4740,8 @@ function renderDashboard(): string {
             <span>Tier: <strong>T\${plan.estimated_tier_required}</strong></span>
           </div>
           <div class="plan-buttons">
-            <button class="exec-btn dry-run" onclick="executePlan(true)" \${['EXECUTED', 'VERIFIED'].includes(plan.status) ? 'disabled' : ''}>DRY RUN</button>
-            <button class="exec-btn execute" onclick="executePlan(false)" \${['EXECUTING', 'EXECUTED', 'VERIFIED'].includes(plan.status) ? 'disabled' : ''}>
+            <button class="exec-btn dry-run" onclick="executePlan(true)" \${['EXECUTED', 'VERIFIED', 'PACKAGED', 'COMPLETED'].includes(plan.status) ? 'disabled' : ''}>DRY RUN</button>
+            <button class="exec-btn execute" onclick="executePlan(false)" \${['EXECUTING', 'EXECUTED', 'VERIFIED', 'PACKAGED', 'COMPLETED'].includes(plan.status) ? 'disabled' : ''}>
               EXECUTE
             </button>
             <button class="exec-btn verify" onclick="verifyPlan()" \${plan.status !== 'EXECUTED' ? 'disabled' : ''}>
@@ -3016,10 +4750,12 @@ function renderDashboard(): string {
             <button class="exec-btn package" onclick="packagePlan()" \${plan.status !== 'VERIFIED' ? 'disabled' : ''}>
               PACKAGE
             </button>
-            <button class="exec-btn report" onclick="reportPlan()" \${plan.status !== 'PACKAGED' ? 'disabled' : ''}>
-              REPORT
-            </button>
+            \${plan.status === 'COMPLETED' ?
+              \`<button class="exec-btn report" onclick="viewReport('\${plan.plan_id}')" style="background: var(--accent-green);">VIEW REPORT</button>\` :
+              \`<button class="exec-btn report" onclick="reportPlan()" \${plan.status !== 'PACKAGED' ? 'disabled' : ''}>REPORT</button>\`
+            }
           </div>
+          \${plan.status === 'COMPLETED' ? \`<div style="margin-top: 8px; font-size: 10px; color: var(--accent-green);">✓ Pipeline complete - click VIEW REPORT to see results</div>\` : ''}
         </div>
       \`;
     }
@@ -3054,6 +4790,13 @@ function renderDashboard(): string {
         if (result.success) {
           await loadLogs(selectedPipelineId);
           await loadPlans();
+          // Auto-advance: if not dry run, automatically verify
+          if (!dryRun && result.success) {
+            setTimeout(() => {
+              console.log('[AUTO-ADVANCE] Execution complete, starting verification...');
+              verifyPlan();
+            }, 1000);
+          }
         } else {
           alert('Execution failed: ' + result.summary);
         }
@@ -3087,7 +4830,11 @@ function renderDashboard(): string {
         if (result.success) {
           await loadLogs(selectedPipelineId);
           await loadPlans();
-          alert('Verification complete: ' + result.summary);
+          // Auto-advance: automatically package after verification
+          setTimeout(() => {
+            console.log('[AUTO-ADVANCE] Verification complete, starting packaging...');
+            packagePlan();
+          }, 1000);
         } else {
           alert('Verification failed: ' + result.summary);
         }
@@ -3120,7 +4867,11 @@ function renderDashboard(): string {
         if (result.success) {
           await loadLogs(selectedPipelineId);
           await loadPlans();
-          alert('Package created: ' + result.summary);
+          // Auto-advance: automatically generate report after packaging
+          setTimeout(() => {
+            console.log('[AUTO-ADVANCE] Packaging complete, generating report...');
+            reportPlan();
+          }, 1000);
         } else {
           alert('Packaging failed: ' + result.summary);
         }
@@ -3153,7 +4904,8 @@ function renderDashboard(): string {
         if (result.success) {
           await loadLogs(selectedPipelineId);
           await loadPlans();
-          alert('Report generated: ' + result.summary);
+          // Show the report panel with real data
+          showReportPanel(result.report);
         } else {
           alert('Report generation failed: ' + result.summary);
         }
@@ -3164,6 +4916,109 @@ function renderDashboard(): string {
       if (reportBtn) reportBtn.disabled = false;
     }
 
+    // Show formatted report panel
+    function showReportPanel(report) {
+      if (!report) {
+        alert('No report data available');
+        return;
+      }
+
+      const outcomeColors = {
+        SUCCESS: 'var(--accent-green)',
+        PARTIAL: 'var(--accent-orange)',
+        FAILED: 'var(--accent-red)'
+      };
+
+      const modal = document.createElement('div');
+      modal.id = 'report-modal';
+      modal.style.cssText = \`
+        position: fixed; top: 0; left: 0; right: 0; bottom: 0;
+        background: rgba(0,0,0,0.85); z-index: 1000;
+        display: flex; align-items: center; justify-content: center;
+        padding: 20px;
+      \`;
+
+      modal.innerHTML = \`
+        <div style="background: var(--bg-secondary); border: 1px solid var(--border-color); border-radius: 8px; max-width: 700px; width: 100%; max-height: 80vh; overflow: auto; padding: 24px;">
+          <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 20px;">
+            <h2 style="margin: 0; color: var(--text-primary); font-size: 18px;">Execution Report</h2>
+            <button onclick="closeReportModal()" style="background: none; border: none; color: var(--text-muted); font-size: 20px; cursor: pointer;">&times;</button>
+          </div>
+
+          <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; margin-bottom: 24px;">
+            <div style="background: var(--bg-tertiary); padding: 16px; border-radius: 6px; text-align: center;">
+              <div style="font-size: 24px; font-weight: 700; color: \${outcomeColors[report.summary.outcome] || 'var(--text-primary)'};">\${report.summary.outcome}</div>
+              <div style="font-size: 11px; color: var(--text-muted); margin-top: 4px;">Outcome</div>
+            </div>
+            <div style="background: var(--bg-tertiary); padding: 16px; border-radius: 6px; text-align: center;">
+              <div style="font-size: 24px; font-weight: 700; color: var(--accent-cyan);">\${(report.summary.confidence * 100).toFixed(0)}%</div>
+              <div style="font-size: 11px; color: var(--text-muted); margin-top: 4px;">Confidence</div>
+            </div>
+            <div style="background: var(--bg-tertiary); padding: 16px; border-radius: 6px; text-align: center;">
+              <div style="font-size: 24px; font-weight: 700; color: var(--text-primary);">\${report.summary.execution_time_ms}ms</div>
+              <div style="font-size: 11px; color: var(--text-muted); margin-top: 4px;">Execution Time</div>
+            </div>
+          </div>
+
+          <div style="margin-bottom: 20px;">
+            <h3 style="font-size: 12px; color: var(--text-secondary); margin-bottom: 8px; text-transform: uppercase;">Summary</h3>
+            <div style="background: var(--bg-tertiary); padding: 12px; border-radius: 6px; font-size: 12px; color: var(--text-primary); white-space: pre-line;">\${report.notes_for_humans}</div>
+          </div>
+
+          <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-bottom: 20px;">
+            <div>
+              <h3 style="font-size: 12px; color: var(--text-secondary); margin-bottom: 8px; text-transform: uppercase;">Phases Completed</h3>
+              <div style="display: flex; flex-wrap: wrap; gap: 6px;">
+                \${report.phases_completed.map(p => \`<span style="background: var(--accent-green); color: #0a0e14; padding: 4px 8px; border-radius: 4px; font-size: 10px; font-weight: 600;">\${p}</span>\`).join('')}
+              </div>
+            </div>
+            <div>
+              <h3 style="font-size: 12px; color: var(--text-secondary); margin-bottom: 8px; text-transform: uppercase;">Assumptions Validated</h3>
+              <div style="font-size: 11px; color: var(--text-primary);">
+                \${report.assumptions_validated.map(a => \`<div style="margin-bottom: 4px;">✓ \${a}</div>\`).join('')}
+              </div>
+            </div>
+          </div>
+
+          <div style="margin-bottom: 20px;">
+            <h3 style="font-size: 12px; color: var(--text-secondary); margin-bottom: 8px; text-transform: uppercase;">Next Actions</h3>
+            <div style="background: var(--bg-tertiary); padding: 12px; border-radius: 6px;">
+              \${report.next_actions.map((a, i) => \`<div style="font-size: 11px; color: var(--text-primary); margin-bottom: 6px;">\${i+1}. \${a}</div>\`).join('')}
+            </div>
+          </div>
+
+          <div style="display: flex; justify-content: space-between; align-items: center; padding-top: 16px; border-top: 1px solid var(--border-color);">
+            <div style="font-size: 10px; color: var(--text-muted);">
+              Report ID: \${report.report_id}<br>
+              Generated: \${new Date(report.generated_at).toLocaleString()}
+            </div>
+            <button onclick="closeReportModal()" style="padding: 8px 20px; background: var(--accent-cyan); border: none; border-radius: 4px; color: #0a0e14; font-weight: 600; cursor: pointer;">Close</button>
+          </div>
+        </div>
+      \`;
+
+      document.body.appendChild(modal);
+    }
+
+    function closeReportModal() {
+      const modal = document.getElementById('report-modal');
+      if (modal) modal.remove();
+    }
+
+    // View existing report for a completed plan
+    async function viewReport(planId) {
+      try {
+        const report = await fetchJSON(\`/api/report/get?plan_id=\${planId}\`);
+        if (report && report.report_id) {
+          showReportPanel(report);
+        } else {
+          alert('Report not found');
+        }
+      } catch (e) {
+        alert('Error loading report: ' + e.message);
+      }
+    }
+
     // Store a plan manually (for testing)
     async function storeTestPlan() {
       if (!selectedPipelineId) {
@@ -3413,6 +5268,779 @@ function renderDashboard(): string {
       }
     }
 
+    // ========== Tab Navigation ==========
+    let currentTab = 'pipelines';
+    let tabDataLoaded = {};
+
+    function switchTab(tabName) {
+      // Update tab buttons
+      document.querySelectorAll('.tab-btn').forEach(btn => {
+        btn.classList.toggle('active', btn.dataset.tab === tabName);
+      });
+
+      // Update tab content
+      document.querySelectorAll('.tab-content').forEach(content => {
+        content.classList.toggle('active', content.id === 'tab-' + tabName);
+      });
+
+      currentTab = tabName;
+
+      // Load data if not already loaded
+      if (!tabDataLoaded[tabName]) {
+        loadTabData(tabName);
+        tabDataLoaded[tabName] = true;
+      }
+    }
+
+    function loadTabData(tabName) {
+      switch(tabName) {
+        case 'checkpoint': loadCheckpoints(); break;
+        case 'memory': loadMemoryEntries(); break;
+        case 'status': loadStatusGrid(); break;
+        case 'integrations': loadIntegrations(); break;
+        case 'analytics': loadAnalytics(); break;
+        case 'bugs': loadBugsSummary(); loadBugs(); break;
+        case 'tiers': loadTierProgression(); break;
+      }
+    }
+
+    // ========== Checkpoint Manager ==========
+    let checkpointsData = [];
+    let selectedCheckpointId = null;
+    let summaryLevel = 'minimal';
+
+    async function loadCheckpoints() {
+      try {
+        checkpointsData = await fetchJSON('/api/checkpoint/list?limit=20');
+        const container = document.getElementById('checkpoint-list');
+
+        if (!checkpointsData || checkpointsData.length === 0) {
+          container.innerHTML = '<div style="color: var(--text-muted); font-size: 11px; padding: 12px;">No checkpoints yet</div>';
+          return;
+        }
+
+        container.innerHTML = checkpointsData.map(cp => \`
+          <div class="checkpoint-item \${cp.id === selectedCheckpointId ? 'active' : ''}"
+               onclick="selectCheckpoint('\${cp.id}')">
+            <div class="checkpoint-id">\${cp.id}</div>
+            <div class="checkpoint-time">\${cp.created_at ? new Date(cp.created_at).toLocaleString() : ''}</div>
+            <div class="checkpoint-notes">\${cp.phase || ''}</div>
+            <div style="font-size: 9px; color: var(--text-muted); margin-top: 2px;">Tasks: \${cp.tasks || 0} | ~\${cp.tokens || 0} tokens</div>
+          </div>
+        \`).join('');
+
+        // Auto-select first checkpoint
+        if (!selectedCheckpointId && checkpointsData.length > 0) {
+          selectCheckpoint(checkpointsData[0].id);
+        }
+      } catch (e) {
+        console.error('Error loading checkpoints:', e);
+      }
+    }
+
+    async function selectCheckpoint(id) {
+      selectedCheckpointId = id;
+      loadCheckpoints(); // Re-render to update active state
+      loadCheckpointDetail();
+    }
+
+    async function loadCheckpointDetail() {
+      if (!selectedCheckpointId) return;
+
+      const container = document.getElementById('checkpoint-detail-content');
+      container.textContent = 'Loading...';
+
+      try {
+        const summary = await fetchJSON(\`/api/checkpoint/summary?level=\${summaryLevel}\`);
+        container.textContent = summary.summary || 'No summary available';
+      } catch (e) {
+        container.textContent = 'Error loading checkpoint: ' + e.message;
+      }
+    }
+
+    function setSummaryLevel(level) {
+      summaryLevel = level;
+      document.querySelectorAll('.summary-level-btn').forEach(btn => {
+        btn.classList.toggle('active', btn.textContent.toLowerCase() === level);
+      });
+      loadCheckpointDetail();
+    }
+
+    async function createCheckpoint() {
+      const notes = prompt('Checkpoint notes (optional):');
+      try {
+        const result = await fetchJSON('/api/checkpoint/create', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ notes })
+        });
+        if (result && result.id) {
+          alert('Checkpoint created: ' + result.id);
+          loadCheckpoints();
+        } else {
+          alert('Failed to create checkpoint');
+        }
+      } catch (e) {
+        alert('Error: ' + e.message);
+      }
+    }
+
+    // ========== Memory Browser ==========
+    let memoryEntriesData = [];
+    let selectedMemoryId = null;
+    let currentChunk = 0;
+    let totalChunks = 1;
+    let memoryEntryData = null;
+
+    async function loadMemoryEntries() {
+      try {
+        const type = document.getElementById('memory-type-filter').value;
+        const url = type ? \`/api/memory/list?type=\${type}&limit=50\` : '/api/memory/list?limit=50';
+        memoryEntriesData = await fetchJSON(url);
+        const container = document.getElementById('memory-list');
+
+        if (!memoryEntriesData || memoryEntriesData.length === 0) {
+          container.innerHTML = '<div style="color: var(--text-muted); font-size: 11px; padding: 12px;">No memory entries</div>';
+          return;
+        }
+
+        container.innerHTML = memoryEntriesData.map(m => \`
+          <div class="memory-item \${m.id === selectedMemoryId ? 'active' : ''}"
+               onclick="selectMemoryEntry('\${m.id}')">
+            <span class="memory-type">\${m.entry_type || 'unknown'}</span>
+            <div style="font-size: 10px; color: var(--text-primary); margin-top: 4px;">\${m.id}</div>
+            <div style="font-size: 9px; color: var(--text-muted);">
+              \${m.chunk_count || 1} chunks | \${formatBytes(m.total_size || 0)}
+            </div>
+            \${m.summary ? \`<div style="font-size: 10px; color: var(--text-secondary); margin-top: 4px;">\${m.summary.substring(0, 100)}...</div>\` : ''}
+          </div>
+        \`).join('');
+      } catch (e) {
+        console.error('Error loading memory:', e);
+      }
+    }
+
+    function formatBytes(bytes) {
+      if (bytes === 0) return '0 B';
+      const k = 1024;
+      const sizes = ['B', 'KB', 'MB', 'GB'];
+      const i = Math.floor(Math.log(bytes) / Math.log(k));
+      return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+    }
+
+    async function selectMemoryEntry(id) {
+      selectedMemoryId = id;
+      currentChunk = 0;
+      loadMemoryEntries(); // Re-render to update active state
+      loadMemoryContent();
+    }
+
+    async function loadMemoryContent() {
+      if (!selectedMemoryId) return;
+
+      const container = document.getElementById('memory-content-display');
+      container.textContent = 'Loading...';
+
+      try {
+        memoryEntryData = await fetchJSON(\`/api/memory/get?id=\${selectedMemoryId}\`);
+        if (memoryEntryData) {
+          totalChunks = memoryEntryData.chunk_count || 1;
+          updateChunkNav();
+          displayCurrentChunk();
+        } else {
+          container.textContent = 'Entry not found';
+        }
+      } catch (e) {
+        container.textContent = 'Error loading: ' + e.message;
+      }
+    }
+
+    function updateChunkNav() {
+      const nav = document.getElementById('chunk-nav');
+      if (totalChunks > 1) {
+        nav.style.display = 'flex';
+        document.getElementById('chunk-indicator').textContent = \`Chunk \${currentChunk + 1} / \${totalChunks}\`;
+        document.getElementById('chunk-prev').disabled = currentChunk === 0;
+        document.getElementById('chunk-next').disabled = currentChunk >= totalChunks - 1;
+      } else {
+        nav.style.display = 'none';
+      }
+    }
+
+    function displayCurrentChunk() {
+      const container = document.getElementById('memory-content-display');
+      if (memoryEntryData) {
+        const chunks = memoryEntryData.chunks || [memoryEntryData.content];
+        container.textContent = chunks[currentChunk] || memoryEntryData.content || 'No content';
+      }
+    }
+
+    function loadChunk(delta) {
+      currentChunk = Math.max(0, Math.min(totalChunks - 1, currentChunk + delta));
+      updateChunkNav();
+      displayCurrentChunk();
+    }
+
+    async function searchMemoryEntries() {
+      const query = document.getElementById('memory-search-input').value.trim();
+      if (!query) {
+        loadMemoryEntries();
+        return;
+      }
+
+      try {
+        memoryEntriesData = await fetchJSON(\`/api/memory/search?q=\${encodeURIComponent(query)}\`);
+        const container = document.getElementById('memory-list');
+
+        if (!memoryEntriesData || memoryEntriesData.length === 0) {
+          container.innerHTML = '<div style="color: var(--text-muted); font-size: 11px; padding: 12px;">No results found</div>';
+          return;
+        }
+
+        container.innerHTML = memoryEntriesData.map(m => \`
+          <div class="memory-item" onclick="selectMemoryEntry('\${m.id}')">
+            <span class="memory-type">\${m.entry_type || 'unknown'}</span>
+            <div style="font-size: 10px; color: var(--text-primary); margin-top: 4px;">\${m.id}</div>
+            \${m.summary ? \`<div style="font-size: 10px; color: var(--text-secondary); margin-top: 4px;">\${m.summary.substring(0, 100)}...</div>\` : ''}
+          </div>
+        \`).join('');
+      } catch (e) {
+        console.error('Error searching memory:', e);
+      }
+    }
+
+    // ========== Status Grid ==========
+    const phaseIcons = {
+      complete: '✓',
+      in_progress: '◐',
+      blocked: '✗',
+      needs_review: '!',
+      not_started: '○'
+    };
+
+    async function loadStatusGrid() {
+      try {
+        const data = await fetchJSON('/api/status/grid');
+        const summaryContainer = document.getElementById('status-summary');
+        const gridContainer = document.getElementById('status-grid-display');
+
+        // Render summary
+        const summary = data.summary || {};
+        summaryContainer.innerHTML = \`
+          <div class="status-stat">
+            <div class="status-stat-value">\${summary.total || 0}</div>
+            <div class="status-stat-label">Total</div>
+          </div>
+          <div class="status-stat" style="border-left: 3px solid var(--accent-green);">
+            <div class="status-stat-value">\${summary.complete || 0}</div>
+            <div class="status-stat-label">Complete</div>
+          </div>
+          <div class="status-stat" style="border-left: 3px solid var(--accent-cyan);">
+            <div class="status-stat-value">\${summary.in_progress || 0}</div>
+            <div class="status-stat-label">In Progress</div>
+          </div>
+          <div class="status-stat" style="border-left: 3px solid var(--accent-red);">
+            <div class="status-stat-value">\${summary.blocked || 0}</div>
+            <div class="status-stat-label">Blocked</div>
+          </div>
+          <div class="status-stat" style="border-left: 3px solid var(--text-muted);">
+            <div class="status-stat-value">\${summary.not_started || 0}</div>
+            <div class="status-stat-label">Not Started</div>
+          </div>
+        \`;
+
+        // Render grid
+        const directories = data.directories || [];
+        if (directories.length === 0) {
+          gridContainer.innerHTML = '<div style="color: var(--text-muted); font-size: 11px; padding: 12px;">No directory status data</div>';
+          return;
+        }
+
+        gridContainer.innerHTML = directories.map(d => {
+          const phase = d.phase || 'not_started';
+          const icon = phaseIcons[phase] || '?';
+          const name = d.path ? d.path.split('/').pop() : 'unknown';
+          return \`
+            <div class="status-cell \${phase}" title="\${d.path}">
+              <div class="status-cell-icon">\${icon}</div>
+              <div class="status-cell-name">\${name}</div>
+              <div class="status-cell-phase">\${phase.replace('_', ' ')}</div>
+            </div>
+          \`;
+        }).join('');
+      } catch (e) {
+        console.error('Error loading status grid:', e);
+      }
+    }
+
+    // ========== Integration Panel ==========
+    const integrationIcons = {
+      slack: '#',
+      github: 'GH',
+      pagerduty: 'PD'
+    };
+
+    async function loadIntegrations() {
+      try {
+        const status = await fetchJSON('/api/integrations/status');
+        const container = document.getElementById('integration-cards');
+
+        // Filter out metadata keys like _note
+        const integrations = Object.entries(status).filter(([key]) => !key.startsWith('_'));
+
+        if (status._note) {
+          container.innerHTML = '<div style="color: var(--text-muted); font-size: 12px; margin-bottom: 16px; padding: 12px; background: var(--bg-tertiary); border-radius: 4px;">' +
+            status._note + '</div>';
+        } else {
+          container.innerHTML = '';
+        }
+
+        container.innerHTML += integrations.map(([key, data]) => \`
+          <div class="integration-card \${data.status === 'deprecated' ? 'deprecated' : ''}">
+            <div class="integration-header">
+              <div class="integration-icon">\${integrationIcons[key] || '?'}</div>
+              <div>
+                <div class="integration-name">\${data.name || key}</div>
+                <div class="integration-status \${data.status}">\${data.status?.replace('_', ' ') || 'unknown'}</div>
+              </div>
+            </div>
+            <div style="font-size: 11px; color: var(--text-secondary); margin: 8px 0;">\${data.details || ''}</div>
+            \${data.status !== 'deprecated' ? \`
+              <button class="integration-test-btn" onclick="testIntegrationConnection('\${key}')" \${data.status !== 'configured' ? 'disabled style="opacity: 0.5; cursor: not-allowed;"' : ''}>
+                Test Connection
+              </button>
+              <div class="integration-result" id="integration-result-\${key}">
+                \${data.status === 'configured' ? 'Ready to test' : 'Configure in Vault first'}
+              </div>
+            \` : \`
+              <div class="integration-result" style="color: var(--text-muted);">
+                See .archive/integrations/ to restore
+              </div>
+            \`}
+          </div>
+        \`).join('');
+      } catch (e) {
+        console.error('Error loading integrations:', e);
+      }
+    }
+
+    async function testIntegrationConnection(name) {
+      const resultEl = document.getElementById('integration-result-' + name);
+      resultEl.textContent = 'Testing...';
+
+      try {
+        const result = await fetchJSON('/api/integrations/test', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name })
+        });
+
+        resultEl.textContent = result.success
+          ? '✓ ' + result.message
+          : '✗ ' + result.message;
+        resultEl.style.color = result.success ? 'var(--accent-green)' : 'var(--accent-red)';
+      } catch (e) {
+        resultEl.textContent = '✗ Error: ' + e.message;
+        resultEl.style.color = 'var(--accent-red)';
+      }
+    }
+
+    // ========== Analytics Charts ==========
+    const chartColors = ['#00ffff', '#3b82f6', '#8b5cf6', '#f59e0b', '#10b981', '#ef4444', '#ec4899'];
+    const severityColors = { critical: '#ef4444', high: '#f59e0b', medium: '#fbbf24', low: '#10b981' };
+
+    async function loadAnalytics() {
+      try {
+        const [summary, byType, bySeverity, byTime] = await Promise.all([
+          fetchJSON('/api/analytics/summary'),
+          fetchJSON('/api/analytics/violations/by-type'),
+          fetchJSON('/api/analytics/violations/by-severity'),
+          fetchJSON('/api/analytics/violations/by-time?days=7')
+        ]);
+
+        // Render summary cards
+        document.getElementById('analytics-summary').innerHTML = \`
+          <div class="analytics-card">
+            <div class="analytics-card-value">\${summary.total_violations || 0}</div>
+            <div class="analytics-card-label">Total Violations</div>
+          </div>
+          <div class="analytics-card">
+            <div class="analytics-card-value" style="color: var(--accent-orange);">\${summary.last_24h || 0}</div>
+            <div class="analytics-card-label">Last 24 Hours</div>
+          </div>
+        \`;
+
+        // Render bar chart (by type)
+        renderBarChart('chart-svg-type', byType, 'type', 'count');
+
+        // Render pie chart (by severity)
+        renderPieChart('chart-svg-severity', bySeverity, 'severity', 'count');
+
+        // Render time series
+        renderTimeChart('chart-svg-time', byTime);
+
+      } catch (e) {
+        console.error('Error loading analytics:', e);
+      }
+    }
+
+    function renderBarChart(containerId, data, labelKey, valueKey) {
+      const svg = document.getElementById(containerId);
+      if (!data || data.length === 0) {
+        svg.innerHTML = '<text x="50%" y="50%" text-anchor="middle" fill="var(--text-muted)" font-size="11">No data</text>';
+        return;
+      }
+
+      const width = 300;
+      const height = 180;
+      const margin = { top: 10, right: 10, bottom: 40, left: 40 };
+      const chartWidth = width - margin.left - margin.right;
+      const chartHeight = height - margin.top - margin.bottom;
+
+      const maxValue = Math.max(...data.map(d => d[valueKey]));
+      const barWidth = chartWidth / data.length - 4;
+
+      let bars = '';
+      data.forEach((d, i) => {
+        const barHeight = (d[valueKey] / maxValue) * chartHeight;
+        const x = margin.left + i * (barWidth + 4);
+        const y = margin.top + chartHeight - barHeight;
+
+        bars += \`
+          <rect class="bar-chart-bar" x="\${x}" y="\${y}" width="\${barWidth}" height="\${barHeight}" fill="\${chartColors[i % chartColors.length]}"/>
+          <text class="bar-chart-value" x="\${x + barWidth/2}" y="\${y - 4}" text-anchor="middle">\${d[valueKey]}</text>
+          <text class="bar-chart-label" x="\${x + barWidth/2}" y="\${height - 5}" text-anchor="middle" transform="rotate(-45, \${x + barWidth/2}, \${height - 5})">\${(d[labelKey] || '').substring(0, 10)}</text>
+        \`;
+      });
+
+      svg.innerHTML = bars;
+    }
+
+    function renderPieChart(containerId, data, labelKey, valueKey) {
+      const svg = document.getElementById(containerId);
+      if (!data || data.length === 0) {
+        svg.innerHTML = '<text x="50%" y="50%" text-anchor="middle" fill="var(--text-muted)" font-size="11">No data</text>';
+        return;
+      }
+
+      const cx = 100;
+      const cy = 100;
+      const radius = 70;
+      const total = data.reduce((sum, d) => sum + d[valueKey], 0);
+
+      let startAngle = 0;
+      let paths = '';
+      let legend = '';
+
+      data.forEach((d, i) => {
+        const sliceAngle = (d[valueKey] / total) * 2 * Math.PI;
+        const endAngle = startAngle + sliceAngle;
+
+        const x1 = cx + radius * Math.cos(startAngle);
+        const y1 = cy + radius * Math.sin(startAngle);
+        const x2 = cx + radius * Math.cos(endAngle);
+        const y2 = cy + radius * Math.sin(endAngle);
+
+        const largeArc = sliceAngle > Math.PI ? 1 : 0;
+        const color = severityColors[d[labelKey]] || chartColors[i % chartColors.length];
+
+        paths += \`
+          <path class="pie-chart-segment" d="M \${cx} \${cy} L \${x1} \${y1} A \${radius} \${radius} 0 \${largeArc} 1 \${x2} \${y2} Z" fill="\${color}"/>
+        \`;
+
+        legend += \`
+          <div class="legend-item">
+            <div class="legend-dot" style="background: \${color}"></div>
+            <span>\${d[labelKey]}: \${d[valueKey]}</span>
+          </div>
+        \`;
+
+        startAngle = endAngle;
+      });
+
+      svg.innerHTML = paths;
+
+      // Add legend below
+      const container = svg.parentElement;
+      let legendEl = container.querySelector('.chart-legend');
+      if (!legendEl) {
+        legendEl = document.createElement('div');
+        legendEl.className = 'chart-legend';
+        container.appendChild(legendEl);
+      }
+      legendEl.innerHTML = legend;
+    }
+
+    function renderTimeChart(containerId, data) {
+      const svg = document.getElementById(containerId);
+      if (!data || data.length === 0) {
+        svg.innerHTML = '<text x="50%" y="50%" text-anchor="middle" fill="var(--text-muted)" font-size="11">No data</text>';
+        return;
+      }
+
+      const width = 600;
+      const height = 130;
+      const margin = { top: 10, right: 10, bottom: 20, left: 30 };
+      const chartWidth = width - margin.left - margin.right;
+      const chartHeight = height - margin.top - margin.bottom;
+
+      const maxValue = Math.max(...data.map(d => d.count), 1);
+      const barWidth = Math.min(chartWidth / data.length - 1, 20);
+
+      let bars = '';
+      data.forEach((d, i) => {
+        const barHeight = (d.count / maxValue) * chartHeight;
+        const x = margin.left + i * (barWidth + 1);
+        const y = margin.top + chartHeight - barHeight;
+
+        bars += \`<rect x="\${x}" y="\${y}" width="\${barWidth}" height="\${barHeight}" fill="var(--accent-cyan)" opacity="0.7"/>\`;
+      });
+
+      // Add axis labels
+      bars += \`<text x="\${margin.left}" y="\${height - 2}" fill="var(--text-muted)" font-size="9">\${data[0]?.hour || ''}</text>\`;
+      bars += \`<text x="\${width - margin.right}" y="\${height - 2}" fill="var(--text-muted)" font-size="9" text-anchor="end">\${data[data.length-1]?.hour || ''}</text>\`;
+
+      svg.innerHTML = bars;
+    }
+
+    // ========== Bug Tracking ==========
+    let selectedBugId = null;
+
+    async function loadBugsSummary() {
+      try {
+        const summary = await fetchJSON('/api/bugs/summary');
+        document.getElementById('bugs-total').textContent = summary.total || 0;
+        document.getElementById('bugs-open').textContent = summary.open || 0;
+        document.getElementById('bugs-in-progress').textContent = summary.in_progress || 0;
+        document.getElementById('bugs-resolved').textContent = summary.resolved || 0;
+      } catch (e) {
+        console.error('Error loading bugs summary:', e);
+      }
+    }
+
+    async function loadBugs() {
+      try {
+        const status = document.getElementById('bug-filter-status').value;
+        const severity = document.getElementById('bug-filter-severity').value;
+
+        let url = '/api/bugs?limit=100';
+        if (status) url += '&status=' + status;
+        if (severity) url += '&severity=' + severity;
+
+        const bugs = await fetchJSON(url);
+        const container = document.getElementById('bugs-list');
+
+        if (!bugs || bugs.length === 0) {
+          container.innerHTML = '<div style="color: var(--text-muted); text-align: center; padding: 40px;">No bugs found</div>';
+          return;
+        }
+
+        container.innerHTML = bugs.map(bug => \`
+          <div class="bug-item" onclick="showBugDetail('\${bug.id}')">
+            <div class="bug-severity \${bug.severity}"></div>
+            <span class="bug-status-badge \${bug.status}">\${bug.status.replace('_', ' ')}</span>
+            <span class="bug-message">\${escapeHtml(bug.message)}</span>
+            <span class="bug-meta">Phase \${bug.phase}</span>
+            <span class="bug-meta">\${formatTimeAgo(bug.detected_at)}</span>
+          </div>
+        \`).join('');
+
+      } catch (e) {
+        console.error('Error loading bugs:', e);
+      }
+    }
+
+    async function showBugDetail(bugId) {
+      try {
+        const bug = await fetchJSON('/api/bugs/' + bugId);
+        if (!bug) return;
+
+        selectedBugId = bugId;
+        document.getElementById('bug-detail-panel').style.display = 'flex';
+        document.getElementById('bug-detail-id').textContent = bug.id;
+
+        document.getElementById('bug-detail-content').innerHTML = \`
+          <div class="bug-detail-row">
+            <span class="bug-detail-label">Status:</span>
+            <span class="bug-status-badge \${bug.status}">\${bug.status.replace('_', ' ')}</span>
+          </div>
+          <div class="bug-detail-row">
+            <span class="bug-detail-label">Severity:</span>
+            <span class="bug-detail-value">\${bug.severity}</span>
+          </div>
+          <div class="bug-detail-row">
+            <span class="bug-detail-label">Type:</span>
+            <span class="bug-detail-value">\${bug.type}</span>
+          </div>
+          <div class="bug-detail-row">
+            <span class="bug-detail-label">Phase:</span>
+            <span class="bug-detail-value">\${bug.phase} - \${bug.phase_name}</span>
+          </div>
+          <div class="bug-detail-row">
+            <span class="bug-detail-label">Directory:</span>
+            <span class="bug-detail-value">\${bug.directory}</span>
+          </div>
+          <div class="bug-detail-row">
+            <span class="bug-detail-label">Detected:</span>
+            <span class="bug-detail-value">\${new Date(bug.detected_at).toLocaleString()}</span>
+          </div>
+          \${bug.assigned_to ? \`<div class="bug-detail-row"><span class="bug-detail-label">Assigned:</span><span class="bug-detail-value">\${bug.assigned_to}</span></div>\` : ''}
+          \${bug.resolution_notes ? \`<div class="bug-detail-row"><span class="bug-detail-label">Notes:</span><span class="bug-detail-value">\${escapeHtml(bug.resolution_notes)}</span></div>\` : ''}
+          <div style="margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border-color);">
+            <strong>Message:</strong><br/>
+            <span style="color: var(--text-primary);">\${escapeHtml(bug.message)}</span>
+          </div>
+        \`;
+
+        // Show appropriate action buttons based on status
+        let actions = '';
+        if (bug.status === 'open') {
+          actions = \`
+            <button onclick="updateBugStatus('\${bugId}', 'in_progress')">Start Working</button>
+            <button class="primary" onclick="updateBugStatus('\${bugId}', 'resolved')">Mark Resolved</button>
+          \`;
+        } else if (bug.status === 'in_progress') {
+          actions = \`
+            <button onclick="updateBugStatus('\${bugId}', 'open')">Reopen</button>
+            <button class="primary" onclick="updateBugStatus('\${bugId}', 'resolved')">Mark Resolved</button>
+          \`;
+        } else {
+          actions = \`
+            <button onclick="updateBugStatus('\${bugId}', 'open')">Reopen</button>
+          \`;
+        }
+        document.getElementById('bug-detail-actions').innerHTML = actions;
+
+      } catch (e) {
+        console.error('Error loading bug detail:', e);
+      }
+    }
+
+    function closeBugDetail() {
+      document.getElementById('bug-detail-panel').style.display = 'none';
+      selectedBugId = null;
+    }
+
+    async function updateBugStatus(bugId, newStatus) {
+      const notes = newStatus === 'resolved' ? prompt('Resolution notes (optional):') : null;
+
+      try {
+        const res = await fetch('/api/bugs/' + bugId, {
+          method: 'PATCH',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ status: newStatus, notes: notes || undefined })
+        });
+
+        if (res.ok) {
+          await loadBugsSummary();
+          await loadBugs();
+          if (selectedBugId === bugId) {
+            await showBugDetail(bugId);
+          }
+        } else {
+          alert('Failed to update bug status');
+        }
+      } catch (e) {
+        console.error('Error updating bug:', e);
+        alert('Error updating bug status');
+      }
+    }
+
+    function showLogBugModal() {
+      const message = prompt('Bug description:');
+      if (!message) return;
+
+      const severity = prompt('Severity (critical/high/medium/low):', 'medium');
+      if (!['critical', 'high', 'medium', 'low'].includes(severity)) {
+        alert('Invalid severity');
+        return;
+      }
+
+      logNewBug(message, severity);
+    }
+
+    async function logNewBug(message, severity) {
+      try {
+        const res = await fetch('/api/bugs', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ message, severity })
+        });
+
+        if (res.ok) {
+          await loadBugsSummary();
+          await loadBugs();
+        } else {
+          alert('Failed to log bug');
+        }
+      } catch (e) {
+        console.error('Error logging bug:', e);
+        alert('Error logging bug');
+      }
+    }
+
+    function formatTimeAgo(dateStr) {
+      const date = new Date(dateStr);
+      const now = new Date();
+      const diffMs = now - date;
+      const diffMins = Math.floor(diffMs / 60000);
+      const diffHours = Math.floor(diffMs / 3600000);
+      const diffDays = Math.floor(diffMs / 86400000);
+
+      if (diffMins < 60) return diffMins + 'm ago';
+      if (diffHours < 24) return diffHours + 'h ago';
+      return diffDays + 'd ago';
+    }
+
+    function escapeHtml(str) {
+      if (!str) return '';
+      return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    }
+
+    // ========== Tier Progression ==========
+    async function loadTierProgression() {
+      try {
+        const [summary, promotions, definitions] = await Promise.all([
+          fetchJSON('/api/tiers/summary'),
+          fetchJSON('/api/tiers/promotions?limit=20'),
+          fetchJSON('/api/tiers/definitions')
+        ]);
+
+        // Render tier cards
+        const cardsContainer = document.getElementById('tier-cards');
+        cardsContainer.innerHTML = definitions.map(def => {
+          const count = summary[\`T\${def.tier.replace('T', '')}\`] || summary[def.tier] || 0;
+          return \`
+            <div class="tier-card \${def.tier.toLowerCase()}">
+              <div class="tier-label">\${def.tier}</div>
+              <div class="tier-count">\${count}</div>
+              <div class="tier-name">\${def.name}</div>
+            </div>
+          \`;
+        }).join('');
+
+        // Render promotion history
+        const historyContainer = document.getElementById('tier-history-list');
+        if (!promotions || promotions.length === 0) {
+          historyContainer.innerHTML = '<div style="color: var(--text-muted); font-size: 11px;">No promotions yet</div>';
+          return;
+        }
+
+        historyContainer.innerHTML = promotions.map(p => \`
+          <div class="tier-history-item">
+            <span style="color: var(--text-primary); font-weight: 600;">\${p.agent_id}</span>
+            <span class="tier-badge t\${p.from_tier || 0}">T\${p.from_tier || 0}</span>
+            <span class="promotion-arrow">→</span>
+            <span class="tier-badge t\${p.to_tier || 0}">T\${p.to_tier || 0}</span>
+            <span style="color: var(--text-muted); margin-left: auto;">\${p.timestamp ? new Date(p.timestamp).toLocaleString() : ''}</span>
+          </div>
+        \`).join('');
+
+      } catch (e) {
+        console.error('Error loading tier progression:', e);
+      }
+    }
+
     // Refresh All
     async function refresh() {
       await Promise.all([
@@ -3426,6 +6054,11 @@ function renderDashboard(): string {
       if (selectedPipelineId) {
         await loadLogs(selectedPipelineId);
       }
+
+      // Refresh current tab data
+      if (currentTab !== 'pipelines' && tabDataLoaded[currentTab]) {
+        loadTabData(currentTab);
+      }
     }
 
     // Initialize
@@ -3486,6 +6119,58 @@ const server = Bun.serve({
         return new Response(JSON.stringify(violations), { headers });
       }
 
+      // Bug Tracking API
+      if (path === "/api/bugs" && req.method === "GET") {
+        const bugs = await getBugs(url.searchParams);
+        return new Response(JSON.stringify(bugs), { headers });
+      }
+
+      if (path === "/api/bugs/summary" && req.method === "GET") {
+        const summary = await getBugSummary();
+        return new Response(JSON.stringify(summary), { headers });
+      }
+
+      if (path.match(/^\/api\/bugs\/[^/]+$/) && req.method === "GET") {
+        const bugId = path.split("/").pop()!;
+        const bug = await getBug(bugId);
+        if (bug) {
+          return new Response(JSON.stringify(bug), { headers });
+        }
+        return new Response(JSON.stringify({ error: "Bug not found" }), { status: 404, headers });
+      }
+
+      if (path === "/api/bugs" && req.method === "POST") {
+        const body = await req.json() as {
+          message: string;
+          severity?: string;
+          type?: string;
+          phase?: number;
+          directory?: string;
+          details?: Record<string, any>;
+        };
+        if (!body.message) {
+          return new Response(JSON.stringify({ error: "message required" }), { status: 400, headers });
+        }
+        const bug = await logBug(body);
+        broadcastUpdate("bug_logged", bug);
+        return new Response(JSON.stringify(bug), { status: 201, headers });
+      }
+
+      if (path.match(/^\/api\/bugs\/[^/]+$/) && req.method === "PATCH") {
+        const bugId = path.split("/").pop()!;
+        const body = await req.json() as {
+          status?: string;
+          notes?: string;
+          assigned_to?: string;
+        };
+        const result = await updateBugStatus(bugId, body);
+        if (result.success) {
+          broadcastUpdate("bug_updated", { id: bugId, ...body });
+          return new Response(JSON.stringify(result), { headers });
+        }
+        return new Response(JSON.stringify(result), { status: 404, headers });
+      }
+
       if (path === "/api/promotions") {
         const limit = parseInt(url.searchParams.get("limit") || "20");
         const promotions = await getPromotions(limit);
@@ -3528,7 +6213,13 @@ const server = Bun.serve({
 
       // Pipeline Control APIs
       if (path === "/api/spawn" && req.method === "POST") {
-        const body = await req.json() as { objective: string; task_id?: string };
+        const body = await req.json() as {
+          objective: string;
+          task_id?: string;
+          auto_continue?: boolean;
+          model?: string;
+          timeout?: number;
+        };
         if (!body.objective) {
           return new Response(JSON.stringify({ error: "objective required" }), { status: 400, headers });
         }
@@ -3536,10 +6227,44 @@ const server = Bun.serve({
           task_id: body.task_id || `task-${Date.now().toString(36)}`,
           objective: body.objective,
           spawn_diagnostic: true,
+          auto_continue: body.auto_continue ?? true,  // Default to auto-continue enabled
+          model: body.model,
+          timeout: body.timeout,
         });
         return new Response(JSON.stringify(result), { headers });
       }
 
+      // Continue pipeline to OpenRouter orchestration
+      if (path === "/api/pipeline/continue" && req.method === "POST") {
+        const body = await req.json() as {
+          pipeline_id: string;
+          model?: string;
+          timeout?: number;
+        };
+        if (!body.pipeline_id) {
+          return new Response(JSON.stringify({ error: "pipeline_id required" }), { status: 400, headers });
+        }
+        const result = await continueOrchestration(body.pipeline_id, body.model, body.timeout);
+        return new Response(JSON.stringify(result), { headers });
+      }
+
+      // Get orchestration status for a pipeline
+      if (path === "/api/pipeline/orchestration") {
+        const pipelineId = url.searchParams.get("pipeline_id");
+        if (!pipelineId) {
+          return new Response(JSON.stringify({ error: "pipeline_id required" }), { status: 400, headers });
+        }
+        const pipelineKey = `pipeline:${pipelineId}`;
+        const data = await redis.hGetAll(pipelineKey);
+        return new Response(JSON.stringify({
+          pipeline_id: pipelineId,
+          status: data.status,
+          orchestration_started_at: data.orchestration_started_at,
+          completed_at: data.completed_at,
+          model: data.model,
+        }), { headers });
+      }
+
       if (path === "/api/active-pipelines") {
         const pipelines = await getActivePipelines();
         return new Response(JSON.stringify(pipelines), { headers });
@@ -3656,6 +6381,67 @@ const server = Bun.serve({
         }
       }
 
+      // Get report by plan_id or report_id
+      if (path === "/api/report/get") {
+        const planId = url.searchParams.get("plan_id");
+        const reportId = url.searchParams.get("report_id");
+
+        try {
+          let report = null;
+
+          if (reportId) {
+            // Fetch directly by report ID
+            const data = await redis.hGetAll(`report:${reportId}`);
+            if (data && data.report_id) {
+              report = {
+                ...data,
+                phases_completed: JSON.parse(data.phases_completed || "[]"),
+                assumptions_validated: JSON.parse(data.assumptions_validated || "[]"),
+                dependencies_used: JSON.parse(data.dependencies_used || "[]"),
+                side_effects_produced: JSON.parse(data.side_effects_produced || "[]"),
+                next_actions: JSON.parse(data.next_actions || "[]"),
+                summary: {
+                  title: data.plan_id,
+                  outcome: data.outcome,
+                  confidence: parseFloat(data.confidence || "0"),
+                  execution_time_ms: parseInt(data.execution_time_ms || "0")
+                }
+              };
+            }
+          } else if (planId) {
+            // Get report_id from plan, then fetch report
+            const storedReportId = await redis.hGet(`plan:${planId}`, "report_id");
+            if (storedReportId) {
+              const data = await redis.hGetAll(`report:${storedReportId}`);
+              if (data && data.report_id) {
+                report = {
+                  ...data,
+                  phases_completed: JSON.parse(data.phases_completed || "[]"),
+                  assumptions_validated: JSON.parse(data.assumptions_validated || "[]"),
+                  dependencies_used: JSON.parse(data.dependencies_used || "[]"),
+                  side_effects_produced: JSON.parse(data.side_effects_produced || "[]"),
+                  next_actions: JSON.parse(data.next_actions || "[]"),
+                  summary: {
+                    title: data.plan_id,
+                    outcome: data.outcome,
+                    confidence: parseFloat(data.confidence || "0"),
+                    execution_time_ms: parseInt(data.execution_time_ms || "0")
+                  }
+                };
+              }
+            }
+          }
+
+          if (report) {
+            return new Response(JSON.stringify(report), { headers });
+          } else {
+            return new Response(JSON.stringify({ error: "Report not found" }), { status: 404, headers });
+          }
+        } catch (e: any) {
+          return new Response(JSON.stringify({ error: e.message }), { status: 500, headers });
+        }
+      }
+
       if (path === "/api/plan/execute-from-pipeline" && req.method === "POST") {
         const body = await req.json() as { pipeline_id: string; dry_run?: boolean; tier?: number };
         if (!body.pipeline_id) {
@@ -3785,6 +6571,145 @@ const server = Bun.serve({
         return new Response(JSON.stringify(solutions), { headers });
       }
 
+      // =========================================================================
+      // New UI Tab APIs
+      // =========================================================================
+
+      // Checkpoint APIs
+      if (path === "/api/checkpoint/list") {
+        const limit = parseInt(url.searchParams.get("limit") || "20");
+        const checkpoints = await getCheckpointList(limit);
+        return new Response(JSON.stringify(checkpoints), { headers });
+      }
+
+      if (path === "/api/checkpoint/get") {
+        const id = url.searchParams.get("id");
+        const detail = await getCheckpointDetail(id || undefined);
+        return new Response(JSON.stringify(detail), { headers });
+      }
+
+      if (path === "/api/checkpoint/diff") {
+        const fromId = url.searchParams.get("from");
+        const toId = url.searchParams.get("to");
+        const diff = await getCheckpointDiff(fromId || undefined, toId || undefined);
+        return new Response(JSON.stringify(diff), { headers });
+      }
+
+      if (path === "/api/checkpoint/summary") {
+        const level = url.searchParams.get("level") || "compact";
+        const summary = await getCheckpointSummary(level);
+        return new Response(JSON.stringify({ summary }), { headers });
+      }
+
+      if (path === "/api/checkpoint/create" && req.method === "POST") {
+        const body = await req.json() as { notes?: string };
+        const result = await createCheckpointNow(body.notes);
+        broadcastUpdate("checkpoint_created", result);
+        return new Response(JSON.stringify(result), { headers });
+      }
+
+      if (path === "/api/checkpoint/report") {
+        const report = await getCheckpointReport();
+        return new Response(JSON.stringify(report), { headers });
+      }
+
+      if (path === "/api/checkpoint/timeline") {
+        const limit = parseInt(url.searchParams.get("limit") || "10");
+        const timeline = await getCheckpointTimeline(limit);
+        return new Response(JSON.stringify(timeline), { headers });
+      }
+
+      // Memory APIs
+      if (path === "/api/memory/list") {
+        const type = url.searchParams.get("type");
+        const limit = parseInt(url.searchParams.get("limit") || "50");
+        const entries = await getMemoryList(type || undefined, limit);
+        return new Response(JSON.stringify(entries), { headers });
+      }
+
+      if (path === "/api/memory/get") {
+        const id = url.searchParams.get("id");
+        if (!id) {
+          return new Response(JSON.stringify({ error: "id required" }), { status: 400, headers });
+        }
+        const entry = await getMemoryEntry(id);
+        return new Response(JSON.stringify(entry), { headers });
+      }
+
+      if (path === "/api/memory/search") {
+        const query = url.searchParams.get("q");
+        if (!query) {
+          return new Response(JSON.stringify({ error: "q required" }), { status: 400, headers });
+        }
+        const results = await searchMemory(query);
+        return new Response(JSON.stringify(results), { headers });
+      }
+
+      if (path === "/api/memory/stats") {
+        const stats = await getMemoryStats();
+        return new Response(JSON.stringify(stats), { headers });
+      }
+
+      // Status Grid API
+      if (path === "/api/status/grid") {
+        const grid = await getStatusGrid();
+        return new Response(JSON.stringify(grid), { headers });
+      }
+
+      // Integration APIs
+      if (path === "/api/integrations/status") {
+        const status = await getIntegrationStatus();
+        return new Response(JSON.stringify(status), { headers });
+      }
+
+      if (path === "/api/integrations/test" && req.method === "POST") {
+        const body = await req.json() as { name: string };
+        if (!body.name) {
+          return new Response(JSON.stringify({ error: "name required" }), { status: 400, headers });
+        }
+        const result = await testIntegration(body.name);
+        return new Response(JSON.stringify(result), { headers });
+      }
+
+      // Analytics APIs
+      if (path === "/api/analytics/violations/by-type") {
+        const data = await getViolationsByType();
+        return new Response(JSON.stringify(data), { headers });
+      }
+
+      if (path === "/api/analytics/violations/by-severity") {
+        const data = await getViolationsBySeverity();
+        return new Response(JSON.stringify(data), { headers });
+      }
+
+      if (path === "/api/analytics/violations/by-time") {
+        const days = parseInt(url.searchParams.get("days") || "7");
+        const data = await getViolationsByTime(days);
+        return new Response(JSON.stringify(data), { headers });
+      }
+
+      if (path === "/api/analytics/summary") {
+        const summary = await getAnalyticsSummary();
+        return new Response(JSON.stringify(summary), { headers });
+      }
+
+      // Tier APIs
+      if (path === "/api/tiers/summary") {
+        const summary = await getTierSummary();
+        return new Response(JSON.stringify(summary), { headers });
+      }
+
+      if (path === "/api/tiers/promotions") {
+        const limit = parseInt(url.searchParams.get("limit") || "20");
+        const promotions = await getTierPromotions(limit);
+        return new Response(JSON.stringify(promotions), { headers });
+      }
+
+      if (path === "/api/tiers/definitions") {
+        const definitions = await getTierDefinitions();
+        return new Response(JSON.stringify(definitions), { headers });
+      }
+
       // HTML Dashboard
       if (path === "/" || path === "/dashboard") {
         return new Response(renderDashboard(), {