zettcode 0.1.12__tar.gz → 0.3.0__tar.gz

{zettcode-0.1.12 → zettcode-0.3.0}/.gitignore

@@ -24,6 +24,10 @@ docs/.vitepress/.temp/
 # The TypeScript client is built from its sources; only dist/ is published.
 clients/typescript/dist/
 
+# The gateway's page is built from clients/gateway into the package when a distribution is made (`make gateway-ui`);
+# the build output is not kept in the repository. pyproject's `artifacts` puts it in the wheel all the same.
+zettcode/src/zettcode/gateway/static/
+
 # The palette gallery is generated by `make palettes`: every widget painted in
 # every palette, written by docs/scripts/palette_gallery.py. Regenerate it
 # rather than committing a 2 MB copy that goes stale the moment a colour moves.

{zettcode-0.1.12 → zettcode-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode
-Version: 0.1.12
+Version: 0.3.0
 Summary: A focused terminal coding agent powered by zett-agent
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Project-URL: Issues, https://github.com/Chang-LeHung/zettcode/issues
@@ -35,7 +35,7 @@ Requires-Dist: truststore<1,>=0.10
 Requires-Dist: uvicorn<1,>=0.35
 Requires-Dist: wcwidth<1,>=0.2
 Requires-Dist: websockets<17,>=15
-Requires-Dist: zett-agent<0.3,>=0.2.0
+Requires-Dist: zett-agent<0.3,>=0.2.2
 Description-Content-Type: text/markdown
 
 # ZettCode

{zettcode-0.1.12 → zettcode-0.3.0}/pyproject.toml

@@ -57,13 +57,17 @@ dependencies = [
   # tiktoken, and httpx behind their first use, so warming a runtime costs less
   # than it did. An exact pin would make zettcode fight every other tool that
   # shares the dependency — including an upgrade of zett-agent itself, which pip
-  # would downgrade to satisfy it.
-  "zett-agent>=0.2.0,<0.3",
+  # would downgrade to satisfy it. 0.2.2 is the floor for one reason this program
+  # now leans on: a hosted tool the provider left open is closed with
+  # ``output={"status": "not_reported"}`` instead of leaving the step waiting, and
+  # `engine/server_tools.describe_output` reads that to say so.
+  "zett-agent>=0.2.2,<0.3",
 ]
 
 [project.scripts]
 zettcode = "zettcode.cli:main"
 zettcode-server = "zettcode.server.cli:main"
+zettcode-gateway = "zettcode.gateway.cli:main"
 
 [project.urls]
 Repository = "https://github.com/Chang-LeHung/zettcode"
@@ -77,6 +81,11 @@ build-backend = "hatchling.build"
 # Single source of truth: the version is written once, in the package.
 path = "src/zettcode/__init__.py"
 
+# The gateway's page is built (make gateway-ui) into the package and is not in git; hatchling skips what git ignores
+# unless it is named here.
+[tool.hatch.build]
+artifacts = ["src/zettcode/gateway/static/**"]
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/zettcode"]
 

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/__init__.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 #: The one place the version is written. ``pyproject.toml`` reads it from here
 #: and the release workflow checks the tag against it, so a bump is one edit.
-__version__ = "0.1.12"
+__version__ = "0.3.0"
 
 #: Where each public name lives; read by :func:`__getattr__` on first use.
 _EXPORTS = {

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/agent/agent/commands.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from zettcode.app.commands import Command, CommandContext, CommandHost, CommandResult
 from zettcode.app.pets import PetCatalog, bundled_pets
 from zettcode.app.plugins.host import HOST_LINK, HostLink
-from zettcode.app.plugins.plugin import TerminalPlugins
+from zettcode.app.plugins.plugin import TuiPlugins
 from zettcode.app.plugins.state import TurnSegment, UiRow
 from zettcode.engine.agent.exports import ExportsMixin
 from zettcode.providers import BUILTIN_PROVIDERS, Provider, merge_providers
@@ -28,10 +28,10 @@ class CommandsMixin(AppearanceMixin, ExportsMixin):
     """The ``/new``, ``/compact``, and ``/export`` commands, and the plugins' commands, mentions, and rows."""
 
     @property
-    def terminal_plugins(self) -> TerminalPlugins:
+    def terminal_plugins(self) -> TuiPlugins:
         """Return what the plugins contributed to the terminal; the engine was built with the terminal's loader."""
         plugins = self.runtime.plugins
-        if not isinstance(plugins, TerminalPlugins):
+        if not isinstance(plugins, TuiPlugins):
             raise TypeError("This agent's engine was not built with the terminal's plugin loader")
         return plugins
 

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/agent/conversation/entries.py

@@ -243,10 +243,16 @@ class ToolEntry(TimedEntry):
 class ReadEntry(ToolEntry):
     """A file that was read: its body is source code, drawn as the language it is.
 
-    ``language`` names the scanner for the output, or is ``None`` for a file that is not code.
+    ``language`` names the scanner for the output, or is ``None`` for a file that is not code. ``lines`` is how many
+    lines came back, once a completed read has one; it is a field of the row rather than part of its title, so the
+    title being restated or cut at the width cannot lose it. ``picture`` marks a path that looks like a picture — the suffix the read tool
+    sends as an image — since a row is opened from the arguments, before the result exists; a file whose content is an
+    image under another name is counted as text until the result itself says otherwise.
     """
 
     language: str | None = None
+    lines: int | None = None
+    picture: bool = False
 
 
 @dataclass(slots=True, kw_only=True)

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/agent/conversation/presenters.py

@@ -680,10 +680,21 @@ class SessionMessagePresenter(ToolPresenter[MessageEntry]):
 
 
 class ReadPresenter(ToolPresenter[ReadEntry]):
-    """A file that was read: the body is highlighted as the language the file is in."""
+    """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
 
+    def after_title(self, entry: ReadEntry, theme: Theme) -> list[Span]:
+        """Say how many lines came back, beside the title rather than inside it.
+
+        A field of the row survives what a title does not: `restate_tool` rewrites the title from the arguments, and
+        the count is drawn from the entry, the way an edit's ``+N -N`` is. A row too narrow for the title and the
+        count together cuts the count, as it cuts any tail — an edit's counts go the same way.
+        """
+        if entry.lines is None:
+            return []
+        return [Span(f" \u00b7 {entry.lines} line" + ("" if entry.lines == 1 else "s"), Style(foreground=theme.subtle))]
+
     def body_lines(self, entry: ReadEntry, width: int, theme: Theme, muted: Style) -> list[TextLine]:
         """Show the output as source code when the file is."""
         return self.output_lines(entry, width, theme, muted, language=entry.language)

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/agent/conversation/rendering.py

@@ -33,7 +33,7 @@ from pathlib import Path
 from zettcode.tui import ELLIPSIS, SEPARATOR
 from zettcode.tui.render import GENERIC, language_for
 
-from .entries import DeleteEntry, EditEntry, MessageEntry, ReadEntry, ToolEntry, WriteEntry
+from .entries import DeleteEntry, EditEntry, EntryStatus, MessageEntry, ReadEntry, ToolEntry, WriteEntry
 from .text import DECLINED_NOTE, limit_output
 
 #: Output kinds the chain shapes; a link claims one or more of them.
@@ -41,9 +41,25 @@ TOOL = "tool"
 THINKING = "thinking"
 ANSWER = "answer"
 
+#: Suffixes that look like a picture, copied from the read tool's accepted set: a row is opened from the arguments,
+#: before the result exists, so the suffix is all it has. The durable answer is a boolean on the finished event, taken
+#: from the result's own content — see :func:`is_picture_path`.
+PICTURE_SUFFIXES = frozenset({".png", ".jpg", ".jpeg", ".gif", ".webp"})
+
+
+def is_picture_path(path: str) -> bool:
+    """Return whether ``path`` looks like a picture by its suffix.
+
+    A guess, and named like one: the read tool decides by the file's signature, so a PNG copied to ``.bin`` is counted
+    as text and a text file named ``notes.png`` is not counted. Both are a line about a row nobody is reading closely;
+    the exact answer needs the boolean the result will carry (see :data:`PICTURE_SUFFIXES`).
+    """
+    return Path(path).suffix.lower() in PICTURE_SUFFIXES
+
+
 #: The hint a bounded read leaves behind; it is advice for the model, not the
 #: reader, and the row already shows the text it applies to.
-CONTINUATION = re.compile(r"\n?\.\.\. \[(?:line truncated|more lines)[^\]]*\]\s*\Z")
+CONTINUATION = re.compile(r"\n?\.\.\. \[(?:line truncated|output truncated|more lines)[^\]]*\]\s*\Z")
 
 #: Wrapper tags a model may leave around its reasoning channel.
 REASONING_TAGS = re.compile(r"</?(?:think(?:ing)?|reasoning)>|<\|(?:thinking|reasoning)\|>", re.IGNORECASE)
@@ -128,6 +144,16 @@ class RenderHandler(ABC):
         """Return the text under a tool row; only a tool link changes this."""
         return output
 
+    def finished(self, entry: ToolEntry, text: str, status: EntryStatus) -> None:
+        """Adjust a row now that its result is in — a count, a size — and change nothing by default.
+
+        Args:
+            entry: The row, whose body is already set and bounded.
+            text: The body as it came back, after :meth:`body` shaped it and before it was bounded.
+            status: Whether the call completed, failed or was skipped: a row may only count what worked.
+        """
+        return None
+
     def text(self, text: str, *, opening: bool) -> str:
         """Return one streamed fragment, unchanged unless a link shapes it.
 
@@ -183,6 +209,12 @@ class Renderers:
         handler = self._claim(TOOL, name)
         return output if handler is None else handler.body(name, output)
 
+    def finished(self, entry: ToolEntry, text: str, status: EntryStatus) -> None:
+        """Let the claiming link adjust a row once its result is in."""
+        handler = self._claim(TOOL, entry.tool)
+        if handler is not None:
+            handler.finished(entry, text, status)
+
     def text(self, kind: str, text: str, *, opening: bool = False) -> str:
         """Return one streamed fragment of ``kind``, shaped by the claiming link."""
         handler = self._claim(kind)
@@ -197,38 +229,48 @@ def argument(arguments: Mapping[str, object], key: str, default: str = "") -> st
     return default
 
 
-def edited_lines(edits: object) -> tuple[int, int]:
+def edit_changes(arguments: Mapping[str, object]) -> tuple[tuple[str, str], ...]:
+    """Return the text pairs an ``edit`` call replaces: one pair now, a list of them from an older transcript.
+
+    A call carries ``old_string`` and ``new_string``. A session stored before that shape gave the arguments an
+    ``edits`` list, and it is read the same way so the row of an old transcript still shows its diff. Anything
+    that is not two strings is dropped rather than guessed at.
+    """
+    legacy = arguments.get("edits")
+    if isinstance(legacy, Sequence) and not isinstance(legacy, str):
+        return tuple(
+            (edit["old_text"], edit["new_text"])
+            for edit in legacy
+            if isinstance(edit, Mapping)
+            and isinstance(edit.get("old_text"), str)
+            and isinstance(edit.get("new_text"), str)
+        )
+    old_string, new_string = arguments.get("old_string"), arguments.get("new_string")
+    if isinstance(old_string, str) and isinstance(new_string, str):
+        return ((old_string, new_string),)
+    return ()
+
+
+def edited_lines(changes: Sequence[tuple[str, str]]) -> tuple[int, int]:
     """Return the lines an ``edit`` call adds and removes.
 
-    The tool answers ``Replaced 2 occurrences in app.py``, which says how many
-    edits landed but not how large they were: a two-line fix and a two-hundred-line
-    rewrite read the same. The edits carry both texts, so the difference is counted
-    here — with :class:`difflib.SequenceMatcher` rather than by subtracting lengths,
-    because a replacement that keeps the lines around it should not read as a
-    rewrite, and that is what a reader comparing two rows is looking at.
+    The tool answers ``Replaced 1 occurrence in app.py``, which says that a change landed but not how large it was:
+    a two-line fix and a two-hundred-line rewrite read the same. The call carries both texts, so the difference is
+    counted here — with :class:`difflib.SequenceMatcher` rather than by subtracting lengths, because a replacement
+    that keeps the lines around it should not read as a rewrite, and that is what a reader comparing two rows is
+    looking at.
 
     Args:
-        edits: The call's ``edits`` argument, as the model sent it: a sequence of
-            mappings with ``old_text`` and ``new_text``. Anything else is ignored
-            rather than guessed at.
+        changes: The old and new text of each change, as :func:`edit_changes` reads them.
 
     Returns:
-        ``(added, removed)`` across every edit; ``(0, 0)`` when there is nothing
-        countable, which is also what a call with no edits at all answers.
+        ``(added, removed)`` across every change; ``(0, 0)`` when the call carried nothing countable.
 
-    An edit that replaces every occurrence counts once, not once per occurrence:
-    how many the file holds is something only the file knows, and the tool's own
-    answer is where that number appears.
+    A change that replaces every occurrence counts once, not once per occurrence: how many the file holds is
+    something only the file knows, and the tool's own answer is where that number appears.
     """
-    if not isinstance(edits, Sequence) or isinstance(edits, str):
-        return (0, 0)
     added = removed = 0
-    for edit in edits:
-        if not isinstance(edit, Mapping):
-            continue
-        old_text, new_text = edit.get("old_text"), edit.get("new_text")
-        if not isinstance(old_text, str) or not isinstance(new_text, str):
-            continue
+    for old_text, new_text in changes:
         matcher = difflib.SequenceMatcher(None, old_text.splitlines(), new_text.splitlines())
         for tag, old_start, old_end, new_start, new_end in matcher.get_opcodes():
             if tag in ("replace", "delete"):
@@ -238,31 +280,24 @@ def edited_lines(edits: object) -> tuple[int, int]:
     return (added, removed)
 
 
-def edit_diff(edits: object, *, limit: int = MAX_DIFF_ROWS) -> tuple[DiffRow, ...]:
+def edit_diff(changes: Sequence[tuple[str, str]], *, limit: int = MAX_DIFF_ROWS) -> tuple[DiffRow, ...]:
     """Return the rows of the change an ``edit`` call makes.
 
-    Each edit carries the text it replaces and the text it puts there, so the change can be shown
+    Each change carries the text it replaces and the text it puts there, so the change can be shown
     without reading the file: the lines that differ, and one unchanged line around each so it reads in
-    place. Edits are told apart by a labelled break when there is more than one, and what is kept is
-    cut at ``limit`` rows with a last row saying so, because the arguments can be a whole file.
+    place. Changes are told apart by a labelled break when there is more than one — which only an older
+    transcript has — and what is kept is cut at ``limit`` rows with a last row saying so, because the
+    arguments can be a whole file.
 
     Args:
-        edits: The call's ``edits`` argument as the model sent it; anything that is not a mapping with
-            two texts is skipped rather than guessed at, exactly as :func:`edited_lines` does.
+        changes: The old and new text of each change, as :func:`edit_changes` reads them.
         limit: Most rows to keep.
     """
-    if not isinstance(edits, Sequence) or isinstance(edits, str):
-        return ()
-    usable = [
-        edit
-        for edit in edits
-        if isinstance(edit, Mapping) and isinstance(edit.get("old_text"), str) and isinstance(edit.get("new_text"), str)
-    ]
     rows: list[DiffRow] = []
-    for number, edit in enumerate(usable, start=1):
-        if len(usable) > 1:
-            rows.append(("@", f"edit {number} of {len(usable)}"))
-        old_lines, new_lines = edit["old_text"].splitlines(), edit["new_text"].splitlines()
+    for number, (old_text, new_text) in enumerate(changes, start=1):
+        if len(changes) > 1:
+            rows.append(("@", f"edit {number} of {len(changes)}"))
+        old_lines, new_lines = old_text.splitlines(), new_text.splitlines()
         opcodes = difflib.SequenceMatcher(None, old_lines, new_lines).get_opcodes()
         for index, (tag, old_start, old_end, new_start, new_end) in enumerate(opcodes):
             if tag == "equal":
@@ -350,6 +385,15 @@ def _value_text(value: object) -> str:
     return str(value)
 
 
+def file_path(arguments: Mapping[str, object], default: str = "") -> str:
+    """Return the path a file tool was called for.
+
+    ``file_path`` is the argument now; a session stored before the rename carries ``path``, and is still shown the
+    file it changed rather than as an unknown one.
+    """
+    return argument(arguments, "file_path") or argument(arguments, "path") or default
+
+
 def language_for_path(path: str) -> str | None:
     """Return the scanner for a file's contents, or ``None`` when it is not code."""
     language = language_for(Path(path).suffix.lstrip("."))
@@ -363,22 +407,40 @@ class ReadTool(ToolHandler):
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
         """Show the file, and highlight the body as the language it is."""
-        path = argument(arguments, "path", "(unknown file)")
+        path = file_path(arguments, "(unknown file)")
         return ToolRow(f"Read {path}", language_for_path(path))
 
     def open_tool(
         self, name: str, arguments: Mapping[str, object], *, id: int, call_id: str, started_at: float
     ) -> ToolEntry:
-        """A read row, which knows the language its body is in."""
+        """A read row, which knows the language its body is in, and whether the file is a picture."""
         row = self.describe(name, arguments)
+        path = file_path(arguments)
         return ReadEntry(
-            id=id, call_id=call_id, tool=name, title=row.title, language=row.language, started_at=started_at
+            id=id,
+            call_id=call_id,
+            tool=name,
+            title=row.title,
+            language=row.language,
+            picture=is_picture_path(path),
+            started_at=started_at,
         )
 
     def body(self, name: str, output: str) -> str:
         """Drop the continuation hint; the row bounds the text it applies to."""
         return CONTINUATION.sub("", output).rstrip()
 
+    def finished(self, entry: ToolEntry, text: str, status: EntryStatus) -> None:
+        """Count what the read returned, on the row, if it returned text and the call worked.
+
+        The count is of what came back — a range asked for is not the same number — and of the whole of it, not of
+        the preview the row keeps, so a read past the output limit is counted in full. A picture carries no lines,
+        and a failed call's body is the error message rather than the file, so neither is counted.
+        """
+        if status is not EntryStatus.COMPLETED or not isinstance(entry, ReadEntry) or entry.picture:
+            return
+        entry.lines = len(text.splitlines())
+
 
 class WriteTool(ToolHandler):
     """``write_file``: the file being written."""
@@ -387,7 +449,7 @@ class WriteTool(ToolHandler):
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
         """Show the file being written: the row is the call, so it says what the call does, not what it did."""
-        return ToolRow(f"Write {argument(arguments, 'path', '(unknown file)')}")
+        return ToolRow(f"Write {file_path(arguments, '(unknown file)')}")
 
     def open_tool(
         self, name: str, arguments: Mapping[str, object], *, id: int, call_id: str, started_at: float
@@ -399,7 +461,7 @@ class WriteTool(ToolHandler):
             call_id=call_id,
             tool=name,
             title=self.describe(name, arguments).title,
-            path=argument(arguments, "path"),
+            path=file_path(arguments),
             added=written_lines(content),
             diff=write_diff(content),
             started_at=started_at,
@@ -407,25 +469,21 @@ class WriteTool(ToolHandler):
 
 
 class EditTool(ToolHandler):
-    """``edit``: the file and how many edits the call carries.
+    """``edit``: the file, and the size of the one change the call makes.
 
-    A session stored before the tool was renamed calls it ``replace_in_file``, and is still shown the same way.
+    A session stored before the tool was renamed calls it ``replace_in_file``, and is still shown the same way; one
+    stored before a call carried a single change gave it a list under ``edits``, and that list is read too.
     """
 
     names = frozenset({"edit", "replace_in_file"})
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
-        """Count the edits, and the lines they add and remove, before they land.
+        """Show the file; the size of the change is drawn beside the title, before it lands.
 
-        A multi-edit call and a one-line call are both worth seeing in advance, and
-        so is the size of the change: `+12 -3` beside the file says whether this is
-        a tweak or a rewrite, which is the question a reader asks the row.
+        `+12 -3` beside the file says whether this is a tweak or a rewrite, which is the question a reader asks
+        the row. One change a call is why the title counts nothing: a count of one is noise on every row.
         """
-        path = argument(arguments, "path", "(unknown file)")
-        edits = arguments.get("edits")
-        count = len(edits) if isinstance(edits, Sequence) and not isinstance(edits, str) else 0
-        suffix = f" ({count} edit{'' if count == 1 else 's'})" if count else ""
-        return ToolRow(f"Edited {path}{suffix}")
+        return ToolRow(f"Edit {file_path(arguments, '(unknown file)')}")
 
     def open_tool(
         self, name: str, arguments: Mapping[str, object], *, id: int, call_id: str, started_at: float
@@ -435,17 +493,17 @@ class EditTool(ToolHandler):
         The counts ride outside the title: they are drawn in the colours an addition and a
         deletion get, which a title made of one string cannot be.
         """
-        edits = arguments.get("edits")
-        added, removed = edited_lines(edits)
+        changes = edit_changes(arguments)
+        added, removed = edited_lines(changes)
         return EditEntry(
             id=id,
             call_id=call_id,
             tool=name,
             title=self.describe(name, arguments).title,
-            path=argument(arguments, "path"),
+            path=file_path(arguments),
             added=added,
             removed=removed,
-            diff=edit_diff(edits),
+            diff=edit_diff(changes),
             started_at=started_at,
         )
 
@@ -457,7 +515,7 @@ class DeleteTool(ToolHandler):
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
         """Show the file being removed."""
-        return ToolRow(f"Deleted {argument(arguments, 'path', '(unknown file)')}")
+        return ToolRow(f"Deleted {file_path(arguments, '(unknown file)')}")
 
     def open_tool(
         self, name: str, arguments: Mapping[str, object], *, id: int, call_id: str, started_at: float
@@ -468,19 +526,21 @@ class DeleteTool(ToolHandler):
             call_id=call_id,
             tool=name,
             title=self.describe(name, arguments).title,
-            path=argument(arguments, "path"),
+            path=file_path(arguments),
             started_at=started_at,
         )
 
 
 class ShellTool(ToolHandler):
-    """``bash``: the command itself, which is the whole story."""
+    """``bash``: the command itself, and the directory it runs in when the call names one."""
 
     names = frozenset({"bash"})
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
-        """Show the command, not a JSON copy of it."""
-        return ToolRow(f"Ran {argument(arguments, 'command', '(unknown command)')}")
+        """Show the command, not a JSON copy of it, and where it runs when that is not the workspace."""
+        command = argument(arguments, "command", "(unknown command)")
+        where = argument(arguments, "work_dir")
+        return ToolRow(f"Bash {command}" + (f" {SEPARATOR} {where}" if where else ""))
 
 
 class SearchTool(ToolHandler):
@@ -493,7 +553,7 @@ class SearchTool(ToolHandler):
         pattern = argument(arguments, "pattern")
         if name == "glob":
             return ToolRow(f"Listed {pattern}" if pattern else "Listed files")
-        where = argument(arguments, "path")
+        where = argument(arguments, "file_pattern") or argument(arguments, "path")
         return ToolRow(f"Searched {pattern or 'the workspace'}" + (f" in {where}" if where else ""))
 
 
@@ -631,6 +691,33 @@ class MessageTool(ToolHandler):
         )
 
 
+class NamespacedTool(ToolHandler):
+    """A tool whose name carries where it came from: ``server__tool``, so the row names the server.
+
+    The server is part of what the call was: the same ``search`` in two servers is two different tools, with
+    different reach and different answers, and a row that drops the server makes them look like one.
+
+    The name is all a renderer knows, so the row says what the name says — ``github/create_issue`` — and not that
+    the tool speaks MCP: a plugin registers a namespaced name of its own with the same shape, and the runtime does
+    not mark its remote tools here. A name without both parts is shown as it arrived.
+    """
+
+    def handles(self, kind: str, name: str = "") -> bool:
+        """Claim a namespaced name that no earlier link claimed."""
+        return kind == TOOL and "__" in name.strip("_") and not name.startswith("__")
+
+    def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
+        """Show ``server/tool``, so the row names where the capability came from.
+
+        The runtime names a remote tool ``<server>__<tool>``; a name that prefixed the family with ``mcp`` —
+        ``mcp__github__create_issue`` — is read the same way, and one without both parts keeps its own name.
+        """
+        remote = name[5:] if name.startswith("mcp__") else name
+        server, _, tool = remote.partition("__")
+        label = f"{server}/{tool}" if server and tool else name
+        return ToolRow(f"{label} {summarise(arguments)}".rstrip())
+
+
 class FallbackTool(ToolHandler):
     """Anything no other link claims: its name and flat arguments, never JSON."""
 
@@ -639,15 +726,8 @@ class FallbackTool(ToolHandler):
         return kind == TOOL
 
     def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
-        """Show ``name key=value`` so an unknown tool still reads as a sentence.
-
-        An MCP tool is namespaced ``<server>__<tool>``; the server is worth
-        keeping because it says where the capability comes from, but it reads
-        better after the tool than in front of it.
-        """
-        server, _, tool = name.partition("__")
-        label = f"{tool} (via {server})" if tool else name
-        return ToolRow(f"{label} {summarise(arguments)}".rstrip())
+        """Show ``name key=value`` so an unknown tool still reads as a sentence."""
+        return ToolRow(f"{name} {summarise(arguments)}".rstrip())
 
 
 class ReasoningHandler(RenderHandler):
@@ -705,6 +785,7 @@ DEFAULT_RENDERERS = Renderers(
         SkillTool(),
         TaskTool(),
         MessageTool(),
+        NamespacedTool(),
         FallbackTool(),
         ReasoningHandler(),
         AnswerHandler(),

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/agent/conversation/transcript/stream.py

@@ -164,7 +164,11 @@ class StreamMixin(TurnMixin):
             return
         # An unknown status is refused before the row is touched at all.
         outcome = EntryStatus(status)
-        entry.text = limit_output(self.renderers.body(entry.tool, output))
+        body = self.renderers.body(entry.tool, output)
+        entry.text = limit_output(body)
+        # The result, unbounded: a count is of what came back, not of the preview the row keeps, and what it says about
+        # the body depends on whether the call worked.
+        self.renderers.finished(entry, body, outcome)
         entry.finish(outcome, self.clock())
         self._changed(entry)
         # The loop calls the model again once the batch has produced its

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/commands.py

@@ -101,19 +101,24 @@ class CommandHost(Protocol):
     async def run_side_question(self, question: str) -> None:
         """Answer a question that is kept out of the conversation."""
 
-    async def prompt(self, text: str) -> bool:
+    async def prompt(self, text: str, *, shown: str | None = None) -> bool:
         """Run ``text`` as one turn of this conversation, exactly as if the reader had typed it.
 
-        The text reaches the model the way a draft does: echoed in the transcript as the reader's own message,
-        stored in the session, streamed as it is answered, and settled by the same row. ``@`` references are
-        resolved; pictures the text cannot carry are not part of it.
+        The text reaches the model the way a draft does: stored in the session, streamed as it is answered, and
+        settled by the same row. ``@`` references are resolved.
+
+        A command whose instructions are longer than what it wants to show passes the two apart: ``text`` is what
+        the model reads, ``shown`` is what the transcript draws in its place. A reader who typed ``/code-review``
+        sees that, not the brief it stands for — while the model reads the brief with that turn, then and in every
+        later turn, because the brief is part of the message the session keeps. Only its display is short.
 
         The turn is awaited, so the command that asked for it holds the request slot until it has been answered,
         and the row the shell shows is the command's own.
 
         Args:
-            text: What to ask. Its own text is what the reader sees, so a command that builds the text should
-                write it as a reader would have.
+            text: What to ask. With no ``shown``, this is also what the reader sees.
+            shown: What the transcript shows, when it differs from ``text``. The message the session keeps is
+                the same either way: ``text`` is in it, and ``shown`` is what a reader is shown of it.
 
         Returns:
             Whether a turn was started and has ended. A request already running, a blank text and a session held
@@ -247,7 +252,7 @@ class Command:
             its sessions, or the model, and is handled by
             :class:`~zettcode.app.agent.TerminalAgent`; ``"plugin"`` comes from
             an installed plugin, registered through
-            :class:`~zettcode.app.plugins.TerminalContainer`.
+            :class:`~zettcode.engine.plugins.context.PluginContext`.
         handler: Runs the command with a :class:`CommandContext` — the trimmed
             argument and the UI surfaces it may write to while it works — and
             returns a :class:`CommandResult` describing anything left to show.

{zettcode-0.1.12 → zettcode-0.3.0}/src/zettcode/app/pets/model.py

@@ -7,7 +7,7 @@ it, moves it, and picks the mood.
 
 Pets are offered the way palettes are: a :class:`PetSource` names one and builds it only when it is asked for,
 the built-in plugin offers the ones that ship, and any other plugin offers its own through
-``PluginContainer.register_pet``. :class:`PetCatalog` is what ``/pet`` and the start-up read.
+``ctx.tui.register_pet``. :class:`PetCatalog` is what ``/pet`` and the start-up read.
 
 Every frame of a pet is the same size, and its height is an even number of pixel rows: two pixels fit in
 one terminal cell.