zettcode-presenters 0.4.0__tar.gz → 0.4.2__tar.gz

{zettcode_presenters-0.4.0 → zettcode_presenters-0.4.2}/.gitignore

@@ -35,3 +35,8 @@ docs/internal/palettes.html
 
 # The release order is generated from the pyproject.toml files (`make order`); it is not kept in git.
 packages/order.txt
+
+# The desktop and phone apps build the gateway's page into their own folders, and electron-builder writes its
+# installers under release/.
+clients/desktop/renderer/
+clients/desktop/release/

{zettcode_presenters-0.4.0 → zettcode_presenters-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode-presenters
-Version: 0.4.0
+Version: 0.4.2
 Summary: The conversation's rows and how ZettCode's terminal draws them
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Author: Chang-LeHung
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: zettcode-engine
 Requires-Dist: zettcode-plugin-api
 Requires-Dist: zettcode-tui
 Provides-Extra: types

{zettcode_presenters-0.4.0 → zettcode_presenters-0.4.2}/pyproject.toml

@@ -19,6 +19,8 @@ classifiers = [
 dependencies = [
   # Written against the plugin contract, which is where the row model and the presenter base class are defined.
   "zettcode-plugin-api",
+  # The `[statusline]` vocabulary (`statusline_parts`) and the TOML reader the boot labels use.
+  "zettcode-engine",
   "zettcode-tui",
 ]
 
@@ -26,9 +28,11 @@ dependencies = [
 # The wording reads `Usage` figures the SDK defines; it is imported for the annotation only.
 types = ["zettcode-sdk"]
 
-# A part of the program, not a plugin: the `zettcode.plugins` group is what the plugin release line looks for.
-[project.entry-points."zettcode.terminal"]
+# A part of the program, not a plugin: the `[tool.zettcode] plugin = true` marker is what the plugin release line looks for.
+[project.entry-points."zettcode.plugin"]
 presenters = "zettcode.presenters.plugin:PresentersPlugin"
+shell = "zettcode.presenters.rows:ShellRows"
+turn-line = "zettcode.presenters.rows:TurnLine"
 
 [project.urls]
 Repository = "https://github.com/Chang-LeHung/zettcode"

zettcode_presenters-0.4.2/src/zettcode/presenters/__init__.py

@@ -0,0 +1,17 @@
+"""The conversation's rows and how the terminal draws them.
+
+`entries` is the data — one class per kind of row a transcript can hold — and `presenters` is how one kind becomes
+lines: a presenter per kind, a presenter per tool name, and the generic `ToolPresenter` that catches any tool no
+name claimed. `brand` is the pixel art the welcome row draws; `labels`, `statusline` and `rows` are the shell's
+header, status and turn-line, published as the `shell`/`turn-line` entry points.
+
+The terminal's transcript, the projector that fills it and the replay that rebuilds it stay in `zettcode.app`: this
+distribution is the part of them that a plugin replaces — a front end registers its own presenter through
+`ctx.tui.register_presenter`, and `zettcode-plugin-api` re-exports `Entry` and `Presenter` so it can.
+
+The plugin that registers the presenters is `zettcode.presenters.plugin`, published as the `presenters` entry point.
+`shell` and `turn-line` are entry points of this distribution too; all are discovered, and the terminal names the
+ones it cannot run without in `REQUIRED_PLUGINS`.
+"""
+
+from __future__ import annotations

zettcode_presenters-0.4.2/src/zettcode/presenters/labels.py

@@ -0,0 +1,244 @@
+"""The text of the built-in header and status rows.
+
+One implementation, two callers: the plugin that draws those rows for the
+running shell, and the frame the command line paints before the application
+exists. Sharing the text is what lets the boot frame put the same characters on
+screen, so the swap fills rows in instead of rewriting them.
+
+Nothing heavy may be imported here — the boot frame's whole purpose is to draw
+before the application's imports happen.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from zettcode.tui import ARROW_DOWN, ARROW_UP, ELLIPSIS, HEADER, STATUS
+from zettcode.tui.render import display_width
+
+from .statusline import TURN_PARTS, Row
+from .text import STOP_HINT
+
+#: The keys worth remembering, shown at the right of the status row.
+KEY_HINTS = f"{STOP_HINT}  ^D exit"
+
+#: The reasoning effort a fresh launch shows until ``/effort`` changes it: the
+#: shell's own default, spelled the way the header spells it. The test that
+#: compares the two frames cell by cell fails if the two ever drift apart.
+DEFAULT_EFFORT = "medium"
+
+
+def compact_path(path: Path, *, limit: int | None = 38) -> str:
+    """Shorten a workspace path for the header.
+
+    Args:
+        path: Absolute path to display.
+        limit: Most columns to keep; the home directory collapses to ``~``, and
+            anything longer keeps a leading ellipsis plus its tail. ``None``
+            keeps the whole path and collapses only the home directory, for a
+            line that has the room to show it.
+    """
+    value = str(path)
+    home = str(Path.home())
+    if value == home or value.startswith(home + "/"):
+        value = "~" + value[len(home) :]
+    if limit is None:
+        return value
+    width = display_width(value)
+    if width <= limit:
+        return value
+    # Count the tail from the end so a wide glyph is dropped whole rather than
+    # overhanging the budget, which the ellipsis also has to fit inside.
+    budget = limit - 1
+    tail = ""
+    for character in reversed(value):
+        if display_width(character) > budget:
+            break
+        tail = character + tail
+        budget -= display_width(character)
+    return f"{ELLIPSIS}{tail}"
+
+
+#: The most columns of a session's title the header keeps. A title can be a hundred and twenty characters, and the
+#: header is cut from its right end when the row is full: unbounded, a long title would push the session's name
+#: and the workspace off the screen.
+TITLE_COLUMNS = 36
+
+
+def header_left(workspace: Path, name: str = "", handle: str = "") -> Row:
+    """Label the app, the session, and the workspace it runs in.
+
+    The session comes before the workspace because a row that is too narrow loses its right end first, and which
+    session this is matters more than a directory that does not change while it is open.
+
+    Args:
+        workspace: Directory the session runs in.
+        name: The session's title, or its placeholder before it has one. Left out, the row names no session, which
+            is how a frame drawn before there is one looks.
+        handle: The name other sessions address this one by (without the ``@``); empty when messaging is off or the
+            session is not registered yet.
+    """
+    row = Row(lead="  ")
+    row.add("app", "The mark and name of the program at the start of the header", f"{HEADER} zettcode").gap()
+    row.add("session", "The session's title; New session until it has one", _fit(name, TITLE_COLUMNS) if name else "")
+    row.add(
+        "handle", "The @name other sessions reach this one by, when messaging is on", f"@{handle}" if handle else ""
+    )
+    row.add("workspace", "The directory the session works in", compact_path(workspace))
+    return row
+
+
+def _fit(text: str, columns: int) -> str:
+    """Return ``text`` cut to ``columns`` with an ellipsis when it is longer; a wide glyph is dropped whole."""
+    if display_width(text) <= columns:
+        return text
+    kept = ""
+    for character in text:
+        if display_width(kept) + display_width(character) > columns - 1:
+            break
+        kept += character
+    return kept.rstrip() + ELLIPSIS
+
+
+#: What the header's model segment says before any model is configured. The row is where a reader looks to see
+#: what will answer them, and an empty segment reads as a rendering accident rather than as a machine to set up.
+NO_MODEL = "no model"
+
+
+def header_right(model: str, effort: str) -> Row:
+    """Show the model and the reasoning effort the next request will use.
+
+    An empty ``model`` — a machine with no ``[[models]]`` entry yet — is named rather than left blank, and the
+    effort goes with it: a level applies to a model, and ``no model · medium`` would name one this machine does
+    not have. ``/config`` is what fills the row in.
+    """
+    row = Row(trail="  ")
+    row.add("model", "The model the next request goes to; no model configured yet", model or NO_MODEL)
+    row.add("effort", "How much the model reasons on the next request", effort if model else "")
+    return row
+
+
+def model_name(config_file: Path) -> str | None:
+    """Return the model the header will name, read from the config file alone.
+
+    The frame the command line paints is drawn before the settings module is
+    imported, and the name it will show is in that file: reading the one value
+    costs a file read, where importing the settings to ask for it costs their
+    whole import graph. The rule is the settings' own — the first ``[[models]]``
+    entry's ``display_model``, falling back to its id — but only that rule, so
+    anything unreadable answers ``None`` and leaves the header's right side for
+    the shell to fill in when it arrives.
+
+    Args:
+        config_file: The file the settings will be read from, which is
+            ``$ZETTCODE_CONFIG`` or the conventional path.
+    """
+    from zettcode._compat import tomllib
+
+    if not config_file.is_file():
+        # Not a file is not a file to open: a FIFO here would block the very frame this answers for, and a
+        # directory would raise where the caller only wants the name.
+        return None
+    try:
+        settings = tomllib.loads(config_file.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    models = settings.get("models")
+    if not isinstance(models, list) or not models or not isinstance(models[0], dict):
+        return None
+    for key in ("display_model", "model"):
+        value = models[0].get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    return None
+
+
+def hidden_parts(config_file: Path) -> tuple[str, ...]:
+    """Return the header and status-line parts the config file switches off, read from the file alone.
+
+    Like :func:`model_name` this is for the frame drawn before the settings are imported, so it reads the one
+    table and trusts nothing: anything unreadable, a name that is no part, or a value that is not ``false``
+    answers "nothing hidden" for that entry, and the application reports the mistake when it arrives.
+    """
+    from zettcode._compat import tomllib
+
+    from .statusline import NAMES
+
+    if not config_file.is_file():
+        return ()
+    try:
+        table = tomllib.loads(config_file.read_text(encoding="utf-8")).get("statusline")
+    except (OSError, ValueError):
+        return ()
+    if not isinstance(table, dict):
+        return ()
+    return tuple(name for name in NAMES if table.get(name) is False)
+
+
+def status_left(
+    label: str,
+    *,
+    icon: str = STATUS,
+    permission: str = "ask",
+    self_compact: bool = False,
+    tokens: str = "",
+    cache: str = "",
+    speed: str = "",
+    ctx: str = "",
+) -> Row:
+    """Show what is happening, the mode it runs in, and what the session has cost so far.
+
+    The session is named in the header. Before the first reply the counters are empty and take no room.
+
+    Args:
+        label: The status word, or the one-off note that stands in for it.
+        icon: The activity glyph; the still dot unless a request is running.
+        permission: The shell permission; ``ask`` is the default and is not shown.
+        self_compact: Whether the model may compact its own context in this session.
+        tokens: Tokens sent and received, as the figures read.
+        cache: The cache share, as it reads.
+        speed: The generation speed, as it reads.
+        ctx: How full the context window is, as it reads.
+    """
+    row = Row(lead="  ")
+    row.add("state", "The activity icon and what is happening: ready, thinking, a tool running", f"{icon} {label}")
+    row.add(
+        "mode",
+        "How much of the shell may run unasked; shown unless it is ask",
+        "" if permission == "ask" else permission,
+    )
+    row.add(
+        "self-compact",
+        "Marks a session where the model may compact its own context",
+        "self-compact" if self_compact else "",
+    )
+    row.gap()
+    row.add("tokens", "Tokens sent and received in this session", tokens)
+    row.add("cache", "The share of input the provider served from its cache", cache)
+    row.add("speed", "How fast the model generates, in tokens per second", speed)
+    row.add("ctx", "How much of the model's context window the last request filled", ctx)
+    return row
+
+
+def turn_line() -> Row:
+    """Show the line a request ends on as the panel previews it: the program's own items on a plausible request."""
+    samples = {
+        "turn-time": "Processed for 12s",
+        "turn-clock": "22:53",
+        "turn-tokens": f"{ARROW_UP}12.3k {ARROW_DOWN}1.2k",
+        "turn-cache": "87.0% cached",
+        "turn-calls": "3 model calls",
+        "turn-speed": "62 tok/s",
+        "turn-tools": "5 tool calls, 1 failed",
+    }
+    row = Row(lead="  ")
+    for name, summary in TURN_PARTS:
+        row.add(name, summary, samples[name])
+    return row
+
+
+def status_right() -> Row:
+    """List the keys worth remembering."""
+    row = Row(lead="  ", trail="  ")
+    row.add("keys", "The keys worth remembering: stop and exit", KEY_HINTS)
+    return row

{zettcode_presenters-0.4.0 → zettcode_presenters-0.4.2}/src/zettcode/presenters/plugin.py

@@ -1,6 +1,6 @@
 """The plugin that offers the program's own row drawing to the terminal.
 
-It is an ordinary plugin, found through the ``zettcode.plugins`` entry point like any other, and the terminal lists it
+It is an ordinary plugin, found through the ``zettcode.plugin`` entry point like any other, and the terminal lists it
 as required: the program does not start without it, and ``[plugins] disable`` does not reach it. It needs nothing
 else, and the plugins that draw more kinds of row depend on it (``deps = ("presenters",)``) so theirs register after.
 """

{zettcode_presenters-0.4.0 → zettcode_presenters-0.4.2}/src/zettcode/presenters/presenters.py

@@ -1,10 +1,10 @@
 """Present entries as styled lines, without mounting a widget per entry.
 
-An entry is data; a *presenter* is what turns one kind of entry into rows. There is
-one presenter per :class:`~.entries.EntryKind`, held in a :class:`Presenters`
-registry that looks the right one up by the entry's kind, so adding a kind of row
-is three things: a member of the enum, an entry class, and a presenter that names
-the kind it presents.
+An entry is data; a *presenter* is what turns a row into lines. The built-in presenters are one per
+:class:`~.entries.EntryKind` and one per tool name, held in a :class:`Presenters` chain: each presenter's
+``handle`` returns itself to claim a row and passes it to the next presenter otherwise, and ``ToolPresenter`` is the
+fallback for any tool no named presenter took. Adding a kind of row is three things: a member of the enum, an entry
+class, and a presenter that claims it.
 
 A presenter also says what its rows depend on (:meth:`Presenter.look`) and whether
 it draws its own marker in the gutter, because both are facts about the same code
@@ -15,10 +15,11 @@ transcript view then stacks the cached rows into one virtualized line source.
 
 from __future__ import annotations
 
-from typing import Any, TypeVar
+from typing import Any, ClassVar, TypeVar
 
 from zettcode.plugin_api.entries import (
     ChangesEntry,
+    DeleteEntry,
     EditEntry,
     Entry,
     EntryKind,
@@ -36,7 +37,14 @@ from zettcode.plugin_api.entries import (
     WaitEntry,
     WriteEntry,
 )
-from zettcode.plugin_api.presenters import CONTENT_INDENT, Indented, LeadingGap, Presenter, Presenters
+from zettcode.plugin_api.presenters import (
+    CONTENT_INDENT,
+    Indented,
+    LeadingGap,
+    NextPresenter,
+    Presenter,
+    Presenters,
+)
 from zettcode.tui import (
     DONE,
     ELLIPSIS,
@@ -156,7 +164,9 @@ def _unindented(spans: list[Span]) -> list[Span]:
 class WelcomePresenter(Presenter[TextEntry]):
     """Draw the shared brand pixels unchanged, with themed title and hint text."""
 
-    kind = EntryKind.WELCOME
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim the welcome banner, and nothing else."""
+        return self if entry.kind is EntryKind.WELCOME else next(entry)
 
     def lines(self, entry: TextEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Keep labels beside the mark, stacking them when the window is narrow."""
@@ -193,7 +203,9 @@ class NoticePresenter(Presenter[TextEntry]):
     failure is what the palette's error colour is for.
     """
 
-    kind = EntryKind.NOTICE
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim a notice, and nothing else."""
+        return self if entry.kind is EntryKind.NOTICE else next(entry)
 
     def lines(self, entry: TextEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Leave a blank separator and let the transcript gutter add the inset."""
@@ -204,7 +216,9 @@ class NoticePresenter(Presenter[TextEntry]):
 class AnnouncementPresenter(Presenter[TextEntry]):
     """Center an announcement — a model or effort change — between rules."""
 
-    kind = EntryKind.ANNOUNCEMENT
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim an announcement, and nothing else."""
+        return self if entry.kind is EntryKind.ANNOUNCEMENT else next(entry)
 
     def lines(self, entry: TextEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Center the label inside the padded content box.
@@ -238,9 +252,12 @@ class AnnouncementPresenter(Presenter[TextEntry]):
 class UserPresenter(Presenter[TextEntry]):
     """Paint a full-width message surface with its arrow flush left."""
 
-    kind = EntryKind.USER
     gutter = True
 
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim the reader's message, and nothing else."""
+        return self if entry.kind is EntryKind.USER else next(entry)
+
     def lines(self, entry: TextEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Wrap the message and fill each row to the edge of the surface.
 
@@ -297,9 +314,12 @@ class RelayPresenter(Presenter[RelayEntry]):
     and the accent for this reader's own message to it.
     """
 
-    kind = EntryKind.RELAY
     gutter = True
 
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim a message between sessions, and nothing else."""
+        return self if entry.kind is EntryKind.RELAY else next(entry)
+
     def lines(self, entry: RelayEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Return the header and the wrapped message on the surface, every row filled to the edge."""
         if entry.outgoing:
@@ -355,9 +375,12 @@ class WaitPresenter(Presenter[WaitEntry]):
     request that was stopped still says how long it ran and when it stopped.
     """
 
-    kind = EntryKind.WAIT
     gutter = True
 
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim the wait row, and nothing else."""
+        return self if entry.kind is EntryKind.WAIT else next(entry)
+
     def look(self, entry: WaitEntry, frame: int) -> object:
         """Add the animation step while the row runs; a settled row is a line.
 
@@ -416,9 +439,12 @@ class WaitPresenter(Presenter[WaitEntry]):
 class ThinkingPresenter(Presenter[ThinkingEntry]):
     """Draw reasoning in the "model" hue, apart from the tool rows' green."""
 
-    kind = EntryKind.THINKING
     gutter = True
 
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim a reasoning row, and nothing else."""
+        return self if entry.kind is EntryKind.THINKING else next(entry)
+
     def lines(self, entry: ThinkingEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Show the heading, plus the indented body when expanded."""
         header = Style(foreground=theme.accent_bright)
@@ -456,9 +482,12 @@ class ToolPresenter(Presenter[T]):
     them and cannot drift apart.
     """
 
-    kind = EntryKind.TOOL
     gutter = True
 
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim any tool row that no more specific presenter took first."""
+        return self if entry.kind is EntryKind.TOOL else next(entry)
+
     def lines(self, entry: T, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Show the call, elapsed time, and whatever body the tool's entry has."""
         running = entry.running
@@ -529,7 +558,27 @@ class ToolPresenter(Presenter[T]):
         return lines
 
 
-class SessionMessagePresenter(ToolPresenter[MessageEntry]):
+class NamedToolPresenter(ToolPresenter[T]):
+    """A tool presenter that claims the tools it names, and leaves every other tool to the next presenter."""
+
+    names: ClassVar[frozenset[str]] = frozenset()
+    requires: ClassVar[type[ToolEntry] | None] = None
+
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim a tool row by the tool's own name; any other row goes on.
+
+        A presenter that reads fields only its family's entry carries names that class in :attr:`requires`, so a
+        plain entry for the same tool — one a handler opened without its family class — is left to the fallback
+        instead of failing on a field it does not have.
+        """
+        if not isinstance(entry, ToolEntry) or entry.tool not in self.names:
+            return next(entry)
+        if self.requires is not None and not isinstance(entry, self.requires):
+            return next(entry)
+        return self
+
+
+class SessionMessagePresenter(NamedToolPresenter[MessageEntry]):
     """A message the agent sent to another session: what it said, then how it ended.
 
     Folded, the row shows the first lines of the message and the one-line outcome; expanded, every
@@ -538,7 +587,8 @@ class SessionMessagePresenter(ToolPresenter[MessageEntry]):
     result — muted when it went, the error colour when it did not.
     """
 
-    entry_type = MessageEntry
+    names = frozenset({"send_message"})
+    requires = MessageEntry
 
     def body_lines(self, entry: MessageEntry, width: int, theme: Theme, muted: Style) -> list[TextLine]:
         """Return the message, bounded as any tool output is, and the outcome under it."""
@@ -567,10 +617,11 @@ class SessionMessagePresenter(ToolPresenter[MessageEntry]):
         return lines
 
 
-class ReadPresenter(ToolPresenter[ReadEntry]):
+class ReadPresenter(NamedToolPresenter[ReadEntry]):
     """A file that was read: the body is highlighted as the language the file is in, and the row says how much."""
 
-    entry_type = ReadEntry
+    names = frozenset({"read_file", "read"})
+    requires = ReadEntry
 
     def after_title(self, entry: ReadEntry, theme: Theme) -> list[Span]:
         """Say how many lines came back, beside the title rather than inside it.
@@ -598,7 +649,7 @@ def _change_counts(added: int, removed: int, theme: Theme) -> list[Span]:
     return spans
 
 
-class FileChangePresenter(ToolPresenter[F]):
+class FileChangePresenter(NamedToolPresenter[F]):
     """A tool that changed a file: the lines it changed beside the name, and the change under it.
 
     What a write and an edit share. They differ only in whether anything is taken away
@@ -655,19 +706,81 @@ class FileChangePresenter(ToolPresenter[F]):
 class WritePresenter(FileChangePresenter[WriteEntry]):
     """A file that was written whole: every line of it an addition."""
 
-    entry_type = WriteEntry
+    names = frozenset({"write_file"})
+    requires = WriteEntry
 
 
 class EditPresenter(FileChangePresenter[EditEntry]):
     """A file that was edited: the lines added and removed, and the change."""
 
-    entry_type = EditEntry
+    names = frozenset({"edit", "replace_in_file"})
+    requires = EditEntry
 
     def removed(self, entry: EditEntry) -> int:
         """Return the lines the edits remove."""
         return entry.removed
 
 
+class DeletePresenter(NamedToolPresenter[DeleteEntry]):
+    """A file that was deleted: the tool row names the file, and the deletion is the result."""
+
+    names = frozenset({"delete_file"})
+
+
+class ShellPresenter(NamedToolPresenter[ToolEntry]):
+    """A shell command: the command is the title, and its output is the body."""
+
+    names = frozenset({"bash"})
+
+
+class SearchPresenter(NamedToolPresenter[ToolEntry]):
+    """A listing or a content search: the pattern and where it looked are the title."""
+
+    names = frozenset({"glob", "grep"})
+
+
+class WebSearchPresenter(NamedToolPresenter[ToolEntry]):
+    """A web search: the endpoint ran it, so the query is the whole of the row's title."""
+
+    names = frozenset({"web_search"})
+
+
+class AskUserPresenter(NamedToolPresenter[ToolEntry]):
+    """A question put to the reader: the body is what they did, not the shell's payload."""
+
+    names = frozenset({"ask_user"})
+
+
+class TodoPresenter(NamedToolPresenter[ToolEntry]):
+    """A plan update: the number of steps is the story."""
+
+    names = frozenset({"todo_write"})
+
+
+class SkillPresenter(NamedToolPresenter[ToolEntry]):
+    """A skill whose instructions were read."""
+
+    names = frozenset({"read_skill"})
+
+
+class TaskPresenter(NamedToolPresenter[ToolEntry]):
+    """Work handed to a subagent: the profile names the row, and the report is the body."""
+
+    names = frozenset({"task"})
+
+
+class HistoryPresenter(NamedToolPresenter[ToolEntry]):
+    """A read of what was said before, with a session or in a group."""
+
+    names = frozenset({"message_history"})
+
+
+class GroupPresenter(NamedToolPresenter[ToolEntry]):
+    """A change to a group chat: what was done, to which group, and with whom."""
+
+    names = frozenset({"manage_group"})
+
+
 #: Files listed under "Changed N files" before the rest are counted. A request that rewrote forty
 #: files has a summary that is a summary, not the list of them.
 MAX_CHANGED_ROWS = 8
@@ -688,7 +801,9 @@ class ChangesPresenter(Presenter[ChangesEntry]):
     The same colours as the tool rows above it, so a count means the same thing in both places.
     """
 
-    kind = EntryKind.CHANGES
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim the changed-files summary, and nothing else."""
+        return self if entry.kind is EntryKind.CHANGES else next(entry)
 
     def lines(self, entry: ChangesEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Return the summary under a blank separator, each row cut at the width."""
@@ -728,6 +843,10 @@ class MarkdownPresenter(Presenter[MarkdownEntry]):
     look-keyed cache: the source is the cache.
     """
 
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim a Markdown row that a more specific answer or message presenter did not take first."""
+        return self if isinstance(entry, MarkdownEntry) else next(entry)
+
     def lines(self, entry: MarkdownEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Return every row of the document at one width, for a caller that wants them all."""
         entry.markdown.theme = theme
@@ -745,13 +864,17 @@ class MarkdownPresenter(Presenter[MarkdownEntry]):
 class AnswerPresenter(MarkdownPresenter):
     """Present the model's reply as it streams in."""
 
-    kind = EntryKind.ANSWER
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim the model's reply, and nothing else."""
+        return self if entry.kind is EntryKind.ANSWER else next(entry)
 
 
 class MessagePresenter(MarkdownPresenter):
     """Present Markdown that is not a reply, such as a command's output."""
 
-    kind = EntryKind.MESSAGE
+    def handle(self, entry: Entry, next: NextPresenter) -> Presenter[Any]:
+        """Claim Markdown that is not a reply, and nothing else."""
+        return self if entry.kind is EntryKind.MESSAGE else next(entry)
 
 
 BUILTIN_PRESENTERS: tuple[Presenter[Any], ...] = (
@@ -770,6 +893,16 @@ BUILTIN_PRESENTERS: tuple[Presenter[Any], ...] = (
     WritePresenter(),
     EditPresenter(),
     SessionMessagePresenter(),
+    DeletePresenter(),
+    ShellPresenter(),
+    SearchPresenter(),
+    WebSearchPresenter(),
+    AskUserPresenter(),
+    TodoPresenter(),
+    SkillPresenter(),
+    TaskPresenter(),
+    HistoryPresenter(),
+    GroupPresenter(),
 )
 
 #: How a transcript draws entries when nothing has registered a presenter: the built-in ones, at the