kiwi-code 0.0.24__tar.gz → 0.0.26__tar.gz

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.24
+Version: 0.0.26
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.24"
+version = "0.0.26"
 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.24 → kiwi_code-0.0.26}/src/kiwi_tui/runtime_agent.py

@@ -27,6 +27,8 @@ import json
 import os
 from pathlib import Path
 import subprocess
+import threading
+import time
 from typing import Any, Literal
 import uuid
 
@@ -57,6 +59,111 @@ BY_RUN_DIR = RUNTIMES_DIR / "by-run"
 PENDING_DIR = RUNTIMES_DIR / "pending"
 
 
+# Runtime log truncation
+# ---------------------
+# Runtime logs are written to a local file and can otherwise grow without bound,
+# consuming both disk and memory (the logs viewer historically read the entire
+# file into RAM). We keep only a small trailing window so the user sees the most
+# recent activity.
+MAX_RUNTIME_LOG_BYTES = 30 * 1024
+_RUNTIME_LOG_TRIM_INTERVAL_SEC = 0.5
+
+
+def _trim_file_to_tail_bytes(path: Path, *, max_bytes: int = MAX_RUNTIME_LOG_BYTES) -> None:
+    """Trim a file in-place to keep only the last ``max_bytes`` bytes.
+
+    Notes:
+    - We *cannot* implement trimming via atomic replace (write temp + rename),
+      because the runtime process inherits an open file descriptor; replacing the
+      path would orphan the original inode and the runtime would keep writing to
+      the unlinked file.
+    - This is therefore best-effort; concurrent appends may result in dropping a
+      few bytes around the trim boundary, which is acceptable for log viewing.
+    """
+    if max_bytes <= 0:
+        return
+    try:
+        if not path.exists():
+            return
+        with open(path, "r+b") as fp:
+            fp.seek(0, os.SEEK_END)
+            size = fp.tell()
+            if size <= max_bytes:
+                return
+
+            # Read the tail and try to start at a newline boundary to avoid
+            # rendering a partial first line.
+            fp.seek(max(0, size - max_bytes), os.SEEK_SET)
+            tail = fp.read(max_bytes)
+            if size > max_bytes:
+                nl = tail.find(b"\n")
+                if 0 <= nl < len(tail) - 1:
+                    tail = tail[nl + 1 :]
+
+            fp.seek(0, os.SEEK_SET)
+            fp.write(tail)
+            fp.truncate(len(tail))
+            try:
+                fp.flush()
+            except Exception:
+                pass
+    except Exception:
+        # Never crash UI / runtime manager due to log trimming.
+        return
+
+
+class _RuntimeLogTrimmer(threading.Thread):
+    def __init__(self, *, log_path: Path, pid: int | None, max_bytes: int) -> None:
+        super().__init__(daemon=True)
+        self._log_path = log_path
+        self._pid = pid
+        self._max_bytes = max_bytes
+        self._stop = threading.Event()
+        self._missing_count = 0
+
+    def stop(self) -> None:
+        self._stop.set()
+
+    def run(self) -> None:
+        while not self._stop.is_set():
+            try:
+                if self._pid and not psutil.pid_exists(self._pid):
+                    break
+            except Exception:
+                # If we can't check, keep trimming while the app is alive.
+                pass
+
+            if not self._log_path.exists():
+                self._missing_count += 1
+                # If the log path was moved (e.g. pending -> by-run), another
+                # trimmer should be started for the new path.
+                if self._missing_count > 20:
+                    break
+            else:
+                self._missing_count = 0
+                _trim_file_to_tail_bytes(self._log_path, max_bytes=self._max_bytes)
+
+            self._stop.wait(_RUNTIME_LOG_TRIM_INTERVAL_SEC)
+
+        # One final trim on exit.
+        _trim_file_to_tail_bytes(self._log_path, max_bytes=self._max_bytes)
+
+
+_LOG_TRIMMERS: dict[str, _RuntimeLogTrimmer] = {}
+_LOG_TRIMMERS_LOCK = threading.Lock()
+
+
+def _ensure_log_trimmer(*, log_path: Path, pid: int | None, max_bytes: int = MAX_RUNTIME_LOG_BYTES) -> None:
+    key = str(log_path)
+    with _LOG_TRIMMERS_LOCK:
+        trimmer = _LOG_TRIMMERS.get(key)
+        if trimmer and trimmer.is_alive():
+            return
+        trimmer = _RuntimeLogTrimmer(log_path=log_path, pid=pid, max_bytes=max_bytes)
+        _LOG_TRIMMERS[key] = trimmer
+        trimmer.start()
+
+
 
 def _read_pid(path: Path) -> int | None:
     if not path.exists():
