aetherius 0.2.0__py3-none-any.whl

aetherius/console/screens/settings.py

@@ -0,0 +1,132 @@
+"""Daemon control (start and stop) and configuration.
+
+Starts and stops the local daemon (`aetherius serve`) without leaving the terminal, and shows its
+bind address and auth state. The daemon is session-scoped: it keeps running as you navigate the
+Console and is stopped when the Console exits. For a daemon that outlives the Console, run
+`aetherius serve` in its own terminal instead.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, cast
+
+from rich.text import Text
+
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.css.query import NoMatches
+from textual.screen import Screen
+from textual.widgets import Button, Footer, Header, Static
+
+from ..theme import LAUREL, STONE, starred
+
+if TYPE_CHECKING:
+    from ..app import AetheriusConsoleApp
+    from ..daemon_control import DaemonController
+
+
+class SettingsScreen(Screen[None]):
+    """Start and stop the local daemon, and see its configuration."""
+
+    DEFAULT_CSS = """
+    SettingsScreen #settings-status, SettingsScreen #settings-config {
+        padding: 1 2 0 2;
+    }
+    SettingsScreen #settings-start, SettingsScreen #settings-stop {
+        border: double $accent;
+        background: $panel;
+        color: $accent;
+        text-style: bold;
+        padding: 0 3;
+    }
+    SettingsScreen #settings-start:hover, SettingsScreen #settings-stop:hover {
+        background: $accent 20%;
+    }
+    SettingsScreen #settings-start:disabled, SettingsScreen #settings-stop:disabled {
+        color: $text-muted;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with VerticalScroll(classes="console-body"):
+            yield Static(starred("Settings"), classes="console-title")
+            yield Static(
+                "Start or stop the local daemon that exposes the engine over HTTP and WebSocket. "
+                "It binds to loopback and is stopped when the Console exits.",
+                classes="console-subtitle",
+            )
+            yield Static(id="settings-status")
+            yield Static(id="settings-config")
+            with Horizontal(classes="run-actions"):
+                yield Button("✦ Start daemon ✦", id="settings-start", variant="primary")
+                yield Button("Stop daemon", id="settings-stop")
+            yield Static(
+                "Once running, drive it from any language via the SDKs "
+                "(see docs/daemon.md). Configure host/port/token with AETHERIUS_DAEMON_*.",
+                classes="console-footer-hint",
+            )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._refresh()
+
+    @property
+    def _controller(self) -> DaemonController:
+        return cast("AetheriusConsoleApp", self.app).daemon
+
+    def _refresh(self, health: str = "") -> None:
+        """Repaint status, config and button states from the controller. Tolerant of a popped screen."""
+        controller = self._controller
+        running = controller.is_running()
+        config = controller.config
+        try:
+            status = self.query_one("#settings-status", Static)
+            if running:
+                line = Text.assemble(("● running", f"bold {LAUREL}"), f"  {controller.base_url}")
+                if health:
+                    line.append(f" · {health}")
+                status.update(line)
+            else:
+                status.update(Text("● stopped", style=f"bold {STONE}"))
+            self.query_one("#settings-config", Static).update(
+                f"host {config.host} · port {config.port} · "
+                f"token {'set' if config.token else 'none'}"
+            )
+            self.query_one("#settings-start", Button).disabled = running
+            self.query_one("#settings-stop", Button).disabled = not running
+        except NoMatches:
+            pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "settings-start":
+            self._controller.start()
+            self.app.notify(f"Daemon starting on {self._controller.base_url}…", timeout=4)
+            self._refresh()
+            self._probe_health()
+        elif event.button.id == "settings-stop":
+            self._controller.stop()
+            self.app.notify("Daemon stopped.", timeout=3)
+            self._refresh()
+
+    @work(thread=True, exclusive=True)
+    def _probe_health(self) -> None:
+        """Poll health off the UI thread until the daemon answers or exits."""
+        for _ in range(50):
+            if self._controller.healthy():
+                self.app.call_from_thread(self._on_healthy)
+                return
+            if not self._controller.is_running():
+                self.app.call_from_thread(self._on_exited)
+                return
+            time.sleep(0.1)
+
+    def _on_healthy(self) -> None:
+        self._refresh(health="healthy")
+        self.app.notify("Daemon is healthy.", timeout=3)
+
+    def _on_exited(self) -> None:
+        self._refresh()
+        self.app.notify("Daemon failed to start.", severity="error", timeout=6)

