adelie-ai 0.1.8 → 0.2.0

package/adelie/__init__.py

@@ -1 +1,16 @@
 """Adelie — Self-communicating autonomous AI loop system."""
+
+from pathlib import Path as _Path
+import json as _json
+
+def _get_version() -> str:
+    """Read version from package.json (single source of truth)."""
+    try:
+        pkg = _Path(__file__).resolve().parent.parent / "package.json"
+        if pkg.exists():
+            return _json.loads(pkg.read_text(encoding="utf-8")).get("version", "0.0.0")
+    except Exception:
+        pass
+    return "0.0.0"
+
+__version__ = _get_version()

package/adelie/cli.py

@@ -167,10 +167,15 @@ def cmd_help(args: argparse.Namespace) -> None:
   [green]adelie config[/green]                    Show current configuration
   [green]adelie config --provider[/green] [dim]ollama[/dim]  Switch LLM provider
   [green]adelie config --model[/green] [dim]gemma3:12b[/dim]  Set model
-  [green]adelie config --interval[/green] [dim]60[/dim]     Set loop interval (seconds)
   [green]adelie config --api-key[/green] [dim]KEY[/dim]     Set Gemini API key
   [green]adelie config --ollama-url[/green] [dim]URL[/dim]  Set Ollama server URL
-  [green]adelie config --lang[/green] [dim]ko|en[/dim]      Set display language
+
+[bold]Settings[/bold]
+  [green]adelie settings[/green]                  Show all settings (workspace + global)
+  [green]adelie settings --global[/green]          Show global-only settings
+  [green]adelie settings set[/green] [dim]<key> <val>[/dim]  Change a workspace setting
+  [green]adelie settings set --global[/green] [dim]<key> <val>[/dim]  Change a global setting
+  [green]adelie settings reset[/green] [dim]<key>[/dim]     Reset setting to default
 
 [bold]Monitoring[/bold]
   [green]adelie status[/green]                    System health & provider status
@@ -783,6 +788,236 @@ def cmd_config(args: argparse.Namespace) -> None:
         console.print(f"[dim]Config: {_workspace_config_path()}[/dim]")
 
 
