aetherius 0.2.0__py3-none-any.whl

aetherius/console/screens/builder/preview.py

@@ -0,0 +1,57 @@
+"""Live JSON preview with real-time schema validation.
+
+Renders the draft's assembled JSON and, below it, the issues from ``validate_draft`` — errors in
+pompeian red, warnings in amber, or a laurel "ready to save" when clean. Colours come from the
+theme; the widget owns no validation logic, it only displays what the builder reports.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from ....builder.factory import BlueprintDraft
+from ....builder.validation import validate_draft
+from ...theme import AMBER, LAUREL, POMPEIAN
+from ...widgets.json_preview import JsonPreview
+
+
+class BlueprintPreview(Vertical):
+    """Syntax-highlighted JSON plus a live list of validation issues."""
+
+    DEFAULT_CSS = """
+    BlueprintPreview {
+        height: auto;
+        border: double $primary;
+        padding: 0 1;
+    }
+    BlueprintPreview #preview-issues {
+        height: auto;
+        padding: 1 0 0 0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield JsonPreview(id="preview-json")
+        yield Static(id="preview-issues")
+
+    def refresh_from(self, draft: BlueprintDraft) -> None:
+        """Re-render the JSON and the issue list from *draft*."""
+        self.query_one("#preview-json", JsonPreview).show(draft.to_data())
+        self.query_one("#preview-issues", Static).update(self._issue_text(draft))
+
+    def _issue_text(self, draft: BlueprintDraft) -> Text:
+        issues = validate_draft(draft)
+        if not issues:
+            return Text("Valid — ready to save.", style=f"bold {LAUREL}")
+        errors = [i for i in issues if i.severity == "error"]
+        warnings = [i for i in issues if i.severity == "warning"]
+        text = Text()
+        for issue in errors:
+            text.append(f"✗ {issue.path}: {issue.message}\n", style=POMPEIAN)
+        for issue in warnings:
+            text.append(f"! {issue.path}: {issue.message}\n", style=AMBER)
+        return text

aetherius/console/screens/builder/screen.py

