rockycode 0.1.0__py3-none-any.whl

rockycode/tui/plangate.py

@@ -0,0 +1,110 @@
+"""The plan-approval gate — inline, at the bottom of the chat.
+
+Mounted (not a modal) when a plan-mode turn ends having CHANGED the plan file —
+the file write IS the handoff signal (no update_plan tool, no tagged-text
+parsing; see docs/plan-mode-design.md). Resolves the passed-in Future with
+"approve" | "discuss" | "exit" | "dismiss", then the caller removes it.
+
+Inline (like InlineApproval) so the transcript stays visible and scrollable
+while you weigh the plan. Verbs follow the goal-mode gate you already know:
+y = approve & build, e = discuss/edit, n = leave plan mode; Esc keeps planning.
+"""
+from __future__ import annotations
+
+import asyncio
+
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from rockycode.palette import LAVENDER, MUTED, VIOLET
+
+_PREVIEW_LINES = 14
+
+
+class InlinePlanGate(Vertical):
+    """Approve a drafted plan. Resolves `future` with the choice; choices are
+    plain Static rows (not an OptionList — it swallows pgup/pgdn, and the
+    transcript-scroll keys must keep working while this holds focus)."""
+
+    can_focus = True
+
+    BINDINGS = [
+        ("up", "move(-1)", "up"),
+        ("down", "move(1)", "down"),
+        ("enter", "confirm", "select"),
+        ("y", "pick('approve')", "approve"),
+        ("g", "pick('goal')", "run as goal"),
+        ("e", "pick('discuss')", "discuss"),
+        ("n", "pick('exit')", "leave"),
+        ("escape", "pick('dismiss')", "keep planning"),
+    ]
+
+    DEFAULT_CSS = """
+    InlinePlanGate {
+        height: auto;
+        margin: 0 1 1 1;
+        padding: 1 2;
+        background: $surface;
+        border: round $primary;
+        border-title-color: $text-muted;
+        border-subtitle-color: $text-muted;
+    }
+    InlinePlanGate #plan-preview { margin: 1 0; color: $text-muted; }
+    InlinePlanGate .plan-opt { height: 1; }
+    InlinePlanGate #plan-keys { color: $text-muted; margin-top: 1; }
+    """
+
+    _CHOICES = (
+        ("approve", "▶  Approve & build here"),
+        ("goal", "◆  Run as goal (sandbox, autonomous)"),
+        ("discuss", "✎  Discuss / edit the plan"),
+        ("exit", "✗  Leave plan mode (keep the file)"),
+    )
+
+    def __init__(self, rel_path: str, plan_text: str, future: "asyncio.Future[str]") -> None:
+        super().__init__()
+        self._rel = rel_path
+        self._plan = plan_text
+        self._future = future
+        self._idx = 0
+
+    def compose(self):
+        lines = self._plan.splitlines()
+        preview = "\n".join(lines[:_PREVIEW_LINES])
+        if len(lines) > _PREVIEW_LINES:
+            preview += f"\n… (+{len(lines) - _PREVIEW_LINES} more lines in the file)"
+        # markup=False: the plan text is shown literally, never parsed.
+        yield Static(preview or "(empty plan)", id="plan-preview", markup=False)
+        for i in range(len(self._CHOICES)):
+            yield Static("", id=f"plan-opt-{i}", classes="plan-opt")
+        yield Static(
+            f"[{LAVENDER}]↑↓[/] choose   [{LAVENDER}]↵[/] select   "
+            f"[{LAVENDER}]y[/] build   [{LAVENDER}]g[/] goal   [{LAVENDER}]e[/] discuss   "
+            f"[{LAVENDER}]n[/] leave   [{LAVENDER}]esc[/] keep planning   [dim]· pgup/pgdn scroll[/]",
+            id="plan-keys",
+        )
+
+    def on_mount(self) -> None:
+        self.border_title = f"📋 review the plan · {self._rel}"
+        self.border_subtitle = "read-only until you approve"
+        self._render_choices()
+        self.focus()
+
+    def _render_choices(self) -> None:
+        for i, (_v, label) in enumerate(self._CHOICES):
+            row = self.query_one(f"#plan-opt-{i}", Static)
+            row.update(f"[b {VIOLET}]▸ {label}[/]" if i == self._idx else f"[{MUTED}]  {label}[/]")
+
+    def action_move(self, delta: int) -> None:
+        self._idx = (self._idx + delta) % len(self._CHOICES)
+        self._render_choices()
+
+    def action_confirm(self) -> None:
+        self._resolve(self._CHOICES[self._idx][0])
+
+    def action_pick(self, choice: str) -> None:
+        self._resolve(choice)
+
+    def _resolve(self, value: str) -> None:
+        if not self._future.done():
+            self._future.set_result(value)

