pythinker-code 0.8.0__tar.gz → 0.9.0__tar.gz

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythinker-code
-Version: 0.8.0
+Version: 0.9.0
 Summary: Pythinker Code is your next CLI agent.
 Keywords: cli,agent,ai,coding-assistant,llm,claude,openai,terminal
 Author: Mohamed Elkholy
@@ -115,18 +115,16 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.8.0
+## 🆕 What's New in 0.9.0
 
-Version-scheme reset. Pythinker Code moves to a `0.MINOR.PATCH` line; `0.8.0` is the new starting release, replacing the prior 1.x/2.x lineage.
+- **Cleaner TUI — tool card backgrounds removed.** The grey pending/running overlay behind tool execution cards (subagents, bash, reads, etc.) is gone. Only user-message blocks keep a background tint, keeping visual focus on your input.
+- **Welcome screen enhancements.** The startup panel now shows the current git branch (highlighted in magenta) and the session auto-save path alongside the working directory and session ID.
+- **Bash header strip styling.** The `$ command` strip in bash execution headers now uses the `tool_pending_bg` theme token, matching the reference renderer across light and dark themes.
+- **Pythinker markdown renderer in all messages.** User, assistant, and custom messages now render through `pythinker_markdown` for consistent heading, code-block, and table styling.
+- **Expanded theme palette.** A new `MarkdownColors` / `markdown_rich_style` subsystem in `theme.py` covers headings, emphasis, inline code, links, blockquotes, table borders, code-block backgrounds, and spinner states with separate dark and light palettes.
+- **Improved tool fallback renderers.** Call fallbacks now show a status glyph (`✔`/`✘`/`●`); result fallbacks truncate at 60 lines / 4000 chars with an italicised note and use correct theme tokens.
 
-- **New version line — `0.MINOR.PATCH`.** `MINOR` is a monotonically increasing release counter; `PATCH` is reserved for hotfixes. No `1.0.0` milestone is planned on this line.
-- **PyPI reset.** All prior `pythinker-code` 1.x/2.x releases have been **yanked** from PyPI. New installs (`pip install pythinker-code`, `pip install --upgrade pythinker-code`, `uv tool install pythinker-code`, and `pythinker update`) resolve to `0.8.0`.
-- **GitHub reset.** All pre-`0.8.0` GitHub Releases and matching git tags have been removed. `v0.8.0` is the first tag on the new line.
-- **Tag scheme.** Release tags are now `v<MAJOR>.<MINOR>.<PATCH>` (e.g. `v0.8.0`). The release workflow trigger and `scripts/check_version_tag.py` both expect the `v` prefix.
-- **No app-level regressions.** All functionality shipped through 2.7.0 is preserved: review-first workflows (`pythinker review`, `pythinker secscan`, `pythinker security-scan`, `pythinker debug`), Reviewflow stateful review/fix workflows, the `code-reviewer` / `security-reviewer` / `debugger` subagent roles, hardened review-output validation, and the read-only PR artifact helpers.
-- **History preserved in-repo.** The detailed 1.x/2.x release notes are archived at [`docs/history/CHANGELOG-pre-0.8.0.md`](docs/history/CHANGELOG-pre-0.8.0.md).
-
-Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.8.0`.
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.9.0`.
 
 
 ---

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/README.md

@@ -50,18 +50,16 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.8.0
+## 🆕 What's New in 0.9.0
 
