aether-robotics 4.2.0a2__tar.gz → 4.2.0a4__tar.gz

{aether_robotics-4.2.0a2/aether_robotics.egg-info → aether_robotics-4.2.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 4.2.0a2
+Version: 4.2.0a4
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

aether_robotics-4.2.0a4/VERSION

@@ -0,0 +1 @@
+4.2.0a4

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4}/aether/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.2.0a2"
+__version__ = "4.2.0a4"
 __author__ = "Chahel Paatur"
 
 # v3.9.6: one-time scrub of any secrets that leaked into experience memory in

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4}/aether/app.py

@@ -1719,7 +1719,8 @@ def _summarize_output(output) -> str:
 
 def _execute_objective(objective: str, registry, llm_planner, corrector,
                        parser_obj, manifest, recent_memory,
-                       available, fix_mode: bool = False) -> Dict:
+                       available, fix_mode: bool = False,
+                       on_step=None) -> Dict:
     """Execute a single objective and return structured result.
 
     Used by agent mode (interactive), server mode (HTTP), and `aether --fix`
@@ -1755,6 +1756,20 @@ def _execute_objective(objective: str, registry, llm_planner, corrector,
     if fix_mode:
         print(f"  [agent] planning: {objective}")
 
+    # v4.2.0a3: optional live-progress hook (TUI). Phases: "plan" (full plan
+    # list, once), "start" (before each step), "done" (after each step).
+    # Presentation-only — a hook failure must never affect execution.
+    def _report(phase: str, data: Dict) -> None:
+        if on_step is None:
+            return
+        try:
+            on_step(phase, data)
+        except Exception:
+            pass
+
+    _report("plan", {"plan": plan, "source": plan_source,
+                     "objective": objective})
+
     # Execute plan steps
     step_faults = 0
     prev_output = None
@@ -1767,6 +1782,8 @@ def _execute_objective(objective: str, registry, llm_planner, corrector,
     for i, action in enumerate(plan, 1):
         tool_name = action["tool"]
         params = dict(action.get("params", {}))
+        _report("start", {"index": i, "total": len(plan),
+                          "tool": tool_name, "params": dict(params)})
 
         # Pipe previous output
         pipe_key = action.get("pipe_input")
@@ -1854,6 +1871,7 @@ def _execute_objective(objective: str, registry, llm_planner, corrector,
 
         action_log.append(entry)
         step_outputs.append(str(prev_output) if prev_output else None)
+        _report("done", {"index": i, "total": len(plan), "entry": dict(entry)})
 
         if fix_mode:
             from aether.core import ui
@@ -1976,6 +1994,8 @@ def bootstrap_agent_state_for_fix() -> dict:
         "parser": parser,
         "manifest": manifest,
         "available": registry.available_tools(),
+        # v4.2.0a3: adapter identity for the TUI status bar / boot detail.
+        "adapter_id": _adapter_id,
     }
 
 

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4}/aether/tui/app.py

@@ -60,8 +60,8 @@ AETHER_THEME = Theme(
 )
 
 from aether import __version__
-from aether.tui.widgets import (AgentWidget, DoctorWidget, PlaceholderWidget,
-                                WelcomeWidget)
+from aether.tui.widgets import (AgentWidget, DoctorWidget, MascotWidget,
+                                PlaceholderWidget, WelcomeWidget)
 
 # (mode id, sidebar label, phase-1 availability)
 MODES = [
@@ -140,9 +140,11 @@ class AetherApp(App):
     #header-bar { dock: top; height: 1; background: ansi_default;
                   padding: 0 1; }
     #body { height: 1fr; background: ansi_default; }
-    #sidebar { width: 14; background: ansi_default; border: none;
-               padding: 0 1; }
+    #sidebar-col { width: 17; background: ansi_default; }
+    #sidebar { width: 100%; height: 1fr; background: ansi_default;
+               border: none; padding: 0 1; }
     #sidebar ListItem { background: ansi_default; padding: 0 1; }
+    #mascot { dock: bottom; }
     #main-switcher { width: 1fr; border: none; background: ansi_default;
                      padding: 0 1; }
     #status-bar { height: 1; background: ansi_default;
@@ -165,15 +167,27 @@ class AetherApp(App):
         super().__init__(**kwargs)
         self._session_start = time.monotonic()
         self._telemetry_enabled: Optional[bool] = None
+        self._captured_prints: list = []   # tail of swallowed print() output
+        self._busy_spin = 0
+
+    def on_print(self, event) -> None:
+        """Swallow print() output from the classic pipeline (see on_mount);
+        keep the last 200 lines for debugging."""
+        text = event.text.rstrip()
+        if text:
+            self._captured_prints.append(text)
+            del self._captured_prints[:-200]
 
     # ── layout ─────────────────────────────────────────────────────────
     def compose(self) -> ComposeResult:
         yield Static(id="header-bar")
         with Horizontal(id="body"):
-            yield ListView(
-                *[ListItem(Label(label), id=f"nav-{mode_id}")
-                  for mode_id, label, _ in MODES],
-                id="sidebar")
+            with Vertical(id="sidebar-col"):
+                yield ListView(
+                    *[ListItem(Label(label), id=f"nav-{mode_id}")
+                      for mode_id, label, _ in MODES],
+                    id="sidebar")
+                yield MascotWidget(id="mascot")
             with ContentSwitcher(initial="welcome", id="main-switcher"):
                 yield WelcomeWidget(id="welcome")
                 yield AgentWidget(id="agent")
@@ -187,6 +201,11 @@ class AetherApp(App):
     def on_mount(self) -> None:
         self.register_theme(AETHER_THEME)
         self.theme = "aether"
+        # v4.2.0a4: the classic pipeline (discovery, adapters, planner) does
+        # raw print()s; uncaptured they hit the terminal under the TUI and
+        # flash/corrupt the screen until the next repaint. Capture them
+        # app-wide; keep the tail for debugging.
+        self.begin_capture_print(self)
         try:
             from aether.core.analytics import load_telemetry_config
             self._telemetry_enabled = bool(
@@ -196,6 +215,7 @@ class AetherApp(App):
         self._refresh_header()
         self._refresh_status()
         self.set_interval(1.0, self._tick_session)
+        self.set_interval(0.12, self._tick_busy)
         self.query_one("#sidebar", ListView).focus()
 
     # ── reactive watchers ──────────────────────────────────────────────
@@ -220,6 +240,13 @@ class AetherApp(App):
     def _tick_session(self) -> None:
         self.session_seconds = int(time.monotonic() - self._session_start)
 
+    def _tick_busy(self) -> None:
+        """Animate the status-bar spinner while something is in flight."""
+        if self.busy_text:
+            from aether.tui.widgets.agent import SPINNER
+            self._busy_spin = (self._busy_spin + 1) % len(SPINNER)
+            self._refresh_status()
+
     def _refresh_header(self) -> None:
         adapters = (f"{self.adapter_count} adapter"
                     f"{'s' if self.adapter_count != 1 else ''}")
@@ -234,8 +261,13 @@ class AetherApp(App):
         m, s = divmod(self.session_seconds, 60)
         telemetry = {True: "enabled", False: "disabled",
                      None: "unknown"}[self._telemetry_enabled]
-        busy = f"  •  [yellow]⣾ {self.busy_text}[/yellow]" if self.busy_text \
-            else ""
+        if self.busy_text:
+            from aether.tui.widgets.agent import SPINNER
+            frame = SPINNER[self._busy_spin]
+            busy = (f"  •  [{AETHER_ORANGE}]{frame} "
+                    f"{self.busy_text}[/{AETHER_ORANGE}]")
+        else:
+            busy = ""
         try:
             self.query_one("#status-bar", Static).update(
                 f"● {self.adapters_line}  •  Telemetry: {telemetry}  •  "
@@ -266,8 +298,14 @@ class AetherApp(App):
                 return
         except Exception:
             pass
+        # Single-adapter path (load_tier1 doesn't fill the active list).
+        adapter_id = state.get("adapter_id")
         n = len(state.get("available", []))
-        self.adapters_line = f"registry ready ({n} tools)"
+        if adapter_id:
+            self.adapters_line = f"{adapter_id} (primary) · {n} tools"
+            self.adapter_count = 1
+        else:
+            self.adapters_line = f"registry ready ({n} tools)"
 
     # ── mode switching ─────────────────────────────────────────────────
     def activate_mode(self, mode_id: str) -> None:

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4}/aether/tui/widgets/__init__.py

@@ -5,7 +5,8 @@ render a PlaceholderWidget until phase 2/3.
 """
 from aether.tui.widgets.agent import AgentWidget
 from aether.tui.widgets.doctor import DoctorWidget