rockycode/tui/prompt_history.py

@@ -0,0 +1,77 @@
+"""Persistent prompt history for the chat input — the up-arrow list survives
+restarts (ported from a research branch, persistence only: draft
+handling and the visual-row navigation stay in ChatInput, which already does
+them better).
+
+ONE global file, like shell history — renaming or moving a project never loses
+it, and prompts can't end up committed inside a repo's tree. Honors
+$ROCKYCODE_HOME, same convention as session.py / trajectory.py.
+
+Storage is append-only JSONL ({"input": ...} per line, the research branch's
+format), adjacent-deduped, capped at LIMIT by a full rewrite once over. All IO
+is best-effort: a broken disk or a torn line must never break typing.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+def default_path() -> Path:
+    home = Path(os.environ.get("ROCKYCODE_HOME") or Path.home() / ".rockycode")
+    return home / "prompt-history.jsonl"
+
+
+class PromptHistory:
+    """Load-on-start, append-on-submit. `items` is oldest-first, ready to seed
+    ChatInput._history directly."""
+
+    LIMIT = 200
+
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or default_path()
+        self.items: list[str] = []
+        self._load()
+
+    def _load(self) -> None:
+        try:
+            lines = self.path.read_text().splitlines()
+        except OSError:
+            return
+        items: list[str] = []
+        for line in lines:
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError:
+                continue  # torn write / hand edit — skip the line, keep the rest
+            text = value.get("input") if isinstance(value, dict) else value
+            if isinstance(text, str) and text.strip():
+                if not items or items[-1] != text:
+                    items.append(text)
+        self.items = items[-self.LIMIT:]
+
+    def _rewrite(self) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(
+                "".join(json.dumps({"input": item}, ensure_ascii=False) + "\n"
+                        for item in self.items))
+        except OSError:
+            pass
+
+    def append(self, text: str) -> None:
+        text = text.strip()
+        if not text or (self.items and self.items[-1] == text):
+            return
+        self.items.append(text)
+        if len(self.items) > self.LIMIT:
+            self.items = self.items[-self.LIMIT:]
+            self._rewrite()
+            return
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            with self.path.open("a") as f:
+                f.write(json.dumps({"input": text}, ensure_ascii=False) + "\n")
+        except OSError:
+            pass

rockycode/tui/proposalcard.py

@@ -0,0 +1,126 @@
+"""The proposal review card — one dream-drafted skill, approve or archive.
+
+Mounted inline above the input by /proposals (one card per pending proposal,
+walked in order). Resolves the passed-in Future with "install" | "archive" |
+"later". Nothing self-installs: this card IS the trust boundary the
+self-evolve design locked — dream drafts, the human decides.
+
+Rows are clickable (house rule) with paired key accelerators: ↑↓ + Enter,
+y = install, n = archive, Esc = later (keeps the proposal pending).
+"""
+from __future__ import annotations
+
+import asyncio
+
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from rockycode.palette import LAVENDER, MUTED, VIOLET
+
+_PREVIEW_LINES = 14
+
+
+class _ChoiceRow(Static):
+    def __init__(self, value: str, idx: int, card: "ProposalCard") -> None:
+        super().__init__("", id=f"prop-opt-{idx}", classes="prop-opt")
+        self._value = value
+        self._card = card
+
+    def on_click(self) -> None:
+        self._card.pick(self._value)
+
+
+class ProposalCard(Vertical):
+    """Review one proposal. Resolves `future` with the choice."""
+
+    can_focus = True
+
+    BINDINGS = [
+        ("up", "move(-1)", "up"),
+        ("down", "move(1)", "down"),
+        ("enter", "confirm", "select"),
+        ("y", "pick('install')", "install"),
+        ("n", "pick('archive')", "archive"),
+        ("escape", "pick('later')", "later"),
+    ]
+
+    DEFAULT_CSS = """
+    ProposalCard {
+        height: auto;
+        margin: 0 1 1 1;
+        padding: 1 2;
+        background: $surface;
+        border: round $primary;
+        border-title-color: $text-muted;
+        border-subtitle-color: $text-muted;
+    }
+    ProposalCard #prop-why { color: $text-muted; }
+    ProposalCard #prop-preview { margin: 1 0; color: $text-muted; }
+    ProposalCard .prop-opt { height: 1; }
+    ProposalCard #prop-keys { color: $text-muted; margin-top: 1; }
+    """
+
+    def __init__(self, proposal, future: "asyncio.Future[str]") -> None:
+        super().__init__()
+        self._p = proposal
+        self._future = future
+        self._idx = 0
+        # kind-aware install label: a routine installs to /routines (click-to-run
+        # until you grant its lease), a skill to /skills.
+        if getattr(proposal, "kind", "skill") == "routine":
+            install = "✓  Install routine (global — /routines, click-to-run until you grant its lease)"
+        else:
+            install = "✓  Install skill (global — /skills next session)"
+        self._CHOICES = (
+            ("install", install),
+            ("archive", "✗  Archive (kept for reference, never asked again)"),
+            ("later", "·  Later (stays in the inbox)"),
+        )
+
+    def compose(self):
+        p = self._p
+        ev = ", ".join(p.evidence[:4]) + ("…" if len(p.evidence) > 4 else "")
+        yield Static(
+            f"[{MUTED}]why: {p.reason or '(recurring pattern)'} · from {ev or 'past sessions'}[/]",
+            id="prop-why",
+        )
+        lines = p.body.splitlines()
+        preview = "\n".join(lines[:_PREVIEW_LINES])
+        if len(lines) > _PREVIEW_LINES:
+            preview += f"\n… (+{len(lines) - _PREVIEW_LINES} more lines)"
+        # markup=False: the drafted body is shown literally, never parsed.
+        yield Static(preview or "(empty draft)", id="prop-preview", markup=False)
+        for i, (value, _label) in enumerate(self._CHOICES):
+            yield _ChoiceRow(value, i, self)
+        yield Static(
+            f"[{LAVENDER}]↑↓[/] choose · [{LAVENDER}]↵[/] select · "
+            f"[{LAVENDER}]y[/] install · [{LAVENDER}]n[/] archive · "
+            f"[{LAVENDER}]esc[/] later · or just click a row",
+            id="prop-keys",
+        )
+
+    def on_mount(self) -> None:
+        self.border_title = f"🌙 dream proposal · {self._p.name}"
+        self.border_subtitle = "drafted while dreaming — nothing installs without you"
+        self._render_choices()
+        self.focus()
+
+    def _render_choices(self) -> None:
+        for i, (_v, label) in enumerate(self._CHOICES):
+            row = self.query_one(f"#prop-opt-{i}", Static)
+            row.update(f"[b {VIOLET}]▸ {label}[/]" if i == self._idx else f"[{MUTED}]  {label}[/]")
+
+    def action_move(self, delta: int) -> None:
+        self._idx = (self._idx + delta) % len(self._CHOICES)
+        self._render_choices()
+
+    def action_confirm(self) -> None:
+        self.pick(self._CHOICES[self._idx][0])
+
+    def action_pick(self, choice: str) -> None:
+        self.pick(choice)
+
+    def pick(self, value: str) -> None:
+        """Idempotent — a stray second click/key must not crash the Future."""
+        if not self._future.done():
+            self._future.set_result(value)

rockycode/tui/resume.py

@@ -0,0 +1,142 @@
+"""The resume picker: a modal list of past sessions, newest on top.
+
+Default scope is the current folder; Ctrl+A flips to all folders (the global
+registry). Type to search; ↑↓ move; Enter resumes; Esc cancels. The search
+box stays focused so you can filter immediately — arrows/enter are handled at
+the screen level so they work without leaving the input.
+"""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Optional
+
+from textual import on
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+from rich.markup import escape
+
+from rockycode.palette import LAVENDER, MUTED, VIOLET
+from rockycode.session import SessionInfo, list_sessions, public_id
+
+
+def rel_time(ts: float) -> str:
+    d = time.time() - ts
+    if d < 60:
+        return "just now"
+    if d < 3600:
+        return f"{int(d // 60)}m ago"
+    if d < 86400:
+        return f"{int(d // 3600)}h ago"
+    if d < 172800:
+        return "yesterday"
+    return f"{int(d // 86400)}d ago"
+
+
+class ResumePicker(ModalScreen):
+    """Returns the chosen SessionInfo via dismiss(), or None on cancel."""
+
+    BINDINGS = [
+        ("escape", "cancel", "cancel"),
+        ("down", "cursor_down", "↓"),
+        ("up", "cursor_up", "↑"),
+        # priority: the search Input otherwise eats ctrl+a as "line start"
+        Binding("ctrl+a", "toggle_scope", "all folders", priority=True),
+    ]
+
+    DEFAULT_CSS = """
+    ResumePicker { align: center middle; }
+    ResumePicker > #picker {
+        width: 88%;
+        height: 80%;
+        padding: 1 2;
+        background: $surface;
+        border: round $primary;
+        border-title-color: $text-muted;
+    }
+    ResumePicker #q { border: round $panel-lighten-2; margin-bottom: 1; }
+    ResumePicker #q:focus { border: round $primary; }
+    ResumePicker OptionList { height: 1fr; background: $surface; }
+    ResumePicker #picker-guide { height: 1; color: $text-muted; }
+    """
+
+    def __init__(self, workdir: Path) -> None:
+        super().__init__()
+        self.workdir = workdir
+        self.scope = "project"
+        self._sessions: list[SessionInfo] = []
+
+    def compose(self):
+        with Vertical(id="picker") as box:
+            box.border_title = "resume a session"
+            yield Input(placeholder="type to search…", id="q")
+            yield OptionList(id="list")
+            yield Static("", id="picker-guide")
+
+    def on_mount(self) -> None:
+        self.query_one("#q", Input).focus()
+        self._reload()
+
+    def _guide(self) -> str:
+        where = "this folder" if self.scope == "project" else "all folders"
+        return (
+            f"[{MUTED}]scope: [{LAVENDER}]{where}[/]  ·  ↑↓ move · ↵ resume · "
+            f"^a {'this folder' if self.scope == 'all' else 'all folders'} · esc cancel[/]"
+        )
+
+    def _fmt(self, s: SessionInfo) -> str:
+        when = rel_time(s.started_at)
+        folder = Path(s.project_path).name if s.project_path else s.project_name
+        # escape: a past session's title/summary is untrusted user text; a stray
+        # "[/…]" in it is a Textual markup close tag that would crash the picker.
+        title = escape(s.display_title)
+        return (f"{when:>9}  {title[:44]:<44}  {s.n_messages:>3} msgs  "
+                f"{public_id(s.session_id)}  📁 {folder}")
+
+    def _reload(self) -> None:
+        q = self.query_one("#q", Input).value or None
+        self._sessions = list_sessions(self.scope, workdir=self.workdir, query=q)
+        ol = self.query_one("#list", OptionList)
+        ol.clear_options()
+        if self._sessions:
+            for i, s in enumerate(self._sessions):
+                ol.add_option(Option(self._fmt(s), id=str(i)))
+            ol.highlighted = 0
+        else:
+            ol.add_option(Option("(no sessions found)", id="none", disabled=True))
+        self.query_one("#picker-guide", Static).update(self._guide())
+
+    @on(Input.Changed, "#q")
+    def _on_search(self, _e: Input.Changed) -> None:
+        self._reload()
+
+    @on(Input.Submitted, "#q")
+    def _on_enter(self, _e: Input.Submitted) -> None:
+        self._select_current()
+
+    @on(OptionList.OptionSelected)
+    def _on_click(self, e: OptionList.OptionSelected) -> None:
+        if e.option.id and e.option.id.isdigit():
+            self.dismiss(self._sessions[int(e.option.id)])
+
+    def _select_current(self) -> None:
+        ol = self.query_one("#list", OptionList)
+        if ol.highlighted is not None and self._sessions:
+            self.dismiss(self._sessions[ol.highlighted])
+
+    def action_cursor_down(self) -> None:
+        self.query_one("#list", OptionList).action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self.query_one("#list", OptionList).action_cursor_up()
+
+    def action_toggle_scope(self) -> None:
+        self.scope = "all" if self.scope == "project" else "project"
+        self._reload()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

rockycode/tui/rocky_pet.py

@@ -0,0 +1,96 @@
+"""Rocky the pet: a small frame-based sprite widget driven by AgentState.
+
+Eridian anatomy: Rocky has FIVE limbs arranged radially — drawn in the
+兴 pose (three limbs up/out over the carapace, two below), never five-down
+like a spider. Carapace carries sonar dots (Rocky has no eyes — he hears).
+A more delicate sprite pass is still planned (user request, 2026-06-10).
+
+Colors are Tokyo Night palette, matching the app theme.
+
+The widget is isolated on purpose: the animation timer repaints only this
+~9×6 cell region, so it can never glitch the transcript.
+"""
+from __future__ import annotations
+
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from rockycode.engine.events import AgentState
+
+# Every frame: 6 lines × 7 cols. 5 limbs (3 over carapace, 2 under),
+# carapace with sonar dots, last line = caption.
+FRAMES: dict[AgentState, list[str]] = {
+    AgentState.IDLE: [
+        " ╲ │ ╱ \n╭─────╮\n│ ∙∙∙ │\n╰─────╯\n ╱   ╲ \n       ",
+        " ╲ │ ╱ \n╭─────╮\n│ ∘∙∘ │\n╰─────╯\n  ╱ ╲  \n       ",
+    ],
+    AgentState.THINKING: [
+        " ╲ │ ♪ \n╭─────╮\n│ ∙∘∙ │\n╰─────╯\n ╱   ╲ \n hmm…  ",
+        " ╲ │ ♫ \n╭─────╮\n│ ∘∙∘ │\n╰─────╯\n ╱   ╲ \n hmm…  ",
+        " ╲ │ ♪ \n╭─────╮\n│ ∘∘∘ │\n╰─────╯\n ╱   ╲ \n hmm…  ",
+    ],
+    AgentState.RESPONDING: [
+        " ╲ │ ╱ \n╭─────╮\n│ ∙∙∙ │\n╰─────╯\n ╱   ╲ \n  ♪    ",
+        " ╲ │ ╱ \n╭─────╮\n│ ∙∙∙ │\n╰─────╯\n ╱   ╲ \n    ♫  ",
+    ],
+    AgentState.TOOL: [
+        " ╲ │ ⚒ \n╭─────╮\n│ ∙∙∙ │\n╰─────╯\n ╱   ╲ \n work… ",
+        " ╲ │ ╱ \n╭────⚒╮\n│ ∙∙∙ │\n╰─────╯\n ╱   ╲ \n work… ",
+    ],
+    AgentState.COMPACTING: [
+        " ╲ │ ╱ \n╭─────╮\n│ >∙< │\n╰─────╯\n ╱   ╲ \nsquish…",
+        " ╲ │ ╱ \n╭─────╮\n│ »∙« │\n╰─────╯\n ╱   ╲ \nsquish…",
+    ],
+    AgentState.AMAZED: [
+        "╲  │  ╱\n╭─────╮\n│ ✧✧✧ │\n╰─────╯\n╱     ╲\namaze! ",
+        " ╲ │ ╱ \n╭─────╮\n│ ✧∙✧ │\n╰─────╯\n ╱   ╲ \namaze! ",
+        "╲  │  ╱\n╭─────╮\n│ ∙✧∙ │\n╰─────╯\n╱     ╲\namaze! ",
+    ],
+    AgentState.ERROR: [
+        " ╲ ? ╱ \n╭─────╮\n│ ××× │\n╰─────╯\n ╳   ╲ \nno good",
+        " ╲ ¿ ╱ \n╭─────╮\n│ ××× │\n╰─────╯\n ╱   ╳ \nno good",
+    ],
+}
+
+# Tokyo Night.
+STYLES: dict[AgentState, str] = {
+    AgentState.IDLE: "#bb9af7",
+    AgentState.THINKING: "#9d7cd8",
+    AgentState.RESPONDING: "#7dcfff",
+    AgentState.TOOL: "#e0af68",
+    AgentState.COMPACTING: "#73daca",
+    AgentState.AMAZED: "bold #7dcfff",
+    AgentState.ERROR: "#f7768e",
+}
+
+FPS = 3  # a pet, not a video game — cheap repaints
+
+
+class RockyPet(Static):
+    state: reactive[AgentState] = reactive(AgentState.IDLE)
+
+    DEFAULT_CSS = """
+    RockyPet {
+        width: 9;
+        height: 6;
+        content-align: center middle;
+    }
+    """
+
+    def on_mount(self) -> None:
+        self._frame = 0
+        self.set_interval(1 / FPS, self._tick)
+        self._render_frame()
+
+    def watch_state(self, _old: AgentState, _new: AgentState) -> None:
+        self._frame = 0
+        self._render_frame()
+
+    def _tick(self) -> None:
+        self._frame += 1
+        self._render_frame()
+
+    def _render_frame(self) -> None:
+        frames = FRAMES[self.state]
+        art = frames[self._frame % len(frames)]
+        self.update(f"[{STYLES[self.state]}]{art}[/]")

rockycode/tui/routinecard.py

@@ -0,0 +1,123 @@
+"""The routine due card — run it, lease it, or turn it off.
+
+Mounted inline by /routines, one card per due routine. Resolves the Future
+with "run" | "auto" | "later" | "off". The auto choice grants (or renews)
+the 7-day lease with the routine's lease budget — the label always shows
+what the lease costs, and on renewal what the last lease actually spent,
+so trust is re-earned with the bill in view (locked design 2026-07-17).
+
+Rows are clickable with paired keys: ↑↓ + Enter, y run, a auto, n off,
+Esc later.
+"""
+from __future__ import annotations
+
+import asyncio
+
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from rockycode.palette import LAVENDER, MUTED, VIOLET
+
+
+class _Row(Static):
+    def __init__(self, value: str, idx: int, card: "RoutineCard") -> None:
+        super().__init__("", id=f"rt-opt-{idx}", classes="rt-opt")
+        self._value = value
+        self._card = card
+
+    def on_click(self) -> None:
+        self._card.pick(self._value)
+
+
+class RoutineCard(Vertical):
+    """One due routine. Resolves `future` with the choice."""
+
+    can_focus = True
+
+    BINDINGS = [
+        ("up", "move(-1)", "up"),
+        ("down", "move(1)", "down"),
+        ("enter", "confirm", "select"),
+        ("y", "pick('run')", "run"),
+        ("a", "pick('auto')", "auto"),
+        ("n", "pick('off')", "off"),
+        ("escape", "pick('later')", "later"),
+    ]
+
+    DEFAULT_CSS = """
+    RoutineCard {
+        height: auto;
+        margin: 0 1 1 1;
+        padding: 1 2;
+        background: $surface;
+        border: round $primary;
+        border-title-color: $text-muted;
+        border-subtitle-color: $text-muted;
+    }
+    RoutineCard #rt-desc { color: $text-muted; }
+    RoutineCard .rt-opt { height: 1; }
+    RoutineCard #rt-keys { color: $text-muted; margin-top: 1; }
+    """
+
+    def __init__(self, routine, lease_spent: float, future: "asyncio.Future[str]") -> None:
+        super().__init__()
+        self._r = routine
+        self._lease_spent = lease_spent
+        self._future = future
+        self._idx = 0
+        auto_label = (
+            f"↻  Renew auto — 7 days, ${routine.budget_lease:.2f} lease "
+            f"(last lease spent ${lease_spent:.2f})"
+            if routine.auto else
+            f"↻  Auto for 7 days (lease · budget ${routine.budget_lease:.2f})"
+        )
+        self._choices = (
+            ("run", "▶  Run now (sandboxed)"),
+            ("auto", auto_label),
+            ("later", "·  Later"),
+            ("off", "✗  Turn off"),
+        )
+
+    def compose(self):
+        r = self._r
+        grants = ", ".join(r.tools) or "none"
+        yield Static(
+            f"[{MUTED}]{r.description or r.prompt[:100]}\n"
+            f"cadence: {r.cadence} · network: {'on' if r.network else 'off'} · "
+            f"grants: {grants} · ≤{r.max_steps} steps[/]",
+            id="rt-desc",
+        )
+        for i, (value, _label) in enumerate(self._choices):
+            yield _Row(value, i, self)
+        yield Static(
+            f"[{LAVENDER}]↑↓[/] choose · [{LAVENDER}]↵[/] select · "
+            f"[{LAVENDER}]y[/] run · [{LAVENDER}]a[/] auto · [{LAVENDER}]n[/] off · "
+            f"[{LAVENDER}]esc[/] later · or just click a row",
+            id="rt-keys",
+        )
+
+    def on_mount(self) -> None:
+        self.border_title = f"⏰ routine due · {self._r.name}"
+        self.border_subtitle = "runs only when you say — auto is a lease, not a switch"
+        self._render_rows()
+        self.focus()
+
+    def _render_rows(self) -> None:
+        for i, (_v, label) in enumerate(self._choices):
+            row = self.query_one(f"#rt-opt-{i}", Static)
+            row.update(f"[b {VIOLET}]▸ {label}[/]" if i == self._idx else f"[{MUTED}]  {label}[/]")
+
+    def action_move(self, delta: int) -> None:
+        self._idx = (self._idx + delta) % len(self._choices)
+        self._render_rows()
+
+    def action_confirm(self) -> None:
+        self.pick(self._choices[self._idx][0])
+
+    def action_pick(self, choice: str) -> None:
+        self.pick(choice)
+
+    def pick(self, value: str) -> None:
+        """Idempotent — a stray second click/key must not crash the Future."""
+        if not self._future.done():
+            self._future.set_result(value)