aetherius/console/screenshots.py

@@ -0,0 +1,173 @@
+"""Generate SVG screenshots of the Console for the documentation.
+
+Dev-only utility (never imported at runtime): it drives the Textual app **headlessly** through
+``run_test``/``Pilot`` — the same mechanism the tests use — and exports each key screen to a
+deterministic SVG under ``docs/screenshots/``. Determinism matters so the committed files change only
+when the UI actually changes: Rich stamps every export with a random id, which we normalise to a
+stable per-file token, and the external web-font ``@font-face`` blocks are stripped so each SVG is
+self-contained. Regenerate with ``make screenshots`` after any Console UI change.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+from textual.pilot import Pilot
+from textual.widgets import Select
+
+from .app import AetheriusConsoleApp
+
+if TYPE_CHECKING:
+    from .screens.builder.screen import BlueprintStudioScreen
+
+# Repo root, resolved from this module so paths don't depend on the working directory.
+_REPO = Path(__file__).resolve().parents[3]
+_EXAMPLE = _REPO / "examples" / "vector" / "ukit-planning-week.blueprint.json"
+
+Setup = Callable[[AetheriusConsoleApp, Pilot[None]], Awaitable[None]]
+
+
+async def _home(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    pass  # HomeScreen is already pushed on mount
+
+
+async def _library(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from .screens.library import LibraryScreen
+
+    app.push_screen(LibraryScreen())
+    await pilot.pause()
+
+
+async def _runs(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from .screens.runs import RunsScreen
+
+    app.push_screen(RunsScreen(_EXAMPLE))
+    await pilot.pause()
+
+
+async def _catalog(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from .screens.catalog import CatalogScreen
+
+    app.push_screen(CatalogScreen())
+    await pilot.pause()
+
+
+async def _recorder(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from .screens.recorder import RecorderScreen
+
+    app.push_screen(RecorderScreen())
+    await pilot.pause()
+
+
+async def _settings(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from .screens.settings import SettingsScreen
+
+    app.push_screen(SettingsScreen())
+    await pilot.pause()
+
+
+async def _open_studio_with_template(
+    app: AetheriusConsoleApp, pilot: Pilot[None]
+) -> BlueprintStudioScreen:
+    from .screens.builder.screen import BlueprintStudioScreen
+
+    screen = BlueprintStudioScreen()
+    app.push_screen(screen)
+    await pilot.pause()
+    await pilot.pause()
+    screen.query_one("#studio-template", Select).value = "continuum.scrape"
+    await pilot.pause()
+    screen._load_template()
+    await pilot.pause()
+    await pilot.pause()
+    return screen
+
+
+async def _studio(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    await _open_studio_with_template(app, pilot)
+
+
+async def _studio_preview(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from textual.widgets import Button
+
+    screen = await _open_studio_with_template(app, pilot)
+    # Scroll the Save button into view: the frame then shows the tail of the validated JSON, the green
+    # "Valid — ready to save.", and the Save button — the flagship live-validation moment.
+    screen.query_one("#studio-save", Button).scroll_visible(animate=False)
+    await pilot.pause()
+
+
+async def _studio_step_editor(app: AetheriusConsoleApp, pilot: Pilot[None]) -> None:
+    from .screens.builder.screen import BlueprintStudioScreen
+    from .screens.builder.step_editor import StepEditorModal
+
+    screen = BlueprintStudioScreen()
+    app.push_screen(screen)
+    await pilot.pause()
+    await pilot.pause()
+    modal = StepEditorModal("continuum")
+    app.push_screen(modal)
+    await pilot.pause()
+    modal.query_one("#step-action", Select).value = "fill"
+    await pilot.pause()
+
+
+# slug -> (terminal size, setup). Sizes are chosen per screen for a legible, well-framed capture.
+_SHOTS: list[tuple[str, tuple[int, int], Setup]] = [
+    ("home", (92, 32), _home),
+    ("library", (100, 26), _library),
+    ("runs", (100, 34), _runs),
+    ("catalog", (110, 26), _catalog),
+    ("recorder", (100, 30), _recorder),
+    ("settings", (100, 26), _settings),
+    ("studio", (104, 50), _studio),
+    ("studio-preview", (104, 40), _studio_preview),
+    ("studio-step-editor", (100, 40), _studio_step_editor),
+]
+
+
+def _normalize(svg: str, slug: str) -> str:
+    """Make the exported SVG deterministic and self-contained.
+
+    Rich uses a random ``terminal-<n>`` id per export (only source of run-to-run churn); we pin it to
+    the slug. The two web-font ``@font-face`` blocks reference an external CDN (blocked on GitHub
+    anyway) — dropping them leaves the ``monospace`` fallback and keeps the file self-contained.
+    """
+    svg = re.sub(r"terminal-\d+", f"terminal-{slug}", svg)
+    svg = re.sub(r"@font-face \{[^}]*\}", "", svg)
+    # Never bake the author's absolute checkout path (username, machine) into a committed doc asset;
+    # this also makes the output identical regardless of where the repo is cloned.
+    svg = svg.replace(str(_REPO), "/home/user/aetherius")
+    return svg
+
+
+async def _capture(slug: str, size: tuple[int, int], setup: Setup, out_dir: Path) -> Path:
+    app = AetheriusConsoleApp()
+    async with app.run_test(size=size) as pilot:
+        await pilot.pause()
+        await setup(app, pilot)
+        await pilot.pause()
+        svg = app.export_screenshot(title="Aetherius")
+    path = out_dir / f"{slug}.svg"
+    path.write_text(_normalize(svg, slug), encoding="utf-8")
+    return path
+
+
+async def capture_all(out_dir: Path) -> list[Path]:
+    """Render every Console screen to ``out_dir/<slug>.svg`` and return the written paths."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    return [await _capture(slug, size, setup, out_dir) for slug, size, setup in _SHOTS]
+
+
+def main() -> None:
+    out_dir = _REPO / "docs" / "screenshots"
+    paths = asyncio.run(capture_all(out_dir))
+    for path in paths:
+        print(f"wrote {path.relative_to(_REPO)}")
+
+
+if __name__ == "__main__":
+    main()