-from aether.tui.widgets.common import PlaceholderWidget, WelcomeWidget
+from aether.tui.widgets.common import (MascotWidget, PlaceholderWidget,
+                                       WelcomeWidget)
 
-__all__ = ["AgentWidget", "DoctorWidget", "PlaceholderWidget",
-           "WelcomeWidget"]
+__all__ = ["AgentWidget", "DoctorWidget", "MascotWidget",
+           "PlaceholderWidget", "WelcomeWidget"]

aether_robotics-4.2.0a4/aether/tui/widgets/agent.py

@@ -0,0 +1,357 @@
+"""Agent mode widget: objective input + in-flow live plan blocks (v4.2.0a4).
+
+Dispatches through the exact same pipeline as the classic REPL:
+bootstrap_agent_state_for_fix() builds the registry/planner once (in a
+thread worker, since it touches hardware), then each objective runs through
+aether.app._execute_objective and its on_step hook.
+
+Layout model: the log is a scroll of blocks. Each objective mounts ONE
+RunBlock directly under it that live-updates in place — thinking spinner →
+concise plan ("thought") line → step list with ○/spinner/●/seconds — and
+simply stays there when the run finishes. Planning is always right below
+the objective, never docked at the bottom. Only presentation; execution is
+untouched (DO NOT CHANGE contract).
+"""
+from typing import Callable, List, Optional
+
+from aether.tui import AETHER_ORANGE
+
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Input, Static
+
+_SLASH_PREFIX = "/"
+SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+def _params_str(params: dict) -> str:
+    return ", ".join(f"{k}={v!r}" for k, v in (params or {}).items())
+
+
+class RunBlock(Static):
+    """One objective's live block: thinking → plan → steps → verdict.
+
+    All mutation happens on the UI thread; `tick()` advances the spinner
+    while anything is in flight.
+    """
+
+    def __init__(self, objective: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.objective = objective
+        self.phase = "thinking"          # thinking | running | finished
+        self.plan_source = ""
+        self.steps: List[dict] = []
+        self.verdict = ""
+        self._spin = 0
+        self._render_now()
+
+    # -- events from the worker (already marshalled to the UI thread) --
+    def on_step(self, phase: str, data: dict) -> None:
+        if phase == "plan":
+            self.phase = "running"
+            self.plan_source = data.get("source", "?")
+            self.steps = [
+                {"tool": a.get("tool", "?"),
+                 "params": dict(a.get("params", {})),
+                 "status": "pending", "secs": None, "error": ""}
+                for a in data.get("plan", [])]
+        elif phase == "start" and self.steps:
+            i = data.get("index", 1) - 1
+            if 0 <= i < len(self.steps):
+                self.steps[i]["status"] = "running"
+        elif phase == "done" and self.steps:
+            i = data.get("index", 1) - 1
+            entry = data.get("entry", {})
+            if 0 <= i < len(self.steps):
+                step = self.steps[i]
+                step["status"] = "done" if entry.get("success") else "failed"
+                step["secs"] = entry.get("duration_ms", 0) / 1000.0
+                step["error"] = entry.get("error", "")
+        self._render_now()
+
+    def finish(self, result: dict) -> None:
+        self.phase = "finished"
+        status = result.get("status", "?")
+        color = "green" if status in ("ok", "success", "SUCCESS",
+                                      "completed") else "yellow"
+        if self.steps:
+            done = sum(1 for s in self.steps if s["status"] == "done")
+            total_s = sum(s["secs"] or 0.0 for s in self.steps)
+            detail = f"{done}/{len(self.steps)} steps · {total_s:.1f}s total"
+        else:
+            # Legacy path (execute_fn without on_step): backfill from result.
+            self.plan_source = result.get("plan_source", "?")
+            self.steps = [
+                {"tool": e.get("tool", "?"), "params": {},
+                 "status": "done" if e.get("success") else "failed",
+                 "secs": e.get("duration_ms", 0) / 1000.0,
+                 "error": e.get("error", "")}
+                for e in result.get("actions", [])]
+            detail = f"{len(self.steps)} step(s)"
+        self.verdict = (f"[{color}]status: {status}[/{color}] "
+                        f"[dim]· {detail}[/dim]")
+        self._render_now()
+
+    def fail(self, message: str) -> None:
+        self.phase = "finished"
+        self.verdict = f"[red]\\[FAIL][/red] {message}"
+        self._render_now()
+
+    def tick(self) -> bool:
+        """Advance the spinner. Returns True while still animating."""
+        if self.phase == "finished":
+            return False
+        self._spin = (self._spin + 1) % len(SPINNER)
+        self._render_now()
+        return True
+
+    # -- rendering --
+    def _thought_line(self) -> str:
+        chain = " → ".join(s["tool"] for s in self.steps)
+        return (f"  [{AETHER_ORANGE}]\\[PLAN][/{AETHER_ORANGE}] "
+                f"{self.plan_source} · {len(self.steps)} step(s)"
+                f"  [dim]{chain}[/dim]")
+
+    def _step_line(self, step: dict) -> str:
+        call = f"{step['tool']}({_params_str(step['params'])})"
+        status = step["status"]
+        if status == "pending":
+            return f"    [dim]○ {call}[/dim]"
+        if status == "running":
+            frame = SPINNER[self._spin]
+            return (f"    [{AETHER_ORANGE}]{frame}[/{AETHER_ORANGE}] {call} "
+                    f"[dim]running...[/dim]")
+        secs = (f" [dim]({step['secs']:.1f}s)[/dim]"
+                if step["secs"] is not None else "")
+        if status == "done":
+            return f"    [green]●[/green] {call}{secs}"
+        return (f"    [red]●[/red] {call}{secs} "
+                f"[red]{step.get('error', '')}[/red]")
+
+    def _render_now(self) -> None:
+        lines = [f"[bold {AETHER_ORANGE}]objective>[/bold {AETHER_ORANGE}] "
+                 f"{self.objective}", ""]
+        if self.phase == "thinking":
+            frame = SPINNER[self._spin]
+            lines.append(f"  [{AETHER_ORANGE}]{frame}[/{AETHER_ORANGE}] "
+                         f"[dim]thinking...[/dim]")
+        else:
+            lines.append(self._thought_line())
+            if self.steps:
+                lines.append("")
+                lines.extend(self._step_line(s) for s in self.steps)
+        if self.verdict:
+            lines.extend(["", f"  {self.verdict}"])
+        self.update("\n".join(lines))
+
+
+class BootBlock(Static):
+    """Animated one-shot block for the hardware bootstrap."""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.done = False
+        self._spin = 0
+        self._render_now()
+
+    def tick(self) -> bool:
+        if self.done:
+            return False
+        self._spin = (self._spin + 1) % len(SPINNER)
+        self._render_now()
+        return True
+
+    def _render_now(self) -> None:
+        frame = SPINNER[self._spin]
+        self.update(f"  [{AETHER_ORANGE}]{frame}[/{AETHER_ORANGE}] "
+                    f"[dim]discovering hardware + adapters...[/dim]")
+
+    def finish(self, lines: List[str]) -> None:
+        self.done = True
+        self.update("\n".join(lines))
+
+
+class AgentWidget(Vertical):
+    """Objective REPL rendered as a TUI pane."""
+
+    DEFAULT_CSS = """
+    AgentWidget { background: ansi_default; }
+    AgentWidget #agent-log { height: 1fr; border: none;
+                             background: ansi_default; padding: 0 1; }
+    AgentWidget #agent-log > Static { margin-bottom: 1;
+                                      background: ansi_default; }
+    AgentWidget #agent-input { border: round $primary 50%;
+                               background: ansi_default; padding: 0 1;
+                               margin-top: 1; }
+    AgentWidget #agent-input:focus { border: round $primary; }
+    """
+
+    def __init__(self, bootstrap_fn: Optional[Callable] = None,
+                 execute_fn: Optional[Callable] = None, **kwargs) -> None:
+        """bootstrap_fn/execute_fn are injectable for tests; the defaults are
+        the production agent pipeline. An injected execute_fn may accept
+        (objective, state) or (objective, state, on_step)."""
+        super().__init__(**kwargs)
+        self._bootstrap_fn = bootstrap_fn
+        self._execute_fn = execute_fn
+        self._agent_state: Optional[dict] = None
+        self._active_blocks: List = []   # blocks still animating
+
+    # -- layout --
+    def compose(self) -> ComposeResult:
+        yield VerticalScroll(id="agent-log")
+        yield Input(placeholder="objective>  (or / for commands)",
+                    id="agent-input")
+
+    def on_mount(self) -> None:
+        self._log("[bold]AETHER Agent[/bold]\n"
+                  "[dim]Type an objective in plain English. "
+                  "First objective boots the hardware registry.[/dim]")
+        self.set_interval(0.12, self._animate)
+
+    def focus_input(self) -> None:
+        self.query_one("#agent-input", Input).focus()
+
+    # -- log helpers --
+    def _scroll(self) -> VerticalScroll:
+        return self.query_one("#agent-log", VerticalScroll)
+
+    def _log(self, markup: str) -> None:
+        log = self._scroll()
+        log.mount(Static(markup))
+        log.scroll_end(animate=False)
+
+    def _mount_block(self, block) -> None:
+        log = self._scroll()
+        log.mount(block)
+        self._active_blocks.append(block)
+        log.scroll_end(animate=False)
+
+    def _animate(self) -> None:
+        if not self._active_blocks:
+            return
+        self._active_blocks = [b for b in self._active_blocks if b.tick()]
+        self._scroll().scroll_end(animate=False)
+
+    def clear_log(self) -> None:
+        self._scroll().remove_children()
+        self._active_blocks = []
+
+    def log_text(self) -> str:
+        """Plain text of every block (used by /help and tests)."""
+        return "\n".join(str(w.render()) for w in self._scroll().children
+                         if isinstance(w, Static))
+
+    # -- input handling --
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        event.input.value = ""
+        if not text:
+            return
+        if text.startswith(_SLASH_PREFIX):
+            self.app.run_slash_command(text)
+            return
+        block = RunBlock(text)
+        self._mount_block(block)
+        self.run_objective(text, block)
+
+    # -- objective pipeline (thread worker: hardware + LLM latency) --
+    @work(thread=True, exclusive=True, group="agent-objective")
+    def run_objective(self, objective: str, block: RunBlock) -> None:
+        app = self.app
+        try:
+            state = self._ensure_agent_state()
+            app.call_from_thread(app.set_busy,
+                                 "planning objective with Claude...")
+
+            def on_step(phase: str, data: dict) -> None:
+                app.call_from_thread(block.on_step, phase, data)
+
+            execute = self._execute_fn or self._default_execute
+            try:
+                result = execute(objective, state, on_step)
+            except TypeError:
+                result = execute(objective, state)  # legacy 2-arg fake
+            app.call_from_thread(block.finish, result)
+            app.call_from_thread(app.count_action)
+        except Exception as e:  # noqa: BLE001 — surface, never crash the TUI
+            app.call_from_thread(block.fail, f"{type(e).__name__}: {e}")
+        finally:
+            app.call_from_thread(app.set_busy, "")
+
+    def _ensure_agent_state(self) -> dict:
+        if self._agent_state is None:
+            app = self.app
+            app.call_from_thread(app.set_busy, "booting hardware registry...")
+            boot = BootBlock()
+            app.call_from_thread(self._mount_block, boot)
+            try:
+                bootstrap = self._bootstrap_fn or self._default_bootstrap
+                self._agent_state = bootstrap()
+            except Exception:
+                app.call_from_thread(
+                    boot.finish, ["  [red]hardware bootstrap failed[/red]"])
+                raise
+            app.call_from_thread(app.on_agent_state_ready, self._agent_state)
+            app.call_from_thread(
+                boot.finish, _adapter_detail_lines(self._agent_state))
+        return self._agent_state
+
+    @staticmethod
+    def _default_bootstrap() -> dict:
+        from aether.app import bootstrap_agent_state_for_fix
+        return bootstrap_agent_state_for_fix()
+
+    @staticmethod
+    def _default_execute(objective: str, state: dict, on_step=None) -> dict:
+        from aether.app import _execute_objective
+        return _execute_objective(
+            objective, state["registry"], state["planner"],
+            state["corrector"], state["parser"], state["manifest"],
+            recent_memory=[], available=state["available"], on_step=on_step)
+
+
+def _adapter_detail_lines(state: dict) -> List[str]:
+    """Boot-time adapter detail: name, role, tool count, address, GPIO.
+    Best effort — never raises."""
+    lines: List[str] = []
+    try:
+        from aether.adapters import (get_active_adapters, get_adapter_gpio_pins,
+                                     get_last_detected, get_primary_adapter,
+                                     get_tool_origin)
+        active = get_active_adapters()
+        addr_of = {d["adapter"]: d.get("address") for d in get_last_detected()}
+        if active:
+            primary = get_primary_adapter()
+            counts: dict = {}
+            for _tool, adp in get_tool_origin().items():
+                counts[adp] = counts.get(adp, 0) + 1
+            for name in active:
+                lines.append(_adapter_line(
+                    name, name == primary, counts.get(name, 0),
+                    addr_of.get(name), get_adapter_gpio_pins(name)))
+            return lines
+        adapter_id = state.get("adapter_id")
+        if adapter_id:
+            tools = len(state.get("manifest", {}).get("adapter_tools", []))
+            lines.append(_adapter_line(
+                adapter_id, True, tools, addr_of.get(adapter_id),
+                get_adapter_gpio_pins(adapter_id)))
+            return lines
+    except Exception:
+        pass
+    if not lines:
+        lines.append(f"  [dim]● registry ready "
+                     f"({len(state.get('available', []))} tools)[/dim]")
+    return lines
+
+
+def _adapter_line(name: str, primary: bool, tools: int, address,
+                  gpio_pins) -> str:
+    role = ("[green]primary[/green]" if primary
+            else f"[{AETHER_ORANGE}]namespaced[/{AETHER_ORANGE}]")
+    gpio = ", ".join(str(p) for p in (gpio_pins or [])) or "none (I2C only)"
+    addr = address or "vendor lib"
+    return (f"  [green]●[/green] [bold]{name}[/bold] — {role} · "
+            f"{tools} tools · addr {addr} · [dim]GPIO {gpio}[/dim]")

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4}/aether/tui/widgets/common.py