@@ -350,6 +457,9 @@ def _spawn_runtime(
             pass
         return False, None, f"Failed to start runtime: {e}"
 
+
+    # Keep runtime log file bounded in the background (avoid disk + RAM blow-ups).
+    _ensure_log_trimmer(log_path=log_path, pid=proc.pid)
     try:
         pid_path.write_text(str(proc.pid), encoding="utf-8")
     except Exception:
@@ -385,6 +495,7 @@ def ensure_runtime_for_run(
     existing = get_running_pid_for_run(run_id)
     lp = log_path_for_run(run_id)
     if existing:
+        _ensure_log_trimmer(log_path=lp, pid=existing)
         return True, existing, lp, f"Runtime already running for run {run_id} (pid={existing})"
 
     ok, pid, msg = _spawn_runtime(
@@ -530,6 +641,14 @@ def bind_pending_to_run(
     except Exception:
         pass
 
+
+    # If the pending runtime directory was moved successfully, start trimming at the
+    # new by-run log path (the old path no longer exists).
+    try:
+        pid = _read_pid(dst / "pid")
+        _ensure_log_trimmer(log_path=dst / "log", pid=pid)
+    except Exception:
+        pass
     return True, dst / "log", f"Bound pending runtime {pending_id} -> run {run_id}"
 
 

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/src/kiwi_tui/screens/dashboard.py

@@ -12,6 +12,7 @@ from kiwi_tui.screens.attach_content import AttachContentScreen
 from kiwi_tui.screens.slash_picker import SlashPickerScreen
 from kiwi_tui.screens.id_picker import IdPickerScreen
 from kiwi_tui.screens.command_result import CommandResultScreen
+from kiwi_tui.screens.help import HelpScreen
 from kiwi_tui.widgets import ChatInput
 from kiwi_tui.inline_file_picker import InlineFilePicker
 from textual.worker import Worker, WorkerState
@@ -573,6 +574,16 @@ class DashboardScreen(Screen):
         # If a command is already running, ignore (prevents the "hung" feeling / double execution).
         if self._cmd_running:
             return
+
+        # /help is a UI-first experience (picker + copy). Don't run it through the CLI dispatcher.
+        if command.strip().lower() == "/help":
+            self.app.push_screen(HelpScreen())
+            try:
+                self.query_one("#chat-input", ChatInput).focus()
+            except Exception:
+                pass
+            return
+
         self._set_command_running(True, f"Running {command} ...")
         self.run_worker(
             self._handle_slash_command_async(command),

kiwi_code-0.0.26/src/kiwi_tui/screens/help.py

@@ -0,0 +1,219 @@
+import subprocess
+import sys
+import time
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from kiwi_tui.slash_commands import SLASH_COMMANDS
+
+
+class HelpScreen(ModalScreen[None]):
+    """Modal that lists available slash commands and allows copying."""
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+        Binding("c", "copy", "Copy", show=True),
+    ]
+
+    CSS = """
+    HelpScreen {
+        align: center middle;
+    }
+
+    #help-container {
+        width: 96;
+        height: 80%;
+        background: $surface;
+        border: solid $accent;
+        /* Reduce top padding so the title/hint sit closer to the border. */
+        padding: 0 3 1 3;
+    }
+
+    #help-title {
+        width: 100%;
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        height: 1;
+        /* Tighten vertical spacing at the top of the modal. */
+        margin-bottom: 0;
+    }
+
+    #help-hint {
+        width: 100%;
+        height: 1;
+        padding: 0 1;
+        color: $text-muted;
+        text-style: italic;
+        margin-bottom: 0;
+    }
+
+    #help-list {
+        height: 1fr;
+        width: 100%;
+        border: solid $panel;
+        background: $surface;
+        scrollbar-size: 1 1;
+        /* Keep the list away from the container border for consistent margins. */
+        margin: 0 1;
+    }
+
+    #help-list > .option-list--option-highlighted {
+        background: $primary-background;
+        color: $primary;
+        text-style: bold;
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._last_copy_notify_at: float = 0.0
+        self._last_highlight_index: int | None = None
+        self._highlight_skip_guard: bool = False
+
+    def on_mount(self) -> None:
+        # Match the UX of the inline @ picker: focus the list and highlight the first command.
+        option_list = self.query_one("#help-list", OptionList)
+        try:
+            for idx, opt in enumerate(option_list.options):
+                if not getattr(opt, "disabled", False) and opt.id:
+                    option_list.highlighted = idx
+                    break
+        except Exception:
+            pass
+        option_list.focus()
+
+    def compose(self) -> ComposeResult:
+        # Column widths tuned for a typical terminal width; the OptionList will clip if narrower.
+        cmd_col_width = 38
+        with Vertical(id="help-container"):
+            yield Static("Slash Commands", id="help-title")
+            yield Static("Enter/click: copy   C: copy highlighted   Esc: close", id="help-hint")
+
+            option_list = OptionList(id="help-list")
+
+            last_category: str | None = None
+            for cmd in SLASH_COMMANDS:
+                if cmd.category != last_category:
+                    # Add a blank spacer row between sections for readability.
+                    if last_category is not None:
+                        option_list.add_option(Option(Text(""), id=None, disabled=True))
+
+                    last_category = cmd.category
+                    option_list.add_option(
+                        Option(Text(f" {cmd.category.upper()}", style="bold cyan"), id=None, disabled=True)
+                    )
+
+                # Option id is the command template so we can copy exactly what is shown.
+                label = f"  {cmd.template:<{cmd_col_width}} {cmd.description}"
+                option_list.add_option(Option(Text(label), id=cmd.template))
+
+            yield option_list
+
+    def on_option_list_option_highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        """Skip spacer/category rows while navigating with arrow keys."""
+        if self._highlight_skip_guard:
+            return
+
+        # Track previous position so we can infer direction.
+        prev = self._last_highlight_index
+
+        # Textual versions differ slightly in attribute names.
+        idx = getattr(event, "index", None)
+        if idx is None:
+            idx = getattr(event, "option_index", None)
+        if idx is None:
+            return
+
+        self._last_highlight_index = idx
+
+        option = event.option
+        if option.id and not getattr(option, "disabled", False):
+            return
+
+        option_list = event.option_list
+        try:
+            direction = -1 if (prev is not None and idx < prev) else 1
+            n = len(option_list.options)
+            self._highlight_skip_guard = True
+            cur = idx
+            while 0 <= cur < n:
+                cur += direction
+                if not (0 <= cur < n):
+                    break
+                opt = option_list.options[cur]
+                if opt.id and not getattr(opt, "disabled", False):
+                    option_list.highlighted = cur
+                    self._last_highlight_index = cur
+                    break
+        finally:
+            self._highlight_skip_guard = False
+
+
+
+    def _notify_once(self, msg: str, *, severity: str) -> None:
+        now = time.monotonic()
+        if now - self._last_copy_notify_at < 1.0:
+            return
+        self._last_copy_notify_at = now
+        self.app.notify(msg, severity=severity)
+
+    def _copy_to_clipboard(self, text: str) -> bool:
+        """Copy text to the system clipboard. Returns True if it likely worked."""
+        copied = False
+
+        # Prefer native OS clipboard tools (more reliable in terminal apps).
+        try:
+            if sys.platform == "darwin":
+                subprocess.run(["pbcopy"], input=text.encode("utf-8"), check=True)
+                copied = True
+            elif sys.platform.startswith("linux"):
+                subprocess.run(
+                    ["xclip", "-selection", "clipboard"],
+                    input=text.encode("utf-8"),
+                    check=True,
+                )
+                copied = True
+            elif sys.platform.startswith("win"):
+                subprocess.run(["clip"], input=text.encode("utf-8"), check=True)
+                copied = True
+        except Exception:
+            copied = False
+
+        # Fallback to Textual's clipboard integration.
+        if not copied:
+            try:
+                self.app.copy_to_clipboard(text)
+                copied = True
+            except Exception:
+                copied = False
+
+        return copied
+
+    def _copy_selected(self, template: str) -> None:
+        if not template.strip():
+            return
+        if self._copy_to_clipboard(template):
+            self._notify_once(f"Copied: {template}", severity="information")
+        else:
+            self._notify_once("Failed to copy to clipboard", severity="error")
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        template = event.option.id
+        if template:
+            self._copy_selected(str(template))
+
+    def action_copy(self) -> None:
+        option_list = self.query_one("#help-list", OptionList)
+        opt = option_list.highlighted_option
+        if opt and opt.id:
+            self._copy_selected(str(opt.id))
+
+    def action_close(self) -> None:
+        self.dismiss(None)

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/src/kiwi_tui/screens/runtime_logs.py

@@ -17,12 +17,30 @@ from textual.screen import Screen
 from textual.widgets import Footer, Header, RichLog, Static
 
 
-def _tail_lines(path: Path, max_lines: int = 3000) -> list[str]:
-    """Read the last N lines of a file without loading the whole file."""
+def _tail_lines(path: Path, max_lines: int = 3000, max_bytes: int = 30 * 1024) -> list[str]:
+    """Read the last N lines of a file without loading the whole file.
+
+    We read only a tail window (``max_bytes``) so opening the logs screen doesn't
+    allocate RAM proportional to the on-disk log size.
+    """
+    if max_bytes <= 0:
+        return []
+
     try:
-        data = path.read_bytes()
+        with open(path, "rb") as fp:
+            fp.seek(0, 2)
+            size = fp.tell()
+            fp.seek(max(0, size - max_bytes), 0)
+            data = fp.read(max_bytes)
     except OSError:
         return []
+
+    # If we started mid-file, drop the partial first line.
+    if size > max_bytes:
+        nl = data.find(b"\n")
+        if 0 <= nl < len(data) - 1:
+            data = data[nl + 1 :]
+
     lines = data.splitlines()[-max_lines:]
     out: list[str] = []
     for b in lines:
@@ -120,6 +138,15 @@ class RuntimeLogsScreen(Screen):
         except Exception:
             return
         if not chunk:
+            # If the runtime log is being trimmed in-place, the file can shrink.
+            # When that happens our read cursor may point past EOF; re-seek to the
+            # new end so streaming continues.
+            try:
+                if self._log_path and self._log_path.exists():
+                    if self._log_path.stat().st_size < self._fp.tell():
+                        self._fp.seek(0, 2)
+            except Exception:
+                pass
             return
 
         try:

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/src/kiwi_tui/screens/slash_picker.py

@@ -1,45 +1,26 @@
 """Slash command picker modal screen."""
 
 from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
 from textual.screen import ModalScreen
-from textual.widgets import Static, Button, OptionList
+from textual.widgets import OptionList, Static
 from textual.widgets.option_list import Option
-from textual.containers import Vertical
-from textual.binding import Binding
+
+from kiwi_tui.slash_commands import SLASH_COMMANDS
 
 
-# Commands and their descriptions
-_COMMANDS = [
-    ("/help", "Show help"),
-    ("/new", "Start new conversation"),
-    ("/status", "Show current action & run"),
-    ("/cancel", "Cancel active request"),
-    ("/actions list", "List recent actions"),
-    ("/runs list", "List recent runs"),
-    ("/graphs list", "List recent graphs"),
-    ("/graph-runs list", "List recent graph runs"),
-    ("/use ", "Switch action by ID"),
-    ("/continue ", "Continue a run by ID"),
-    ("/upload ", "Upload file(s) by path"),
-    ("/files", "Show pending files"),
-    ("/clear-files", "Clear pending files"),
-    ("/login", "Log in"),
-    ("/logout", "Log out"),
-    ("/metadata", "Show metadata"),
-    ("/metadata set ", "Set metadata key"),
-    ("/metadata remove ", "Remove metadata key"),
-    ("/metadata clear", "Clear all metadata"),
-    ("/connect-cli", "Tell the agent to connect to the local CLI"),
-    ("/show-logs", "Show local CLI (runtime) logs"),
-]
+# Commands and their descriptions (single source of truth).
+# We show the template in the picker, and return insert_text on selection.
+_COMMANDS = [(c.insert_text, c.template, c.description) for c in SLASH_COMMANDS]
 
 
 class SlashPickerScreen(ModalScreen[str]):
     """Modal that lets the user pick a slash command.
 
-    Returns the command string, or empty string if cancelled.
-    Commands that don't need arguments (no trailing space) are returned as-is
-    for immediate execution.
+    Returns the command string (insert_text), or empty string if cancelled.
+    Commands that don't need arguments are returned as-is for immediate execution.
+    Commands that expect args end with a trailing space ("/use ").
     """
 
     BINDINGS = [
@@ -79,8 +60,8 @@ class SlashPickerScreen(ModalScreen[str]):
         with Vertical(id="slash-container"):
             yield Static("Select a command", id="slash-title")
             option_list = OptionList(id="slash-list")
-            for cmd, desc in _COMMANDS:
-                option_list.add_option(Option(f"{cmd:<25} {desc}", id=cmd))
+            for insert_text, template, desc in _COMMANDS:
+                option_list.add_option(Option(f"{template:<32} {desc}", id=insert_text))
             yield option_list
 
     def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:

kiwi_code-0.0.26/src/kiwi_tui/slash_commands.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class SlashCommand:
+    category: str
+    template: str
+    description: str
+    insert_text: str
+
+    @property
+    def needs_args(self) -> bool:
+        return self.insert_text.endswith(" ")
+
+
+# NOTE: Keep this aligned with DashboardScreen's TUI command handler.
+SLASH_COMMANDS: list[SlashCommand] = [
+    # Session
+    SlashCommand("Session", "/help", "Show all slash commands", "/help"),
+    SlashCommand("Session", "/new", "Start new conversation", "/new"),
+    SlashCommand("Session", "/status", "Show current action & run", "/status"),
+    SlashCommand("Session", "/cancel", "Cancel active request", "/cancel"),
+    SlashCommand("Session", "/use <action_id>", "Switch to a different action", "/use "),
+    SlashCommand("Session", "/continue <run_id>", "Continue an existing run", "/continue "),
+
+    # Files
+    SlashCommand("Files", "/upload <path> [path2 ...]", "Upload file(s) and attach to next message", "/upload "),
+    SlashCommand("Files", "/files", "Show pending attachments", "/files"),
+    SlashCommand("Files", "/clear-files", "Clear pending attachments", "/clear-files"),
+
+    # Auth
+    SlashCommand("Auth", "/login", "Log in", "/login"),
+    SlashCommand("Auth", "/logout", "Log out", "/logout"),
+
+    # Metadata
+    SlashCommand("Metadata", "/metadata", "Show effective metadata", "/metadata"),
+    SlashCommand("Metadata", "/metadata set <key> <value>", "Set a metadata field", "/metadata set "),
+    SlashCommand("Metadata", "/metadata remove <key>", "Remove a metadata field", "/metadata remove "),
+    SlashCommand("Metadata", "/metadata clear", "Clear all metadata overrides", "/metadata clear"),
+
+    # Runtime (local CLI agent)
+    SlashCommand("Runtime", "/connect-cli", "Tell the agent to connect to the local CLI", "/connect-cli"),
+    SlashCommand("Runtime", "/show-logs", "Show local CLI (runtime) logs", "/show-logs"),
+    SlashCommand("Runtime", "/runtime", "Runtime commands (currently disabled)", "/runtime"),
+
+    # Query (API)
+    SlashCommand("Query", "/actions list", "List recent actions", "/actions list"),
+    SlashCommand("Query", "/actions get <id>", "Get an action by id", "/actions get "),
+    SlashCommand("Query", "/runs list", "List recent runs", "/runs list"),
+    SlashCommand("Query", "/runs get <id>", "Get a run by id", "/runs get "),
+    SlashCommand("Query", "/graphs list", "List recent graphs", "/graphs list"),
+    SlashCommand("Query", "/graphs get <id>", "Get a graph by id", "/graphs get "),
+    SlashCommand("Query", "/graph-runs list", "List recent graph runs", "/graph-runs list"),
+    SlashCommand("Query", "/graph-runs get <id>", "Get a graph run by id", "/graph-runs get "),
+]
+
+
+def autocomplete_commands() -> list[str]:
+    """Return strings used for chat input autocomplete."""
+    # We keep the insert_text version for consistency with the actual command parser.
+    return [c.insert_text for c in SLASH_COMMANDS]

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/src/kiwi_tui/widgets.py

@@ -12,34 +12,10 @@ from textual.widgets._text_area import TextArea
 from rich.text import Text
 
 
-# Slash commands for autocomplete
-_SLASH_COMMANDS = [
-    "/help",
-    "/actions list",
-    "/actions get ",
-    "/runs list",
-    "/runs get ",
-    "/graphs list",
-    "/graphs get ",
-    "/graph-runs list",
-    "/graph-runs get ",
-    "/use ",
-    "/continue ",
-    "/new",
-    "/status",
-    "/cancel",
-    "/upload ",
-    "/files",
-    "/clear-files",
-    "/login",
-    "/logout",
-    "/metadata",
-    "/metadata set ",
-    "/metadata remove ",
-    "/metadata clear",
-    "/connect-cli",
-    "/show-logs",
-]
+# Slash commands for autocomplete (single source of truth)
+from kiwi_tui.slash_commands import autocomplete_commands
+
+_SLASH_COMMANDS = autocomplete_commands()
 
 
 class ChatInput(TextArea):

kiwi_code-0.0.26/tests/test_runtime_log_trimming.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from kiwi_tui.runtime_agent import MAX_RUNTIME_LOG_BYTES, _trim_file_to_tail_bytes
+from kiwi_tui.screens.runtime_logs import _tail_lines
+
+
+def _make_log_bytes(num_lines: int) -> bytes:
+    # Fixed-width lines make expected tails deterministic.
+    return b"".join([f"line-{i:06d} hello world\n".encode("utf-8") for i in range(num_lines)])
+
+
+def test_trim_file_to_tail_bytes_keeps_last_bytes(tmp_path: Path) -> None:
+    p = tmp_path / "log"
+    payload = _make_log_bytes(20000)  # plenty bigger than 30KB
+    p.write_bytes(payload)
+
+    _trim_file_to_tail_bytes(p, max_bytes=MAX_RUNTIME_LOG_BYTES)
+
+    data = p.read_bytes()
+    assert len(data) <= MAX_RUNTIME_LOG_BYTES
+
+    # We should keep the most recent line.
+    assert b"line-019999" in data
+
+    # We should *not* keep the earliest line.
+    assert b"line-000000" not in data
+
+
+def test_tail_lines_reads_tail_window(tmp_path: Path) -> None:
+    p = tmp_path / "log"
+    payload = _make_log_bytes(5000)
+    p.write_bytes(payload)
+
+    # Read a small tail window and last few lines from it.
+    lines = _tail_lines(p, max_lines=5, max_bytes=512)
+    assert len(lines) == 5
+
+    # Must include the final log line.
+    assert lines[-1].startswith("line-004999")

{kiwi_code-0.0.24 → kiwi_code-0.0.26}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.24"
+version = "0.0.26"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },