kiwi-code 0.0.504__tar.gz → 0.0.505__tar.gz

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.504
+Version: 0.0.505
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.504"
+version = "0.0.505"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_cli/run_activity.py

@@ -37,6 +37,8 @@ NOTES_KEPT = 3
 #: The thinking blocks of a turn whose text is kept, and how much of each.
 THOUGHTS_KEPT = 20
 THOUGHT_CHARS = 8000
+#: The file changes whose diffs are kept, the latest only; older ones keep their counts.
+DIFFS_KEPT = 30
 #: The trace lines kept for the trace panel.
 TRACE_LINES = 200
 _TRACE_TEXT = 220
@@ -61,6 +63,9 @@ class ToolLine:
     args: str = ""  # the server's preview of its arguments, as indented JSON
     args_chars: int | None = None
     args_truncated: bool = False
+    #: The changes it made to files, as the user's runtime recorded them: path, added,
+    #: removed, diff (unified, without its header), truncated, created, deleted.
+    edits: list[dict] = field(default_factory=list)
 
 
 @dataclass
@@ -252,6 +257,10 @@ class RunActivityView:
         self._followed: tuple[str, int] | None = None
         self._following = False
         self.trace: deque[TraceLine] = deque(maxlen=TRACE_LINES)
+        # Each call's file changes, kept apart from the turns so a rebuild keeps them.
+        self._edits: dict[str, list[dict]] = {}
+        self._with_diff: deque[dict] = deque()
+        self._edits_seen: deque[tuple] = deque(maxlen=DIFFS_KEPT * 8)
         self.trace_start: int | None = None
         #: Counts every change, so a redraw can tell whether there is anything new.
         self.version = 0
@@ -348,6 +357,54 @@ class RunActivityView:
         turn = self.followed
         return turn is not None and turn.finished is not None
 
+    # ---- file changes ----
+
+    def add_edit(self, record: object) -> bool:
+        """A change the user's runtime made to a file, shown under the call that made it.
+        A record that names no call (an older backend) goes to the latest file tool of
+        the turn being followed. Whether it found a call."""
+        if not isinstance(record, dict):
+            return False
+        seen = (record.get("at"), record.get("call_id"), record.get("path"), record.get("op"))
+        if seen in self._edits_seen:
+            return False  # read again after the record file was trimmed
+        self._edits_seen.append(seen)
+        call_id = str(record.get("call_id") or "")
+        tool = self._tool(call_id) if call_id else None
+        if not call_id:
+            tool = self._latest_file_tool()
+            if tool is None:
+                return False
+            call_id = tool.call_id
+        edit = {k: record.get(k) for k in ("path", "added", "removed", "diff", "truncated", "created", "deleted")}
+        edits = self._edits.setdefault(call_id, [])
+        edits.append(edit)
+        if tool is not None:
+            tool.edits = edits
+        self._with_diff.append(edit)
+        while len(self._with_diff) > DIFFS_KEPT:
+            self._with_diff.popleft()["diff"] = ""
+        if len(self._edits) > DIFFS_KEPT * 4:
+            for key in list(self._edits)[: len(self._edits) - DIFFS_KEPT * 4]:
+                del self._edits[key]
+        self.version += 1
+        return True
+
+    def _tool(self, call_id: str) -> ToolLine | None:
+        for turn in reversed(self._turns):
+            if call_id in turn.tools:
+                return turn.tools[call_id]
+        return None
+
+    def _latest_file_tool(self) -> ToolLine | None:
+        turn = self.followed
+        if turn is None:
+            return None
+        for tool in reversed(list(turn.tools.values())):
+            if tool.name == "file_system_tool":
+                return tool
+        return None
+
     # ---- trace ----
 
     def _trace(self, event: dict) -> None:
@@ -451,6 +508,8 @@ class RunActivityView:
                 call_id=call_id, name=str(event.get("name") or "tool"), step=step,
                 parent=event.get("parent_call_id"),
             )