aetherius/console/theme.py

@@ -0,0 +1,114 @@
+"""Consistent visual theme for the Console (palette, wordmark and ornaments).
+
+Pure data and tiny ornament factories: a registered Textual Theme, the per-Act accent colors,
+and the decorative pixel ornaments (mosaic frieze, wordmark, cloud bank, starfield) shared by
+the screens. No widget logic here.
+
+Art direction: nocturnal aether — the temple at night. Dark void sky, moonlit clouds, imperial
+gold relics, tyrian violet for the veiled and the mystic, laurel green for triumph. Pixel-mosaic
+friezes and starfields as details. Echoes the Latin name of the tool.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.theme import Theme
+
+# Palette: single source for the Theme, the Act badges and every decorative detail.
+# Dominants requested by the user: pourpre, violet, dark green — readability kept by leaving
+# body text near-white and letting the purples carry structure (frames, friezes), not prose.
+VOID = "#141020"  # violet-tinted night background
+NIMBUS = "#1c1730"  # twilight surface
+PANEL = "#282045"  # raised panels
+MOONLIGHT = "#dcd7e8"  # violet-tinged moonlight, main text
+STONE = "#7f7a90"  # weathered stone, muted and pending things
+VIOLET = "#9d7bd8"  # twilight violet, primary structure
+TYRIAN = "#b0568c"  # tyrian pourpre, the imperial dye, mystic accents
+GOLD = "#d4af37"  # imperial gold, reserved for stars and the wordmark
+LAUREL = "#4e8a5a"  # dark laurel green, success and vines
+AMBER = "#d08a3e"  # torchlight, warnings
+POMPEIAN = "#c1564a"  # pompeian red, errors
+
+AETHERIUS_THEME = Theme(
+    name="aetherius",
+    primary=VIOLET,
+    secondary=TYRIAN,
+    accent=GOLD,
+    warning=AMBER,
+    error=POMPEIAN,
+    success=LAUREL,
+    foreground=MOONLIGHT,
+    background=VOID,
+    surface=NIMBUS,
+    panel=PANEL,
+    dark=True,
+)
+
+# Each Act's own accent colour. It is only shown once the Act is runnable; a pending Act stays
+# muted stone (see `act_color`), so a badge's colour always reflects real availability rather than
+# a hand-maintained list that drifts as Acts land.
+ACT_ACCENT: dict[str, str] = {
+    "vector": LAUREL,
+    "continuum": VIOLET,
+    "oracle": TYRIAN,
+    "phantom": AMBER,
+}
+
+
+def act_color(act: str, implemented: bool) -> str:
+    """Badge colour for *act*: its own accent when runnable, muted stone while pending."""
+    return ACT_ACCENT.get(act, STONE) if implemented else STONE
+
+
+ACT_LABELS: dict[str, str] = {
+    "vector": "I - Vector",
+    "continuum": "II - Continuum",
+    "oracle": "III - Oracle",
+    "phantom": "IV - Phantom",
+}
+
+# Ornaments. The wordmark spells AETHERIVS (Roman V), generated once with pyfiglet
+# (font "ansi_shadow", dev-time only — never a runtime dependency) and frozen here.
+# All rows are 69 columns, guarded by a test. Regenerate with:
+#   python -c "import pyfiglet; print(pyfiglet.figlet_format('AETHERIVS', font='ansi_shadow'))"
+WORDMARK: tuple[str, ...] = (
+    " █████╗ ███████╗████████╗██╗  ██╗███████╗██████╗ ██╗██╗   ██╗███████╗",
+    "██╔══██╗██╔════╝╚══██╔══╝██║  ██║██╔════╝██╔══██╗██║██║   ██║██╔════╝",
+    "███████║█████╗     ██║   ███████║█████╗  ██████╔╝██║██║   ██║███████╗",
+    "██╔══██║██╔══╝     ██║   ██╔══██║██╔══╝  ██╔══██╗██║╚██╗ ██╔╝╚════██║",
+    "██║  ██║███████╗   ██║   ██║  ██║███████╗██║  ██║██║ ╚████╔╝ ███████║",
+    "╚═╝  ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝",
+)
+MOTTO = "per nubes, ad aethera"
+STARFIELD = "˚ ✦ ·       ✦      · ˚       ✦ ·      ˚ ·     ✦    · ˚ ✦      · ✦ ˚"
+
+# The hedera (Latin for ivy) is the leaf ornament Romans carved into inscriptions as a
+# separator. It is the closest thing to a vine a character grid can honestly offer.
+HEDERA = "❦"
+HEDERA_ALT = "❧"
+
+
+def frieze(width: int = 69) -> str:
+    """Horizontal mosaic frieze strip, the Console's recurring pixel ornament."""
+    return ("▚▞" * ((width + 1) // 2))[:width]
+
+
+def frieze_column(height: int) -> str:
+    """Vertical mosaic frieze (one glyph per line), for flanking content like temple columns."""
+    return "\n".join("▚" if i % 2 == 0 else "▞" for i in range(height))
+
+
+def garland(width: int = 45) -> str:
+    """Ivy garland: hederae threaded on a vine line, the Console's vine ornament."""
+    inner = "─" * max((width - 5) // 2, 1)
+    return f"{HEDERA_ALT}{inner} {HEDERA} {inner}{HEDERA_ALT}"
+
+
+def starred(title: str) -> Text:
+    """Title flanked by small gold stars — the recurring ornament for screen titles."""
+    text = Text()
+    text.append("✦ ", style=GOLD)
+    text.append(title)
+    text.append(" ✦", style=GOLD)
+    return text

aetherius/console/widgets/__init__.py

@@ -0,0 +1 @@
+"""Reusable Console widgets."""

aetherius/console/widgets/event_log.py

@@ -0,0 +1,44 @@
+"""Live event and log stream widget."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.widgets import RichLog
+
+from ...core.events.models import EventType, RunEvent
+from ...core.events.sinks import format_event
+from ..theme import AMBER, POMPEIAN, STONE
+
+_LEVEL_STYLE: dict[str, str] = {
+    "debug": STONE,
+    "info": "",
+    "warning": AMBER,
+    "error": f"bold {POMPEIAN}",
+}
+
+
+class EventLog(RichLog):
+    """Scrolling, color-coded view of the RunEvents emitted by a Blueprint run."""
+
+    # Fixed height with internal scroll: the stream must never push the result summary
+    # (or anything else) out of the screen.
+    DEFAULT_CSS = """
+    EventLog {
+        height: 12;
+        border: double $primary;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(self, **kwargs: object) -> None:
+        super().__init__(markup=False, wrap=True, auto_scroll=True, **kwargs)  # type: ignore[arg-type]
+
+    def write_event(self, event: RunEvent) -> None:
+        level = event.level or ("debug" if event.type == EventType.DEBUG else "info")
+        if event.type == EventType.ERROR:
+            level = "error"
+        elif event.type == EventType.DONE and event.data.get("status") == "success":
+            level = "info"
+        style = _LEVEL_STYLE.get(level, "")
+        self.write(Text(format_event(event), style=style))

aetherius/console/widgets/form.py

@@ -0,0 +1,101 @@
+"""Generic form widget rendering fields from a Blueprint's inputs and secrets."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Input, Label, Switch
+
+from ...core.blueprint.models import InputSpec
+
+_INPUT_ID_PREFIX = "bp-input-"
+_SECRET_ID_PREFIX = "bp-secret-"
+
+
+class BlueprintInputForm(Vertical):
+    """Renders one field per declared Blueprint input and secret.
+
+    Boolean inputs get a Switch; everything else gets a text Input (secrets are masked).
+    ``collect()`` reads the current values back out; ``validation_errors()`` runs a client-side
+    pre-check for required fields before a run is allowed to start.
+    """
+
+    # height: auto everywhere: fields must keep their natural height and let the screen scroll,
+    # never get squeezed into overlapping fractions when the terminal is short.
+    DEFAULT_CSS = """
+    BlueprintInputForm {
+        height: auto;
+        padding: 1 1 0 1;
+    }
+    BlueprintInputForm .form-field {
+        height: auto;
+        padding-bottom: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        inputs: dict[str, InputSpec],
+        secrets: list[str],
+        available_secrets: set[str] | None = None,
+    ) -> None:
+        super().__init__()
+        self._inputs = inputs
+        self._secrets = secrets
+        # Secrets already resolvable from the environment (.env): shown optional, not required.
+        self._available_secrets = available_secrets or set()
+
+    def compose(self) -> ComposeResult:
+        for name, spec in self._inputs.items():
+            label = name + (" *" if spec.required else "")
+            if spec.description:
+                label += f" - {spec.description}"
+            with Vertical(classes="form-field"):
+                yield Label(label)
+                if spec.type == "boolean":
+                    yield Switch(value=bool(spec.default), id=_INPUT_ID_PREFIX + name)
+                else:
+                    default = "" if spec.default is None else str(spec.default)
+                    yield Input(
+                        value=default,
+                        placeholder=spec.type,
+                        id=_INPUT_ID_PREFIX + name,
+                    )
+        for name in self._secrets:
+            from_env = name in self._available_secrets
+            label = f"{name} (secret · loaded from .env)" if from_env else f"{name} (secret)"
+            placeholder = "leave blank to use .env value" if from_env else ""
+            with Vertical(classes="form-field"):
+                yield Label(label)
+                yield Input(password=True, placeholder=placeholder, id=_SECRET_ID_PREFIX + name)
+
+    def collect(self) -> tuple[dict[str, Any], dict[str, str]]:
+        """Read the current form values into (inputs, secrets) dicts."""
+        input_values: dict[str, Any] = {}
+        for name, spec in self._inputs.items():
+            widget_id = "#" + _INPUT_ID_PREFIX + name
+            if spec.type == "boolean":
+                input_values[name] = self.query_one(widget_id, Switch).value
+            else:
+                value = self.query_one(widget_id, Input).value
+                if value:
+                    input_values[name] = value
+
+        secret_values: dict[str, str] = {}
+        for name in self._secrets:
+            value = self.query_one("#" + _SECRET_ID_PREFIX + name, Input).value
+            if value:
+                secret_values[name] = value
+
+        return input_values, secret_values
+
+    def validation_errors(self) -> list[str]:
+        """Client-side pre-check; the engine's own input resolution remains authoritative."""
+        input_values, _ = self.collect()
+        errors = []
+        for name, spec in self._inputs.items():
+            if spec.required and name not in input_values:
+                errors.append(f"Missing required input '{name}'.")
+        return errors

aetherius/console/widgets/json_preview.py

@@ -0,0 +1,18 @@
+"""Syntax-highlighted, validated JSON preview widget."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.syntax import Syntax
+
+from textual.widgets import Static
+
+
+class JsonPreview(Static):
+    """Read-only, syntax-highlighted rendering of arbitrary JSON-serializable data."""
+
+    def show(self, data: Any) -> None:
+        text = json.dumps(data, indent=2, default=str, ensure_ascii=False)
+        self.update(Syntax(text, "json", theme="ansi_dark", word_wrap=True))

aetherius/console/widgets/run_summary.py

@@ -0,0 +1,82 @@
+"""Renders the final Result of a Blueprint run: status, per-step outcomes, and outputs."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import DataTable, Static
+
+from ...core.runtime.result import Result, RunStatus
+from ..theme import AMBER, LAUREL, POMPEIAN
+from .json_preview import JsonPreview
+
+_STATUS_STYLE: dict[RunStatus, str] = {
+    RunStatus.SUCCESS: f"bold {LAUREL}",
+    RunStatus.FAILED: f"bold {POMPEIAN}",
+    RunStatus.PARTIAL: f"bold {AMBER}",
+}
+
+
+class RunSummary(Vertical):
+    """Hidden until `show(result)` reveals it once a run completes; `reset()` hides it again."""
+
+    DEFAULT_CSS = """
+    RunSummary {
+        display: none;
+        height: auto;
+        border: double $success;
+        padding: 0 1 1 1;
+    }
+    RunSummary.-revealed {
+        display: block;
+    }
+    #run-summary-status {
+        height: auto;
+        padding: 1 0;
+    }
+    #run-summary-steps {
+        height: auto;
+        max-height: 12;
+    }
+    #run-summary-outputs {
+        height: auto;
+        margin-top: 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="run-summary-status")
+        yield DataTable(id="run-summary-steps", cursor_type="none")
+        yield JsonPreview(id="run-summary-outputs")
+
+    def on_mount(self) -> None:
+        self.query_one("#run-summary-steps", DataTable).add_columns(
+            "Step", "Action", "Status", "Duration"
+        )
+
+    def show(self, result: Result) -> None:
+        status_line = self.query_one("#run-summary-status", Static)
+        style = _STATUS_STYLE.get(result.status, "")
+        text = Text(f"{result.status.value} — {result.duration_ms:.1f} ms", style=style)
+        if result.error:
+            text.append(f"\n{result.error}", style=POMPEIAN)
+        status_line.update(text)
+
+        steps = self.query_one("#run-summary-steps", DataTable)
+        steps.clear()
+        for step in result.step_results:
+            steps.add_row(
+                step.step_id or "-",
+                step.action,
+                Text(step.status.value, style=_STATUS_STYLE.get(step.status, "")),
+                f"{step.duration_ms:.1f} ms",
+            )
+
+        self.query_one("#run-summary-outputs", JsonPreview).show(result.outputs)
+        self.add_class("-revealed")
+
+    def reset(self) -> None:
+        """Hide the previous result while a new run is in flight."""
+        self.remove_class("-revealed")

aetherius/core/__init__.py

@@ -0,0 +1 @@
+"""Engine-agnostic backbone: blueprint model, action dictionary, runtime, extraction, events."""

aetherius/core/actions/__init__.py

@@ -0,0 +1 @@
+"""The action dictionary: base types, registry and the concrete action groups shared across Acts."""