-Version-scheme reset. Pythinker Code moves to a `0.MINOR.PATCH` line; `0.8.0` is the new starting release, replacing the prior 1.x/2.x lineage.
+- **Cleaner TUI — tool card backgrounds removed.** The grey pending/running overlay behind tool execution cards (subagents, bash, reads, etc.) is gone. Only user-message blocks keep a background tint, keeping visual focus on your input.
+- **Welcome screen enhancements.** The startup panel now shows the current git branch (highlighted in magenta) and the session auto-save path alongside the working directory and session ID.
+- **Bash header strip styling.** The `$ command` strip in bash execution headers now uses the `tool_pending_bg` theme token, matching the reference renderer across light and dark themes.
+- **Pythinker markdown renderer in all messages.** User, assistant, and custom messages now render through `pythinker_markdown` for consistent heading, code-block, and table styling.
+- **Expanded theme palette.** A new `MarkdownColors` / `markdown_rich_style` subsystem in `theme.py` covers headings, emphasis, inline code, links, blockquotes, table borders, code-block backgrounds, and spinner states with separate dark and light palettes.
+- **Improved tool fallback renderers.** Call fallbacks now show a status glyph (`✔`/`✘`/`●`); result fallbacks truncate at 60 lines / 4000 chars with an italicised note and use correct theme tokens.
 
-- **New version line — `0.MINOR.PATCH`.** `MINOR` is a monotonically increasing release counter; `PATCH` is reserved for hotfixes. No `1.0.0` milestone is planned on this line.
-- **PyPI reset.** All prior `pythinker-code` 1.x/2.x releases have been **yanked** from PyPI. New installs (`pip install pythinker-code`, `pip install --upgrade pythinker-code`, `uv tool install pythinker-code`, and `pythinker update`) resolve to `0.8.0`.
-- **GitHub reset.** All pre-`0.8.0` GitHub Releases and matching git tags have been removed. `v0.8.0` is the first tag on the new line.
-- **Tag scheme.** Release tags are now `v<MAJOR>.<MINOR>.<PATCH>` (e.g. `v0.8.0`). The release workflow trigger and `scripts/check_version_tag.py` both expect the `v` prefix.
-- **No app-level regressions.** All functionality shipped through 2.7.0 is preserved: review-first workflows (`pythinker review`, `pythinker secscan`, `pythinker security-scan`, `pythinker debug`), Reviewflow stateful review/fix workflows, the `code-reviewer` / `security-reviewer` / `debugger` subagent roles, hardened review-output validation, and the read-only PR artifact helpers.
-- **History preserved in-repo.** The detailed 1.x/2.x release notes are archived at [`docs/history/CHANGELOG-pre-0.8.0.md`](docs/history/CHANGELOG-pre-0.8.0.md).
-
-Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.8.0`.
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.9.0`.
 
 
 ---

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pythinker-code"
-version = "0.8.0"
+version = "0.9.0"
 description = "Pythinker Code is your next CLI agent."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -158,3 +158,9 @@ seeked = "seeked"
 iterm = "iterm"
 # Verbatim pyright CLI output ("0 informations") quoted in docs.
 informations = "informations"
+# Project/domain-specific names and generated IDs.
+reviewr = "reviewr"
+fnd = "fnd"
+edn = "edn"
+Encrypter = "Encrypter"
+uest = "uest"

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/src/pythinker_code/CHANGELOG.md