@@ -0,0 +1,235 @@
+"""Blueprint Studio orchestrator screen.
+
+Guided creation and editing of a Blueprint without hand-writing JSON: pick an Act, declare inputs
+and secrets, assemble steps through forms, set the durable options, and watch a live JSON preview
+validated against the schema. The screen owns the single :class:`BlueprintDraft`; its child editors
+report changes, it re-reads them into the draft and refreshes the preview. Everything is local and
+fast, so no worker is needed. Opened with a *path* it edits that file in place; otherwise it creates
+a new one under ``./blueprints``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Button, Footer, Header, Input, Label, Select, Static
+
+from ....builder.factory import BlueprintDraft, StepDraft, save_blueprint
+from ....builder.templates import list_templates, template_draft
+from ....core.blueprint.loader import load_blueprint
+from ....core.errors import AetheriusError
+from ...theme import starred
+from .act_picker import ActPicker
+from .io_editor import InputsEditor, VarsOutputsEditor
+from .options_editor import OptionsEditor
+from .preview import BlueprintPreview
+from .step_editor import StepEditorModal, StepList
+
+
+class BlueprintStudioScreen(Screen[None]):
+    """Assemble or edit a Blueprint through forms, with a live validated JSON preview."""
+
+    AUTO_FOCUS = "#studio-name"
+
+    DEFAULT_CSS = """
+    BlueprintStudioScreen #studio-save {
+        border: double $accent;
+        background: $panel;
+        color: $accent;
+        text-style: bold;
+        padding: 0 3;
+        margin: 1 0;
+    }
+    BlueprintStudioScreen #studio-save:hover { background: $accent 20%; }
+    BlueprintStudioScreen .studio-field { height: auto; padding: 1 1 0 1; }
+    BlueprintStudioScreen #studio-template-row { height: auto; padding: 1 1 0 1; }
+    """
+
+    def __init__(self, path: Path | str | None = None) -> None:
+        super().__init__()
+        self._edit_path: Path | None = Path(path) if path is not None else None
+        self._draft = self._initial_draft()
+
+    def _initial_draft(self) -> BlueprintDraft:
+        if self._edit_path is None:
+            return BlueprintDraft()
+        # Prefer the canonical loader; fall back to a raw read so a well-formed-but-act-pending file
+        # still opens for editing. A truly unparseable file is caught by Library before we get here.
+        try:
+            return BlueprintDraft.from_data(load_blueprint(self._edit_path).model_dump())
+        except AetheriusError:
+            data = json.loads(Path(self._edit_path).read_text(encoding="utf-8"))
+            return BlueprintDraft.from_data(data)
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with VerticalScroll(classes="console-body"):
+            title = "Blueprint Studio" + (" — editing" if self._edit_path else "")
+            yield Static(starred(title), classes="console-title")
+            yield Static(
+                "Pick an Act, declare inputs, assemble steps, set options. The JSON preview is "
+                "validated live; Save writes it to ./blueprints (or overwrites the edited file).",
+                classes="console-subtitle",
+            )
+            if self._edit_path is None:
+                with Horizontal(id="studio-template-row"):
+                    yield Select(
+                        [(t.title + f" ({t.act})", t.key) for t in list_templates()],
+                        prompt="Start from a template…",
+                        id="studio-template",
+                    )
+                    yield Button("Load template", id="studio-load-template")
+            with Vertical(classes="studio-field"):
+                yield Label("Name (e.g. domain.task)")
+                yield Input(value=self._draft.name, placeholder="domain.task", id="studio-name")
+                yield Label("Description (optional)")
+                yield Input(value=self._draft.description or "", id="studio-description")
+            yield ActPicker(self._draft.act)
+            yield InputsEditor()
+            steps = StepList()
+            steps.border_title = "✦ Steps ✦"
+            yield steps
+            yield OptionsEditor()
+            yield VarsOutputsEditor()
+            preview = BlueprintPreview()
+            preview.border_title = "✦ Live preview ✦"
+            yield preview
+            yield Button("✦ Save Blueprint ✦", id="studio-save", variant="primary")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.query_one(InputsEditor).load(self._draft.inputs, self._draft.secrets)
+        self.query_one(OptionsEditor).load(self._draft.options)
+        self.query_one(VarsOutputsEditor).load(self._draft.vars, self._draft.outputs)
+        self._render_steps()
+        # Render straight from the draft: the editors were just loaded from it, and their freshly
+        # mounted children are not queryable yet, so a sync-back would momentarily read them empty.
+        self.query_one(BlueprintPreview).refresh_from(self._draft)
+
+    # ── Draft synchronisation ───────────────────────────────────────────────
+
+    def _sync_from_editors(self) -> None:
+        """Read every editor back into the draft (steps are mutated in place elsewhere)."""
+        self._draft.name = self.query_one("#studio-name", Input).value.strip()
+        description = self.query_one("#studio-description", Input).value.strip()
+        self._draft.description = description or None
+        self._draft.inputs, self._draft.secrets = self.query_one(InputsEditor).collect()
+        self._draft.options = self.query_one(OptionsEditor).collect()
+        self._draft.vars, self._draft.outputs = self.query_one(VarsOutputsEditor).collect()
+
+    def _refresh_preview(self) -> None:
+        self._sync_from_editors()
+        self.query_one(BlueprintPreview).refresh_from(self._draft)
+
+    def _render_steps(self) -> None:
+        self.query_one(StepList).refresh_from(self._draft.steps)
+
+    # ── Events ────────────────────────────────────────────────────────────────
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        self._refresh_preview()
+
+    def on_switch_changed(self, event: object) -> None:
+        self._refresh_preview()
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.id == "studio-template":
+            return  # loaded explicitly via the button, not on selection
+        self._refresh_preview()
+
+    def on_text_area_changed(self, event: object) -> None:
+        self._refresh_preview()
+
+    def on_act_picker_act_changed(self, event: ActPicker.ActChanged) -> None:
+        self._draft.act = event.act
+        self._render_steps()
+        self._refresh_preview()
+
+    def on_inputs_editor_changed(self, event: InputsEditor.Changed) -> None:
+        self._refresh_preview()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        button = event.button.id
+        if button == "studio-load-template":
+            self._load_template()
+        elif button == "studio-step-add":
+            self.app.push_screen(StepEditorModal(self._draft.act), self._on_step_added)
+        elif button == "studio-step-edit":
+            self._edit_selected_step()
+        elif button == "studio-step-remove":
+            self._remove_selected_step()
+        elif button == "studio-step-up":
+            self._move_selected_step(-1)
+        elif button == "studio-step-down":
+            self._move_selected_step(1)
+        elif button == "studio-save":
+            self._save()
+
+    # ── Steps ───────────────────────────────────────────────────────────────
+
+    def _on_step_added(self, step: StepDraft | None) -> None:
+        if step is not None:
+            self._draft.steps.append(step)
+            self._render_steps()
+            self._refresh_preview()
+
+    def _edit_selected_step(self) -> None:
+        index = self.query_one(StepList).selected_index
+        if index is None:
+            return
+
+        def _apply(step: StepDraft | None) -> None:
+            if step is not None:
+                self._draft.steps[index] = step
+                self._render_steps()
+                self._refresh_preview()
+
+        self.app.push_screen(StepEditorModal(self._draft.act, self._draft.steps[index]), _apply)
+
+    def _remove_selected_step(self) -> None:
+        index = self.query_one(StepList).selected_index
+        if index is not None:
+            self._draft.remove_step(index)
+            self._render_steps()
+            self._refresh_preview()
+
+    def _move_selected_step(self, delta: int) -> None:
+        index = self.query_one(StepList).selected_index
+        if index is not None:
+            self._draft.move_step(index, delta)
+            self._render_steps()
+            self._refresh_preview()
+
+    # ── Template & save ─────────────────────────────────────────────────────
+
+    def _load_template(self) -> None:
+        select = self.query_one("#studio-template", Select)
+        if select.value is Select.BLANK:
+            return
+        self._draft = template_draft(str(select.value))
+        self.query_one("#studio-name", Input).value = self._draft.name
+        self.query_one("#studio-description", Input).value = self._draft.description or ""
+        self.query_one(ActPicker).query_one("#act-select", Select).value = self._draft.act
+        self.query_one(InputsEditor).load(self._draft.inputs, self._draft.secrets)
+        self.query_one(OptionsEditor).load(self._draft.options)
+        self.query_one(VarsOutputsEditor).load(self._draft.vars, self._draft.outputs)
+        self._render_steps()
+        self._refresh_preview()
+        self.app.notify(f"Loaded template {select.value}.")
+
+    def _save(self) -> None:
+        self._sync_from_editors()
+        if self.query_one(VarsOutputsEditor).has_errors:
+            self.app.notify("Fix the invalid JSON in vars/outputs first.", severity="warning")
+            return
+        try:
+            path = save_blueprint(self._draft, path=self._edit_path)
+        except AetheriusError as exc:
+            self.app.notify(str(exc), title="Cannot save", severity="error", timeout=8)
+            return
+        self._edit_path = path  # subsequent saves overwrite the same file
+        self.app.notify(f"Saved {path}", timeout=6)

aetherius/console/screens/builder/step_editor.py

@@ -0,0 +1,249 @@
+"""Add and edit steps through forms driven by the builder catalog.
+
+``StepEditorModal`` renders one form field per parameter of the chosen action (a JSON text area for
+object/array parameters), plus a "raw JSON" escape hatch so any parameter combination — including
+actions the forms do not fully model — stays reachable. ``StepList`` is the read-only table of steps
+with its add/edit/remove/reorder controls; it owns no state, the Studio screen does.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, DataTable, Input, Label, Select, Static, Switch, TextArea
+
+from ....builder.catalog import actions_for_act
+from ....builder.factory import StepDraft
+from ....core.actions.registry import get_spec
+from ....core.actions.spec import ParamSpec
+
+_JSON_KINDS = ("object", "array")
+
+
+def _params_summary(params: dict[str, Any]) -> str:
+    """A short, one-line digest of a step's parameters for the table."""
+    parts = []
+    for key, value in list(params.items())[:3]:
+        text = json.dumps(value) if isinstance(value, (dict, list)) else str(value)
+        parts.append(f"{key}={text[:24]}")
+    return ", ".join(parts)
+
+
+class StepEditorModal(ModalScreen[StepDraft | None]):
+    """Edit one step: pick an action, fill its parameters, dismiss with the resulting StepDraft."""
+
+    DEFAULT_CSS = """
+    StepEditorModal { align: center middle; }
+    StepEditorModal #step-dialog {
+        width: 80%;
+        max-width: 90;
+        height: auto;
+        max-height: 90%;
+        border: double $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    StepEditorModal .step-field { height: auto; padding: 0 0 1 0; }
+    StepEditorModal TextArea { height: 5; }
+    StepEditorModal #step-raw { height: 8; }
+    StepEditorModal .step-actions { height: auto; padding: 1 0 0 0; }
+    """
+
+    def __init__(self, act: str, step: StepDraft | None = None) -> None:
+        super().__init__()
+        self._act = act
+        self._editing = step
+        self._action = step.action if step and step.action else self._default_action()
+
+    def _default_action(self) -> str:
+        actions = actions_for_act(self._act)
+        return actions[0].spec.name if actions else ""
+
+    def compose(self) -> ComposeResult:
+        options = [
+            (info.spec.name + ("" if info.runnable else " (not runnable yet)"), info.spec.name)
+            for info in actions_for_act(self._act)
+        ]
+        with VerticalScroll(id="step-dialog"):
+            yield Static("Edit step", classes="console-title")
+            with Vertical(classes="step-field"):
+                yield Label("Action")
+                yield Select(options, value=self._action, allow_blank=False, id="step-action")
+            with Vertical(classes="step-field"):
+                yield Label("Step id (optional)")
+                yield Input(
+                    value=(self._editing.id or "") if self._editing else "",
+                    placeholder="e.g. login",
+                    id="step-id",
+                )
+            with Horizontal(classes="step-field"):
+                yield Switch(value=False, id="step-raw-toggle")
+                yield Label("Edit raw JSON params")
+            yield Vertical(id="step-params")
+            yield TextArea(id="step-raw")
+            with Horizontal(classes="step-actions"):
+                yield Button("Save", id="step-ok", variant="primary")
+                yield Button("Cancel", id="step-cancel")
+
+    def on_mount(self) -> None:
+        self.query_one("#step-raw", TextArea).display = False
+        self._render_params(self._action)
+
+    # ── Parameter form ────────────────────────────────────────────────────────
+
+    def _render_params(self, action: str) -> None:
+        container = self.query_one("#step-params", Vertical)
+        container.remove_children()
+        try:
+            spec = get_spec(action)
+        except Exception:
+            return
+        existing = self._editing.params if self._editing and self._editing.action == action else {}
+        for param in spec.params:
+            container.mount(self._field(param, existing.get(param.name)))
+
+    def _field(self, param: ParamSpec, value: Any) -> Vertical:
+        wid = f"param-{param.name}"
+        label = (
+            param.name
+            + (" *" if param.required else "")
+            + (f" — {param.help}" if param.help else "")
+        )
+        editor: Switch | TextArea | Input
+        if param.kind == "boolean":
+            editor = Switch(value=bool(value), id=wid)
+        elif param.kind in _JSON_KINDS:
+            text = json.dumps(value, indent=2) if value not in (None, "", {}, []) else ""
+            editor = TextArea(text=text, id=wid)
+        else:
+            shown = "" if value in (None, "") else str(value)
+            editor = Input(value=shown, placeholder=param.placeholder or param.kind, id=wid)
+        return Vertical(Label(label), editor, classes="step-field")
+
+    # ── Events ──────────────────────────────────────────────────────────────
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.id == "step-action":
+            event.stop()
+            self._action = str(event.value)
+            self._render_params(self._action)
+
+    def on_switch_changed(self, event: Switch.Changed) -> None:
+        if event.switch.id != "step-raw-toggle":
+            return
+        event.stop()
+        raw = self.query_one("#step-raw", TextArea)
+        params_box = self.query_one("#step-params", Vertical)
+        if event.value:
+            raw.text = json.dumps(self._collect_fields() or {}, indent=2)
+            raw.display = True
+            params_box.display = False
+        else:
+            raw.display = False
+            params_box.display = True
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "step-cancel":
+            self.dismiss(None)
+        elif event.button.id == "step-ok":
+            self._save()
+
+    # ── Collection ────────────────────────────────────────────────────────────
+
+    def _collect_fields(self) -> dict[str, Any] | None:
+        """Read the per-parameter widgets; None if a JSON field does not parse."""
+        try:
+            spec = get_spec(self._action)
+        except Exception:
+            return {}
+        params: dict[str, Any] = {}
+        for param in spec.params:
+            widget = self.query_one(f"#param-{param.name}")
+            if param.kind == "boolean":
+                if isinstance(widget, Switch) and widget.value:
+                    params[param.name] = True
+            elif param.kind in _JSON_KINDS:
+                text = widget.text.strip() if isinstance(widget, TextArea) else ""
+                if text:
+                    try:
+                        params[param.name] = json.loads(text)
+                    except ValueError:
+                        self.app.notify(f"Invalid JSON in '{param.name}'.", severity="error")
+                        return None
+            else:
+                value = widget.value.strip() if isinstance(widget, Input) else ""
+                if value:
+                    params[param.name] = self._coerce(param, value)
+        return params
+
+    @staticmethod
+    def _coerce(param: ParamSpec, value: str) -> Any:
+        if param.kind in ("number", "integer"):
+            try:
+                return int(value) if param.kind == "integer" else float(value)
+            except ValueError:
+                return value  # leave it; the preview's schema check will flag it
+        return value
+
+    def _save(self) -> None:
+        if self.query_one("#step-raw-toggle", Switch).value:
+            text = self.query_one("#step-raw", TextArea).text.strip()
+            try:
+                params = json.loads(text) if text else {}
+            except ValueError:
+                self.app.notify("Invalid raw JSON.", severity="error")
+                return
+            if not isinstance(params, dict):
+                self.app.notify("Raw params must be a JSON object.", severity="error")
+                return
+        else:
+            collected = self._collect_fields()
+            if collected is None:
+                return
+            params = collected
+        step_id = self.query_one("#step-id", Input).value.strip() or None
+        self.dismiss(StepDraft(action=self._action, id=step_id, params=params))
+
+
+class StepList(Vertical):
+    """The steps table with add / edit / remove / reorder controls (a pure view of the draft)."""
+
+    DEFAULT_CSS = """
+    StepList {
+        height: auto;
+        border: round $primary;
+        padding: 0 1 1 1;
+        margin: 1 1 0 1;
+    }
+    StepList DataTable { height: auto; max-height: 16; }
+    StepList .step-list-actions { height: auto; padding: 1 0 0 0; }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield DataTable(id="studio-steps", cursor_type="row")
+        with Horizontal(classes="step-list-actions"):
+            yield Button("+ Add", id="studio-step-add")
+            yield Button("Edit", id="studio-step-edit")
+            yield Button("Remove", id="studio-step-remove")
+            yield Button("↑", id="studio-step-up")
+            yield Button("↓", id="studio-step-down")
+
+    def on_mount(self) -> None:
+        self.query_one("#studio-steps", DataTable).add_columns("#", "Action", "Id", "Parameters")
+
+    def refresh_from(self, steps: list[StepDraft]) -> None:
+        table = self.query_one("#studio-steps", DataTable)
+        table.clear()
+        for index, step in enumerate(steps):
+            table.add_row(str(index + 1), step.action, step.id or "", _params_summary(step.params))
+
+    @property
+    def selected_index(self) -> int | None:
+        table = self.query_one("#studio-steps", DataTable)
+        if table.row_count == 0:
+            return None
+        return table.cursor_row

aetherius/console/screens/catalog.py

@@ -0,0 +1,52 @@
+"""Explore and explain the four Acts and their action capabilities."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Header, Static
+
+from ..theme import ACT_LABELS, LAUREL, STONE, act_color, starred
+from ...builder.catalog import act_infos, actions_for_act
+
+
+class CatalogScreen(Screen[None]):
+    """Read-only reference: the 4 Acts, their status, and their supported actions.
+
+    A pure projection of the shared builder catalogue (``builder/catalog.py``), so the Act
+    descriptions and the runnable/pending status never drift from what the Studio offers.
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical(classes="console-body"):
+            yield Static(starred("Act Catalog"), classes="console-title")
+            yield Static(
+                "Each Blueprint declares one Act; a step using an unsupported action fails "
+                "validation before it ever runs.",
+                classes="console-subtitle",
+            )
+            yield DataTable(id="catalog-table", cursor_type="row")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#catalog-table", DataTable)
+        table.add_columns("Act", "Status", "Description", "Actions")
+        for info in act_infos():
+            color = act_color(info.act, info.implemented)
+            status = (
+                Text("implemented", style=f"bold {LAUREL}")
+                if info.implemented
+                else Text("not runnable yet", style=STONE)
+            )
+            # A dagger marks actions declared but not yet dispatched by the Act's driver.
+            names = [a.spec.name + ("" if a.runnable else " †") for a in actions_for_act(info.act)]
+            table.add_row(
+                Text(ACT_LABELS[info.act], style=color),
+                status,
+                info.summary,
+                ", ".join(names),
+            )

aetherius/console/screens/home.py

@@ -0,0 +1,90 @@
+"""Home dashboard and main menu."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.app import ComposeResult
+from textual.containers import VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Footer, Header, OptionList, Static
+from textual.widgets.option_list import Option
+
+from ...core.runtime.engine import IMPLEMENTED_ACTS
+from ...version import __version__
+from ..theme import GOLD, LAUREL, MOTTO, STARFIELD, TYRIAN, VIOLET, WORDMARK, frieze, garland
+
+# A gold star marks the sections that are usable today; a dot marks the pending ones.
+_MENU: list[tuple[str, str]] = [
+    ("library", "✦ Library — browse Blueprints and run one"),
+    ("catalog", "✦ Catalog — the 4 Acts and their capabilities"),
+    ("recorder", "✦ Recorder — capture a Blueprint by demonstration"),
+    ("builder", "✦ Blueprint Studio — create and edit Blueprints, guided"),
+    ("sessions", "· Sessions — profiles and warmup (coming soon)"),
+    ("settings", "✦ Settings — start/stop the daemon and see its config"),
+]
+
+
+def _banner() -> Text:
+    text = Text(justify="center")
+    text.append(frieze() + "\n", style=VIOLET)
+    text.append(STARFIELD + "\n", style=GOLD)
+    for row in WORDMARK:
+        text.append(row + "\n", style=f"bold {GOLD}")
+    text.append(garland() + "\n", style=LAUREL)
+    text.append("✦  ", style=GOLD)
+    text.append(MOTTO, style=f"italic {TYRIAN}")
+    text.append("  ✦\n", style=GOLD)
+    text.append(frieze(), style=VIOLET)
+    return text
+
+
+class HomeScreen(Screen[None]):
+    """Landing screen: wordmark, Act availability, and the section menu."""
+
+    # The menu must own the focus so arrow keys and Enter work immediately,
+    # instead of the scroll container grabbing it.
+    AUTO_FOCUS = "#home-menu"
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with VerticalScroll(classes="console-body"):
+            yield Static(_banner(), id="home-banner")
+            yield Static(
+                f"v{__version__} · implemented acts: {', '.join(sorted(IMPLEMENTED_ACTS))} "
+                "(the rest are visible in Catalog, not runnable yet)",
+                id="home-status",
+                classes="console-subtitle",
+            )
+            yield OptionList(
+                *(Option(label, id=key) for key, label in _MENU),
+                id="home-menu",
+            )
+        yield Footer()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        key = event.option.id
+        if key == "library":
+            from .library import LibraryScreen
+
+            self.app.push_screen(LibraryScreen())
+        elif key == "catalog":
+            from .catalog import CatalogScreen
+
+            self.app.push_screen(CatalogScreen())
+        elif key == "sessions":
+            from .sessions import SessionsScreen
+
+            self.app.push_screen(SessionsScreen())
+        elif key == "settings":
+            from .settings import SettingsScreen
+
+            self.app.push_screen(SettingsScreen())
+        elif key == "recorder":
+            from .recorder import RecorderScreen
+
+            self.app.push_screen(RecorderScreen())
+        elif key == "builder":
+            from .builder.screen import BlueprintStudioScreen
+
+            self.app.push_screen(BlueprintStudioScreen())