evaporator 0.2.0__py3-none-any.whl

evaporator/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

evaporator/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app(prog_name="evaporator")

evaporator/app/__init__.py

@@ -0,0 +1,3 @@
+from .onboarding import ConnectScreen, KeyScreen, LogsScreen, ModelScreen, OnboardingApp
+
+__all__ = ["ConnectScreen", "KeyScreen", "LogsScreen", "ModelScreen", "OnboardingApp"]

evaporator/app/app.tcss

@@ -0,0 +1,55 @@
+/* Pitch black, like the fx UI. Colours are tui.py's palette; the "evaporator" theme (theme.py) blacks out the rest. */
+Screen { background: #000000; color: #c3cfdf; }
+* { scrollbar-background: #000000; scrollbar-background-hover: #000000; scrollbar-background-active: #000000; scrollbar-corner-color: #000000;
+    scrollbar-color: #3d4350; scrollbar-color-hover: #5b6474; scrollbar-color-active: #8ab4ff; }
+Header { background: #000000; color: #8ab4ff; }
+Footer { background: #000000; }
+.panel { padding: 0 3; height: 1fr; }
+.title { color: #8ab4ff; text-style: bold; margin-bottom: 1; }
+.hidden { display: none; }
+#note { color: #9aa8ba; margin-bottom: 1; }
+#status { color: #e8743b; margin: 1 0; height: auto; }
+OptionList { height: auto; max-height: 14; background: #000000; border: round #3d4350; }
+OptionList:focus { border: round #8ab4ff; background-tint: #000000 0%; }
+OptionList > .option-list--option-highlighted { background: #3559b0; color: white; }
+OptionList > .option-list--option-disabled { color: #6b7587; }
+Input { margin-bottom: 0; background: #000000; border: round #3d4350; }
+Input:focus { border: round #8ab4ff; background-tint: #000000 0%; }
+Button, Button.-primary { margin-right: 2; background: #000000; color: #c3cfdf; border: round #3d4350; }
+Button.-primary { color: #8ab4ff; border: round #4c7be0; }
+Button:hover, Button.-primary:hover { background: #000000; border: round #8ab4ff; }
+Button:focus, Button.-primary:focus { background: #000000; color: #ffb36b; border: round #e8743b; text-style: bold; background-tint: #000000 0%; }
+Button.-active { background: #000000; border: round #8ab4ff; tint: transparent; }
+Checkbox { background: #000000; border: round #3d4350; }
+Checkbox:focus { border: round #8ab4ff; background-tint: #000000 0%; }
+TextArea { background: #000000; border: round #3d4350; }
+TextArea:focus { border: round #8ab4ff; }
+DataTable { background: #000000; }
+#snippet { height: 8; margin: 1 0; }
+#instructions { color: #4fc68b; margin-bottom: 1; height: auto; }
+Horizontal { height: auto; }
+#topbar { height: 1; background: #000000; color: #8ab4ff; padding: 0 1; }
+#banner { height: auto; color: #e8743b; padding: 0 1; }
+#panes { height: 1fr; }
+#sites { width: 46; height: 1fr; background: #000000; border: round #3d4350; }
+#sites:focus { border: round #8ab4ff; background-tint: #000000 0%; }
+#detail-scroll { height: 1fr; padding: 0 1; }
+#detail { height: auto; }
+ModalScreen { background: #000000 70%; align: center middle; }
+.dialog { width: 84; height: auto; max-height: 90%; padding: 1 2; background: #000000; border: round #4c7be0; }
+.dialog.wide { width: 116; }
+.dialog DataTable { height: auto; max-height: 20; }
+.buttons { margin-top: 1; }
+#chat-header { height: 1; background: #000000; color: #8ab4ff; padding: 0 1; }
+#transcript { height: 1fr; padding: 0 1; background: #000000; }
+#transcript > Static { height: auto; }
+.chat-info { color: #c3cfdf; }
+.chat-hint { color: #9aa8ba; }
+.chat-user { color: #8ab4ff; text-style: bold; margin-top: 1; }
+.chat-tool { color: #9aa8ba; }
+.chat-error { color: #e8743b; }
+.chat-reply { background: #000000; margin: 0; padding: 0; }
+#chat-status { height: 1; color: #4fc68b; padding: 0 1; }
+#prompt { border: round #3d4350; background: #000000; }
+#prompt:focus { border: round #8ab4ff; }
+#chat-hint { height: 1; color: #7f8a9c; padding: 0 1; background: #000000; }

evaporator/app/chat.py

@@ -0,0 +1,618 @@
+"""The chat: one line of what was found, a prompt at the bottom, answers above it (like Claude Code).
+
+Setup is detection, not questions: the connection and the logs are found in a worker thread and said in one line.
+Only a real choice (several logs) or a real gap (no connection) opens a screen. Engine turns run on a daemon thread
+guarded by one busy flag, so a second Enter never starts a second engine process and quitting never waits for a turn;
+the UI is only touched through call_from_thread. Quitting closes the engine and kills every agent child.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import replace
+from pathlib import Path
+from typing import Callable, Optional
+
+from rich.text import Text
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.timer import Timer
+from textual.widget import Widget
+from textual.widgets import Input, Label, Markdown, OptionList, Static
+from textual.widgets.option_list import Option
+
+from ..chat.api_engine import ApiEngine
+from ..chat.claude_engine import ClaudeEngine
+from ..chat.codex_engine import CodexEngine
+from ..chat.discover import LogCandidate, find_logs, pick_connection, remember_logs
+from ..chat.engine import Engine, Event
+from ..chat.gate import Gate
+from ..connect import list_models
+from ..handoff import agent_launch, fx_has_foreign_entry, install_fx
+from ..llm.subscriptions import detect, kill_all
+from ..mcp import Server
+from ..settings import SUBSCRIPTIONS, ProjectConfig, Resolved, UserConfig, load_project, project_root, save_project, save_user_config
+from .chat_commands import TYPE_PATH, SlashCommands, command_word
+from .chat_confirm import NOT_BAA_TAG, Card, ConfirmFlow, changed_reports, report_stamps
+from .figures import ScanFigure, WelcomeFigure, figure_fits
+from .main import default_exe, one_line
+from .onboarding import SNIPPET, ConnectScreen, KeyScreen, ModelScreen, Picked, Selection
+from .theme import use_black_theme
+from .widgets import SPINNER
+
+CONNECTION_WORDS = {
+    "claude-code": "your Claude Code sign-in",
+    "codex": "your Codex sign-in",
+    "anthropic": "your Anthropic API key",
+    "openai": "your OpenAI API key",
+    "gateway": "your gateway key",
+}
+SUGGESTION = "Try: which of my AI calls can become code?"
+BUSY = "Still working on the last message"
+NO_CONNECTION = ("No AI connection found. Sign in with `claude auth login` (Claude Code) or `codex login` (Codex) "
+                 "in a terminal, or connect one here.")
+NOT_CONNECTED = ("There is no AI connection for this chat yet. Type /model to connect one, or sign in with "
+                 "`claude auth login` or `codex login` and start evaporator again.")
+NOT_CONNECTED_SENSITIVE = ("This project has personal data, so the chat needs an API key on a BAA-covered endpoint. "
+                           "Type /model to connect one.")
+FOOTER = "Enter sends · /help for commands · ctrl+q quits"
+CAPTURE = (
+    "To find out which AI calls can become code I need a log of them. Wrap the function that makes the call:\n\n"
+    f"```python\n{SNIPPET}```\n\n"
+    "Once some calls have gone through, start evaporator again, or tell me where your logs are."
+)
+
+
+def make_engine(resolved: Resolved, project: ProjectConfig, gate_path: Path, *, root: Optional[Path] = None,
+                evaporator_exe: Optional[str] = None) -> Engine:
+    """The engine for this connection: the signed-in agent CLI, else the app's own API-key loop."""
+    root = Path(root) if root is not None else project_root()
+    if resolved.provider == "claude-code":
+        return ClaudeEngine(resolved, root, evaporator_exe or default_exe(), Path(gate_path))
+    if resolved.provider == "codex":
+        return CodexEngine(resolved, root, evaporator_exe or default_exe(), Path(gate_path))
+    return ApiEngine(resolved, Server(root / ".evaporator", resolved, project, gate=Gate(Path(gate_path))))
+
+
+_DEFAULT_MAKE_ENGINE = make_engine
+
+
+class Line(Static):
+    """One plain transcript line. Text from the agent or the logs is never parsed as markup."""
+
+    def __init__(self, text: str, classes: str = "") -> None:
+        super().__init__(Text(text), classes=classes)
+        self.plain = text
+
+    def set(self, text: str) -> None:
+        self.plain = text
+        self.update(Text(text))
+
+
+class Reply(Markdown):
+    def __init__(self, text: str) -> None:
+        super().__init__(text, classes="chat-reply")
+        self.plain = text
+
+
+class LogPickerScreen(ModalScreen):
+    """Several call logs were found: pick one (Esc: none for now). With typed=True (/logs) the last option is
+    "Type a path…", which dismisses with TYPE_PATH."""
+
+    BINDINGS = [Binding("escape", "skip", "skip")]
+
+    def __init__(self, candidates: "list[LogCandidate]", typed: bool = False) -> None:
+        super().__init__()
+        self.candidates = list(candidates)
+        self.typed = typed
+
+    def compose(self) -> ComposeResult:
+        options = [Option(Text(c.describe()), id=f"log{i}") for i, c in enumerate(self.candidates)]
+        if self.typed:
+            options.append(Option("Type a path…", id=TYPE_PATH))
+        with Vertical(classes="dialog"):
+            yield Label("Which logs should I use?", classes="title")
+            yield OptionList(*options)
+            yield Static(Text("Enter picks · Esc skips for now", style="dim"))
+
+    def on_mount(self) -> None:
+        options = self.query_one(OptionList)
+        options.highlighted = 0
+        options.focus()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        self.dismiss(TYPE_PATH if event.option_id == TYPE_PATH else self.candidates[event.option_index])
+
+    def action_skip(self) -> None:
+        self.dismiss(None)
+
+
+class ChatConnectScreen(ConnectScreen):
+    """The connect screen, but Esc goes back to the chat (where the sign-in hint stays visible)."""
+
+    BINDINGS = [Binding("escape", "back", "back to the chat")]
+
+
+class ChatApp(SlashCommands, ConfirmFlow, App[Optional[str]]):
+    """Returns None when the user quits, "dashboard" when they ask for the dashboard (/dashboard)."""
+
+    CSS_PATH = "app.tcss"
+    TITLE = "evaporator"
+    BINDINGS = [
+        Binding("ctrl+q", "quit", "quit", priority=True),
+        Binding("ctrl+c", "quit", "quit", priority=True, show=False),
+    ]
+
+    def __init__(
+        self,
+        root: Path,
+        *,
+        discover_logs: Callable[[Path], "list[LogCandidate]"] = find_logs,
+        pick: Callable[[], Optional[Resolved]] = pick_connection,
+        make_engine: Callable[[Resolved, ProjectConfig, Path], Engine] = make_engine,
+        evaporator_exe: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        use_black_theme(self)
+        self.root = Path(root)
+        self.discover_logs, self.pick = discover_logs, pick
+        self.evaporator_exe = evaporator_exe or default_exe()
+        if make_engine is _DEFAULT_MAKE_ENGINE:  # the real factory also needs where to run and which evaporator
+            self.make_engine = lambda r, p, g: _DEFAULT_MAKE_ENGINE(r, p, g, root=self.root, evaporator_exe=self.evaporator_exe)
+        else:
+            self.make_engine = make_engine
+        self.detect_fn: Callable = detect  # used by the connect screens and /agent; tests replace them
+        self.list_models_fn: Callable = list_models
+        self.launch_fn: Callable = agent_launch
+        self.run_agent: Callable = subprocess.call
+        self.install_fn: Callable = install_fx
+        self.foreign_fn: Callable = fx_has_foreign_entry
+        self.fx_home: Optional[Path] = None  # None: ~/.fx
+        self.fx_replace: Optional[bool] = None  # the answer to "replace your fx entry?", asked once per session
+        self.greeted = False  # the first greeting says what was found; later ones say what changed
+        self.resolved: Optional[Resolved] = None
+        self.project = ProjectConfig()
+        self.logs_desc: Optional[str] = None
+        self.logs_name: Optional[str] = None
+        self.engine: Optional[Engine] = None
+        self.gate_path: Optional[Path] = None  # the current engine's gate file
+        self.gate_paths: "list[Path]" = []  # every gate file made this session, all deleted on exit
+        self.selection: Optional[Selection] = None
+        self.setting_up = True
+        self.busy = False
+        self.turn = 0  # which turn busy belongs to; an engine swapped mid-turn still ends its turn
+        self.status = ""
+        self.started = 0.0
+        self.timer: Optional[Timer] = None
+        self.welcome: Optional[WelcomeFigure] = None  # animates until the first message
+        self.scanning: Optional[ScanFigure] = None  # the one scan animation, while a scan tool call runs
+        self.quitting = False  # set on exit: a turn thread still running posts nothing more
+
+    # -- layout --------------------------------------------------------------------------------------------------
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="chat-header")
+        yield VerticalScroll(id="transcript")
+        yield Static(id="chat-status")
+        yield Input(placeholder="Ask about your AI calls…", id="prompt")
+        yield Static(Text(FOOTER), id="chat-hint")
+
+    def on_mount(self) -> None:
+        self._part("#chat-status").display = False
+        self._header("looking for your logs and AI connection…")
+        if figure_fits(self):
+            self.welcome = self._add(WelcomeFigure())
+        self.prompt.focus()
+        self._setup()
+
+    def _part(self, selector: str, kind: type = Widget):
+        """A widget of the chat itself, even while a dialog or the connect screens are on top."""
+        return self.screen_stack[0].query_one(selector, kind)
+
+    @property
+    def prompt(self) -> Input:
+        return self._part("#prompt", Input)
+
+    def _header(self, rest: str) -> None:
+        self._part("#chat-header", Static).update(Text(f"evaporator · {rest}", no_wrap=True, overflow="ellipsis"))
+
+    def header_text(self) -> str:
+        return str(self._part("#chat-header", Static).content)
+
+    def transcript_lines(self) -> "list[str]":
+        return [w.plain for w in self._part("#transcript").children if isinstance(w, (Line, Reply, Card))]
+
+    def status_text(self) -> str:
+        return self.status if self.busy else ""
+
+    def _add(self, widget: Widget) -> Widget:
+        transcript = self._part("#transcript", VerticalScroll)
+        transcript.mount(widget)
+        transcript.scroll_end(animate=False)
+        return widget
+
+    def _line(self, text: str, kind: str = "info") -> Line:
+        return self._add(Line(text, f"chat-{kind}"))
+
+    def _post(self, fn: Callable, *args) -> None:
+        if self.quitting:
+            return
+        try:
+            self.call_from_thread(fn, *args)
+        except RuntimeError:
+            pass  # the app already closed
+
+    # -- setup: connection and logs, found rather than asked -----------------------------------------------------
+
+    @work(thread=True, exclusive=True, group="setup", exit_on_error=False)
+    def _setup(self) -> None:
+        problem = None
+        try:
+            resolved = self.pick()
+        except Exception as exc:  # a broken config file: say so and offer the connect flow
+            resolved, problem = None, one_line(exc)
+        try:
+            project = load_project(self.root)
+        except (OSError, ValueError):
+            project = ProjectConfig()
+        try:
+            candidates = self.discover_logs(self.root)
+        except Exception:
+            candidates = []
+        saved = self._path(project.logs)
+        chosen: Optional[LogCandidate] = None
+        if saved is not None and saved.is_file():  # chosen before and still there
+            chosen = next((c for c in candidates if c.path.resolve() == saved.resolve()), None)
+        else:
+            saved = None
+            if project.logs:  # the saved logs are gone: forget them rather than chat about a missing file
+                project = self._forget_logs(project)
+            if len(candidates) == 1:
+                chosen = candidates[0]
+                project = self._remember(chosen, project)
+        self._post(self._found, resolved, project, candidates, chosen, saved, problem)
+
+    def _path(self, value: Optional[str]) -> Optional[Path]:
+        if not value:
+            return None
+        path = Path(value).expanduser()
+        return path if path.is_absolute() else self.root / path
+
+    def _forget_logs(self, project: ProjectConfig) -> ProjectConfig:
+        project = replace(project, logs=None, labels=None)
+        try:
+            save_project(self.root, project)
+        except (OSError, ValueError):
+            pass  # still forgotten for this session
+        return project
+
+    def _remember(self, cand: LogCandidate, project: ProjectConfig) -> ProjectConfig:
+        try:
+            return remember_logs(self.root, cand)
+        except (OSError, ValueError):  # unsaved, but still used this session
+            return replace(project, logs=str(cand.path), labels=str(cand.labels) if cand.labels else None)
+
+    def _found(self, resolved: Optional[Resolved], project: ProjectConfig, candidates: "list[LogCandidate]",
+               chosen: Optional[LogCandidate], saved: Optional[Path], problem: Optional[str]) -> None:
+        self.resolved, self.project = resolved, project
+        if problem:
+            self._line(f"Could not read your saved connection: {problem}", "error")
+        if chosen is not None or saved is not None:
+            self._use_logs(chosen, saved)
+            self._connect()
+        elif not candidates:
+            self._connect()
+        else:
+            self._line(f"Found {len(candidates)} call logs here.")
+            self.push_screen(LogPickerScreen(candidates), self._picked)
+
+    def _use_logs(self, cand: Optional[LogCandidate], path: Optional[Path] = None) -> None:
+        if cand is not None:
+            self.logs_desc = cand.describe()
+            path = cand.path
+        else:
+            self.logs_desc = path.name
+        try:
+            self.logs_name = path.relative_to(self.root).as_posix()
+        except ValueError:
+            self.logs_name = str(path)
+
+    def _picked(self, cand: Optional[LogCandidate]) -> None:
+        if cand is None:
+            self._line("No logs picked for now; you can tell me where your logs are.")
+        else:
+            self.project = self._remember(cand, self.project)
+            self._use_logs(cand)
+        self._connect()
+
+    def _connect(self) -> None:
+        if self.resolved is not None:
+            return self._greet()
+        self._header("not connected")
+        self._line(NO_CONNECTION)
+        self._connect_flow()
+
+    # the Connect -> (Key) -> Model chain, as in onboarding; every step can go back but not out
+    def _connect_flow(self) -> None:
+        # a project with personal data is steered to an API key; a subscription is warned about once (decision 9)
+        self.push_screen(ChatConnectScreen(self.detect_fn, sensitive=bool(self.project.sensitive)), self._on_connect)
+
+    def _on_connect(self, selection: Optional[Selection]) -> None:
+        if selection is None:  # Esc: back to the chat, still not connected
+            self.setting_up = False
+            self.prompt.focus()
+            return
+        self.selection = selection
+        if selection.provider in SUBSCRIPTIONS and self.project.sensitive:  # Connect an API key: back to the choices
+            self.warn_subscription(lambda: self._choose_model([]), self._connect_flow, selection.provider)
+        elif selection.provider in SUBSCRIPTIONS:
+            self._choose_model([])
+        else:
+            self._ask_key()
+
+    def _ask_key(self) -> None:
+        sel = self.selection
+        self.push_screen(KeyScreen(sel.provider, sel.base_url, self.list_models_fn),
+                         lambda models: self._connect_flow() if models is None else self._choose_model(models))
+
+    def _choose_model(self, models: "list[str]") -> None:
+        self.push_screen(ModelScreen(self.selection.provider, models), self._on_model)
+
+    def _on_model(self, pick: Optional[Picked]) -> None:
+        sel = self.selection
+        if pick is None:
+            return self._connect_flow() if sel.provider in SUBSCRIPTIONS else self._ask_key()
+        try:
+            save_user_config(UserConfig(provider=sel.provider, model=pick.model, base_url=sel.base_url))
+        except (OSError, ValueError) as exc:
+            self._line(f"Could not save the connection: {one_line(exc)}", "error")
+            return self._connect_flow()
+        self._repick()
+
+    @work(thread=True, exclusive=True, group="setup", exit_on_error=False)
+    def _repick(self) -> None:
+        try:
+            resolved = self.pick()
+        except Exception:
+            resolved = None
+        self._post(self._repicked, resolved)
+
+    def _repicked(self, resolved: Optional[Resolved]) -> None:
+        if resolved is None:
+            self._line("Still no working connection; pick one again.", "error")
+            return self._connect_flow()
+        if self.selection is not None and resolved.provider != self.selection.provider:
+            self._line(f"EVAPORATOR_PROVIDER overrides your choice: using {resolved.provider}.")
+        self.resolved = resolved
+        self._greet()
+
+    def _show_header(self) -> None:
+        header = Text(f"evaporator · {self.resolved.describe()}", no_wrap=True, overflow="ellipsis")
+        if self.personal_on_subscription() and self.project.allow_subscription:
+            header.append(" · ").append(NOT_BAA_TAG, style="yellow")
+        header.append(f" · {self.logs_name or 'no logs yet'}")
+        self._part("#chat-header", Static).update(header)
+
+    def _greet(self) -> None:
+        resolved = self.resolved
+        words = CONNECTION_WORDS.get(resolved.provider, f"your {resolved.provider} connection")
+        self._show_header()
+        if self.greeted:  # a new connection (/model, or an API key after a refused subscription): a fresh conversation
+            self._line(f"Now using {words} ({resolved.describe()}). This is a new conversation.")
+        elif self.logs_desc is not None:
+            self._line(f"Found {self.logs_desc} · using {words}.")
+            self._line(SUGGESTION, "hint")
+        else:
+            self._line(f"No call logs found here yet · using {words}.")
+            self._add(Reply(CAPTURE))
+        self.greeted = True
+        if self.personal_on_subscription():
+            return self.warn_subscription(self._begin)  # no subscription engine starts before the warning is answered
+        self._begin()
+
+    def _begin(self) -> None:
+        self._start_engine()
+        self.setting_up = False
+        self.prompt.focus()
+
+    def _start_engine(self) -> None:
+        """A new engine for the current connection and project; the old one (if any) is closed first."""
+        self._stop_engine()
+        try:
+            # A fresh gate file per engine: a request a closed engine wrote (or writes later, from a thread that
+            # outlived close) can never be shown, let alone approved, under the new connection.
+            self._drop_gate(self.gate_path)
+            fd, name = tempfile.mkstemp(prefix="evaporator-gate-", suffix=".json")
+            os.close(fd)
+            self.gate_path = Path(name)
+            self.gate_paths.append(self.gate_path)
+            self.engine = self.make_engine(self.resolved, self.project, self.gate_path)
+        except Exception as exc:
+            self._line(f"Could not start the chat: {one_line(exc)}", "error")
+
+    def _stop_engine(self) -> None:
+        """Close the engine for good (close is final; a new connection makes a new engine)."""
+        engine, self.engine = self.engine, None
+        if engine is not None:
+            try:
+                engine.close()
+            except Exception:
+                pass
+
+    # -- a turn ----------------------------------------------------------------------------------------------------
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id != "prompt" or event.input.screen is not self.screen:
+            return  # the connect screens' own inputs
+        event.stop()
+        text = event.value.strip()
+        if not text:
+            return
+        word = command_word(text)
+        if word is not None:
+            if self.run_command(word, text):
+                event.input.value = ""
+            return
+        if self.busy:
+            self.notify(BUSY)  # the typed text stays in the prompt
+            return
+        if self.setting_up:
+            self.notify("Still getting set up, one moment")
+            return
+        event.input.value = ""
+        self.send_message(text)
+
+    def send_message(self, text: str) -> None:
+        """Echo the user's message (typed, or an answer to a confirmation) and run it as a turn."""
+        if self.engine is not None and self.resolved.provider == "codex" and self.project.sensitive is None:
+            # Codex can read the project's files even in its read-only sandbox (Claude only gets Evaporator's tools,
+            # whose listing shows no log text): the personal-data answer comes before its first turn
+            return self.ask_personal(lambda: self.send_message(text), lambda: self._unsent(text), "Before Codex reads this project")
+        if self.welcome is not None:  # the welcome picture stays in the scrollback, still
+            self.welcome.stop()
+        self._line(f"› {text}", "user")
+        if self.engine is None:
+            refused = self.personal_on_subscription() and not self.project.allow_subscription
+            self._line(NOT_CONNECTED_SENSITIVE if refused else NOT_CONNECTED, "error")
+            return
+        self.busy = True
+        self.turn += 1
+        self.started = time.monotonic()
+        self._set_status("Thinking")
+        self._part("#chat-status").display = True
+        if self.timer is None:
+            self.timer = self.set_interval(1 / 12, self._tick)
+        self._turn(self.engine, text, self.turn)
+
+    def _unsent(self, text: str) -> None:
+        """A message that was not sent (the question before it was cancelled) goes back into an empty prompt."""
+        if not self.prompt.value:
+            self.prompt.value = text
+        self.prompt.focus()
+
+    def _turn(self, engine: Engine, text: str, turn: int) -> None:
+        # A daemon thread, not a Textual thread worker: asyncio joins its executor's threads at shutdown, so a turn
+        # that can't be interrupted (an API call, an in-process scan) would keep the process alive after quitting.
+        threading.Thread(target=self._run_turn, args=(engine, text, turn), name="evaporator-turn", daemon=True).start()
+
+    def _run_turn(self, engine: Engine, text: str, turn: int) -> None:
+        workdir = self.root / ".evaporator"
+        before: Optional[dict] = None
+        reports: "list[dict]" = []
+        try:
+            before = report_stamps(workdir)
+            engine.send(text, lambda event: self._post(self._event, engine, event))
+        except Exception as exc:  # an engine bug: one line, never a traceback
+            self._post(self._event, engine, Event("error", one_line(exc)))
+        finally:
+            try:  # a scan finished during the turn: show its card; nothing here may keep the turn from ending
+                reports = changed_reports(workdir, before) if before is not None else []
+            except Exception:
+                reports = []
+            self._post(self._turn_done, engine, turn, reports)
+
+    def _event(self, engine: Engine, event: Event) -> None:
+        if engine is not self.engine:
+            return  # a closed engine's late events
+        if event.kind == "text":
+            self._add(Reply(event.text))
+        elif event.kind == "tool" and event.tool == "scan" and figure_fits(self):
+            self._end_scan()  # only one animation at a time
+            self.scanning = self._add(ScanFigure(event.text, event.tool))
+            self._set_status(event.text)
+            self._part("#chat-status").display = False  # the figure carries the status and the seconds
+        elif event.kind == "tool":
+            self._line(f"{event.text}…", "tool").tool = event.tool
+            self._set_status(event.text)
+        elif event.kind == "tool_done" and self.scanning is not None and event.tool == self.scanning.tool:
+            self._end_scan(" done")
+            self._set_status("Thinking")
+        elif event.kind == "tool_done":
+            pending = [w for w in self.screen_stack[0].query(".chat-tool") if getattr(w, "tool", None) == event.tool and not w.plain.endswith(" done")]
+            if pending:
+                pending[-1].set(pending[-1].plain + " done")
+            self._set_status("Thinking")
+        else:
+            self._line(event.text, "error")
+
+    def _turn_done(self, engine: Engine, turn: int, reports: "list[dict]") -> None:
+        if turn == self.turn:  # by turn, not engine: a turn whose engine was replaced still frees the prompt
+            self.busy = False
+            self.status = ""
+            self._part("#chat-status").display = False
+            if self.timer is not None:
+                self.timer.stop()
+                self.timer = None
+            self._end_scan()
+        if engine is not self.engine:
+            return  # a closed engine's turn: nothing of it is shown or approved
+        self._cards(reports)
+        self._check_gate()
+
+    def _end_scan(self, suffix: str = "") -> None:
+        """Stop the scan animation and put the plain tool line in its place ("… done" once the tool finished)."""
+        figure, self.scanning = self.scanning, None
+        if figure is None:
+            return
+        figure.stop()
+        self._part("#chat-status").display = self.busy
+        if figure.is_attached:
+            line = Line(f"{figure.message}…{suffix}", "chat-tool")
+            line.tool = figure.tool
+            transcript = self._part("#transcript", VerticalScroll)
+            transcript.mount(line, before=figure)
+            figure.remove()
+            transcript.scroll_end(animate=False)
+
+    def _stop_animations(self) -> None:
+        for figure in (self.welcome, self.scanning):
+            if figure is not None:
+                figure.stop()
+        if self.timer is not None:
+            self.timer.stop()
+            self.timer = None
+
+    def _set_status(self, text: str) -> None:
+        self.status = text
+        self._tick()
+
+    def _tick(self) -> None:
+        elapsed = time.monotonic() - self.started
+        frame = SPINNER[int(elapsed * 12) % len(SPINNER)]
+        self._part("#chat-status", Static).update(Text(f"{frame} {self.status}…  {int(elapsed)}s"))
+
+    # -- quitting ----------------------------------------------------------------------------------------------------
+
+    def exit(self, *args, **kwargs) -> None:
+        self._stop_animations()
+        self._teardown()
+        super().exit(*args, **kwargs)
+
+    async def run_async(self, *args, **kwargs):
+        try:
+            return await super().run_async(*args, **kwargs)
+        finally:
+            self._teardown()
+
+    def _teardown(self) -> None:
+        """Close the engine (kills its child), kill any other agent child, delete the gate file. Safe to repeat."""
+        self.quitting = True
+        self._stop_engine()
+        kill_all()
+        for path in self.gate_paths:
+            self._drop_gate(path)
+
+    @staticmethod
+    def _drop_gate(path: Optional[Path]) -> None:
+        if path is not None:
+            try:
+                path.unlink(missing_ok=True)
+            except OSError:
+                pass