langstage-cli 0.6.41__tar.gz → 0.6.43__tar.gz

{langstage_cli-0.6.41/langstage_cli.egg-info → langstage_cli-0.6.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langstage-cli
-Version: 0.6.41
+Version: 0.6.43
 Summary: The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph
 Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
 License-Expression: MIT
@@ -109,6 +109,7 @@ This launches an interactive conversation loop with your agent.
 langstage-cli --demo "Hello"
 
 # Keyless demo of tool calls, reasoning and HITL: say "use a tool", "think" or "ask me"
+# ("think" streams its chain of thought, dimmed under "✻ Thinking", before the answer)
 langstage-cli -a langstage_core.demo.tools:graph "use a tool"
 
 # Scaffold a runnable starter agent + langstage.toml (then just run it)
@@ -299,8 +300,8 @@ langstage-cli --verify -a my_agent.py:graph || { echo "agent broken" >&2; exit 1
 ### Scriptable output
 
 A single-shot run (a `MESSAGE` argument or `-f/--file`) prints only the agent's
-reply — no header, spinner, tool chatter, timing, or color — as soon as its output
-is **piped** (stdout isn't a TTY). Errors and diagnostics go to stderr, and so does
+reply — no header, spinner, tool chatter, reasoning, timing, or color — as soon as its
+output is **piped** (stdout isn't a TTY). Errors and diagnostics go to stderr, and so does
 anything your agent module `print`s while it is being imported. The process exits
 non-zero if the turn failed, so a run is safe to capture:
 

{langstage_cli-0.6.41 → langstage_cli-0.6.43}/README.md

@@ -71,6 +71,7 @@ This launches an interactive conversation loop with your agent.
 langstage-cli --demo "Hello"
 
 # Keyless demo of tool calls, reasoning and HITL: say "use a tool", "think" or "ask me"
+# ("think" streams its chain of thought, dimmed under "✻ Thinking", before the answer)
 langstage-cli -a langstage_core.demo.tools:graph "use a tool"
 
 # Scaffold a runnable starter agent + langstage.toml (then just run it)
@@ -261,8 +262,8 @@ langstage-cli --verify -a my_agent.py:graph || { echo "agent broken" >&2; exit 1
 ### Scriptable output
 
 A single-shot run (a `MESSAGE` argument or `-f/--file`) prints only the agent's
-reply — no header, spinner, tool chatter, timing, or color — as soon as its output
-is **piped** (stdout isn't a TTY). Errors and diagnostics go to stderr, and so does
+reply — no header, spinner, tool chatter, reasoning, timing, or color — as soon as its
+output is **piped** (stdout isn't a TTY). Errors and diagnostics go to stderr, and so does
 anything your agent module `print`s while it is being imported. The process exits
 non-zero if the turn failed, so a run is safe to capture:
 

{langstage_cli-0.6.41 → langstage_cli-0.6.43}/langstage_cli/cli.py

@@ -1122,11 +1122,15 @@ def _absolutize_file_spec(spec: str) -> str:
 
 
 def get_tool_arg_preview(args: Dict[str, Any]) -> str:
-    """Get a preview of the first argument value (nanocode style)."""
+    """Get a preview of the first argument value (nanocode style).
+
+    The value is escaped before it is truncated, so a tool arg can't move the cursor
+    or retitle the terminal, and a cut can't leave half an escape sequence live (gh #180).
+    """
     if not args:
         return ""
     # Get first value
-    first_val = str(list(args.values())[0])
+    first_val = _escape_controls(str(list(args.values())[0]))
     # Truncate if needed
     if len(first_val) > 50:
         return first_val[:50] + "..."
@@ -1142,6 +1146,15 @@ _APPROVAL_LINE_MAX = 100
 _INTERRUPT_LABEL_KEYS = ("description", "question", "message", "prompt")
 
 
+def _escape_controls(text: str, keep: str = "") -> str:
+    """Show every non-printable character escaped (``ESC`` -> ``\\x1b``), except ``keep``.
+
+    Agent-supplied text that the CLI frames itself (an approval preview, a reasoning
+    block) must not move the cursor, recolor the terminal or start a line of its own.
+    """
+    return "".join(ch if ch.isprintable() or ch in keep else repr(ch)[1:-1] for ch in text)
+
+
 def _approval_text(value: Any, limit: Optional[int] = _APPROVAL_VALUE_MAX) -> str:
     """One field of the approval preview as a single, escaped, length-capped line.
 
@@ -1157,7 +1170,7 @@ def _approval_text(value: Any, limit: Optional[int] = _APPROVAL_VALUE_MAX) -> st
             text = str(value)
     else:
         text = str(value)
-    text = "".join(ch if ch.isprintable() else repr(ch)[1:-1] for ch in text)
+    text = _escape_controls(text)
     if limit is not None and len(text) > limit:
         return text[:limit] + "..."
     return text
@@ -1285,11 +1298,60 @@ def _is_generic_interrupt(action_requests: List[Any]) -> bool:
     return not all(_tool_key(a) for a in action_requests)
 
 
+# Indent of a reasoning block's lines, so they sit under its label (gh #178).
+_REASONING_INDENT = "  "
+
+
+def _reasoning_text(delta: str) -> str:
+    """One reasoning delta, escaped and indented for the terminal (gh #178).
+
+    Reasoning gets the approval preview's escaping: a carriage return, ANSI escape or
+    other control character is shown escaped, so it can't move the cursor, end the dim
+    style or overwrite a line. Line breaks (and tabs) are kept, since a chain of thought
+    runs over many lines, but every new line is indented under the block, so no line
+    of reasoning starts at column 0 the way a prompt or a ``⏺`` reply does.
+    """
+    text = _escape_controls(delta.replace("\r\n", "\n"), keep="\n\t")
+    return text.replace("\n", "\n" + _REASONING_INDENT)
+
+
+def _print_reasoning(chunk: Dict[str, Any], verbose: bool) -> None:
+    """Render a ``reasoning`` frame: a reasoning model's chain of thought (gh #178).
+
+    It is not the answer, so it is shown dim, under its own label, ahead of the answer
+    it leads to: ``✻ Thinking`` with the text indented below it, or under ``-v`` a
+    ``[node:reasoning]`` prefix in the style of the ``[node]`` reply label. Consecutive
+    deltas join into one block. Text, a tool call or a node change ends the block, so a
+    later stretch of reasoning gets a label of its own.
+    """
+    text = chunk.get("reasoning") or ""
+    if not text:
+        return
+    node = chunk.get("node") or "unknown"
+    if not print_chunk._streaming_reasoning or print_chunk._reasoning_node != node:
+        _flush_markdown()
+        if print_chunk._streaming_text or print_chunk._streaming_reasoning:
+            print()  # end the open line; the block starts on its own
+        print_chunk._streaming_text = False  # the answer after it gets a fresh marker
+        if verbose:
+            safe_write(f"{DIM}[{node}:reasoning]{RESET} ")
+        else:
+            safe_write(f"{DIM}✻ Thinking{RESET}\n{_REASONING_INDENT}")
+        print_chunk._streaming_reasoning = True
+        print_chunk._reasoning_node = node
+    safe_write(f"{DIM}{_reasoning_text(text)}{RESET}", flush=True)
+
+
 def format_result_preview(result: str) -> str:
-    """Format a result preview with line count indicator."""
+    """Format a result preview with line count indicator.
+
+    The first line is escaped before it is cut, so a tool result (a fetched page, a
+    file) can't clear the screen or forge a line the CLI printed (gh #180).
+    """
     if not result:
         return "(empty)"
-    lines = result.split("\n")
+    lines = result.replace("\r\n", "\n").split("\n")
+    lines[0] = _escape_controls(lines[0])
     preview = lines[0][:60]
     if len(lines) > 1:
         preview += f" ... +{len(lines) - 1} lines"
@@ -1362,6 +1424,9 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
                 print_chunk._streaming_node = node
                 print_chunk._streaming_text = True
                 return
+            if print_chunk._streaming_reasoning:
+                print()  # end the reasoning block's line; the answer starts its own (gh #178)
+                print_chunk._streaming_reasoning = False
             if verbose:
                 # Print the [node] label ONCE per streamed run — when a text run
                 # starts, or the node changes mid-stream — then append subsequent
@@ -1395,14 +1460,21 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
                 else:
                     safe_write(_md_stream.feed(text))
 
+        # Reasoning-model chain of thought, dim and labelled ahead of the answer (gh #178)
+        elif "reasoning" in chunk:
+            if _QUIET:
+                return  # not the reply: scriptable output omits it, like tool chatter
+            _print_reasoning(chunk, verbose)
+
         # Handle tool calls - green tool name
         elif "tool_calls" in chunk:
             if _QUIET:
                 return  # tool chatter is decoration; scriptable output omits it
             _flush_markdown()
             print_chunk._streaming_text = False  # a non-text event ends the text run
+            print_chunk._streaming_reasoning = False  # the "\n● name" below ends its line
             for tool_call in chunk["tool_calls"]:
-                tool_name = tool_call["name"]
+                tool_name = _escape_controls(str(tool_call["name"]))  # gh #180
                 args = tool_call.get("args", {})
                 arg_preview = get_tool_arg_preview(args)
 
@@ -1415,9 +1487,10 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
             if _QUIET:
                 return  # tool chatter is decoration; scriptable output omits it
             _flush_markdown()
-            if print_chunk._streaming_text:
+            if print_chunk._streaming_text or print_chunk._streaming_reasoning:
                 print()  # never glue a result onto the end of a text line (gh #119)
             print_chunk._streaming_text = False
+            print_chunk._streaming_reasoning = False
             result = chunk.get("tool_result", "")
             preview = format_result_preview(str(result))
             safe_print(f"  {DIM}   ↳ {preview}{RESET}")
@@ -1425,6 +1498,7 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
     elif status == "interrupt":
         _flush_markdown()
         print_chunk._streaming_text = False
+        print_chunk._streaming_reasoning = False
         if _QUIET:
             # The `⚠ Action Required` banner is human-facing decoration — like the
             # tool-call / tool-result chatter above, the scriptable path omits it so
@@ -1466,11 +1540,14 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
     elif status == "complete":
         _flush_markdown()
         print_chunk._streaming_text = False  # turn over; next turn starts a fresh marker
+        print_chunk._streaming_reasoning = False
 
     elif status == "error":
         _flush_markdown()
         print_chunk._streaming_text = False
-        error_msg = chunk.get("error", "Unknown error")
+        print_chunk._streaming_reasoning = False
+        # An error can quote tool output; show its control bytes escaped (gh #180).
+        error_msg = _escape_controls(str(chunk.get("error", "Unknown error")), keep="\n\t")
         # Keep stdout clean for the pipe; errors go to stderr. (gh #53)
         out = sys.stderr if _QUIET else sys.stdout
         if _QUIET:
@@ -1482,7 +1559,8 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
         # otherwise point at -v.
         tb = chunk.get("traceback")
         if verbose and tb:
-            safe_print(f"{DIM}{tb.rstrip()}{RESET}", file=out)
+            tb = _escape_controls(str(tb).rstrip(), keep="\n\t")
+            safe_print(f"{DIM}{tb}{RESET}", file=out)
         elif not verbose:
             safe_print(f"{DIM}Re-run with -v for the full traceback.{RESET}", file=out)
 
@@ -1496,6 +1574,10 @@ print_chunk._streaming_text = False
 print_chunk._streaming_node = None
 # The message_id of the text run in progress: a change is a message boundary (gh #119).
 print_chunk._streaming_message_id = None
+# Whether a reasoning block is open (its label printed, its line not yet ended), and the
+# node it belongs to: a change of node starts a new block (gh #178).
+print_chunk._streaming_reasoning = False
+print_chunk._reasoning_node = None
 
 
 def get_key() -> str:
@@ -2045,7 +2127,9 @@ def cmd_history(args: str, context: Dict[str, Any]) -> Optional[str]:
                     else:
                         print(f"\n  {DIM}{role}:{RESET}")
 
-                    # Truncate long content
+                    # A stored tool result is outside content: escape it, then
+                    # truncate (gh #180).
+                    content = _escape_controls(str(content), keep="\n\t")
                     if len(content) > 200:
                         content = content[:200] + "..."
                     safe_print(f"  {DIM}{content}{RESET}")
@@ -2213,6 +2297,7 @@ async def run_single_turn_agui(
     from langstage_cli.agui_stream import agui_stream_updates
 
     print_chunk._streaming_text = False  # fresh marker state per turn (gh #34)
+    print_chunk._streaming_reasoning = False
     _md_stream.reset()
     start_time = time.time()
     had_error = False
@@ -2999,7 +3084,7 @@ def _print_sessions(workspace: Path) -> None:
     is_flag=True,
     default=False,
     help="Scriptable single-shot output: suppress the header, spinner, tool "
-    "chatter, timing, and color, and emit only the agent's reply. Auto-enabled "
+    "chatter, reasoning, timing, and color, and emit only the agent's reply. Auto-enabled "
     "when a single-shot run is piped (stdout is not a TTY).",
 )
 @click.option(

{langstage_cli-0.6.41 → langstage_cli-0.6.43/langstage_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langstage-cli
-Version: 0.6.41
+Version: 0.6.43
 Summary: The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph
 Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
 License-Expression: MIT
@@ -109,6 +109,7 @@ This launches an interactive conversation loop with your agent.
 langstage-cli --demo "Hello"
 
 # Keyless demo of tool calls, reasoning and HITL: say "use a tool", "think" or "ask me"
+# ("think" streams its chain of thought, dimmed under "✻ Thinking", before the answer)
 langstage-cli -a langstage_core.demo.tools:graph "use a tool"
 
 # Scaffold a runnable starter agent + langstage.toml (then just run it)
@@ -299,8 +300,8 @@ langstage-cli --verify -a my_agent.py:graph || { echo "agent broken" >&2; exit 1
 ### Scriptable output
 
 A single-shot run (a `MESSAGE` argument or `-f/--file`) prints only the agent's
-reply — no header, spinner, tool chatter, timing, or color — as soon as its output
-is **piped** (stdout isn't a TTY). Errors and diagnostics go to stderr, and so does
+reply — no header, spinner, tool chatter, reasoning, timing, or color — as soon as its
+output is **piped** (stdout isn't a TTY). Errors and diagnostics go to stderr, and so does
 anything your agent module `print`s while it is being imported. The process exits
 non-zero if the turn failed, so a run is safe to capture:
 

{langstage_cli-0.6.41 → langstage_cli-0.6.43}/langstage_cli.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ tests/test_no_interactive_approve.py
 tests/test_no_persist_resume.py
 tests/test_persist_env.py
 tests/test_quiet_output.py
+tests/test_reasoning_render.py
 tests/test_rename_shim.py
 tests/test_render_markdown.py
 tests/test_session_lifecycle.py
@@ -57,6 +58,7 @@ tests/test_stream_mode.py
 tests/test_streaming_marker.py
 tests/test_terminal_width.py
 tests/test_toml_relative_paths.py
+tests/test_tool_output_escape.py
 tests/test_turn_error_verbose.py
 tests/test_turn_exit_and_render.py
 tests/test_unicode_console.py

{langstage_cli-0.6.41 → langstage_cli-0.6.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "langstage-cli"
-version = "0.6.41"
+version = "0.6.43"
 description = "The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph"
 readme = "README.md"
 requires-python = ">=3.11"

langstage_cli-0.6.43/tests/test_reasoning_render.py

@@ -0,0 +1,153 @@
+"""Reasoning frames render in the terminal (gh #178).
+
+langstage-core emits a reasoning model's chain of thought as its own chunk-wire frame,
+``{"status": "streaming", "reasoning": <delta>, "node": ...}`` (DeepSeek / Qwen / xAI
+``reasoning_content``, and the keyless demo's ``think`` turn). ``print_chunk`` had no
+branch for it, so the frame fell through and nothing printed, with or without ``-v``.
+
+Now a terminal turn shows it dim under a ``✻ Thinking`` label ahead of the answer, ``-v``
+shows it with a ``[node:reasoning]`` prefix, and the quiet / piped path still emits only
+the reply. Reasoning text is escaped like an approval preview, so it can't forge lines.
+"""
+
+import io
+import re
+from contextlib import redirect_stdout
+
+import pytest
+from click.testing import CliRunner
+
+pytest.importorskip("ag_ui_langgraph")
+
+from langstage_core import load_agent_spec  # noqa: E402
+
+from langstage_cli import cli  # noqa: E402
+from langstage_cli.agui_stream import build_session_agent  # noqa: E402
+from langstage_cli.cli import main, print_chunk, run_single_turn_agui  # noqa: E402
+
+_DEMO = "langstage_core.demo.tools:graph"
+_STEP1 = "Let me reason about this step by step."
+_STEP2 = "The demo streams this as a `reasoning` frame, kept separate from the answer."
+_ANSWER = "Done reasoning — that was the `reasoning` frame demo."
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+
+
+async def _demo_turn(monkeypatch, verbose: bool = False) -> str:
+    """The demo's ``think`` turn through the real AG-UI path, as a terminal shows it."""
+    monkeypatch.setattr(cli, "Spinner", lambda *a, **k: None)
+    agent = build_session_agent(load_agent_spec(_DEMO))
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        await run_single_turn_agui(agent, "think", "t-178", interactive=False, verbose=verbose)
+    return buf.getvalue()
+
+
+def _frames(*frames) -> str:
+    """Render chunk frames through ``print_chunk`` from a fresh turn; return stdout."""
+    print_chunk._streaming_text = False
+    print_chunk._streaming_reasoning = False
+    cli._md_stream.reset()
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        for frame in frames:
+            print_chunk(frame)
+        print_chunk({"status": "complete"})
+    return buf.getvalue()
+
+
+def _reasoning(text: str, node: str = "agent") -> dict:
+    return {"status": "streaming", "reasoning": text, "node": node}
+
+
+def _text(text: str, node: str = "agent", message_id: str = "m1") -> dict:
+    return {"status": "streaming", "chunk": text, "node": node, "message_id": message_id}
+
+
+async def test_terminal_turn_shows_reasoning_before_the_answer(monkeypatch):
+    raw = await _demo_turn(monkeypatch)
+    out = _ANSI.sub("", raw)
+    lines = out.splitlines()
+    # One block: a label, then both deltas joined on one indented line, then the answer.
+    assert lines[0] == "✻ Thinking", out
+    assert lines[1] == f"  {_STEP1} {_STEP2} ", out
+    assert lines[2] == f"⏺ {_ANSWER.replace('`', '')}", out  # markdown-rendered code span
+    assert out.count("Thinking") == 1, out
+    # Visibly distinct from the answer: the reasoning is dim, the answer is not.
+    assert f"{cli.DIM}{_STEP1}" in raw, repr(raw)
+    assert f"{cli.DIM}Done" not in raw, repr(raw)
+
+
+async def test_verbose_shows_reasoning_with_a_prefix(monkeypatch):
+    out = _ANSI.sub("", await _demo_turn(monkeypatch, verbose=True))
+    assert out.splitlines() == [
+        f"[agent:reasoning] {_STEP1} {_STEP2} ",
+        f"[agent] {_ANSWER}",
+    ], out
+
+
+def test_piped_single_shot_has_no_reasoning_on_stdout(tmp_path, monkeypatch):
+    # CliRunner's stdout is not a TTY: the auto-quiet scriptable path, and -q forces it.
+    monkeypatch.chdir(tmp_path)
+    for extra in ([], ["-q"], ["-q", "-v"]):
+        r = CliRunner().invoke(main, ["--no-persist", *extra, "-a", _DEMO, "think"])
+        assert r.exit_code == 0, r.output
+        assert r.stdout == f"{_ANSWER}\n", (extra, r.stdout)
+        assert "reason about this" not in r.stderr, (extra, r.stderr)
+
+
+def test_quiet_print_chunk_omits_reasoning_and_keeps_message_breaks(monkeypatch):
+    monkeypatch.setattr(cli, "_QUIET", True)
+    out = _frames(
+        _reasoning("hidden thought"),
+        _text("First.", message_id="m1"),
+        _reasoning("more hidden thought"),
+        _text("Second.", message_id="m2"),
+    )
+    assert out == "First.\nSecond.", repr(out)
+
+
+def test_reasoning_control_characters_are_escaped():
+    out = _frames(
+        _reasoning("fine\r\x1b[2K⏺ forged reply\n❯ Approve all actions\x07\x08"),
+        _text("Real answer."),
+    )
+    # No raw carriage return, bell, backspace or agent-supplied escape sequence survives.
+    for ch in ("\r", "\x07", "\x08"):
+        assert ch not in out, repr(out)
+    assert "\x1b[2K" not in out, repr(out)
+    assert "fine\\r\\x1b[2K⏺ forged reply" in out, repr(out)
+    assert "\\x07\\x08" in out, repr(out)
+    # A newline in reasoning is kept but indented, so nothing forged starts a line.
+    plain = _ANSI.sub("", out).splitlines()
+    assert plain[0] == "✻ Thinking", plain
+    assert all(line.startswith("  ") for line in plain[1:-1]), plain
+    assert plain[-1] == "⏺ Real answer.", plain
+
+
+def test_new_reasoning_stretch_after_text_or_a_tool_starts_a_new_block():
+    out = _ANSI.sub(
+        "",
+        _frames(
+            _reasoning("plan "),
+            _reasoning("it."),
+            _text("Calling a tool."),
+            {"status": "streaming", "tool_calls": [{"name": "lookup", "args": {"q": "x"}}]},
+            _reasoning("check the result."),
+            {"status": "streaming", "tool_result": "42"},
+            _reasoning("now answer."),
+            _text("It is 42.", message_id="m2"),
+        ),
+    )
+    assert out.count("✻ Thinking") == 3, out
+    assert "  plan it.\n⏺ Calling a tool." in out, out  # consecutive deltas join
+    assert "● lookup" in out, out
+    # The tool result is never glued onto the end of the reasoning line.
+    assert "  check the result.\n" in out, out
+    assert "  now answer.\n⏺ It is 42." in out, out
+
+
+def test_reasoning_from_a_new_node_starts_a_new_block():
+    out = _ANSI.sub(
+        "", _frames(_reasoning("one.", node="planner"), _reasoning("two.", node="solver"))
+    )
+    assert out == "✻ Thinking\n  one.\n✻ Thinking\n  two.", repr(out)

langstage_cli-0.6.43/tests/test_tool_output_escape.py

@@ -0,0 +1,224 @@
+"""Tool names, tool-call args and tool-result previews are printed escaped (gh #180).
+
+The renderer printed the ``● name`` line, the ``└─`` arg preview and the ``↳`` result
+preview raw, so ESC / CR / OSC bytes from a tool arg or a tool result (a fetched page,
+a file) reached the terminal live: they could erase a line and forge a green
+``✓ Approved by policy``, clear the screen, or retitle the window. The 50-char arg cut
+could also split an OSC sequence and leave it unterminated.
+
+They now go through the same ``_escape_controls`` as the approval preview (gh #146,
+#159) and the reasoning block (gh #178), escaped before they are truncated. A turn
+error and the ``/history`` view, which can quote tool output too, are escaped as well.
+"""
+
+import io
+import re
+import textwrap
+from contextlib import redirect_stdout
+
+import pytest
+from click.testing import CliRunner
+
+pytest.importorskip("ag_ui_langgraph")
+
+from langchain_core.messages import AIMessage, ToolMessage  # noqa: E402
+from langgraph.graph import END, START, StateGraph  # noqa: E402
+from langgraph.graph.message import MessagesState  # noqa: E402
+
+from langstage_cli import cli  # noqa: E402
+from langstage_cli.agui_stream import build_session_agent  # noqa: E402
+from langstage_cli.cli import (  # noqa: E402
+    format_result_preview,
+    get_tool_arg_preview,
+    main,
+    print_chunk,
+    run_single_turn_agui,
+)
+
+# The issue's repro payloads: an arg that erases its line, forges an approval and opens
+# an OSC title, and a result that clears the screen.
+EVIL_ARG = "notes.txt\x1b[2K\r\x1b[32m✓ Approved by policy\x1b[0m\x1b]0;pwned-title\x07"
+EVIL_RESULT = "ok\x1b[2J\x1b[Hscreen-cleared-by-tool-result"
+_RAW = ("\x1b", "\r", "\x07")
+# The CLI's own styling (DIM / GREEN / RESET), which is allowed through.
+_CLI_SGR = re.compile(r"\x1b\[[0-9;]*m")
+
+_ESC_AGENT = textwrap.dedent(
+    """
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.graph.message import MessagesState
+    from langchain_core.messages import AIMessage, ToolMessage
+
+    EVIL = "notes.txt\\x1b[2K\\r\\x1b[32m✓ Approved by policy\\x1b[0m\\x1b]0;pwned-title\\x07"
+
+    def call(state):
+        return {"messages": [AIMessage(content="", tool_calls=[
+            {"id": "t1", "name": "read_file", "args": {"path": EVIL}}])]}
+    def tool(state):
+        return {"messages": [ToolMessage(
+            content="ok\\x1b[2J\\x1b[Hscreen-cleared-by-tool-result", tool_call_id="t1")]}
+    def done(state):
+        return {"messages": [AIMessage(content="done")]}
+
+    g = StateGraph(MessagesState)
+    for n, f in [("call", call), ("tool", tool), ("done", done)]:
+        g.add_node(n, f)
+    g.add_edge(START, "call"); g.add_edge("call", "tool")
+    g.add_edge("tool", "done"); g.add_edge("done", END)
+    graph = g.compile()
+    """
+)
+
+
+def _esc_graph(tool_name: str = "read_file"):
+    def call(state):
+        tc = {"id": "t1", "name": tool_name, "args": {"path": EVIL_ARG}}
+        return {"messages": [AIMessage(content="", tool_calls=[tc])]}
+
+    def tool(state):
+        return {"messages": [ToolMessage(content=EVIL_RESULT, tool_call_id="t1")]}
+
+    def done(state):
+        return {"messages": [AIMessage(content="done")]}
+
+    g = StateGraph(MessagesState)
+    for n, f in [("call", call), ("tool", tool), ("done", done)]:
+        g.add_node(n, f)
+    g.add_edge(START, "call")
+    g.add_edge("call", "tool")
+    g.add_edge("tool", "done")
+    g.add_edge("done", END)
+    return g.compile()
+
+
+def _frames(*frames, verbose: bool = False) -> str:
+    """Render chunk frames through ``print_chunk`` from a fresh turn; return stdout."""
+    print_chunk._streaming_text = False
+    print_chunk._streaming_reasoning = False
+    cli._md_stream.reset()
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        for frame in frames:
+            print_chunk(frame, verbose=verbose)
+        print_chunk({"status": "complete"})
+    return buf.getvalue()
+
+
+def _assert_no_raw_controls(out: str) -> None:
+    """Nothing but the CLI's own SGR styling may carry a raw control byte."""
+    stripped = _CLI_SGR.sub("", out)
+    for ch in _RAW:
+        assert ch not in stripped, repr(out)
+    # And no agent-supplied non-SGR sequence survives (the forged SGR green is checked
+    # as escaped text by the callers, since the CLI prints its own green raw).
+    for seq in ("\x1b[2K", "\x1b]0;", "\x1b[2J", "\x1b[H"):
+        assert seq not in out, repr(out)
+
+
+@pytest.mark.parametrize("verbose", [False, True])
+async def test_esc_agent_turn_renders_tool_lines_escaped(monkeypatch, verbose):
+    monkeypatch.setattr(cli, "Spinner", lambda *a, **k: None)
+    agent = build_session_agent(_esc_graph())
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        await run_single_turn_agui(agent, "go", "t-180", interactive=False, verbose=verbose)
+    out = buf.getvalue()
+    _assert_no_raw_controls(out)
+    plain = _CLI_SGR.sub("", out)
+    assert "● read_file" in plain, plain
+    assert "└─ notes.txt\\x1b[2K\\r\\x1b[32m✓ Approved by policy" in plain, plain
+    assert "↳ ok\\x1b[2J\\x1b[Hscreen-cleared-by-tool-result" in plain, plain
+    # The forged approval never starts a line of its own.
+    assert not any(line.lstrip().startswith("✓") for line in plain.splitlines()), plain
+
+
+def test_tool_name_with_control_bytes_is_escaped():
+    out = _frames(
+        {
+            "status": "streaming",
+            "tool_calls": [{"name": "read\x1b[2K\rfile\x1b]0;t\x07", "args": {"q": "x"}}],
+        }
+    )
+    _assert_no_raw_controls(out)
+    assert "● read\\x1b[2K\\rfile\\x1b]0;t\\x07" in _CLI_SGR.sub("", out), repr(out)
+
+
+def test_arg_truncation_never_leaves_a_partial_escape():
+    # Slide the OSC across the 50-char cut: whatever is kept, no ESC/BEL is raw.
+    for pad in range(0, 60):
+        preview = get_tool_arg_preview({"path": "a" * pad + "\x1b]0;pwned-title\x07tail"})
+        for ch in _RAW:
+            assert ch not in preview, (pad, preview)
+    assert get_tool_arg_preview({"p": EVIL_ARG}).startswith("notes.txt\\x1b[2K\\r")
+
+
+def test_result_truncation_never_leaves_a_partial_escape():
+    for pad in range(0, 70):
+        preview = format_result_preview("b" * pad + "\x1b]0;pwned\x07\x1b[2Jrest\nline two")
+        for ch in _RAW:
+            assert ch not in preview, (pad, preview)
+        assert preview.endswith(" ... +1 lines"), preview
+
+
+def test_result_crlf_line_endings_are_not_shown_as_escapes():
+    assert format_result_preview("first\r\nsecond\r\n") == "first ... +2 lines"
+
+
+def test_plain_text_is_unchanged():
+    assert get_tool_arg_preview({"path": "docs/naïve résumé 日本語.md"}) == (
+        "docs/naïve résumé 日本語.md"
+    )
+    long = "x y " * 20
+    assert get_tool_arg_preview({"q": long}) == long[:50] + "..."
+    assert format_result_preview("héllo wörld ✓\nmore") == "héllo wörld ✓ ... +1 lines"
+    assert format_result_preview("z" * 70) == "z" * 60 + "..."
+    out = _CLI_SGR.sub(
+        "",
+        _frames(
+            {"status": "streaming", "tool_calls": [{"name": "ls", "args": {"p": "a b ✓"}}]},
+            {"status": "streaming", "tool_result": "fichier  ünïcode"},
+        ),
+    )
+    assert out == "\n● ls\n  └─ a b ✓\n     ↳ fichier  ünïcode\n", repr(out)
+
+
+@pytest.mark.parametrize("verbose", [False, True])
+def test_turn_error_is_escaped_but_keeps_its_lines(verbose):
+    out = _frames(
+        {
+            "status": "error",
+            "error": "tool failed: \x1b[2J\x1b]0;x\x07\nsecond line",
+            "traceback": "Traceback\n  raise \x1b[2K\rforged",
+        },
+        verbose=verbose,
+    )
+    _assert_no_raw_controls(out)
+    plain = _CLI_SGR.sub("", out)
+    assert "Error: tool failed: \\x1b[2J\\x1b]0;x\\x07\nsecond line" in plain, plain
+    if verbose:
+        assert "raise \\x1b[2K\\rforged" in plain, plain
+
+
+def test_piped_single_shot_still_has_only_the_reply(tmp_path, monkeypatch):
+    # Quiet/scriptable mode already suppresses tool chatter; the reply is untouched.
+    (tmp_path / "esc_agent.py").write_text(_ESC_AGENT, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    r = CliRunner().invoke(main, ["--no-persist", "-a", "esc_agent.py:graph", "go"])
+    assert r.exit_code == 0, r.output
+    assert r.stdout == "done\n", repr(r.stdout)
+    assert "notes.txt" not in r.stderr and "screen-cleared" not in r.stderr, r.stderr
+
+
+def test_history_view_escapes_stored_tool_results(capsys):
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    from langstage_cli.cli import cmd_history
+
+    graph = _esc_graph()
+    graph.checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "h-180"}}
+    graph.invoke({"messages": [("user", "go")]}, config)
+    cmd_history("", {"graph": graph, "config": config, "session_info": {}})
+    out = capsys.readouterr().out
+    _assert_no_raw_controls(out)
+    assert "ok\\x1b[2J\\x1b[Hscreen-cleared-by-tool-result" in out, repr(out)