@@ -1,9 +1,32 @@
-"""Shared TUI widgets: first-run welcome screen and phase-2 placeholders."""
+"""Shared TUI widgets: mascot mark, first-run welcome, phase-2 placeholders."""
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
 from textual.widgets import Button, Static
 
 from aether import __version__
+from aether.tui import AETHER_ORANGE
+
+# Compact rendition of the AETHER banner mascot (the robot face) for the
+# bottom-left corner of the TUI.
+_MASCOT_ART = (
+    f"[{AETHER_ORANGE}]▄████▄ ▄████▄[/{AETHER_ORANGE}]\n"
+    f"[{AETHER_ORANGE}]█████████████[/{AETHER_ORANGE}]\n"
+    f"[dim]█▀▀[/dim][{AETHER_ORANGE}]███████[/{AETHER_ORANGE}][dim]▀▀█[/dim]\n"
+    f"[{AETHER_ORANGE}]▀████▀ ▀████▀[/{AETHER_ORANGE}]\n"
+    f"[dim] ━━ AETHER ━━[/dim]"
+)
+
+
+class MascotWidget(Static):
+    """The AETHER robot face, parked bottom-left under the sidebar."""
+
+    DEFAULT_CSS = """
+    MascotWidget { height: 5; background: ansi_default; padding: 0 1;
+                   color: $primary; }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(_MASCOT_ART, **kwargs)
 
 
 class WelcomeWidget(Vertical):

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4/aether_robotics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 4.2.0a2
+Version: 4.2.0a4
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aether-robotics"
-version = "4.2.0a2"
+version = "4.2.0a4"
 description = "Autonomous multi-agent robotics system with DRL-First Hybrid FDIR"
 readme = "README.md"
 license = {text = "MIT"}