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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.504
+Version: 0.0.506
 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.506}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.504"
+version = "0.0.506"
 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.506}/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.506}/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.506/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.506}/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.506}/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.506/src/kiwi_tui/attention.py

@@ -0,0 +1,107 @@
+"""Calling the user back when the agent needs them: a question waiting for an answer, or a
+run that has finished.
+
+While kiwi's window has focus the user is there, and the screen itself shows it. When they
+are elsewhere (the terminal tells kiwi when its window loses focus), kiwi:
+
+- shows a desktop notification, through the terminal (OSC 777 / 9 / 99), so it also works
+  over ssh; a terminal with none of them gets `notify-send` / `osascript` instead, when
+  kiwi runs on the user's own machine;
+- rings the terminal bell (a sound, and a mark on the tab or dock icon in most terminals);
+- puts a mark in the tab title, until the window has focus again.
+
+`/notify on | quiet | off` chooses: quiet leaves out the bell; off does none of it.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from collections.abc import Mapping
+
+MODES = ("on", "quiet", "off")
+DEFAULT_MODE = "on"
+#: The tab title kiwi starts with; set by main once it knows the folder.
+BASE_TITLE = "kiwi"
+
+_CONTROL = re.compile(r"[\x00-\x1f\x7f]+")
+
+
+def mode_from(settings: Mapping) -> str:
+    mode = str(settings.get("notify") or DEFAULT_MODE).lower()
+    return mode if mode in MODES else DEFAULT_MODE
+
+
+def _clean(text: str, limit: int = 160) -> str:
+    """One line, no control characters (they could end the sequence), and short."""
+    text = " ".join(_CONTROL.sub(" ", str(text or "")).split())
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+def notification_sequence(title: str, body: str, env: Mapping[str, str] = os.environ) -> str:
+    """The escape sequence that makes this terminal show a desktop notification; "" for a
+    terminal not known to have one (an unknown one would print it, or ignore it)."""
+    title, body = _clean(title, 60), _clean(body)
+    program = env.get("TERM_PROGRAM", "").lower()
+    term = env.get("TERM", "").lower()
+    if env.get("TMUX") or term.startswith(("screen", "tmux")):
+        return ""  # tmux keeps these to itself unless told to pass them on
+    if env.get("KITTY_WINDOW_ID") or "kitty" in term:
+        return f"\x1b]99;;{title}: {body}\x1b\\"
+    if program in ("ghostty", "wezterm") or "ghostty" in term:
+        # `;` separates the fields of OSC 777.
+        return f"\x1b]777;notify;{title.replace(';', ',')};{body.replace(';', ',')}\x07"
+    if program == "iterm.app":
+        return f"\x1b]9;{title}: {body}\x07"
+    return ""
+
+
+def local_notification_command(
+    title: str, body: str, env: Mapping[str, str] = os.environ, platform: str | None = None
+) -> list[str] | None:
+    """A command that shows the notification on this machine, for a terminal that cannot;
+    None over ssh (it would show on the wrong machine) or when there is none."""
+    if env.get("SSH_CONNECTION") or env.get("SSH_TTY"):
+        return None
+    platform = platform or sys.platform
+    title, body = _clean(title, 60), _clean(body)
+    if platform == "darwin":
+        def quoted(s: str) -> str:
+            return '"' + s.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+        return ["osascript", "-e", f"display notification {quoted(body)} with title {quoted(title)}"]
+    if platform.startswith("linux") and shutil.which("notify-send"):
+        return ["notify-send", "--app-name=Kiwi", title, body]
+    return None
+
+
+def title_sequence(title: str) -> str:
+    return f"\x1b]2;{_clean(title, 120)}\x07"
+
+
+def call_out(write, *, mode: str, title: str, body: str, tab: str, env: Mapping[str, str] = os.environ) -> None:
+    """Notify, ring and mark the tab, as `mode` allows. `write` sends text to the terminal."""
+    if mode == "off":
+        return
+    out = title_sequence(tab)
+    if mode == "on":
+        out += "\a"
+    sequence = notification_sequence(title, body, env)
+    write(out + sequence)
+    if not sequence:
+        command = local_notification_command(title, body, env)
+        if command:
+            launch(command)
+
+
+def launch(command: list[str]) -> None:
+    """Start `command` and leave it: kiwi does not wait for the notification."""
+    try:
+        subprocess.Popen(
+            command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL, start_new_session=True,
+        )
+    except OSError:
+        pass

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

@@ -43,6 +43,7 @@ from kiwi_tui.runtime_agent import (
 )
 
 from kiwi_tui.ui_settings import load_settings as load_ui_settings, update_settings as update_ui_settings
+from kiwi_tui import attention
 
 
 
@@ -309,9 +310,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 +359,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 +378,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 +399,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."""
@@ -885,6 +903,32 @@ class AutobotsTUI(App):
     #: The most toasts shown at once; older ones give way.
     MAX_TOASTS = 3
 
+    def call_for_attention(self, *, title: str, body: str, tab: str) -> bool:
+        """Call the user back (notification, bell, tab title) when kiwi's window is not
+        in focus: when it is, they are here. Whether it did."""
+        if self.app_focus:
+            return False
+        try:
+            mode = attention.mode_from(load_ui_settings())
+            attention.call_out(self._write_to_terminal, mode=mode, title=title, body=body, tab=tab)
+        except Exception as e:
+            logger.debug(f"Calling for attention failed: {e}")
+            return False
+        self._tab_marked = mode != "off"
+        return True
+
+    def _write_to_terminal(self, text: str) -> None:
+        driver = self._driver
+        if driver is not None and text:
+            driver.write(text)
+            driver.flush()
+
+    def on_app_focus(self, _event) -> None:
+        # Back at kiwi: the mark on the tab has done its job.
+        if getattr(self, "_tab_marked", False):
+            self._tab_marked = False
+            self._write_to_terminal(attention.title_sequence(attention.BASE_TITLE))
+
     def _on_notify(self, event) -> None:
         make_room_for_toast(self._notifications, event.notification, self.MAX_TOASTS)
         super()._on_notify(event)
@@ -1280,7 +1324,8 @@ def main() -> int:
     if sys.stdout.isatty():
         # Strip C0 control chars and DEL to prevent terminal injection via crafted dir names.
         safe_dir = "".join(ch for ch in display_dir if ch >= " " and ch != "\x7f")
-        sys.stdout.write(f"\033]0;kiwi ({safe_dir})\007")
+        attention.BASE_TITLE = f"kiwi ({safe_dir})"
+        sys.stdout.write(f"\033]0;{attention.BASE_TITLE}\007")
         sys.stdout.flush()
 
     runtime_args = _build_runtime_args(args)