dscli-agent 0.6.0__tar.gz → 0.7.0__tar.gz

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dscli-agent
-Version: 0.6.0
+Version: 0.7.0
 Summary: A local coding agent that uses DeepSeek web chat as its model
 Author: Anish
 License-Expression: MIT
@@ -232,7 +232,8 @@ every run with `dscli config --set deeplanning=true`, or turn it off for one run
 | --- | --- |
 | `Enter` | Send the message (or accept a `/` completion). |
 | `Esc` then `Enter`, or `Ctrl+J` | Insert a newline for multi-line input. |
-| `Ctrl+C` | While the agent is working: interrupt the current turn, keep the browser session, and return to the prompt. At the prompt: clear the input. |
+| `Esc` | While the agent is working: interrupt the current turn, keep the browser session, and return to the prompt. |
+| `Ctrl+C` | While the agent is working: interrupt the current turn. At the prompt: clear the input. |
 | `Ctrl+D` | Exit dscli. |
 | `↑` / `↓` | Browse previous messages. |
 | `Ctrl+O` | Expand the last thinking block or tool output in full. |
@@ -317,7 +318,7 @@ failures and unconfirmed completions are always logged to stderr, including unde
 | `--headed` / `--headless` | Show or hide the browser. Headless is the default. |
 | `--search` | Turn DeepSeek's Search mode on for the run (DeepThink is always on). |
 | `--deeplanning` | Require a non-empty `update_plan` before writes or commands (alias: `--deep-planning`). |
-| `--max-steps N` | Maximum model turns (default 20, cap 150). |
+| `--max-steps N` | Maximum model turns (default 20, cap 2000). |
 | `--timeout N` | Response timeout per turn in seconds (default 300). |
 | `--verify CMD` | Run CMD automatically after file edits; failures block success. |
 | `--no-verify` | Disable the configured `verify_command` for this run. |
@@ -558,8 +559,8 @@ Debug screenshots and unparsed replies are written to `%APPDATA%\dscli\debug`.
   `complete: true`; tool calls still wait for the complete, validated JSON envelope.
   The context bar is likewise a local estimate of sent and received text, not usage
   reported by DeepSeek.
-- Interrupting with Ctrl+C clicks DeepSeek's labelled stop button when dscli can find
-  it. If the page does not expose one, generation may continue in the web chat; the
+- Interrupting with Esc or Ctrl+C clicks DeepSeek's labelled stop button when dscli can
+  find it. If the page does not expose one, generation may continue in the web chat; the
   interrupted answer is discarded, and the next message (or `/new`) re-establishes a
   clean turn.
 - Web-chat attachments accept only certain file types. When a file cannot be attached,

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/README.md

@@ -202,7 +202,8 @@ every run with `dscli config --set deeplanning=true`, or turn it off for one run
 | --- | --- |
 | `Enter` | Send the message (or accept a `/` completion). |
 | `Esc` then `Enter`, or `Ctrl+J` | Insert a newline for multi-line input. |
-| `Ctrl+C` | While the agent is working: interrupt the current turn, keep the browser session, and return to the prompt. At the prompt: clear the input. |
+| `Esc` | While the agent is working: interrupt the current turn, keep the browser session, and return to the prompt. |
+| `Ctrl+C` | While the agent is working: interrupt the current turn. At the prompt: clear the input. |
 | `Ctrl+D` | Exit dscli. |
 | `↑` / `↓` | Browse previous messages. |
 | `Ctrl+O` | Expand the last thinking block or tool output in full. |
@@ -287,7 +288,7 @@ failures and unconfirmed completions are always logged to stderr, including unde
 | `--headed` / `--headless` | Show or hide the browser. Headless is the default. |
 | `--search` | Turn DeepSeek's Search mode on for the run (DeepThink is always on). |
 | `--deeplanning` | Require a non-empty `update_plan` before writes or commands (alias: `--deep-planning`). |
-| `--max-steps N` | Maximum model turns (default 20, cap 150). |
+| `--max-steps N` | Maximum model turns (default 20, cap 2000). |
 | `--timeout N` | Response timeout per turn in seconds (default 300). |
 | `--verify CMD` | Run CMD automatically after file edits; failures block success. |
 | `--no-verify` | Disable the configured `verify_command` for this run. |