+            if call_id in self._edits:
+                tool.edits = self._edits[call_id]
             turn.tools[call_id] = tool
             turn.tool_total += 1
             turn._add(tool)

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_runtime/cli.py

@@ -42,6 +42,7 @@ from kiwi_runtime.ui import (
     BackgroundWriter,
     C,
     print_banner,
+    print_edit,
     print_section,
     print_status,
 )
@@ -361,6 +362,11 @@ def _run_until_stopped(loop: asyncio.AbstractEventLoop, runtime) -> None:
 
     terminal = sys.stdout
     sys.stdout = BackgroundWriter(terminal)
+    if getattr(terminal, "isatty", lambda: False)():
+        # Each change made to a file shows its diff here; not in a log file.
+        from kiwi_runtime.fs import edits
+
+        edits.show = print_edit
 
     try:
         loop.run_until_complete(runtime)

kiwi_code-0.0.505/src/kiwi_runtime/fs/edits.py

@@ -0,0 +1,185 @@
+"""The diff of each change the runtime makes to a file, for the TUI to show under the tool
+call that made it.
+
+One JSON line per change, in `~/.kiwi/edits/<run_id>.jsonl`:
+
+    {"v": 1, "at": 1760…, "run_id": "…", "call_id": "call_8f2a", "op": "replace_in_file",
+     "path": "src/app.py", "added": 2, "removed": 1, "diff": "@@ -3,3 +3,4 @@\\n…",
+     "truncated": false, "created": false, "deleted": false}
+
+The backend names the tool call (`call_id`) and run (`run_id`) in each request; a backend
+that does not falls back to the run this runtime is bound to. Recording a change never
+stops the change: anything that goes wrong here is skipped.
+"""
+from __future__ import annotations
+
+import contextvars
+import difflib
+import json
+import os
+import re
+import threading
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+#: The operations that change a file's content.
+MUTATING = frozenset({
+    "write_file", "append_file", "replace_in_file", "replace_line_range", "insert_at_line",
+    "apply_unified_diff", "file_write_finish", "delete_path",
+})
+#: Files larger than this are not read to diff (a log or a data dump is not worth it).
+MAX_FILE_BYTES = 2_000_000
+#: A diff is kept to this many lines; the counts still cover all of it.
+MAX_DIFF_LINES = 400
+#: A run's record file is trimmed to its latest changes once it grows past this.
+MAX_RECORD_BYTES = 1_000_000
+KEEP_RECORDS = 200
+
+#: Called with each record as it is made, e.g. to print the diff in the runtime's terminal.
+show: Callable[[dict[str, Any]], None] | None = None
+
+_lock = threading.Lock()
+# The tool call a batch belongs to, for the operations inside it, which do not name it.
+_LINK: contextvars.ContextVar[tuple[str, str] | None] = contextvars.ContextVar("kiwi_edit_link", default=None)
+
+
+def edits_dir() -> Path:
+    try:
+        from kiwi_cli.checkpoints import kiwi_home_dir
+
+        return kiwi_home_dir() / "edits"
+    except Exception:
+        return Path.home() / ".kiwi" / "edits"
+
+
+def edits_path(run_id: str) -> Path:
+    return edits_dir() / f"{re.sub(r'[^A-Za-z0-9_.-]', '_', run_id)}.jsonl"
+
+
+def link(msg: dict[str, Any]) -> contextvars.Token | None:
+    """While a request runs, what it says about its tool call and run, so the operations
+    of a batch inside it are recorded against the same call."""
+    call_id, run_id = str(msg.get("call_id") or ""), str(msg.get("run_id") or "")
+    if not (call_id or run_id):
+        return None
+    return _LINK.set((call_id, run_id))
+
+
+def unlink(token: contextvars.Token | None) -> None:
+    if token is not None:
+        _LINK.reset(token)
+
+
+def before(msg: dict[str, Any], *, mode: str, allowed_dirs: list[str] | None, chunked_writes: dict) -> tuple[str, str | None] | None:
+    """The file a change is about to touch and its text now (None if it cannot be read as
+    text), or None when the request changes no file."""
+    try:
+        op = msg.get("type")
+        if op not in MUTATING:
+            return None
+        if op == "file_write_finish":
+            state = chunked_writes.get(msg.get("upload_id"))
+            path = getattr(state, "path", None)
+        else:
+            from kiwi_runtime.restricted import validate_fs_path
+
+            raw = msg.get("path")
+            if not raw:
+                return None
+            ok, path, _reason = validate_fs_path(raw, mode, allowed_dirs)
+            if not ok:
+                return None
+        if not path or os.path.isdir(path):
+            return None
+        return str(path), _read_text(str(path))
+    except Exception:
+        return None
+
+
+def after(msg: dict[str, Any], watched: tuple[str, str | None]) -> None:
+    """Record the change a successful request made to the file `before` watched."""
+    try:
+        path, old = watched
+        if old is None:
+            return  # not text, or too large to diff
+        new = "" if msg.get("type") == "delete_path" else _read_text(path)
+        if new is None or new == old:
+            return
+        call_id, run_id = _LINK.get() or ("", "")
+        call_id = str(msg.get("call_id") or call_id)
+        run_id = str(msg.get("run_id") or run_id or _bound_run_id())
+        if not run_id:
+            return
+        record = _record(msg.get("type"), path, old, new, call_id=call_id, run_id=run_id)
+        _append(edits_path(run_id), record)
+        if show is not None:
+            show(record)
+    except Exception:
+        pass
+
+
+def _record(op: Any, path: str, old: str, new: str, *, call_id: str, run_id: str) -> dict[str, Any]:
+    lines = list(difflib.unified_diff(
+        old.splitlines(), new.splitlines(), lineterm="", n=3,
+    ))[2:]  # without the ---/+++ header: the path is shown on its own
+    added = sum(1 for line in lines if line.startswith("+"))
+    removed = sum(1 for line in lines if line.startswith("-"))
+    return {
+        "v": 1,
+        "at": time.time(),
+        "run_id": run_id,
+        "call_id": call_id,
+        "op": str(op or ""),
+        "path": _display_path(path),
+        "added": added,
+        "removed": removed,
+        "diff": "\n".join(lines[:MAX_DIFF_LINES]),
+        "truncated": len(lines) > MAX_DIFF_LINES,
+        "created": old == "" and op != "delete_path",
+        "deleted": op == "delete_path",
+    }
+
+
+def _read_text(path: str) -> str | None:
+    """The file's text; "" for a file not there yet; None for one too large or not text."""
+    try:
+        if not os.path.exists(path):
+            return ""
+        if os.path.getsize(path) > MAX_FILE_BYTES:
+            return None
+        with open(path, "rb") as f:
+            data = f.read()
+        if b"\0" in data[:8192]:
+            return None
+        return data.decode("utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+
+
+def _display_path(path: str) -> str:
+    try:
+        rel = os.path.relpath(path)
+        return path if rel.startswith("..") else rel
+    except ValueError:
+        return path
+
+
+def _bound_run_id() -> str:
+    try:
+        from kiwi_runtime.checkpoints import _get_current_run_id
+
+        return _get_current_run_id()
+    except Exception:
+        return ""
+
+
+def _append(target: Path, record: dict[str, Any]) -> None:
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+    with _lock:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with open(target, "a", encoding="utf-8") as f:
+            f.write(line)
+        if target.stat().st_size > MAX_RECORD_BYTES:
+            kept = target.read_text(encoding="utf-8").splitlines(keepends=True)[-KEEP_RECORDS:]
+            target.write_text("".join(kept), encoding="utf-8")

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_runtime/fs/handler.py

@@ -7,7 +7,7 @@ from concurrent.futures import ProcessPoolExecutor
 from concurrent.futures.process import BrokenProcessPool
 from typing import Any, Callable
 
-from kiwi_runtime.fs import batch, codelens, paths, read, search, upload, write
+from kiwi_runtime.fs import batch, codelens, edits, paths, read, search, upload, write
 from kiwi_runtime.fs.context import ChunkedWriteState, FsRequest
 
 FS_MAX_CONCURRENCY = 8
@@ -62,14 +62,22 @@ def _handle_fs_request_sync(
             "message": f"Unsupported file operation type: {msg_type}",
         }
 
+    # A change to a file is recorded with its diff, for the TUI to show under the call.
+    token = edits.link(msg)
+    watched = edits.before(msg, mode=mode, allowed_dirs=allowed_dirs, chunked_writes=chunked_writes)
     try:
-        return handler(FsRequest(msg, request_id, mode, allowed_dirs, chunked_writes))
+        result = handler(FsRequest(msg, request_id, mode, allowed_dirs, chunked_writes))
     except Exception as e:
         return {
             "request_id": request_id,
             "success": False,
             "message": str(e),
         }
+    finally:
+        edits.unlink(token)
+    if watched is not None and isinstance(result, dict) and result.get("success"):
+        edits.after(msg, watched)
+    return result
 
 
 # Pure-Python scans over many files. In a thread they would share the interpreter with the

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_runtime/ui.py

@@ -234,3 +234,26 @@ def print_pty_log(session_id: str, message: str, level: str = "info"):
     else:
         icon = f"{C}~{RESET}"
     _safe_print(f"  {icon} {tag} {message}")
+
+
+
+#: A diff printed under its request is kept to this many lines.
+SHOWN_DIFF_LINES = 40
+
+
+def print_edit(record: dict) -> None:
+    """The diff of a change made to a file, under the request that made it."""
+    added, removed = record.get("added") or 0, record.get("removed") or 0
+    what = "new file" if record.get("created") else "deleted" if record.get("deleted") else "edited"
+    lines = [
+        f"    {GREY}{what}{RESET} {BOLD}{record.get('path', '')}{RESET}  "
+        f"{GREEN}+{added}{RESET} {RED}-{removed}{RESET}"
+    ]
+    diff = str(record.get("diff") or "").splitlines()
+    for line in diff[:SHOWN_DIFF_LINES]:
+        color = GREEN if line.startswith("+") else RED if line.startswith("-") else C if line.startswith("@@") else GREY
+        lines.append(f"      {color}{line}{RESET}")
+    more = len(diff) - SHOWN_DIFF_LINES
+    if more > 0 or record.get("truncated"):
+        lines.append(f"      {GREY}… more lines not shown{RESET}")
+    _safe_print("\n".join(lines))

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_tui/main.py

@@ -309,9 +309,20 @@ class AutobotsTUI(App):
 
 
     DEFAULT_THEME = "kiwi-black"
-    #: The theme a new install starts with, and `/theme reset` returns to. `DEFAULT_THEME`
-    #: stays Kiwi's own palette, and the fallback when a theme cannot be applied.
-    INITIAL_THEME = "tokyo-night"
+    #: What a new install starts with, and `/theme reset` returns to: the terminal's own
+    #: look (see `initial_theme`). `DEFAULT_THEME` stays Kiwi's own palette, and the fallback
+    #: when a theme cannot be applied.
+    INITIAL_THEME = "terminal"
+
+    def initial_theme(self) -> str:
+        """The theme that follows the terminal: its background and colours, light or dark
+        as the terminal is. Asked once, before the TUI takes over the terminal."""
+        theme = getattr(self, "_terminal_theme", None)
+        if theme is None:
+            from kiwi_tui.terminal_theme import terminal_theme
+
+            theme = self._terminal_theme = terminal_theme()
+        return theme
 
     def _register_kiwi_theme(self) -> None:
         """Register Kiwi's default theme with Textual's theme system."""
@@ -347,17 +358,17 @@ class AutobotsTUI(App):
         settings = load_ui_settings()
         stored = settings.get("theme") if isinstance(settings, dict) else None
         if isinstance(stored, str) and stored.strip():
-            return stored.strip()
+            return self.initial_theme() if stored.strip().lower() == "terminal" else stored.strip()
 
         t = str(getattr(self.config, "theme", "") or "").strip()
         tl = t.lower()
-        if tl in {"dark", "default"}:
-            return self.INITIAL_THEME
+        if tl in {"dark", "default", "terminal", ""}:
+            return self.initial_theme()
         if tl == "black":
             return self.DEFAULT_THEME
         if tl in {"light"}:
             return "textual-light"
-        return t or self.INITIAL_THEME
+        return t
 
     def set_theme_preference(self, theme_name: str, *, persist: bool = True) -> tuple[bool, str]:
         """Set the active theme and (optionally) persist it to ~/.kiwi/settings.json."""
@@ -366,8 +377,12 @@ class AutobotsTUI(App):
             return False, "Usage: /theme set <name>"
 
         norm = raw
+        saved = None
         nl = raw.lower()
-        if nl in {"dark", "black", "default"}:
+        if nl == "terminal":
+            # Follow the terminal: remembered as such, so the next start asks it again.
+            norm, saved = self.initial_theme(), "terminal"
+        elif nl in {"dark", "black", "default"}:
             norm = self.DEFAULT_THEME
         elif nl in {"light"}:
             norm = "textual-light"
@@ -383,9 +398,11 @@ class AutobotsTUI(App):
 
         if persist:
             try:
-                update_ui_settings({"theme": norm})
+                update_ui_settings({"theme": saved or norm})
             except Exception:
                 pass
+        if saved == "terminal":
+            return True, f"Theme follows your terminal ({norm})"
         return True, f"Theme set to: {norm}"
     def _is_dark_theme(self) -> bool:
         """Best-effort detection of whether the active theme is dark."""

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_tui/screens/term_activity_view.py

@@ -25,6 +25,8 @@ SHOWN_ITEMS = 14
 SHOWN_TOOLS = 6
 #: Lines of a tool's arguments drawn when it is open.
 SHOWN_ARG_LINES = 15
+#: Lines of each file's diff drawn when its tool line is open.
+SHOWN_DIFF_LINES = 40
 #: Lines of a thinking block drawn when it is open.
 SHOWN_THOUGHT_LINES = 40
 #: How streamed text is revealed: it arrives in bursts, and is shown at one calm, steady
@@ -128,6 +130,13 @@ def _tool_text(tool: ToolLine, *, live: bool, cyan: str, depth: int, opened: boo
         line.append("  preparing" if tool.state == "forming" else "  queued", style="dim")
     if running and tool.note and not opened:
         line.append(f"  {tool.note}", style="dim")
+    if tool.edits:
+        if len(tool.edits) == 1:
+            line.append(f"  {tool.edits[0].get('path') or ''}", style="dim")
+        added = sum(int(e.get("added") or 0) for e in tool.edits)
+        removed = sum(int(e.get("removed") or 0) for e in tool.edits)
+        line.append(f"  +{added}", style="green")
+        line.append(f" −{removed}", style="red")
     took = duration(tool.duration_ms)
     if took:
         line.append(f"  {took}", style="dim")
@@ -139,24 +148,54 @@ def _tool_text(tool: ToolLine, *, live: bool, cyan: str, depth: int, opened: boo
 
 
 def _tool_details(tool: ToolLine, pad: str) -> Text:
-    """What Agent Studio shows when a tool line is opened."""
+    """What Agent Studio shows when a tool line is opened, and the diff of each file the
+    call changed."""
     out = Text()
     if tool.error:
         out.append(f"\n{pad}{tool.error}", style="red")
+    for edit in tool.edits:
+        out.append_text(_diff_text(edit, pad))
     for note in tool.notes:
         out.append(f"\n{pad}• {note}", style="dim")
-    if tool.args:
+    if tool.args and not tool.edits:  # an edit's diff says what its arguments did, better
         lines = tool.args.splitlines()
         for line in lines[:SHOWN_ARG_LINES]:
             out.append(f"\n{pad}{line}", style="dim")
         if len(lines) > SHOWN_ARG_LINES:
             out.append(f"\n{pad}… {len(lines) - SHOWN_ARG_LINES} more lines", style="dim italic")
-    if tool.args_truncated and tool.args_chars:
+    if tool.args_truncated and tool.args_chars and not tool.edits:
         out.append(f"\n{pad}Arguments shortened · {tool.args_chars} characters in full", style="dim italic")
     out.append(f"\n{pad}{tool.name} · {tool.call_id}", style="dim")
     return out
 
 
+def _diff_text(edit: dict, pad: str) -> Text:
+    """One file's change: its path, then its diff in red and green."""
+    out = Text()
+    path = str(edit.get("path") or "")
+    what = " (new file)" if edit.get("created") else " (deleted)" if edit.get("deleted") else ""
+    out.append(f"\n{pad}{path}{what}", style="bold")
+    out.append(f"  +{int(edit.get('added') or 0)}", style="green")
+    out.append(f" −{int(edit.get('removed') or 0)}", style="red")
+    diff = str(edit.get("diff") or "")
+    if not diff:
+        out.append(f"\n{pad}  (diff no longer kept: only the latest changes are)", style="dim italic")
+        return out
+    lines = diff.splitlines()
+    for line in lines[:SHOWN_DIFF_LINES]:
+        style = (
+            "green" if line.startswith("+") else
+            "red" if line.startswith("-") else
+            "cyan dim" if line.startswith("@@") else
+            "dim"
+        )
+        out.append(f"\n{pad}  {line}", style=style)
+    more = len(lines) - SHOWN_DIFF_LINES
+    if more > 0 or edit.get("truncated"):
+        out.append(f"\n{pad}  … {max(more, 0)} more lines" if more > 0 else f"\n{pad}  … the rest of the diff is not kept", style="dim italic")
+    return out
+
+
 def activity_renderable(
     turn: TurnView,
     *,

{kiwi_code-0.0.504 → kiwi_code-0.0.505}/src/kiwi_tui/screens/term_dashboard.py

@@ -117,6 +117,16 @@ def _lighten(color: str, amount: float = 0.6) -> str:
     return "#%02x%02x%02x" % tuple(round(c + (255 - c) * amount) for c in (r, g, b))
 
 
+def _edits_path(run_id: str):
+    """Where the user's runtime records the diffs of its changes to files for `run_id`."""
+    try:
+        from kiwi_runtime.fs.edits import edits_path
+
+        return edits_path(run_id)
+    except Exception:
+        return None
+
+
 class TermDashboardScreen(Screen):
     BINDINGS = [
         Binding("escape", "dismiss_or_clear", "Dismiss", show=False, priority=True),
@@ -365,7 +375,14 @@ class TermDashboardScreen(Screen):
         )
 
         self._scroll_poll_timer = self.set_interval(0.2, self._poll_transcript_scroll)
+        # Rows can grow after they are laid out (a slow machine, a row updated on mount):
+        # a transcript that follows its end stays there.
+        root = self.query_one("#term-scroll-transcript", VerticalScroll)
+        self.watch(root, "virtual_size", self._keep_at_end, init=False)
 
+    def _keep_at_end(self) -> None:
+        if self._follow_tail and not getattr(self, "_lazy_loading", False) and not self._near_bottom():
+            self._scroll_end_root()
 
     def _poll_transcript_scroll(self) -> None:
         if getattr(self, "_lazy_loading", False):
@@ -3302,7 +3319,9 @@ class TermDashboardScreen(Screen):
                     current = getattr(self.app, "theme", None)
                     cur = str(current).strip() if current is not None else ""
 
-                    rows: list[dict[str, str]] = []
+                    rows: list[dict[str, str]] = [
+                        {"label": "    terminal  (follows your terminal's colours)", "run_id": "terminal"}
+                    ]
                     for t in themes:
                         marker = "*" if t == cur else " "
                         rows.append({"label": f"  {marker} {t}", "run_id": t})
@@ -3322,7 +3341,7 @@ class TermDashboardScreen(Screen):
                         return
                     theme_name = args[1]
                 elif sub == "reset":
-                    theme_name = getattr(self.app, "INITIAL_THEME", "tokyo-night")
+                    theme_name = getattr(self.app, "INITIAL_THEME", "terminal")
                 else:
                     theme_name = args[0]
 
@@ -4849,6 +4868,7 @@ class TermDashboardScreen(Screen):
 
         _last_render = -1
         _last_render_at = 0.0
+        redraw_due = [False]
         self._activity_view = activity
         self._stream_state = "connecting"
         # A turn that has finished while prompts are still queued behind it: its text is
@@ -4869,6 +4889,16 @@ class TermDashboardScreen(Screen):
             try:
                 now = time.monotonic()
                 if not force and (now - _last_render_at) < 0.03:
+                    # Too soon after the last draw: draw this change at the end of the pause
+                    # rather than drop it (it may be the last of a burst).
+                    if not redraw_due[0]:
+                        redraw_due[0] = True
+
+                        def _due() -> None:
+                            redraw_due[0] = False
+                            _render(force=True)
+
+                        asyncio.get_running_loop().call_later(0.035, _due)
                     return
                 turn = activity.followed
                 if turn is None or (not force and activity.version == _last_render):
@@ -5230,6 +5260,9 @@ class TermDashboardScreen(Screen):
                 if kind in ("subagent.started", "subagent.finished"):
                     self._poke_subagents()
                 return
+            if kind in ("tool.finished", "turn.finished"):
+                # A file the call changed has been recorded by now.
+                _read_edits()
             if not was_finished and activity.followed_finished():
                 # The turn is over: fetch its saved result now rather than at the next poll.
                 asyncio.create_task(_fetch_final())
@@ -5252,6 +5285,38 @@ class TermDashboardScreen(Screen):
         paced: set = set()
         joining = False  # set while the first read-back is taken
 
+        # The diffs of the changes the user's runtime makes to files, as it records them.
+        edit_file = _edits_path(run_id)
+        edit_offset = 0
+
+        def _read_edits() -> bool:
+            """Take the records added since the last read; whether any reached a call."""
+            nonlocal edit_offset
+            if edit_file is None:
+                return False
+            try:
+                size = edit_file.stat().st_size
+                if size < edit_offset:
+                    edit_offset = 0  # trimmed to its latest records: read it again
+                if size == edit_offset:
+                    return False
+                with open(edit_file, "rb") as f:
+                    f.seek(edit_offset)
+                    data = f.read()
+            except OSError:
+                return False
+            end = data.rfind(b"\n")
+            if end < 0:
+                return False  # a line still being written
+            edit_offset += end + 1
+            changed = False
+            for line in data[:end].splitlines():
+                try:
+                    changed = activity.add_edit(json.loads(line)) or changed
+                except ValueError:
+                    continue
+            return changed
+
         def _pace_new_turn() -> None:
             """A turn seen for the first time is revealed from its start; one that was
             already under way when we joined shows what it had written at once."""
@@ -5304,6 +5369,7 @@ class TermDashboardScreen(Screen):
         else:
             _stream_trouble(f"reading it back failed, HTTP {code}")
         activity.start_following()
+        _read_edits()
         # Rejoining a turn under way: what it had written already shows at once.
         joining = True
         _pace_new_turn()