@@ -15,14 +15,46 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.9.0 (2026-05-21)
+
+### What changed in this release
+
+- **Cleaner TUI — tool card backgrounds removed.** The grey pending/running
+  background overlay that appeared behind every tool execution card (subagents,
+  bash executions, reads, etc.) has been removed. Only user-message blocks
+  retain a background tint, keeping the visual hierarchy focused on your input.
+- **Welcome screen enhancements.** The startup info panel now shows the current
+  git branch (when inside a git repo) and the session auto-save path alongside
+  the working directory and session ID. Branch name is highlighted in magenta
+  for quick scanning.
+- **Bash header strip styling.** The `$ command` portion of bash execution
+  headers now picks up the `tool_pending_bg` token for the strip background,
+  matching the reference renderer style and providing consistent visual weight
+  across themes.
+- **Pythinker markdown renderer wired into message components.** User messages,
+  assistant messages, and custom messages now render through `pythinker_markdown`
+  (the project's own Markdown renderer) instead of raw `rich.markdown.Markdown`,
+  giving consistent heading, code-block, and table styling everywhere.
+- **Expanded theme palette.** `theme.py` gains a full `MarkdownColors` /
+  `markdown_rich_style` subsystem with dark and light palettes covering headings,
+  emphasis, inline code, links, blockquotes, table borders, code-block borders
+  and backgrounds, and spinner states (active/done/failed).
+- **Improved tool fallback renderers.** The call fallback now emits a
+  status-glyph header (`✔`/`✘`/`●`) instead of a bare label. The result
+  fallback now truncates long outputs at 60 lines / 4000 chars with an
+  italicised note (matching the card renderer's behaviour), and applies the
+  correct theme tokens for error vs. muted output.
+
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.9.0`.
+
 ## 0.8.0 (2026-05-21)
 
-Version-scheme reset. The next release after `pythinker-code` 2.7.0 ships as
-`0.8.0` under the new `0.MINOR.PATCH` line.
+Version-scheme reset. `pythinker-code` now ships as `0.8.0` under the new
+`0.MINOR.PATCH` line.
 
 ### What changed in this release
 
-- **Version line reset.** `pyproject.toml` `version` moves from `2.7.0` to `0.8.0`.
+- **Version line reset.** `pyproject.toml` `version` is `0.8.0` under the new release design.
   All prior `pythinker-code` 1.x/2.x releases have been yanked from PyPI and
   removed from the GitHub Releases page. New installs of
   `pip install --upgrade pythinker-code==0.8.0` resolve to the `0.x` line.
@@ -44,9 +76,9 @@ Version-scheme reset. The next release after `pythinker-code` 2.7.0 ships as
   instead of a hard-coded string, so future version bumps don't require a test
   edit.
 
-### Carried forward from 2.7.0
+### Included in 0.8.0
 
-All functionality shipped through `pythinker-code` 2.7.0 is preserved:
+All functionality included in `pythinker-code` 0.8.0 is preserved:
 review-first workflows (`pythinker review`, `pythinker secscan`,
 `pythinker security-scan`, `pythinker debug`), Reviewflow stateful
 review/fix workflows, the new `code-reviewer` / `security-reviewer` /
@@ -55,6 +87,6 @@ read-only PR artifact helpers (`describe`, `improve` / `suggest`, `ask`,
 `labels`, `changelog`, `docs`, `compliance`, etc.).
 
 See [`docs/history/CHANGELOG-pre-0.8.0.md`](docs/history/CHANGELOG-pre-0.8.0.md)
-for the detailed 2.x release-by-release notes.
+for the archived pre-reset release-by-release notes.
 
 Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.8.0`.

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/src/pythinker_code/app.py

@@ -41,6 +41,26 @@ if TYPE_CHECKING:
 _CWD_LOCK = asyncio.Lock()
 
 
+def _safe_git_branch(cwd: str | Path) -> str | None:
+    """Return the current git branch name, or ``None`` outside a repo / on error."""
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(cwd), "branch", "--show-current"],
+            capture_output=True,
+            text=True,
+            timeout=1.0,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    branch = result.stdout.strip()
+    return branch or None
+
+
 def _patch_session_id(record: dict[str, Any]) -> None:
     """Inject the current session ID (from ContextVar) into log records."""
     try:
@@ -723,12 +743,20 @@ class PythinkerCLI:
             print_update_banner()
             schedule_auto_update_check()
 
+        work_dir = self._runtime.session.work_dir
         welcome_info = [
-            WelcomeInfoItem(
-                name="Directory", value=str(shorten_home(self._runtime.session.work_dir))
-            ),
-            WelcomeInfoItem(name="Session", value=self._runtime.session.id),
+            WelcomeInfoItem(name="Directory", value=str(shorten_home(work_dir))),
         ]
+        branch_name = _safe_git_branch(work_dir)
+        if branch_name:
+            welcome_info.append(WelcomeInfoItem(name="Branch", value=branch_name))
+        welcome_info.append(WelcomeInfoItem(name="Session", value=self._runtime.session.id))
+        try:
+            auto_save_path = str(shorten_home(self._runtime.session.context_file))
+        except Exception:
+            auto_save_path = ""
+        if auto_save_path:
+            welcome_info.append(WelcomeInfoItem(name="Auto-save", value=auto_save_path))
         if base_url := self._env_overrides.get("PYTHINKER_BASE_URL"):
             welcome_info.append(
                 WelcomeInfoItem(

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/src/pythinker_code/ui/shell/__init__.py

@@ -1735,6 +1735,10 @@ def _value_style_for_label(label: str, level: WelcomeInfoItem.Level) -> str:
         return "grey39"
     if label == "Model":
         return "bold bright_white"
+    if label == "Branch":
+        return "magenta"
+    if label == "Auto-save":
+        return "grey50"
     return level.value
 
 

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/src/pythinker_code/ui/shell/components/bash_execution.py

@@ -76,6 +76,18 @@ def _accent_style(state: BashExecutionState) -> RichStyle:
     return tui_rich_style("muted" if state.exclude_from_context else "bash_mode")
 
 
+def _command_strip_style(state: BashExecutionState) -> RichStyle:
+    """Background tint for the ``$ cmd`` portion of the bash header.
+
+    Mirrors the dark 256-color strip used by the reference renderer; on light
+    themes we use the tool pending background so the strip still reads as a
+    contiguous run rather than blending into the surrounding card.
+    """
+    accent = _accent_style(state)
+    bg = tui_rich_style("tool_pending_bg")
+    return accent + bg + RichStyle(bold=True)
+
+
 def _output_lines(output: str) -> list[str]:
     cleaned = sanitize_ansi(output).replace("\r\n", "\n").replace("\r", "\n")
     if cleaned == "":
@@ -136,11 +148,12 @@ def _status_header(state: BashExecutionState) -> Text:
         header = Text("✔ ", style=tui_rich_style("success"))
         header.append("Ran", style=tui_rich_style("success") + RichStyle(bold=True))
 
+    strip = _command_strip_style(state)
     header.append(" ")
-    header.append("$ ", style=accent + RichStyle(bold=True))
+    header.append("$ ", style=strip)
     header.append(
         format_bash_command_for_header(state.command, expanded=state.expanded),
-        style=accent + RichStyle(bold=True),
+        style=strip,
     )
     if state.header_suffix:
         header.append(state.header_suffix, style=tui_rich_style("muted"))

pythinker_code-0.9.0/src/pythinker_code/ui/shell/components/markdown.py

@@ -0,0 +1,233 @@
+"""Pythinker markdown renderer with bordered code blocks and themed accents.
+
+Wraps Rich's ``Markdown`` element with three changes:
+
+1. Fenced code blocks are framed by ``╭─ {lang}`` / ``╰─`` rules in the
+   markdown palette's ``code_block_border`` color and tinted with the
+   ``code_block_bg`` background.
+2. Inline elements (headings, strong, emphasis, links, inline code, block
+   quotes) resolve against ``pythinker_code.ui.theme.get_markdown_colors``
+   so dark/light themes share the same renderer.
+3. A small streaming helper, :class:`PythinkerMarkdownStream`, buffers
+   incoming deltas and flushes when a safe boundary appears — either a
+   blank line *or* a sentence-final character outside of any open fence,
+   so long paragraphs no longer stall the visible stream.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from rich.console import Console, ConsoleOptions, Group, RenderResult, RenderableType
+from rich.markdown import CodeBlock, Markdown
+from rich.padding import Padding
+from rich.rule import Rule
+from rich.style import Style as RichStyle
+from rich.syntax import Syntax
+from rich.text import Text
+
+from pythinker_code.ui.theme import ThemeName, get_markdown_colors
+
+__all__ = [
+    "PythinkerMarkdown",
+    "PythinkerMarkdownStream",
+    "pythinker_markdown",
+]
+
+
+class _BorderedCodeBlock(CodeBlock):
+    """Code block with ``╭─ lang`` / ``╰─`` border rules and background tint."""
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        colors = get_markdown_colors()
+        border_style = RichStyle(color=colors.code_block_border, bold=True)
+        bg_style = RichStyle(bgcolor=colors.code_block_bg) if colors.code_block_bg else RichStyle()
+
+        label = self.lexer_name.strip() or "code"
+        opener = Rule(
+            title=Text(f" {label} ", style=border_style),
+            characters="─",
+            style=border_style,
+            align="left",
+        )
+        code_text = str(self.text).rstrip("\n")
+        body: RenderableType = Syntax(
+            code_text,
+            self.lexer_name,
+            theme=self.theme,
+            word_wrap=True,
+            padding=(0, 1),
+            background_color=colors.code_block_bg or None,
+        )
+        if bg_style:
+            body = Padding(body, (0, 0), style=bg_style)
+        closer = Rule(characters="─", style=border_style)
+        yield opener
+        yield body
+        yield closer
+
+
+def _markdown_style_overrides(theme: ThemeName | None = None) -> dict[str, RichStyle]:
+    """Translate the active markdown palette into Rich style names."""
+    colors = get_markdown_colors(theme)
+    return {
+        "markdown.h1": RichStyle(color=colors.heading, bold=True),
+        "markdown.h1.border": RichStyle(color=colors.heading),
+        "markdown.h2": RichStyle(bold=True, underline=True),
+        "markdown.h3": RichStyle(color=colors.heading, bold=True),
+        "markdown.h4": RichStyle(color=colors.heading, bold=True, dim=True),
+        "markdown.strong": RichStyle(color=colors.strong, bold=True),
+        "markdown.em": RichStyle(color=colors.emphasis, italic=True),
+        "markdown.emph": RichStyle(color=colors.emphasis, italic=True),
+        "markdown.code": RichStyle(color=colors.inline_code, bold=True),
+        "markdown.link": RichStyle(color=colors.link, underline=True),
+        "markdown.link_url": RichStyle(color=colors.link, underline=True),
+        "markdown.block_quote": RichStyle(color=colors.quote, italic=True),
+        "markdown.hr": RichStyle(color=colors.code_block_border),
+        "markdown.item.bullet": RichStyle(color=colors.strong, bold=True),
+        "markdown.item.number": RichStyle(color=colors.strong, bold=True),
+    }
+
+
+class PythinkerMarkdown(Markdown):
+    """Drop-in replacement for ``rich.markdown.Markdown`` with the Pythinker palette."""
+
+    elements = {**Markdown.elements, "fence": _BorderedCodeBlock, "code_block": _BorderedCodeBlock}
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        overrides = _markdown_style_overrides()
+        with console.use_theme(_PythinkerMarkdownTheme(overrides)):
+            yield from super().__rich_console__(console, options)
+
+
+class _PythinkerMarkdownTheme:
+    """Lightweight Rich ``Theme`` shim — only enough to satisfy ``Console.use_theme``."""
+
+    def __init__(self, styles: dict[str, RichStyle]) -> None:
+        from rich.theme import Theme
+
+        self._theme = Theme(styles, inherit=True)
+
+    def __getattr__(self, name: str):  # type: ignore[no-untyped-def]
+        return getattr(self._theme, name)
+
+
+def pythinker_markdown(text: str, *, code_theme: str = "monokai") -> PythinkerMarkdown:
+    """Build a :class:`PythinkerMarkdown` with the palette pre-wired."""
+    return PythinkerMarkdown(text, code_theme=code_theme)
+
+
+# ---------------------------------------------------------------------------
+# Streaming boundary helper
+# ---------------------------------------------------------------------------
+
+
+_FENCE_CHARS = ("`", "~")
+_SENTENCE_END = (".", "!", "?", ";", ":")
+
+
+@dataclass(slots=True)
+class _FenceMarker:
+    char: str
+    length: int
+
+
+def _parse_fence_opener(line: str) -> _FenceMarker | None:
+    stripped = line.lstrip(" ")
+    indent = len(line) - len(stripped)
+    if indent > 3 or not stripped:
+        return None
+    ch = stripped[0]
+    if ch not in _FENCE_CHARS:
+        return None
+    length = 0
+    for c in stripped:
+        if c == ch:
+            length += 1
+        else:
+            break
+    if length < 3:
+        return None
+    info = stripped[length:]
+    if ch == "`" and "`" in info:
+        return None
+    return _FenceMarker(char=ch, length=length)
+
+
+def _line_closes_fence(line: str, opener: _FenceMarker) -> bool:
+    stripped = line.lstrip(" ")
+    indent = len(line) - len(stripped)
+    if indent > 3:
+        return False
+    length = 0
+    for c in stripped:
+        if c == opener.char:
+            length += 1
+        else:
+            break
+    if length < opener.length:
+        return False
+    rest = stripped[length:]
+    return all(c in " \t" for c in rest)
+
+
+def _find_stream_safe_boundary(text: str) -> int | None:
+    """Return an index in ``text`` that is safe to flush, or ``None``.
+
+    Safe boundaries are blank lines outside any open code fence, or — to avoid
+    the well-known long-paragraph stall — the end of a non-fenced line that
+    ends in sentence-final punctuation.
+    """
+    open_fence: _FenceMarker | None = None
+    last_boundary: int | None = None
+    cursor = 0
+    for line in text.splitlines(keepends=True):
+        line_end = cursor + len(line)
+        content = line.rstrip("\n")
+        if open_fence is not None:
+            if _line_closes_fence(content, open_fence):
+                open_fence = None
+                last_boundary = line_end
+            cursor = line_end
+            continue
+        opener = _parse_fence_opener(content)
+        if opener is not None:
+            open_fence = opener
+            cursor = line_end
+            continue
+        if not content.strip():
+            last_boundary = line_end
+        elif content.rstrip().endswith(_SENTENCE_END):
+            last_boundary = line_end
+        cursor = line_end
+    return last_boundary
+
+
+@dataclass(slots=True)
+class PythinkerMarkdownStream:
+    """Buffer streamed markdown deltas and yield safe-to-render slices."""
+
+    pending: str = field(default="")
+
+    def push(self, delta: str) -> str | None:
+        """Append ``delta`` and return the next ready slice, or ``None``."""
+        self.pending += delta
+        cut = _find_stream_safe_boundary(self.pending)
+        if cut is None or cut == 0:
+            return None
+        ready = self.pending[:cut]
+        self.pending = self.pending[cut:]
+        return ready
+
+    def flush(self) -> str | None:
+        """Return any remaining buffered markdown, clearing the buffer."""
+        if not self.pending.strip():
+            self.pending = ""
+            return None
+        pending = self.pending
+        self.pending = ""
+        return pending

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/src/pythinker_code/ui/shell/components/messages.py

@@ -19,11 +19,11 @@ from dataclasses import dataclass
 from typing import Literal
 
 from rich.console import Group, RenderableType
-from rich.markdown import Markdown
 from rich.padding import Padding
 from rich.style import Style as RichStyle
 from rich.text import Text
 
+from pythinker_code.ui.shell.components.markdown import pythinker_markdown
 from pythinker_code.ui.theme import tui_rich_style
 
 __all__ = [
@@ -64,7 +64,7 @@ def render_user_message(text: str) -> RenderableType:
     and one cell of right padding. Avoid vertical padding so submitted prompts
     do not look like standalone panels.
     """
-    md = Markdown(text)
+    md = pythinker_markdown(text)
     bg = tui_rich_style("user_message_bg")
     fg = tui_rich_style("user_message_text")
     style = bg + fg if fg else bg
@@ -96,7 +96,7 @@ def render_assistant_message(
     for i, item in enumerate(items):
         next_visible = i + 1 < len(items)
         if item.kind == "text":
-            blocks.append(Markdown(item.text.strip()))
+            blocks.append(pythinker_markdown(item.text.strip()))
         elif item.kind == "thinking":
             if hide_thinking:
                 blocks.append(Text(hidden_thinking_label, style=thinking_style))
@@ -141,9 +141,9 @@ def render_custom_message(message: CustomMessageInput) -> RenderableType:
     bg_style = tui_rich_style("custom_message_bg")
 
     label = Text(f"[{message.custom_type}]", style=label_style)
-    body = Markdown(message.text) if message.text.strip() else Text("")
+    body = pythinker_markdown(message.text) if message.text.strip() else Text("")
 
-    if isinstance(body, Markdown):
+    if not isinstance(body, Text):
         block = Group(label, Text(""), body)
     elif text_style:
         block = Group(label, Text(""), Text(message.text, style=text_style))

{pythinker_code-0.8.0 → pythinker_code-0.9.0}/src/pythinker_code/ui/shell/components/tool_execution.py

@@ -52,6 +52,9 @@ class ToolExecutionStatus(Enum):
 
 _PENDING_LIKE = frozenset({ToolExecutionStatus.PENDING, ToolExecutionStatus.RUNNING})
 
+_MAX_RESULT_LINES = 60
+_MAX_RESULT_CHARS = 4000
+
 
 @dataclass(slots=True)
 class _CallState:
@@ -232,25 +235,47 @@ class ToolExecutionComponent:
         return None
 
     def _background_style(self) -> Style | None:
-        if self._status == ToolExecutionStatus.SUCCESS:
-            return None
-        if self._status == ToolExecutionStatus.ERROR or self._status == ToolExecutionStatus.DENIED:
-            token = "tool_error_bg"
-        elif self._status in _PENDING_LIKE:
-            token = "tool_pending_bg"
-        else:
-            token = "tool_pending_bg"
-        return tui_rich_style(token)
+        return None
 
     def _call_fallback(self) -> RenderableType:
-        return Text(self._definition.label or self._state.tool_name, style="bold")
+        label = self._definition.label or self._state.tool_name
+        if self._status == ToolExecutionStatus.SUCCESS:
+            glyph = "✔ "
+            glyph_style = tui_rich_style("success") + Style(bold=True)
+        elif self._status in (ToolExecutionStatus.ERROR, ToolExecutionStatus.DENIED):
+            glyph = "✘ "
+            glyph_style = tui_rich_style("error") + Style(bold=True)
+        elif self._status == ToolExecutionStatus.CANCELLED:
+            glyph = "● "
+            glyph_style = tui_rich_style("warning") + Style(bold=True)
+        else:
+            glyph = "● "
+            glyph_style = tui_rich_style("muted") + Style(bold=True)
+        header = Text()
+        header.append(glyph, style=glyph_style)
+        header.append(label, style=Style(bold=True))
+        return header
 
     def _result_fallback(self) -> RenderableType | None:
         result = self._state.result
         if result is None or not result.text:
             return None
-        style = "red" if result.is_error else "grey70"
-        return Text(result.text, style=style)
+        text = result.text
+        truncated = False
+        if not self._state.expanded:
+            lines = text.splitlines()
+            if len(lines) > _MAX_RESULT_LINES or len(text) > _MAX_RESULT_CHARS:
+                lines = lines[:_MAX_RESULT_LINES]
+                text = "\n".join(lines)[:_MAX_RESULT_CHARS]
+                truncated = True
+        style = tui_rich_style("error") if result.is_error else tui_rich_style("muted")
+        body = Text(text, style=style)
+        if truncated:
+            body.append(
+                "\n… output truncated for display; full result preserved in session.",
+                style=tui_rich_style("muted") + Style(italic=True),
+            )
+        return body
 
     def _is_truncatable(self) -> bool:
         """Heuristic: only show the expand hint when there's likely more to see."""