@@ -528,8 +529,8 @@ Debug screenshots and unparsed replies are written to `%APPDATA%\dscli\debug`.
   `complete: true`; tool calls still wait for the complete, validated JSON envelope.
   The context bar is likewise a local estimate of sent and received text, not usage
   reported by DeepSeek.
-- Interrupting with Ctrl+C clicks DeepSeek's labelled stop button when dscli can find
-  it. If the page does not expose one, generation may continue in the web chat; the
+- Interrupting with Esc or Ctrl+C clicks DeepSeek's labelled stop button when dscli can
+  find it. If the page does not expose one, generation may continue in the web chat; the
   interrupted answer is discarded, and the next message (or `/new`) re-establishes a
   clean turn.
 - Web-chat attachments accept only certain file types. When a file cannot be attached,

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/dscli/__init__.py

@@ -1,3 +1,3 @@
 """dscli - a local coding agent for your terminal."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/dscli/cli.py

@@ -199,7 +199,7 @@ def _apply_run_config(cfg: Config, args: argparse.Namespace) -> Config:
     if args.max_steps is not None:
         if args.max_steps < 1:
             raise ValueError("--max-steps must be at least 1.")
-        cfg.max_steps = min(args.max_steps, 150)
+        cfg.max_steps = min(args.max_steps, 2000)
     if args.search is not None:
         cfg.search = args.search
     if args.deeplanning is not None:
@@ -641,6 +641,14 @@ def _chat_loop_plain(
             first_message = True
 
 
+def _run_agent_interruptible(tui, **kwargs):
+    tui.start_interrupt_watch()
+    try:
+        return run_agent(**kwargs)
+    finally:
+        tui.stop_interrupt_watch()
+
+
 def _chat_loop_tui(
     session: ChatSession,
     toolbox: Toolbox,
@@ -700,7 +708,8 @@ def _chat_loop_tui(
         pending_resume = None
         started = time.monotonic()
         try:
-            outcome = run_agent(
+            outcome = _run_agent_interruptible(
+                tui,
                 session=session,
                 config=cfg,
                 toolbox=toolbox,

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/dscli/tui.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import _thread
 import os
 import re
+import sys
 import textwrap
+import threading
 import time
 from pathlib import Path
 from typing import TYPE_CHECKING, Callable
@@ -140,6 +143,114 @@ class TuiQuit(KeyboardInterrupt):
     """The user chose q at an approval prompt; exit instead of continuing."""
 
 
+def _read_key_windows() -> str | None:
+    import msvcrt
+
+    if not msvcrt.kbhit():
+        return None
+    return msvcrt.getwch()
+
+
+def _read_key_posix(fd: int) -> str | None:
+    import select
+
+    ready, _, _ = select.select([fd], [], [], 0.05)
+    if not ready:
+        return None
+    data = os.read(fd, 1)
+    if data != b"\x1b":
+        return data.decode(errors="replace")
+    # Arrow and function keys start with Esc, so wait a beat: a lone Esc
+    # interrupts, while a full escape sequence is discarded.
+    ready, _, _ = select.select([fd], [], [], 0.02)
+    if not ready:
+        return "\x1b"
+    sequence = bytearray(os.read(fd, 32))
+    while True:
+        ready, _, _ = select.select([fd], [], [], 0.005)
+        if not ready:
+            break
+        sequence += os.read(fd, 32)
+    return "\x1b" + sequence.decode(errors="replace")
+
+
+class _EscapeKeyWatcher:
+    """Watch the terminal for Esc while the agent runs.
+
+    prompt_toolkit only owns stdin while the prompt is active, so between
+    messages this watcher takes the terminal over in cbreak mode and turns
+    Esc into an interruption. Every other keypress is discarded. It stays
+    inert when stdin is not a terminal.
+    """
+
+    def __init__(
+        self,
+        on_escape: Callable[[], None],
+        *,
+        read_key: Callable[[], str | None] | None = None,
+    ) -> None:
+        self._on_escape = on_escape
+        self._read_key = read_key
+        self._thread: threading.Thread | None = None
+        self._stop = threading.Event()
+
+    @property
+    def running(self) -> bool:
+        return self._thread is not None
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        if self._read_key is None:
+            stream = sys.stdin
+            if stream is None or not stream.isatty():
+                return
+        self._stop.clear()
+        self._thread = threading.Thread(
+            target=self._run, name="dscli-esc-watch", daemon=True
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop.set()
+        thread = self._thread
+        self._thread = None
+        if thread is not None and thread is not threading.current_thread():
+            thread.join(timeout=1.0)
+
+    def _run(self) -> None:
+        try:
+            if self._read_key is not None:
+                self._loop(self._read_key)
+            elif os.name == "nt":
+                self._loop(_read_key_windows)
+            else:
+                self._loop_posix()
+        except Exception:
+            pass
+
+    def _loop_posix(self) -> None:
+        import termios
+        import tty
+
+        fd = sys.stdin.fileno()
+        previous = termios.tcgetattr(fd)
+        try:
+            tty.setcbreak(fd, termios.TCSANOW)
+            self._loop(lambda: _read_key_posix(fd))
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, previous)
+
+    def _loop(self, read_key: Callable[[], str | None]) -> None:
+        while not self._stop.is_set():
+            key = read_key()
+            if key == "\x1b":
+                self._on_escape()
+                return
+            if key is None:
+                self._stop.wait(0.05)
+
+
 class SlashCompleter(Completer):
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor
@@ -332,6 +443,7 @@ class Tui:
         console: Console | None = None,
         prompt_session: PromptSession | None = None,
         approval_session: PromptSession | None = None,
+        interrupt_watcher: _EscapeKeyWatcher | None = None,
         clock: Callable[[], float] = time.monotonic,
     ) -> None:
         self.workspace = workspace
@@ -369,6 +481,9 @@ class Tui:
         self._plan_snapshot: list[tuple[str, str]] = []
         self._prompt_session = prompt_session or self._build_prompt_session()
         self._approval_session = approval_session or self._build_approval_session()
+        self._interrupt_watcher = interrupt_watcher or _EscapeKeyWatcher(
+            self._interrupt_current_run
+        )
 
     # ---------------------------------------------------------------- prompt
     def _history(self):
@@ -459,6 +574,18 @@ class Tui:
             [("class:prompt", "❯ ")], in_thread=True
         )
 
+    # ------------------------------------------------------- interrupt by Esc
+    def start_interrupt_watch(self) -> None:
+        self._interrupt_watcher.start()
+
+    def stop_interrupt_watch(self) -> None:
+        self._interrupt_watcher.stop()
+
+    def _interrupt_current_run(self) -> None:
+        # Take the same path as Ctrl+C: unwind the run in the main thread,
+        # where the chat loop stops generation and keeps the session alive.
+        _thread.interrupt_main()
+
     # -------------------------------------------------------------- lifecycle
     def banner(self, cfg: Config) -> None:
         self._stop_live()
@@ -585,7 +712,8 @@ class Tui:
         keys.add_column()
         keys.add_row("Enter", "send the message")
         keys.add_row("Esc+Enter / Ctrl+J", "insert a newline")
-        keys.add_row("Ctrl+C", "interrupt while working, or clear the input")
+        keys.add_row("Esc / Ctrl+C", "interrupt the response while working")
+        keys.add_row("Ctrl+C", "clear the input at the prompt")
         keys.add_row("Ctrl+O", "expand the last thinking block or tool output")
         keys.add_row("Ctrl+D", "exit dscli")
         self.console.print(keys)
@@ -595,6 +723,7 @@ class Tui:
         self.console.print(Text(message, style="dim"))
 
     def close(self) -> None:
+        self._interrupt_watcher.stop()
         self._stop_live()
 
     def interrupted(self) -> None:
@@ -716,7 +845,7 @@ class Tui:
         line.append(f"  {elapsed:.0f}s", style="dim")
         if detail:
             line.append(f"  ·  {detail}", style="dim")
-        line.append("  ·  Ctrl+C to interrupt", style="dim")
+        line.append("  ·  Esc / Ctrl+C to interrupt", style="dim")
         return line
 
     def _render_status(self):
@@ -1265,6 +1394,18 @@ class Tui:
 
     # -------------------------------------------------------------- approval
     def confirm(self, title: str, detail: str | None) -> bool:
+        # The approval prompt owns stdin; a parallel Esc watcher would eat
+        # the answer keys, so pause it while the question is on screen.
+        resume_watch = self._interrupt_watcher.running
+        if resume_watch:
+            self._interrupt_watcher.stop()
+        try:
+            return self._confirm(title, detail)
+        finally:
+            if resume_watch:
+                self._interrupt_watcher.start()
+
+    def _confirm(self, title: str, detail: str | None) -> bool:
         self._settle()
         self.console.print()
         self.console.print(Text(title, style=f"bold {branding.BROWN}"))

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/dscli_agent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dscli-agent
-Version: 0.6.0
+Version: 0.7.0
 Summary: A local coding agent that uses DeepSeek web chat as its model
 Author: Anish
 License-Expression: MIT
@@ -232,7 +232,8 @@ every run with `dscli config --set deeplanning=true`, or turn it off for one run
 | --- | --- |
 | `Enter` | Send the message (or accept a `/` completion). |
 | `Esc` then `Enter`, or `Ctrl+J` | Insert a newline for multi-line input. |
-| `Ctrl+C` | While the agent is working: interrupt the current turn, keep the browser session, and return to the prompt. At the prompt: clear the input. |
+| `Esc` | While the agent is working: interrupt the current turn, keep the browser session, and return to the prompt. |
+| `Ctrl+C` | While the agent is working: interrupt the current turn. At the prompt: clear the input. |
 | `Ctrl+D` | Exit dscli. |
 | `↑` / `↓` | Browse previous messages. |
 | `Ctrl+O` | Expand the last thinking block or tool output in full. |
@@ -317,7 +318,7 @@ failures and unconfirmed completions are always logged to stderr, including unde
 | `--headed` / `--headless` | Show or hide the browser. Headless is the default. |
 | `--search` | Turn DeepSeek's Search mode on for the run (DeepThink is always on). |
 | `--deeplanning` | Require a non-empty `update_plan` before writes or commands (alias: `--deep-planning`). |
-| `--max-steps N` | Maximum model turns (default 20, cap 150). |
+| `--max-steps N` | Maximum model turns (default 20, cap 2000). |
 | `--timeout N` | Response timeout per turn in seconds (default 300). |
 | `--verify CMD` | Run CMD automatically after file edits; failures block success. |
 | `--no-verify` | Disable the configured `verify_command` for this run. |
@@ -558,8 +559,8 @@ Debug screenshots and unparsed replies are written to `%APPDATA%\dscli\debug`.
   `complete: true`; tool calls still wait for the complete, validated JSON envelope.
   The context bar is likewise a local estimate of sent and received text, not usage
   reported by DeepSeek.
-- Interrupting with Ctrl+C clicks DeepSeek's labelled stop button when dscli can find
-  it. If the page does not expose one, generation may continue in the web chat; the
+- Interrupting with Esc or Ctrl+C clicks DeepSeek's labelled stop button when dscli can
+  find it. If the page does not expose one, generation may continue in the web chat; the
   interrupted answer is discarded, and the next message (or `/new`) re-establishes a
   clean turn.
 - Web-chat attachments accept only certain file types. When a file cannot be attached,

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/tests/test_cli.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import _thread
 import io
 import os
 import tempfile
+import threading
+import time
 import unittest
 from contextlib import redirect_stderr, redirect_stdout
 from pathlib import Path
@@ -28,7 +31,7 @@ from dscli.cli import (
 )
 from dscli.config import Config
 from dscli.protocol import ProtocolError
-from dscli.tui import TuiQuit
+from dscli.tui import Tui, TuiQuit, _EscapeKeyWatcher
 
 
 class FakeSession:
@@ -72,6 +75,18 @@ class FakeSession:
         return self.resume_result
 
 
+class StubPromptSession:
+    def __init__(self, answers: list[str]) -> None:
+        self.answers = list(answers)
+        self.calls: list[dict] = []
+
+    def prompt(self, message="", **kwargs) -> str:
+        self.calls.append(kwargs)
+        if not self.answers:
+            raise AssertionError("unexpected prompt")
+        return self.answers.pop(0)
+
+
 class FakeTui:
     def __init__(self, inputs) -> None:
         self.inputs = iter(inputs)
@@ -84,6 +99,10 @@ class FakeTui:
         self.statuses = []
         self.usage: list[int] = []
         self.events: list[str] | None = None
+        self.watch_starts = 0
+        self.watch_stops = 0
+        self.watching = False
+        self.watching_at_interrupt: bool | None = None
 
     def prompt(self) -> str:
         value = next(self.inputs)
@@ -140,6 +159,15 @@ class FakeTui:
 
     def interrupted(self) -> None:
         self.interrupts += 1
+        self.watching_at_interrupt = self.watching
+
+    def start_interrupt_watch(self) -> None:
+        self.watch_starts += 1
+        self.watching = True
+
+    def stop_interrupt_watch(self) -> None:
+        self.watch_stops += 1
+        self.watching = False
 
     def close(self) -> None:
         self.closed += 1
@@ -254,17 +282,17 @@ class InteractiveChatTests(unittest.TestCase):
         )
         self.assertTrue(cfg.shell_enabled)
 
-    def test_max_steps_defaults_to_20_and_is_capped_at_150(self) -> None:
+    def test_max_steps_defaults_to_20_and_is_capped_at_2000(self) -> None:
         parser = build_parser()
         self.assertEqual(Config().max_steps, 20)
         cfg = _apply_run_config(
-            Config(), parser.parse_args(["run", "task", "--max-steps", "150"])
+            Config(), parser.parse_args(["run", "task", "--max-steps", "2000"])
         )
-        self.assertEqual(cfg.max_steps, 150)
+        self.assertEqual(cfg.max_steps, 2000)
         cfg = _apply_run_config(
-            Config(), parser.parse_args(["run", "task", "--max-steps", "500"])
+            Config(), parser.parse_args(["run", "task", "--max-steps", "5000"])
         )
-        self.assertEqual(cfg.max_steps, 150)
+        self.assertEqual(cfg.max_steps, 2000)
 
     def test_should_use_tui_respects_flags_and_environment(self) -> None:
         plain = build_parser().parse_args(["chat", "--plain"])
@@ -353,12 +381,63 @@ class InteractiveChatTests(unittest.TestCase):
         self.assertEqual(result, 0)
         self.assertEqual(session.stopped, 1)
         self.assertEqual(fake_tui.interrupts, 1)
+        self.assertFalse(fake_tui.watching_at_interrupt)
+        self.assertEqual(fake_tui.watch_starts, 2)
+        self.assertEqual(fake_tui.watch_stops, 2)
         self.assertEqual(len(fake_tui.completed), 1)
         self.assertEqual(fake_tui.completed[0][0].final, "recovered")
         self.assertEqual(session.closed, 1)
         calls = run_agent.call_args_list
         self.assertEqual([call.kwargs["followup"] for call in calls], [False, True])
 
+    def test_escape_interrupts_a_running_turn(self) -> None:
+        args = build_parser().parse_args(["chat", "--workspace", str(self.workspace)])
+        session = FakeSession()
+        entered = threading.Event()
+
+        def read_key() -> str | None:
+            return "\x1b" if entered.is_set() else None
+
+        def slow_run(**_kwargs):
+            entered.set()
+            deadline = time.monotonic() + 5
+            while time.monotonic() < deadline:
+                time.sleep(0.05)
+
+        def interrupt() -> None:
+            tui._interrupt_current_run()
+
+        watcher = _EscapeKeyWatcher(interrupt, read_key=read_key)
+        console = Console(file=io.StringIO(), force_terminal=False, record=True)
+        tui = Tui(
+            workspace=self.workspace,
+            console=console,
+            prompt_session=StubPromptSession(["hello", "/exit"]),
+            approval_session=StubPromptSession([]),
+            interrupt_watcher=watcher,
+        )
+        with (
+            patch("dscli.cli.ensure_config_file"),
+            patch("dscli.cli.load_config", return_value=Config()),
+            patch("dscli.cli._should_use_tui", return_value=True),
+            patch("dscli.cli._try_create_tui", return_value=tui),
+            patch("dscli.cli._new_session", return_value=session),
+            patch(
+                "dscli.cli._ensure_ready",
+                side_effect=lambda session, cfg, allow_auto_login, **_kw: session,
+            ),
+            patch("dscli.cli.run_agent", side_effect=slow_run),
+            redirect_stderr(io.StringIO()),
+        ):
+            started = time.monotonic()
+            result = cmd_chat(args)
+            elapsed = time.monotonic() - started
+        self.assertEqual(result, 0)
+        self.assertEqual(session.stopped, 1)
+        self.assertLess(elapsed, 3.0)
+        self.assertFalse(watcher.running)
+        self.assertIn("Interrupted", console.export_text())
+
     def test_tui_ctrl_c_at_prompt_clears_input(self) -> None:
         result, session, fake_tui, run_agent = self.run_tui_chat(
             [KeyboardInterrupt(), "/exit"], []

{dscli_agent-0.6.0 → dscli_agent-0.7.0}/tests/test_tui.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import _thread
 import io
 import time
 import unittest
@@ -14,7 +15,7 @@ from dscli import branding
 from dscli.agent import AgentOutcome
 from dscli.config import Config
 from dscli.protocol import ToolCall
-from dscli.tui import SlashCompleter, Tui, TuiQuit
+from dscli.tui import SlashCompleter, Tui, TuiQuit, _EscapeKeyWatcher
 from dscli.tools import PlanStep, ToolResult
 
 
@@ -40,6 +41,21 @@ class FakeClock:
         return self.now
 
 
+class FakeWatcher:
+    def __init__(self) -> None:
+        self.starts = 0
+        self.stops = 0
+        self.running = False
+
+    def start(self) -> None:
+        self.starts += 1
+        self.running = True
+
+    def stop(self) -> None:
+        self.stops += 1
+        self.running = False
+
+
 class TuiTests(unittest.TestCase):
     def make_tui(
         self,
@@ -241,7 +257,7 @@ class TuiTests(unittest.TestCase):
             tui.stop_status()
         text = self.output()
         self.assertIn("Thinking", text)
-        self.assertIn("Ctrl+C to interrupt", text)
+        self.assertIn("Esc / Ctrl+C to interrupt", text)
         self.assertNotIn("DeepSeek", text)
 
     def test_tool_status_shows_the_tool_and_target(self) -> None:
@@ -276,7 +292,7 @@ class TuiTests(unittest.TestCase):
         self.console.print(tui._render_answer())
         text = self.output()
         self.assertIn("Responding", text)
-        self.assertIn("Ctrl+C to interrupt", text)
+        self.assertIn("Esc / Ctrl+C to interrupt", text)
         self.assertIn("Hello world", text)
 
     def test_confirm_prompts_and_returns_answers(self) -> None:
@@ -316,6 +332,69 @@ class TuiTests(unittest.TestCase):
         with self.assertRaises(TuiQuit):
             tui.confirm("Create a.py?", None)
 
+    def test_escape_watcher_fires_on_esc_and_ignores_other_keys(self) -> None:
+        pressed: list[bool] = []
+        keys = iter(["x", "\x1b[A", "\x1b"])
+        watcher = _EscapeKeyWatcher(
+            lambda: pressed.append(True), read_key=lambda: next(keys, None)
+        )
+        watcher.start()
+        self.assertTrue(watcher.running)
+        try:
+            deadline = time.monotonic() + 2
+            while not pressed and time.monotonic() < deadline:
+                time.sleep(0.01)
+        finally:
+            watcher.stop()
+        self.assertEqual(pressed, [True])
+        self.assertFalse(watcher.running)
+
+    def test_escape_interrupts_the_main_thread(self) -> None:
+        def trigger() -> None:
+            time.sleep(0.1)
+            _thread.interrupt_main()
+
+        watcher = _EscapeKeyWatcher(trigger, read_key=lambda: "\x1b")
+        watcher.start()
+        try:
+            with self.assertRaises(KeyboardInterrupt):
+                time.sleep(3)
+        finally:
+            watcher.stop()
+
+    def test_watch_methods_delegate_to_the_watcher(self) -> None:
+        fake = FakeWatcher()
+        tui = Tui(
+            workspace=Path("C:/workspace"),
+            console=Console(file=io.StringIO()),
+            prompt_session=FakePromptSession(),
+            approval_session=FakePromptSession(),
+            interrupt_watcher=fake,
+        )
+        tui.start_interrupt_watch()
+        self.assertTrue(fake.running)
+        tui.stop_interrupt_watch()
+        self.assertFalse(fake.running)
+        self.assertEqual((fake.starts, fake.stops), (1, 1))
+        tui.start_interrupt_watch()
+        tui.close()
+        self.assertFalse(fake.running)
+        self.assertEqual(fake.stops, 2)
+
+    def test_approval_pauses_and_resumes_the_escape_watcher(self) -> None:
+        fake = FakeWatcher()
+        fake.running = True
+        tui = Tui(
+            workspace=Path("C:/workspace"),
+            console=Console(file=io.StringIO()),
+            prompt_session=FakePromptSession(),
+            approval_session=FakePromptSession(["y"]),
+            interrupt_watcher=fake,
+        )
+        self.assertTrue(tui.confirm("Create a.py?", None))
+        self.assertTrue(fake.running)
+        self.assertEqual((fake.starts, fake.stops), (1, 1))
+
     def test_slash_completer_only_completes_commands(self) -> None:
         completer = SlashCompleter()
         completions = list(