+# ═══════════════════════════════════════════════════════════════════════════════
+# SETTINGS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Settings definition: key -> (env_var, config_json_key, default, type, description)
+# env_var: key in .env file (or None if stored in config.json)
+# config_json_key: key in config.json (or None if stored in .env)
+_SETTINGS_DEFS: dict[str, dict] = {
+    "dashboard":          {"env": "DASHBOARD_ENABLED",  "cfg": None, "default": "true",   "type": "bool",  "desc": "대시보드 on/off",             "group": "🌐 Dashboard"},
+    "dashboard.port":     {"env": "DASHBOARD_PORT",     "cfg": None, "default": "5042",   "type": "int",   "desc": "대시보드 포트",               "group": "🌐 Dashboard"},
+    "loop.interval":      {"env": None,                 "cfg": "loop_interval", "default": "30", "type": "int", "desc": "루프 간격 (초)",          "group": "⚡ Runtime"},
+    "plan.mode":          {"env": "PLAN_MODE",          "cfg": None, "default": "false",  "type": "bool",  "desc": "Plan Mode (승인 후 실행)",    "group": "⚡ Runtime"},
+    "sandbox":            {"env": "SANDBOX_MODE",       "cfg": None, "default": "none",   "type": "str",   "desc": "샌드박스 (none/seatbelt/docker)", "group": "⚡ Runtime"},
+    "mcp":                {"env": "MCP_ENABLED",        "cfg": None, "default": "true",   "type": "bool",  "desc": "MCP 프로토콜 on/off",        "group": "⚡ Runtime"},
+    "browser.search":     {"env": "BROWSER_SEARCH_ENABLED", "cfg": None, "default": "true", "type": "bool", "desc": "브라우저 검색 on/off",      "group": "🔍 Search"},
+    "browser.max_pages":  {"env": "BROWSER_SEARCH_MAX_PAGES","cfg": None,"default": "3",  "type": "int",   "desc": "검색 최대 페이지",           "group": "🔍 Search"},
+    "fallback.models":    {"env": "FALLBACK_MODELS",    "cfg": None, "default": "",       "type": "str",   "desc": "폴백 모델 체인",             "group": "🔄 Fallback"},
+    "fallback.cooldown":  {"env": "FALLBACK_COOLDOWN_SECONDS","cfg": None,"default": "60","type": "int",   "desc": "폴백 쿨다운 (초)",           "group": "🔄 Fallback"},
+    "language":           {"env": "ADELIE_LANGUAGE",    "cfg": None, "default": "ko",     "type": "str",   "desc": "언어 (ko/en)",               "group": "🎨 Display"},
+}
+
+_GLOBAL_SETTINGS_FILE = Path.home() / ".adelie" / "settings.json"
+
+
+def _load_global_settings() -> dict:
+    """Load global settings from ~/.adelie/settings.json."""
+    if _GLOBAL_SETTINGS_FILE.exists():
+        try:
+            return json.loads(_GLOBAL_SETTINGS_FILE.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            return {}
+    return {}
+
+
+def _save_global_settings(settings: dict) -> None:
+    """Save global settings to ~/.adelie/settings.json."""
+    _GLOBAL_SETTINGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _GLOBAL_SETTINGS_FILE.write_text(
+        json.dumps(settings, indent=2, ensure_ascii=False), encoding="utf-8"
+    )
+
+
+def _read_ws_env_value(env_key: str) -> str | None:
+    """Read a specific env key from workspace .env file (raw file read, not os.environ)."""
+    ws_root = _find_workspace_root()
+    env_path = ws_root / ".env"
+    if not env_path.exists():
+        return None
+    for line in env_path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if stripped.startswith(f"{env_key}="):
+            return stripped.split("=", 1)[1].strip()
+    return None
+
+
+def _resolve_setting(key: str, is_global: bool = False) -> tuple[str, str]:
+    """
+    Resolve a setting value and its source.
+    Priority: workspace .env/config.json > global settings > default
+    Returns (value, source).
+    """
+    defn = _SETTINGS_DEFS.get(key)
+    if not defn:
+        return ("", "unknown")
+
+    # If global-only, just check global settings
+    if is_global:
+        gs = _load_global_settings()
+        if key in gs:
+            return (str(gs[key]), "global")
+        return (defn["default"], "default")
+
+    # Workspace level: check .env or config.json
+    ws_value = None
+    if defn["env"]:
+        ws_value = _read_ws_env_value(defn["env"])
+    elif defn["cfg"]:
+        ws_config = _load_workspace_config()
+        if defn["cfg"] in ws_config:
+            ws_value = str(ws_config[defn["cfg"]])
+
+    if ws_value is not None:
+        return (ws_value, "workspace")
+
+    # Fall back to global
+    gs = _load_global_settings()
+    if key in gs:
+        return (str(gs[key]), "global")
+
+    return (defn["default"], "default")
+
+
+def cmd_settings(args: argparse.Namespace) -> None:
+    """View, update, or reset settings (global or workspace-level)."""
+    _ensure_adelie_config()
+
+    action = getattr(args, "settings_action", "show") or "show"
+    is_global = getattr(args, "use_global", False)
+
+    if action == "set":
+        key = getattr(args, "settings_key", None)
+        value = getattr(args, "settings_value", None)
+        if not key or value is None:
+            console.print("[red]Usage: adelie settings set <key> <value>[/red]")
+            return
+
+        if key not in _SETTINGS_DEFS:
+            console.print(f"[red]ERROR: Unknown setting: {key}[/red]")
+            console.print(f"[dim]Available: {', '.join(sorted(_SETTINGS_DEFS.keys()))}[/dim]")
+            return
+
+        defn = _SETTINGS_DEFS[key]
+
+        # Validate type
+        if defn["type"] == "bool" and value.lower() not in ("true", "false"):
+            console.print(f"[red]ERROR: '{key}' must be 'true' or 'false'[/red]")
+            return
+        if defn["type"] == "int":
+            try:
+                int(value)
+            except ValueError:
+                console.print(f"[red]ERROR: '{key}' must be a number[/red]")
+                return
+
+        if is_global:
+            gs = _load_global_settings()
+            gs[key] = value
+            _save_global_settings(gs)
+            console.print(f"[green]✅ [global] {key} → {value}[/green]")
+        else:
+            if defn["env"]:
+                _update_env_file({defn["env"]: value})
+            elif defn["cfg"]:
+                ws_config = _load_workspace_config()
+                ws_config[defn["cfg"]] = int(value) if defn["type"] == "int" else value
+                _save_workspace_config(ws_config)
+            console.print(f"[green]✅ [workspace] {key} → {value}[/green]")
+
+    elif action == "reset":
+        key = getattr(args, "settings_key", None)
+        if not key:
+            console.print("[red]Usage: adelie settings reset <key>[/red]")
+            return
+
+        if key not in _SETTINGS_DEFS:
+            console.print(f"[red]ERROR: Unknown setting: {key}[/red]")
+            return
+
+        defn = _SETTINGS_DEFS[key]
+        default_val = defn["default"]
+
+        if is_global:
+            gs = _load_global_settings()
+            gs.pop(key, None)
+            _save_global_settings(gs)
+            console.print(f"[green]✅ [global] {key} reset (removed)[/green]")
+        else:
+            # Reset workspace value to default
+            if defn["env"]:
+                _update_env_file({defn["env"]: default_val})
+            elif defn["cfg"]:
+                ws_config = _load_workspace_config()
+                if defn["type"] == "int":
+                    ws_config[defn["cfg"]] = int(default_val)
+                else:
+                    ws_config[defn["cfg"]] = default_val
+                _save_workspace_config(ws_config)
+            console.print(f"[green]✅ [workspace] {key} → {default_val} (default)[/green]")
+
+    else:
+        # Show all settings
+        scope_label = "Global Settings" if is_global else "Settings (workspace + global)"
+        table = Table(
+            title=f"Adelie {scope_label}",
+            show_header=True,
+            border_style="cyan",
+        )
+        table.add_column("Setting", style="bold")
+        table.add_column("Value")
+        table.add_column("Source", style="dim")
+        table.add_column("Description", style="dim")
+
+        current_group = ""
+        for key in _SETTINGS_DEFS:
+            defn = _SETTINGS_DEFS[key]
+            group = defn["group"]
+
+            # Group separator
+            if group != current_group:
+                if current_group:
+                    table.add_row("", "", "", "", style="dim")
+                current_group = group
+                table.add_row(f"[bold cyan]{group}[/bold cyan]", "", "", "")
+
+            value, source = _resolve_setting(key, is_global)
+
+            # Color the source
+            if source == "workspace":
+                source_styled = "[green]workspace[/green]"
+            elif source == "global":
+                source_styled = "[yellow]global[/yellow]"
+            else:
+                source_styled = "[dim]default[/dim]"
+
+            # Color bool values
+            if defn["type"] == "bool":
+                if value.lower() == "true":
+                    value_styled = "[green]true[/green]"
+                else:
+                    value_styled = "[dim]false[/dim]"
+            elif not value:
+                value_styled = "[dim](not set)[/dim]"
+            else:
+                value_styled = value
+
+            table.add_row(f"  {key}", value_styled, source_styled, defn["desc"])
+
+        console.print(table)
+
+        if is_global:
+            console.print(f"\n[dim]Global: {_GLOBAL_SETTINGS_FILE}[/dim]")
+        else:
+            ws_root = _find_workspace_root()
+            console.print(f"\n[dim]Workspace: {ws_root / '.env'} + {_workspace_config_path()}[/dim]")
+            console.print(f"[dim]Global:    {_GLOBAL_SETTINGS_FILE}[/dim]")
+
+        console.print(f"\n[dim]Change: adelie settings set <key> <value>[/dim]")
+        console.print(f"[dim]Global: adelie settings set --global <key> <value>[/dim]")
+
+
 def cmd_kb(args: argparse.Namespace) -> None:
     """Knowledge Base management."""
     _ensure_adelie_config()
@@ -1457,12 +1692,15 @@ def cmd_metrics(args: argparse.Namespace) -> None:
 
 
 def main() -> None:
+    from adelie import __version__
     parser = argparse.ArgumentParser(
         prog="adelie",
         description="Adelie — Self-Communicating Autonomous AI Loop",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="Run [adelie help] for detailed command reference.",
     )
+    parser.add_argument("-v", "--version", action="version",
+                        version=f"adelie {__version__}")
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
     # ── help ──────
@@ -1540,6 +1778,19 @@ def main() -> None:
     p_config.add_argument("--plan-mode", type=str, dest="plan_mode", help="Plan mode: 'true' or 'false'")
     p_config.set_defaults(func=cmd_config)
 
+    # ── settings ──
+    p_settings = subparsers.add_parser("settings", help="Manage runtime settings (global & workspace)")
+    p_settings.add_argument("settings_action", nargs="?", default="show",
+                            choices=["show", "set", "reset"],
+                            help="show (default) / set / reset")
+    p_settings.add_argument("settings_key", nargs="?", default=None,
+                            help="Setting key (e.g. dashboard, loop.interval)")
+    p_settings.add_argument("settings_value", nargs="?", default=None,
+                            help="New value (for set)")
+    p_settings.add_argument("--global", action="store_true", dest="use_global",
+                            help="Target global settings (~/.adelie/settings.json)")
+    p_settings.set_defaults(func=cmd_settings)
+
     # ── kb ────────
     p_kb = subparsers.add_parser("kb", help="Knowledge Base management")
     p_kb.add_argument("--clear-errors", action="store_true", help="Clear error files")
@@ -1653,7 +1904,7 @@ def main() -> None:
         except Exception:
             provider_info = "(not configured)"
         console.print(Panel.fit(
-            f"[bold cyan]Adelie[/bold cyan] — Autonomous AI Loop\n"
+            f"[bold cyan]Adelie[/bold cyan] v{__version__} — Autonomous AI Loop\n"
             f"[dim]LLM: {provider_info}[/dim]",
             border_style="cyan",
         ))

package/adelie/dashboard.py

@@ -7,7 +7,8 @@ Serves a single-page dashboard on a configurable port (default 5042).
 Features:
   - SSE (Server-Sent Events) for live push to browsers
   - JSON REST API for initial state / history
-  - Thread-safe event broadcasting
+  - Thread-safe event broadcasting with batching
+  - ThreadingHTTPServer for concurrent SSE + API handling
   - No external dependencies — uses stdlib http.server
 
 Started automatically from interactive.py when `adelie run` is called.
@@ -15,9 +16,11 @@ Started automatically from interactive.py when `adelie run` is called.
 
 from __future__ import annotations
 
+import collections
 import json
 import queue
 import re
+import socketserver
 import threading
 import time
 from datetime import datetime
@@ -30,14 +33,14 @@ from adelie.dashboard_html import DASHBOARD_HTML
 # ── Event Bus ────────────────────────────────────────────────────────────────
 
 class EventBus:
-    """Thread-safe pub/sub for SSE clients."""
+    """Thread-safe pub/sub for SSE clients with event coalescing."""
 
     def __init__(self):
         self._clients: list[queue.Queue] = []
         self._lock = threading.Lock()
 
     def subscribe(self) -> queue.Queue:
-        q: queue.Queue = queue.Queue(maxsize=200)
+        q: queue.Queue = queue.Queue(maxsize=500)
         with self._lock:
             self._clients.append(q)
         return q
@@ -73,18 +76,15 @@ class EventBus:
 # ── Log Ring Buffer ──────────────────────────────────────────────────────────
 
 class LogBuffer:
-    """Thread-safe ring buffer for recent log entries."""
+    """Thread-safe ring buffer for recent log entries using deque for O(1) ops."""
 
     def __init__(self, maxlen: int = 200):
-        self._buf: list[dict] = []
-        self._maxlen = maxlen
+        self._buf: collections.deque = collections.deque(maxlen=maxlen)
         self._lock = threading.Lock()
 
     def append(self, entry: dict) -> None:
         with self._lock:
             self._buf.append(entry)
-            if len(self._buf) > self._maxlen:
-                self._buf.pop(0)
 
     def get_all(self) -> list[dict]:
         with self._lock:
@@ -110,10 +110,22 @@ class DashboardState:
         self.events = EventBus()
         self.logs = LogBuffer(maxlen=200)
         self._lock = threading.Lock()
+        # Debounce tracking for agent updates
+        self._agent_last_publish: dict[str, float] = {}
+        self._agent_debounce_ms: float = 0.05  # 50ms debounce for same agent
 
     def update_agent(self, name: str, info: dict) -> None:
+        now = time.monotonic()
         with self._lock:
             self.agents[name] = info
+            last = self._agent_last_publish.get(name, 0)
+            # Coalesce rapid agent updates (< 50ms apart) unless state changed
+            prev_state = self._agent_last_publish.get(f"{name}_state")
+            cur_state = info.get("state")
+            if cur_state == prev_state and (now - last) < self._agent_debounce_ms:
+                return
+            self._agent_last_publish[name] = now
+            self._agent_last_publish[f"{name}_state"] = cur_state
         self.events.publish("agent", {"name": name, **info})
 
     def update_cycle(self, iteration: int, phase: str, state: str) -> None:
@@ -124,6 +136,7 @@ class DashboardState:
             # Reset agents
             for name in list(self.agents.keys()):
                 self.agents[name] = {"state": "idle", "detail": "idle", "elapsed": 0}
+            self._agent_last_publish.clear()
         self.events.publish("cycle_start", {"iteration": iteration, "phase": phase, "state": state})
         self.events.publish("state", {"cycle": iteration, "phase": phase, "goal": self.goal})
 
@@ -212,7 +225,7 @@ class DashboardHandler(BaseHTTPRequestHandler):
             self.send_error(404)
 
     def _handle_sse(self, ds: DashboardState) -> None:
-        """Stream Server-Sent Events to the client."""
+        """Stream Server-Sent Events to the client with batched flushing."""
         self.send_response(200)
         self.send_header("Content-Type", "text/event-stream")
         self.send_header("Cache-Control", "no-cache")
@@ -228,20 +241,52 @@ class DashboardHandler(BaseHTTPRequestHandler):
         client_q = ds.events.subscribe()
         try:
             while True:
+                # Batch: collect all available events within a short window
+                batch: list[str] = []
                 try:
-                    payload = client_q.get(timeout=15)
-                    self.wfile.write(payload.encode("utf-8"))
-                    self.wfile.flush()
+                    # Block up to 100ms for first event, then drain
+                    payload = client_q.get(timeout=0.1)
+                    batch.append(payload)
                 except queue.Empty:
-                    # Send keepalive comment
-                    self.wfile.write(": keepalive\n\n".encode("utf-8"))
+                    pass
+
+                # Drain any additional queued events (non-blocking)
+                while not client_q.empty() and len(batch) < 50:
+                    try:
+                        batch.append(client_q.get_nowait())
+                    except queue.Empty:
+                        break
+
+                if batch:
+                    # Write all events in one I/O call
+                    combined = "".join(batch)
+                    self.wfile.write(combined.encode("utf-8"))
                     self.wfile.flush()
+                else:
+                    # Send keepalive every ~15s (150 empty 100ms cycles)
+                    # Use a counter to avoid frequent keepalives
+                    if not hasattr(self, '_keepalive_counter'):
+                        self._keepalive_counter = 0
+                    self._keepalive_counter += 1
+                    if self._keepalive_counter >= 150:  # ~15 seconds
+                        self.wfile.write(": keepalive\n\n".encode("utf-8"))
+                        self.wfile.flush()
+                        self._keepalive_counter = 0
+
         except (BrokenPipeError, ConnectionResetError, OSError):
             pass
         finally:
             ds.events.unsubscribe(client_q)
 
 
+# ── Threading HTTP Server ────────────────────────────────────────────────────
+
+class ThreadingDashboardHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
+    """Multi-threaded HTTP server so SSE connections don't block API requests."""
+    daemon_threads = True
+    allow_reuse_address = True
+
+
 # ── Dashboard Server ─────────────────────────────────────────────────────────
 
 class DashboardServer:
@@ -258,13 +303,13 @@ class DashboardServer:
     def __init__(self, state: DashboardState, port: int = 5042):
         self.state = state
         self.port = port
-        self._httpd: Optional[HTTPServer] = None
+        self._httpd: Optional[ThreadingDashboardHTTPServer] = None
         self._thread: Optional[threading.Thread] = None
 
     def start(self) -> bool:
         """Start the dashboard server in a background thread. Returns True on success."""
         try:
-            self._httpd = HTTPServer(("0.0.0.0", self.port), DashboardHandler)
+            self._httpd = ThreadingDashboardHTTPServer(("0.0.0.0", self.port), DashboardHandler)
             self._httpd._dashboard_state = self.state  # type: ignore
             self._httpd.timeout = 0.5
             self._thread = threading.Thread(

package/adelie/dashboard_html.py

@@ -3,6 +3,12 @@ adelie/dashboard_html.py
 
 Embedded HTML/CSS/JS template for the Adelie real-time web dashboard.
 Served as a single self-contained page — no external assets needed.
+
+Performance-optimized:
+  - requestAnimationFrame DOM batching
+  - DocumentFragment for bulk log insertion
+  - Event throttling for rapid agent updates
+  - Phase timeline class-toggle (no full re-render)
 """
 
 DASHBOARD_HTML = r"""<!DOCTYPE html>
@@ -49,8 +55,8 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
 /* ── Agent Grid ─────────────────────── */
 .section-title{font-size:13px;font-weight:600;color:var(--fg2);text-transform:uppercase;letter-spacing:1px;margin-bottom:10px}
 .agents-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:10px;margin-bottom:16px}
-.agent-card{background:var(--glass);border:1px solid var(--border);border-radius:10px;padding:14px;transition:all .3s ease;position:relative;overflow:hidden}
-.agent-card:hover{border-color:var(--fg3);transform:translateY(-1px)}
+.agent-card{background:var(--glass);border:1px solid var(--border);border-radius:10px;padding:14px;transition:border-color .3s ease,box-shadow .3s ease;position:relative;overflow:hidden;contain:layout style}
+.agent-card:hover{border-color:var(--fg3)}
 .agent-card.running{border-color:var(--cyan);box-shadow:0 0 20px rgba(88,166,255,.1)}
 .agent-card.running::before{content:'';position:absolute;top:0;left:-100%;width:100%;height:2px;background:linear-gradient(90deg,transparent,var(--cyan),transparent);animation:scan 2s linear infinite}
 @keyframes scan{to{left:100%}}
@@ -128,7 +134,7 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
     <svg viewBox="0 0 32 32" fill="none"><circle cx="16" cy="12" r="10" fill="#58a6ff" opacity=".15" stroke="#58a6ff" stroke-width="1.5"/><circle cx="13" cy="10" r="1.5" fill="#e6edf3"/><circle cx="19" cy="10" r="1.5" fill="#e6edf3"/><ellipse cx="16" cy="14" rx="3" ry="2" fill="#f0883e"/><path d="M10 20 C10 26 22 26 22 20" stroke="#58a6ff" stroke-width="1.5" fill="none"/><path d="M6 14 C4 18 8 22 10 20" stroke="#58a6ff" stroke-width="1.5" fill="none"/><path d="M26 14 C28 18 24 22 22 20" stroke="#58a6ff" stroke-width="1.5" fill="none"/></svg>
     Adelie Dashboard
   </div>
-  <span class="version" id="version">v0.1.5</span>
+  <span class="version" id="version">v0.2.0</span>
   <div class="spacer"></div>
   <div class="status-dot" id="statusDot"></div>
   <span class="status-label" id="statusLabel">Connected</span>
@@ -199,7 +205,6 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
 
   // ── Agents ──────────────────────────
   const AGENTS = ["Writer","Expert","Scanner","Coder","Reviewer","Tester","Runner","Monitor","Analyst","Research"];
-  const AGENT_COLORS = {Writer:"#58a6ff",Expert:"#58a6ff",Scanner:"#bc8cff",Coder:"#3fb950","Coder:0":"#3fb950","Coder:1":"#3fb950","Coder:2":"#3fb950",Reviewer:"#d29922",Tester:"#f85149",Runner:"#3fb950",Monitor:"#58a6ff",Analyst:"#bc8cff",Inform:"#58a6ff",Research:"#d29922"};
 
   // ── Phases ──────────────────────────
   const PHASES = [
@@ -213,7 +218,7 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
 
   // ── State ───────────────────────────
   let state = {agents:{},cycle:0,phase:"initial",goal:"",workspace:"",metrics:{}};
-  let logs = [];
+  let logCount = 0;
   const MAX_LOGS = 300;
   let autoScroll = true;
 
@@ -221,11 +226,33 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
   const $ = id => document.getElementById(id);
   const agentsGrid = $("agentsGrid");
   const logBody = $("logBody");
-  const logCount = $("logCount");
+  const logCountEl = $("logCount");
+
+  // ── RAF Batch Queue ─────────────────
+  // All DOM mutations are queued and applied in a single rAF frame
+  let pendingUpdates = [];
+  let rafScheduled = false;
+
+  function scheduleUpdate(fn) {
+    pendingUpdates.push(fn);
+    if (!rafScheduled) {
+      rafScheduled = true;
+      requestAnimationFrame(flushUpdates);
+    }
+  }
+
+  function flushUpdates() {
+    const updates = pendingUpdates;
+    pendingUpdates = [];
+    rafScheduled = false;
+    for (let i = 0; i < updates.length; i++) {
+      updates[i]();
+    }
+  }
 
   // ── Init agents grid ────────────────
   function initAgents(){
-    agentsGrid.innerHTML = "";
+    const frag = document.createDocumentFragment();
     AGENTS.forEach(name => {
       const card = document.createElement("div");
       card.className = "agent-card";
@@ -234,79 +261,157 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
         <div class="agent-name"><span class="dot idle" id="dot-${name}"></span>${name}</div>
         <div class="agent-detail" id="detail-${name}">idle</div>
         <div class="agent-elapsed" id="elapsed-${name}"></div>`;
-      agentsGrid.appendChild(card);
+      frag.appendChild(card);
     });
+    agentsGrid.appendChild(frag);
   }
 
-  // ── Update agent card ───────────────
+  // ── Update agent card (throttled) ──
+  const agentThrottleMap = {};
+  const AGENT_THROTTLE_MS = 80;
+
   function updateAgent(name, info){
-    const card = $("agent-"+name);
-    if(!card) return;
-    const dot = $("dot-"+name);
-    const detail = $("detail-"+name);
-    const elapsed = $("elapsed-"+name);
-    const st = info.state || "idle";
-    card.className = "agent-card " + st;
-    dot.className = "dot " + st;
-    detail.textContent = info.detail || st;
-    if(info.elapsed > 0) elapsed.textContent = info.elapsed.toFixed(1)+"s";
-    else elapsed.textContent = st === "running" ? "…" : "";
+    const now = performance.now();
+    const lastUpdate = agentThrottleMap[name] || 0;
+    const prevState = agentThrottleMap[name + "_state"];
+    const curState = info.state || "idle";
+
+    // Skip if same state and within throttle window
+    if (curState === prevState && (now - lastUpdate) < AGENT_THROTTLE_MS) {
+      return;
+    }
+    agentThrottleMap[name] = now;
+    agentThrottleMap[name + "_state"] = curState;
+
+    scheduleUpdate(() => {
+      const card = $("agent-"+name);
+      if(!card) return;
+      const dot = $("dot-"+name);
+      const detail = $("detail-"+name);
+      const elapsed = $("elapsed-"+name);
+      const st = info.state || "idle";
+      card.className = "agent-card " + st;
+      dot.className = "dot " + st;
+      detail.textContent = info.detail || st;
+      if(info.elapsed > 0) elapsed.textContent = info.elapsed.toFixed(1)+"s";
+      else elapsed.textContent = st === "running" ? "…" : "";
+    });
   }
 
-  // ── Update phase timeline ──────────
-  function updatePhase(current){
+  // ── Init phase timeline (once) ─────
+  let phaseElements = [];
+  function initPhaseTimeline() {
     const tl = $("phaseTimeline");
-    tl.innerHTML = "";
-    let found = false;
-    PHASES.forEach(p => {
+    const frag = document.createDocumentFragment();
+    PHASES.forEach((p, i) => {
       const item = document.createElement("div");
       item.className = "phase-item";
-      if(p.value === current){ item.classList.add("active"); found = true; }
-      else if(!found){ item.classList.add("completed"); }
+      item.dataset.phase = p.value;
       item.innerHTML = `<span class="phase-name">${p.label}</span>`;
-      tl.appendChild(item);
+      frag.appendChild(item);
+      phaseElements.push(item);
+    });
+    tl.appendChild(frag);
+  }
+
+  // ── Update phase timeline (class toggle only) ──
+  let currentPhase = "";
+  function updatePhase(current){
+    if (current === currentPhase) return;
+    currentPhase = current;
+
+    scheduleUpdate(() => {
+      let found = false;
+      for (let i = 0; i < phaseElements.length; i++) {
+        const el = phaseElements[i];
+        el.classList.remove("active", "completed");
+        if (el.dataset.phase === current) {
+          el.classList.add("active");
+          found = true;
+        } else if (!found) {
+          el.classList.add("completed");
+        }
+      }
+      $("phaseBadge").textContent = (PHASES.find(p=>p.value===current)||{}).label || current;
     });
-    $("phaseBadge").textContent = (PHASES.find(p=>p.value===current)||{}).label || current;
   }
 
   // ── Update metrics panel ───────────
   function updateMetrics(m){
     if(!m) return;
-    $("mTokens").textContent = (m.total_tokens||0).toLocaleString();
-    $("mCalls").textContent = m.llm_calls || m.calls || 0;
-    $("mFiles").textContent = m.files_written || 0;
-    $("mTime").textContent = (m.cycle_time||0).toFixed(1)+"s";
-    if(m.tests_total > 0) $("mTests").textContent = m.tests_passed+"/"+m.tests_total;
-    if(m.review_score > 0) $("mReview").textContent = m.review_score.toFixed(0)+"/10";
+    scheduleUpdate(() => {
+      $("mTokens").textContent = (m.total_tokens||0).toLocaleString();
+      $("mCalls").textContent = m.llm_calls || m.calls || 0;
+      $("mFiles").textContent = m.files_written || 0;
+      $("mTime").textContent = (m.cycle_time||0).toFixed(1)+"s";
+      if(m.tests_total > 0) $("mTests").textContent = m.tests_passed+"/"+m.tests_total;
+      if(m.review_score > 0) $("mReview").textContent = m.review_score.toFixed(0)+"/10";
+    });
   }
 
   // ── Update cycle chart ─────────────
   function updateChart(history){
-    const bars = $("chartBars");
-    if(!history||!history.length){ bars.innerHTML="<span style='color:var(--fg3);font-size:11px'>No data yet</span>"; return; }
-    const maxTime = Math.max(...history.map(h=>h.cycle_time||1), 1);
-    bars.innerHTML = "";
-    history.slice(-30).forEach(h => {
-      const pct = Math.max(5, ((h.cycle_time||0)/maxTime)*100);
-      const bar = document.createElement("div");
-      bar.className = "chart-bar";
-      bar.style.height = pct+"%";
-      bar.innerHTML = `<div class="tooltip">#${h.cycle} · ${(h.cycle_time||0).toFixed(1)}s · ${((h.tokens||{}).total||0).toLocaleString()} tok</div>`;
-      bars.appendChild(bar);
+    scheduleUpdate(() => {
+      const bars = $("chartBars");
+      if(!history||!history.length){ bars.innerHTML="<span style='color:var(--fg3);font-size:11px'>No data yet</span>"; return; }
+      const slice = history.slice(-30);
+      const maxTime = Math.max(...slice.map(h=>h.cycle_time||1), 1);
+      const frag = document.createDocumentFragment();
+      slice.forEach(h => {
+        const pct = Math.max(5, ((h.cycle_time||0)/maxTime)*100);
+        const bar = document.createElement("div");
+        bar.className = "chart-bar";
+        bar.style.height = pct+"%";
+        bar.innerHTML = `<div class="tooltip">#${h.cycle} · ${(h.cycle_time||0).toFixed(1)}s · ${((h.tokens||{}).total||0).toLocaleString()} tok</div>`;
+        frag.appendChild(bar);
+      });
+      bars.innerHTML = "";
+      bars.appendChild(frag);
     });
   }
 
-  // ── Add log entry ──────────────────
+  // ── Add log entries (batched) ──────
   const CAT_ICONS = {agent_start:"▶",agent_end:"✓",error:"✕",warning:"⚠",phase_change:"◆",info:"·",debug:"·",cycle_header:"─",cycle_summary:"📊",progress:"→"};
+  let pendingLogs = [];
+  let logRafScheduled = false;
+
   function addLog(entry){
-    logs.push(entry);
-    if(logs.length > MAX_LOGS){ logs.shift(); logBody.removeChild(logBody.firstChild); }
-    const div = document.createElement("div");
-    div.className = "log-entry " + (entry.category||"info");
-    const ts = entry.timestamp ? new Date(entry.timestamp).toLocaleTimeString() : "";
-    div.innerHTML = `<span class="log-ts">${ts}</span><span class="log-cat">${CAT_ICONS[entry.category]||"·"}</span><span class="log-msg">${escHtml(entry.message||"")}</span>`;
-    logBody.appendChild(div);
-    logCount.textContent = logs.length + " entries";
+    pendingLogs.push(entry);
+    logCount++;
+    if (!logRafScheduled) {
+      logRafScheduled = true;
+      requestAnimationFrame(flushLogs);
+    }
+  }
+
+  function flushLogs() {
+    logRafScheduled = false;
+    const entries = pendingLogs;
+    pendingLogs = [];
+    if (!entries.length) return;
+
+    // Trim excess before adding
+    const totalAfter = logBody.childElementCount + entries.length;
+    if (totalAfter > MAX_LOGS) {
+      const toRemove = totalAfter - MAX_LOGS;
+      for (let i = 0; i < toRemove && logBody.firstChild; i++) {
+        logBody.removeChild(logBody.firstChild);
+      }
+    }
+
+    // Build all new entries in a DocumentFragment
+    const frag = document.createDocumentFragment();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const div = document.createElement("div");
+      div.className = "log-entry " + (entry.category||"info");
+      const ts = entry.timestamp ? new Date(entry.timestamp).toLocaleTimeString() : "";
+      div.innerHTML = `<span class="log-ts">${ts}</span><span class="log-cat">${CAT_ICONS[entry.category]||"·"}</span><span class="log-msg">${escHtml(entry.message||"")}</span>`;
+      frag.appendChild(div);
+    }
+    logBody.appendChild(frag);
+
+    logCountEl.textContent = Math.min(logCount, MAX_LOGS) + " entries";
     if(autoScroll) logBody.scrollTop = logBody.scrollHeight;
   }
 
@@ -316,7 +421,7 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
   logBody.addEventListener("scroll", () => {
     const gap = logBody.scrollHeight - logBody.scrollTop - logBody.clientHeight;
     autoScroll = gap < 40;
-  });
+  }, {passive: true});
 
   // ── Load initial state ──────────────
   async function loadState(){
@@ -354,9 +459,18 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
   // ── SSE Connection ─────────────────
   let evtSource = null;
   let reconnectDelay = 1000;
+  let reconnectTimer = null;
 
   function connectSSE(){
-    if(evtSource) evtSource.close();
+    if(evtSource){
+      evtSource.close();
+      evtSource = null;
+    }
+    if(reconnectTimer){
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+
     evtSource = new EventSource("/events");
 
     evtSource.onopen = () => {
@@ -368,9 +482,9 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
 
     evtSource.addEventListener("state", (e) => {
       const d = JSON.parse(e.data);
-      if(d.cycle) $("cycleNum").textContent = "#"+d.cycle;
+      if(d.cycle) scheduleUpdate(() => { $("cycleNum").textContent = "#"+d.cycle; });
       if(d.phase) updatePhase(d.phase);
-      if(d.goal) $("goal").textContent = d.goal;
+      if(d.goal) scheduleUpdate(() => { $("goal").textContent = d.goal; });
     });
 
     evtSource.addEventListener("agent", (e) => {
@@ -390,7 +504,9 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
 
     evtSource.addEventListener("cycle_start", (e) => {
       const d = JSON.parse(e.data);
-      $("cycleNum").textContent = "#"+(d.iteration||0);
+      scheduleUpdate(() => {
+        $("cycleNum").textContent = "#"+(d.iteration||0);
+      });
       // Reset agents
       AGENTS.forEach(name => updateAgent(name, {state:"idle",detail:"idle",elapsed:0}));
     });
@@ -406,21 +522,20 @@ body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--f
       $("statusDot").style.background = "var(--red)";
       $("statusLabel").textContent = "Disconnected";
       evtSource.close();
-      setTimeout(connectSSE, reconnectDelay);
-      reconnectDelay = Math.min(reconnectDelay * 2, 10000);
+      evtSource = null;
+      reconnectTimer = setTimeout(connectSSE, reconnectDelay);
+      reconnectDelay = Math.min(reconnectDelay * 1.5, 15000);
     };
   }
 
   // ── Init ────────────────────────────
   initAgents();
+  initPhaseTimeline();
   loadState().then(()=>{
     loadLogs();
     loadHistory();
     connectSSE();
   });
-
-  // Refresh history every 30s
-  setInterval(loadHistory, 30000);
 })();
 </script>
 </body>

package/adelie/interactive.py

@@ -62,14 +62,14 @@ AGENT_COLORS = {
 # ── Header ────────────────────────────────────────────────────────────────────
 
 def print_header(goal: str, phase: str, model: str, workspace: str):
-    """Print the startup header — gemini-cli style ASCII icon + info."""
+    """Print the startup header — penguin ASCII icon + info."""
+    from adelie import __version__
     width = shutil.get_terminal_size((80, 24)).columns
 
     console.print()
-    console.print("  [cyan]▝▜▄[/cyan]    [bold]Adelie[/bold] [dim]v0.1.0[/dim]")
-    console.print(f"    [cyan]▝▜▄[/cyan]  [dim]{model}[/dim]")
-    console.print(f"   [cyan]▗▟▀[/cyan]  [dim]Phase:[/dim] {phase}")
-    console.print(f"  [cyan]▝▀[/cyan]")
+    console.print("    [cyan]  (o_  [/cyan]  [bold]Adelie[/bold] [dim]v" + __version__ + "[/dim]")
+    console.print("    [cyan]  //\\\\  [/cyan]  [dim]" + model + "[/dim]")
+    console.print("    [cyan]  V_/_ [/cyan]  [dim]Phase:[/dim] " + phase)
     console.print()
 
     # Goal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adelie-ai",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Adelie — Self-Communicating Autonomous AI Loop CLI",
   "bin": {
     "adelie": "bin/adelie.js"