pythinker-code 0.10.0__tar.gz → 0.12.0__tar.gz

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythinker-code
-Version: 0.10.0
+Version: 0.12.0
 Summary: Pythinker Code is your next CLI agent.
 Keywords: cli,agent,ai,coding-assistant,llm,claude,openai,terminal
 Author: Mohamed Elkholy
@@ -23,7 +23,7 @@ Requires-Dist: agent-client-protocol==0.8.0
 Requires-Dist: aiofiles>=24.0,<26.0
 Requires-Dist: aiohttp==3.13.4
 Requires-Dist: typer==0.21.1
-Requires-Dist: pythinker-core[contrib]==1.1.0
+Requires-Dist: pythinker-core[contrib]==1.1.1
 Requires-Dist: loguru>=0.6.0,<0.7
 Requires-Dist: prompt-toolkit==3.0.52
 Requires-Dist: pillow==12.2.0
@@ -115,17 +115,14 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.10.0
+## 🆕 What's New in 0.12.0
 
-- **Tool failure recovery improvements.** The agent loop now handles malformed or empty tool-call responses more gracefully and can continue the session instead of leaving the UI stuck after a bad provider turn.
-- **Safer file edits.** File write and replace tools now create restore points before mutating files, giving sessions a clearer recovery path after risky changes.
-- **Session UX state tracking.** Runtime session state now records additional UX metadata so shell surfaces can provide better continuity across long-running work.
-- **Shell command enhancements.** New shell slash-command plumbing improves discoverability and keeps interactive workflows smoother.
-- **TUI renderer polish.** Tool cards now share more consistent status glyphs, truncation behavior, and result summaries across bash, read, write, edit, grep, find, web, subagent, background, ask-user, and think renderers.
-- **Clipboard handling hardening.** Clipboard helpers now degrade more cleanly when platform clipboard access is unavailable.
-- **Release and TUI specs.** The repository now includes the blackbox TUI port design and a visual smoke-test criterion for future terminal UI work.
+- **Native Windows installer.** A `PythinkerSetup-0.12.0.exe` is now attached to every GitHub Release. One double-click installs Pythinker per-user with no UAC prompt, no Python / Node / uv prerequisite, and registers `pythinker` on your PATH automatically. Uninstall via Apps & Features reverses every change. See the new *Windows — native installer* section in Quick Start for details.
+- **In-app updates for the native build.** `pythinker update` from inside the native installer detects the build, fetches the latest installer from GitHub Releases, verifies its SHA-256, and re-runs it silently. The existing `PYTHINKER_CLI_NO_AUTO_UPDATE` env var now gates both the PyPI and native update flows — one opt-out, both paths.
+- **Tag-triggered Windows CI.** A new `.github/workflows/windows-installer.yml` runs on every `pythinker-code-v*` tag, freezes `pythinker` via PyInstaller (`--onedir`), compiles the Inno Setup script, signs the result when the Authenticode cert is available, and uploads the `.exe` + SHA-256 to the Release.
+- **Shell terminal rhythm refinements.** Tone tokens, motion timing, and the sky-blue accent palette (`#7dd3fc` / `#93c5fd`) were retuned so transcript rows, motion status, and dialog surfaces breathe consistently. UI snapshot tests updated to lock the new rhythm in place.
 
-Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.10.0`.
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.12.0`, or — on Windows — download `PythinkerSetup-0.12.0.exe` from the [Releases page](https://github.com/mohamed-elkholy95/Pythinker-Code/releases/latest).
 
 
 ---
@@ -210,6 +207,56 @@ Swap providers and models per-session: `--model openai/gpt-5.5`, hosted Pythinke
 
 ## ⚡ Quick Start
 
+### 🪟 Windows — native installer (recommended)
+
+`PythinkerSetup-x.y.z.exe` is attached to every GitHub Release. It bundles
+Pythinker as a self-contained executable — **you do not need Python, Node, or
+uv installed**, and there is no UAC / admin prompt.
+
+**Install in three steps:**
+
+1. Download `PythinkerSetup-x.y.z.exe` and its `.sha256` companion from the
+   [latest Release](https://github.com/mohamed-elkholy95/Pythinker-Code/releases/latest).
+2. (Optional, recommended) Verify the SHA-256:
+   ```powershell
+   Get-FileHash .\PythinkerSetup-x.y.z.exe -Algorithm SHA256
+   Get-Content  .\PythinkerSetup-x.y.z.exe.sha256
+   ```
+   The hash from `Get-FileHash` must match the one in the `.sha256` file.
+3. Double-click the installer. It writes to `%LOCALAPPDATA%\Programs\Pythinker`,
+   registers `pythinker` on your user PATH (`HKCU\Environment`), and broadcasts
+   `WM_SETTINGCHANGE` so any new shell window picks it up.
+
+Open a fresh PowerShell and run `pythinker --version` to confirm.
+
+> 🛡 **First-launch SmartScreen warning** — until the Authenticode signing
+> cert is wired into the CI pipeline (see [build.ps1](./packages/windows-installer/build.ps1)
+> and the `WINDOWS_CERT_PFX_BASE64` / `WINDOWS_CERT_PASSWORD` secrets), the
+> installer ships unsigned and Windows SmartScreen will show *"Windows
+> protected your PC."* Click **More info → Run anyway**. The published
+> `.sha256` is your integrity check in the meantime.
+
+**Built-in auto-update:** running `pythinker update` from inside the native
+build queries the GitHub Releases API, downloads the newest installer,
+verifies its SHA-256, and re-runs it silently (`/VERYSILENT /SUPPRESSMSGBOXES
+/NORESTART`). Set `PYTHINKER_CLI_NO_AUTO_UPDATE=1` to disable the proactive
+update check on shell startup (this is the same opt-out the PyPI/uv install
+path uses — one knob, both flows).
+
+**Uninstall:** Apps & Features → *Pythinker Code* → Uninstall. The uninstaller
+removes the install directory and reverts the user-PATH edit. A new shell will
+no longer find `pythinker`.
+
+**Per-machine install** (multi-user / IT-managed boxes): pass `/ALLUSERS` to
+the installer from an admin console:
+
+```powershell
+.\PythinkerSetup-x.y.z.exe /ALLUSERS
+```
+
+This installs to `%ProgramFiles%\Pythinker` and registers PATH at the HKLM
+scope. The default (no flag) remains per-user.
+
 ### ✨ Recommended install (clean, with logo)
 
 ```sh

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/README.md

@@ -50,17 +50,14 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.10.0
+## 🆕 What's New in 0.12.0
 
-- **Tool failure recovery improvements.** The agent loop now handles malformed or empty tool-call responses more gracefully and can continue the session instead of leaving the UI stuck after a bad provider turn.
-- **Safer file edits.** File write and replace tools now create restore points before mutating files, giving sessions a clearer recovery path after risky changes.
-- **Session UX state tracking.** Runtime session state now records additional UX metadata so shell surfaces can provide better continuity across long-running work.
-- **Shell command enhancements.** New shell slash-command plumbing improves discoverability and keeps interactive workflows smoother.
-- **TUI renderer polish.** Tool cards now share more consistent status glyphs, truncation behavior, and result summaries across bash, read, write, edit, grep, find, web, subagent, background, ask-user, and think renderers.
-- **Clipboard handling hardening.** Clipboard helpers now degrade more cleanly when platform clipboard access is unavailable.
-- **Release and TUI specs.** The repository now includes the blackbox TUI port design and a visual smoke-test criterion for future terminal UI work.
+- **Native Windows installer.** A `PythinkerSetup-0.12.0.exe` is now attached to every GitHub Release. One double-click installs Pythinker per-user with no UAC prompt, no Python / Node / uv prerequisite, and registers `pythinker` on your PATH automatically. Uninstall via Apps & Features reverses every change. See the new *Windows — native installer* section in Quick Start for details.
+- **In-app updates for the native build.** `pythinker update` from inside the native installer detects the build, fetches the latest installer from GitHub Releases, verifies its SHA-256, and re-runs it silently. The existing `PYTHINKER_CLI_NO_AUTO_UPDATE` env var now gates both the PyPI and native update flows — one opt-out, both paths.
+- **Tag-triggered Windows CI.** A new `.github/workflows/windows-installer.yml` runs on every `pythinker-code-v*` tag, freezes `pythinker` via PyInstaller (`--onedir`), compiles the Inno Setup script, signs the result when the Authenticode cert is available, and uploads the `.exe` + SHA-256 to the Release.
+- **Shell terminal rhythm refinements.** Tone tokens, motion timing, and the sky-blue accent palette (`#7dd3fc` / `#93c5fd`) were retuned so transcript rows, motion status, and dialog surfaces breathe consistently. UI snapshot tests updated to lock the new rhythm in place.
 
-Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.10.0`.
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.12.0`, or — on Windows — download `PythinkerSetup-0.12.0.exe` from the [Releases page](https://github.com/mohamed-elkholy95/Pythinker-Code/releases/latest).
 
 
 ---
@@ -145,6 +142,56 @@ Swap providers and models per-session: `--model openai/gpt-5.5`, hosted Pythinke
 
 ## ⚡ Quick Start
 
+### 🪟 Windows — native installer (recommended)
+
+`PythinkerSetup-x.y.z.exe` is attached to every GitHub Release. It bundles
+Pythinker as a self-contained executable — **you do not need Python, Node, or
+uv installed**, and there is no UAC / admin prompt.
+
+**Install in three steps:**
+
+1. Download `PythinkerSetup-x.y.z.exe` and its `.sha256` companion from the
+   [latest Release](https://github.com/mohamed-elkholy95/Pythinker-Code/releases/latest).
+2. (Optional, recommended) Verify the SHA-256:
+   ```powershell
+   Get-FileHash .\PythinkerSetup-x.y.z.exe -Algorithm SHA256
+   Get-Content  .\PythinkerSetup-x.y.z.exe.sha256
+   ```
+   The hash from `Get-FileHash` must match the one in the `.sha256` file.
+3. Double-click the installer. It writes to `%LOCALAPPDATA%\Programs\Pythinker`,
+   registers `pythinker` on your user PATH (`HKCU\Environment`), and broadcasts
+   `WM_SETTINGCHANGE` so any new shell window picks it up.
+
+Open a fresh PowerShell and run `pythinker --version` to confirm.
+
+> 🛡 **First-launch SmartScreen warning** — until the Authenticode signing
+> cert is wired into the CI pipeline (see [build.ps1](./packages/windows-installer/build.ps1)
+> and the `WINDOWS_CERT_PFX_BASE64` / `WINDOWS_CERT_PASSWORD` secrets), the
+> installer ships unsigned and Windows SmartScreen will show *"Windows
+> protected your PC."* Click **More info → Run anyway**. The published
+> `.sha256` is your integrity check in the meantime.
+
+**Built-in auto-update:** running `pythinker update` from inside the native
+build queries the GitHub Releases API, downloads the newest installer,
+verifies its SHA-256, and re-runs it silently (`/VERYSILENT /SUPPRESSMSGBOXES
+/NORESTART`). Set `PYTHINKER_CLI_NO_AUTO_UPDATE=1` to disable the proactive
+update check on shell startup (this is the same opt-out the PyPI/uv install
+path uses — one knob, both flows).
+
+**Uninstall:** Apps & Features → *Pythinker Code* → Uninstall. The uninstaller
+removes the install directory and reverts the user-PATH edit. A new shell will
+no longer find `pythinker`.
+
+**Per-machine install** (multi-user / IT-managed boxes): pass `/ALLUSERS` to
+the installer from an admin console:
+
+```powershell
+.\PythinkerSetup-x.y.z.exe /ALLUSERS
+```
+
+This installs to `%ProgramFiles%\Pythinker` and registers PATH at the HKLM
+scope. The default (no flag) remains per-user.
+
 ### ✨ Recommended install (clean, with logo)
 
 ```sh

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pythinker-code"
-version = "0.10.0"
+version = "0.12.0"
 description = "Pythinker Code is your next CLI agent."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -26,7 +26,7 @@ dependencies = [
     "aiofiles>=24.0,<26.0",
     "aiohttp==3.13.4",
     "typer==0.21.1",
-    "pythinker-core[contrib]==1.1.0",
+    "pythinker-core[contrib]==1.1.1",
     # notify-py (via batrachian-toad) caps loguru at <=0.6.0 on 3.14+.
     "loguru>=0.6.0,<0.7",
     "prompt-toolkit==3.0.52",

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/CHANGELOG.md

@@ -15,6 +15,30 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.12.0 (2026-05-22)
+
+### What changed in this release
+
+- **Native Windows installer.** A signed `PythinkerSetup-x.y.z.exe` is now attached to every GitHub Release — install Pythinker on Windows with one download, no Python / Node / uv prerequisite. The wizard installs per-user (no UAC) into `%LOCALAPPDATA%\Programs\Pythinker`, registers `pythinker` on the user PATH, and broadcasts `WM_SETTINGCHANGE` so new shells pick the change up immediately. Uninstall reverses the PATH edit. Code-signing is wired through `signtool` and ships unsigned until the Authenticode cert lands; from that point forward the same CI job produces signed installers with no code change required.
+- **In-app updates for the native build.** `pythinker update` from a native install detects the build (via a `.pythinker-native` sentinel next to `pythinker.exe`), fetches the latest GitHub Release asset, verifies its SHA-256, and re-runs the installer silently (`/VERYSILENT /SUPPRESSMSGBOXES /NORESTART`). The `PYTHINKER_CLI_NO_AUTO_UPDATE` opt-out env var that the PyPI path already honors now also gates the native auto-update path — one knob, both flows. The update banner shows a human-readable `PythinkerSetup-x.y.z.exe` line instead of leaking internal markers.
+- **Tag-triggered Windows build pipeline.** A new `.github/workflows/windows-installer.yml` runs on every `pythinker-code-v*` tag, freezes `pythinker` via PyInstaller (`--onedir` for faster startup and fewer AV false positives), compiles the Inno Setup script, signs the result if `WINDOWS_CERT_PFX_BASE64` / `WINDOWS_CERT_PASSWORD` secrets are populated, and uploads the `.exe` plus its `.sha256` to the corresponding Release.
+- **Shell terminal rhythm refinements.** Tone tokens, motion timing, and theme palette were retuned (sky-blue `#7dd3fc` / `#93c5fd` accents) so transcript rows, motion status, and dialog surfaces breathe consistently. UI snapshot tests updated to lock the new rhythm in place.
+
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.12.0`, or — on Windows — download `PythinkerSetup-0.12.0.exe` from the Releases page.
+
+## 0.11.0 (2026-05-22)
+
+### What changed in this release
+
+- **Fixed PyPI install conflict (was failing on Windows and every other platform).** `pip install pythinker-code==0.10.0` failed with `fastmcp 3.2.0 depends on mcp<2.0 and >=1.24.0` vs `pythinker-core 1.1.0 depends on mcp<1.17 and >=1`. 0.11.0 pins the republished `pythinker-core 1.1.1`, whose widened `mcp>=1.23,<2` constraint lets the resolver pick a single `mcp` version compatible with `fastmcp==3.2.0`.
+- **Blackbox-style TUI port — phase 1.** Shell design primitives, compact transcript activity rows, blackbox-style motion status, standardized shell dialogs, aligned footer status styling, and a restyled tool-result surface land together. The TUI now shares a coherent visual language across rows, dialogs, and motion.
+- **Refreshed TUI accent palette.** Dark/light theme accent retuned to a cleaner sky-blue (`#7dd3fc` dark, `#0284c7` light) for better contrast against the new tool-result surfaces.
+- **Markdown + report polish.** Report spacing and markdown code blocks render with improved breathing room and consistent fences.
+- **Rotating thinking-word indicator restored** with a leading space before the live stream status so the spinner no longer abuts surrounding text.
+- **Internal audit + smoke evaluation.** A blackbox TUI scope map, prompt/agent audit, and a recorded visual smoke evaluation join the repo to govern future TUI work.
+
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.11.0`.
+
 ## 0.10.0 (2026-05-22)
 
 ### What changed in this release

pythinker_code-0.12.0/src/pythinker_code/native.py

@@ -0,0 +1,38 @@
+"""Native-build detection + GitHub Releases lookup helpers.
+
+The Windows native installer drops a sentinel file ``.pythinker-native`` next
+to the PyInstaller-frozen ``pythinker.exe``. The runtime probes for that file
+to decide whether ``pythinker update`` should re-run the native installer
+instead of shelling out to ``uv tool upgrade``.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+GITHUB_REPO = "mohamed-elkholy95/Pythinker-Code"
+SENTINEL_FILENAME = ".pythinker-native"
+
+
+def is_native_build() -> bool:
+    """True iff this process is a Pythinker native (Inno Setup) install."""
+    if not getattr(sys, "frozen", False):
+        return False
+    try:
+        exe_dir = Path(sys.executable).resolve().parent
+    except OSError:
+        return False
+    return (exe_dir / SENTINEL_FILENAME).is_file()
+
+
+def native_installer_release_url(channel: str = "latest") -> str:
+    """Return the GitHub API URL for the requested release channel."""
+    if channel == "latest":
+        return f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
+    return f"https://api.github.com/repos/{GITHUB_REPO}/releases/tags/{channel}"
+
+
+def native_installer_asset_name(version: str) -> str:
+    """Filename of the installer asset attached to a Release."""
+    return f"PythinkerSetup-{version}.exe"

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/ui/shell/components/footer.py

@@ -19,10 +19,10 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 from rich.console import Group, RenderableType
-from rich.style import Style as RichStyle
 from rich.text import Text
 
 from pythinker_code.ui.shell.components.render_utils import truncate_to_width
+from pythinker_code.ui.shell.design_system import ShellTone, render_segment_line
 from pythinker_code.ui.theme import tui_rich_style
 
 __all__ = [
@@ -196,31 +196,20 @@ def render_footer(state: FooterState, *, width: int) -> RenderableType:
     pwd_truncated = truncate_to_width(pwd, max(1, width))
     pwd_text = Text(pwd_truncated, style=dim)
 
-    stats_left_text, stats_left_plain = _build_stats_left(state)
+    _, stats_left_plain = _build_stats_left(state)
     if len(stats_left_plain) > width:
         truncated = truncate_to_width(stats_left_plain, width)
-        stats_left_text = Text(truncated, style=dim)
         stats_left_plain = truncated
 
     right = _build_right_side(state, plain_left_width=len(stats_left_plain), width=width)
-    if right:
-        space = max(2, width - len(stats_left_plain) - len(right))
-        # If even the minimum 2-space gap plus right doesn't fit, truncate right.
-        if len(stats_left_plain) + 2 + len(right) > width:
-            avail = width - len(stats_left_plain) - 2
-            if avail > 0:
-                right = truncate_to_width(right, avail, ellipsis="")
-                space = max(0, width - len(stats_left_plain) - len(right))
-            else:
-                right = ""
-                space = 0
-        stats_line = Text()
-        stats_line.append_text(stats_left_text)
-        if right:
-            stats_line.append(" " * space, style=dim)
-            stats_line.append(right, style=dim + RichStyle(bold=False))
-    else:
-        stats_line = stats_left_text
+    stats_line = render_segment_line(
+        left=[stats_left_plain],
+        right=[right],
+        width=width,
+        tone=ShellTone.MUTED,
+    )
+    if state.context_percent is not None and state.context_percent > 70:
+        stats_line.stylize(tui_rich_style("warning" if state.context_percent <= 90 else "error"))
 
     children: list[RenderableType] = [pwd_text, stats_line]
     if state.extension_statuses:

pythinker_code-0.12.0/src/pythinker_code/ui/shell/design_system.py

@@ -0,0 +1,105 @@
+"""Shared Rich primitives for the Pythinker shell TUI."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Literal
+
+from rich.console import Group, RenderableType
+from rich.style import Style
+from rich.text import Text
+
+from pythinker_code.ui.shell.components.render_utils import cell_width, truncate_to_width
+
+
+class ShellTone(StrEnum):
+    NORMAL = "normal"
+    MUTED = "muted"
+    ACCENT = "accent"
+    SUCCESS = "success"
+    WARNING = "warning"
+    ERROR = "error"
+    INFO = "info"
+
+
+StatusName = Literal[
+    "running",
+    "completed",
+    "failed",
+    "denied",
+    "interrupted",
+    "waiting",
+    "question",
+    "approval",
+]
+
+
+_TONE_STYLES: dict[ShellTone, Style] = {
+    ShellTone.NORMAL: Style(color="default"),
+    ShellTone.MUTED: Style(color="grey50"),
+    ShellTone.ACCENT: Style(color="#7dd3fc"),
+    ShellTone.SUCCESS: Style(color="green"),
+    ShellTone.WARNING: Style(color="yellow"),
+    ShellTone.ERROR: Style(color="red"),
+    ShellTone.INFO: Style(color="#93c5fd"),
+}
+
+_STATUS: dict[StatusName, tuple[str, ShellTone]] = {
+    "running": ("●", ShellTone.ACCENT),
+    "completed": ("✓", ShellTone.SUCCESS),
+    "failed": ("!", ShellTone.ERROR),
+    "denied": ("×", ShellTone.WARNING),
+    "interrupted": ("■", ShellTone.MUTED),
+    "waiting": ("○", ShellTone.MUTED),
+    "question": ("?", ShellTone.WARNING),
+    "approval": ("?", ShellTone.ACCENT),
+}
+
+
+def shell_style(tone: ShellTone) -> Style:
+    return _TONE_STYLES[tone]
+
+
+def status_icon(name: StatusName) -> Text:
+    icon, tone = _STATUS[name]
+    return Text(icon, style=shell_style(tone))
+
+
+def keyboard_hint(key: str, label: str) -> Text:
+    text = Text()
+    text.append(key, style=Style(color="cyan", bold=True))
+    if label:
+        text.append(f" {label}", style=shell_style(ShellTone.MUTED))
+    return text
+
+
+def dialog_title(kind: StatusName, title: str) -> Text:
+    text = Text()
+    text.append_text(status_icon(kind))
+    text.append(f" {title}", style=Style(bold=True))
+    return text
+
+
+def render_segment_line(
+    *,
+    left: list[str],
+    right: list[str],
+    width: int,
+    tone: ShellTone = ShellTone.MUTED,
+) -> Text:
+    left_text = " | ".join(part for part in left if part)
+    right_parts = [part for part in right if part]
+    right_text = " | ".join(right_parts)
+    if width <= 0:
+        return Text("")
+    while right_parts and cell_width(left_text) + 2 + cell_width(right_text) > width:
+        right_parts.pop()
+        right_text = " | ".join(right_parts)
+    if not right_text:
+        return Text(truncate_to_width(left_text, width), style=shell_style(tone))
+    gap = max(2, width - cell_width(left_text) - cell_width(right_text))
+    return Text(left_text + (" " * gap) + right_text, style=shell_style(tone))
+
+
+def render_row(icon: str | Text, content: RenderableType) -> RenderableType:
+    return Group(Text.assemble(icon, " "), content)

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/ui/shell/echo.py

@@ -5,7 +5,7 @@ from rich.console import RenderableType
 from rich.text import Text
 
 from pythinker_code.ui.shell.components import render_user_message
-from pythinker_code.ui.shell.prompt import PROMPT_SYMBOL
+from pythinker_code.ui.shell.prompt import PROMPT_SYMBOL_AGENT_INPUT
 from pythinker_code.ui.tui_config import is_card_style
 from pythinker_code.utils.message import message_stringify
 
@@ -20,11 +20,11 @@ def render_user_echo(message: Message) -> RenderableType:
     text = message_stringify(message)
     if is_card_style():
         return render_user_message(text)
-    return Text(f"{PROMPT_SYMBOL} {text}")
+    return Text(f"{PROMPT_SYMBOL_AGENT_INPUT} {text}")
 
 
 def render_user_echo_text(text: str) -> RenderableType:
     """Render the local prompt text exactly as the user saw it in the buffer."""
     if is_card_style():
         return render_user_message(text)
-    return Text(f"{PROMPT_SYMBOL} {text}")
+    return Text(f"{PROMPT_SYMBOL_AGENT_INPUT} {text}")

pythinker_code-0.12.0/src/pythinker_code/ui/shell/motion.py

@@ -0,0 +1,90 @@
+"""Blackbox-inspired motion helpers for the shell TUI."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from rich.text import Text
+
+from pythinker_code.soul import format_token_count
+from pythinker_code.ui.shell.components.render_utils import cell_width
+from pythinker_code.ui.shell.design_system import ShellTone, shell_style
+from pythinker_code.utils.datetime import format_elapsed
+
+_FRAMES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
+_FRAME_INTERVAL_S = 0.08
+
+
+@dataclass(frozen=True, slots=True)
+class ActivitySnapshot:
+    label: str
+    elapsed_s: float
+    tokens: int = 0
+    token_rate: int | None = None
+    stalled: bool = False
+    interrupt_hint: str = ""
+    reduced_motion: bool = False
+
+
+def reduced_motion_enabled() -> bool:
+    return os.environ.get("PYTHINKER_REDUCED_MOTION", "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def spinner_frame_at(elapsed_s: float, *, reduced_motion: bool = False) -> str:
+    if reduced_motion:
+        return "●"
+    index = int(max(0.0, elapsed_s) / _FRAME_INTERVAL_S) % len(_FRAMES)
+    return _FRAMES[index]
+
+
+def _candidate_parts(snapshot: ActivitySnapshot) -> list[str]:
+    parts = [format_elapsed(snapshot.elapsed_s)]
+    if snapshot.tokens:
+        parts.append(f"↓ {format_token_count(snapshot.tokens)} tokens")
+    if snapshot.token_rate:
+        parts.append(f"{snapshot.token_rate} t/s")
+    if snapshot.interrupt_hint:
+        hint = "esc" if snapshot.interrupt_hint == "esc to interrupt" else snapshot.interrupt_hint
+        parts.append(hint)
+    return parts
+
+
+def _activity_label(label: str) -> str:
+    stripped = label.rstrip()
+    if stripped.endswith(("…", "...")):
+        return stripped
+    return f"{stripped}…"
+
+
+def activity_status_line(snapshot: ActivitySnapshot, *, width: int | None = None) -> Text:
+    reduced = snapshot.reduced_motion or reduced_motion_enabled()
+    glyph_style = ShellTone.WARNING if snapshot.stalled else ShellTone.ACCENT
+    text = Text(
+        spinner_frame_at(snapshot.elapsed_s, reduced_motion=reduced),
+        style=shell_style(glyph_style),
+    )
+    text.append(" ")
+    text.append(
+        _activity_label(snapshot.label),
+        style="italic" if snapshot.label.lower() == "thinking" else "",
+    )
+
+    parts = _candidate_parts(snapshot)
+    if width is not None:
+        base_width = cell_width(text.plain)
+        kept: list[str] = []
+        for part in parts:
+            candidate = " · ".join([*kept, part])
+            if base_width + 3 + cell_width(candidate) <= width:
+                kept.append(part)
+        parts = kept
+    if parts:
+        text.append(" ")
+        text.append(f"({' · '.join(parts)})", style=shell_style(ShellTone.MUTED))
+    return text

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/ui/shell/spinner_words.py

@@ -43,7 +43,7 @@ SPINNER_VERBS: tuple[str, ...] = (
     "Channelling",
     "Choreographing",
     "Churning",
-    "Clauding",
+    "Pythinking",
     "Coalescing",
     "Cogitating",
     "Combobulating",

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/ui/shell/tool_renderers/bash.py

@@ -20,8 +20,10 @@ from pythinker_code.ui.shell.components.bash_execution import (
     BashExecutionState,
     BashStatus,
     format_bash_command_for_header,
+    render_bash_execution,
     render_bash_result_output,
 )
+from pythinker_code.ui.shell.components.render_utils import sanitize_ansi
 from pythinker_code.ui.shell.tool_renderers import (
     ToolRenderContext,
     ToolRenderDefinition,
@@ -67,6 +69,8 @@ def _render_call(ctx: ToolRenderContext) -> RenderableType | None:
         description = as_str(args.get("description"))
         suffix = f" (background: {description})" if description else " (background)"
         line.append_text(fg("muted", suffix))
+    if ctx.has_result and command:
+        return None
     return running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
 
 
@@ -88,15 +92,39 @@ def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> Rendera
     status: BashStatus = "error" if result.is_error else "complete"
     bash_state = BashExecutionState(
         command=command,
-        output=result.text or "",
+        output=sanitize_ansi(result.text or ""),
         status=status,
         exit_code=None if not result.is_error else 1,
         expanded=ctx.expanded,
         header_suffix="".join(suffix_parts),
     )
+    if _is_short_inline_output(bash_state.output):
+        return _render_inline_completed_result(bash_state, is_error=result.is_error)
+    if ctx.has_result:
+        return render_bash_execution(bash_state, width=ctx.width)
     return render_bash_result_output(bash_state, width=ctx.width)
 
 
+def _is_short_inline_output(output: str) -> bool:
+    text = output.strip()
+    return bool(text) and "\n" not in text and len(text) <= 80
+
+
+def _render_inline_completed_result(state: BashExecutionState, *, is_error: bool) -> Text:
+    status_style = tui_rich_style("error" if is_error else "success")
+    line = Text("✘ " if is_error else "✔ ", style=status_style)
+    line.append("$ ", style=tui_rich_style("bash_mode") + RichStyle(bold=True))
+    line.append(
+        format_bash_command_for_header(state.command, expanded=state.expanded),
+        style=tui_rich_style("bash_mode") + RichStyle(bold=True),
+    )
+    if state.header_suffix:
+        line.append(state.header_suffix, style=tui_rich_style("muted"))
+    line.append(" · ", style=tui_rich_style("muted"))
+    line.append(state.output.strip(), style=tui_rich_style("error" if is_error else "muted"))
+    return line
+
+
 SHELL_RENDERER = ToolRenderDefinition(
     name=_TOOL_NAME,
     label="bash",

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/ui/shell/tool_renderers/generic.py

@@ -11,7 +11,7 @@ import json
 from rich.console import Group, RenderableType
 from rich.text import Text
 
-from pythinker_code.ui.shell.components import sanitize_ansi
+from pythinker_code.ui.shell.components.render_utils import sanitize_ansi
 from pythinker_code.ui.shell.tool_renderers import (
     ToolRenderContext,
     ToolRenderDefinition,

{pythinker_code-0.10.0 → pythinker_code-0.12.0}/src/pythinker_code/ui/shell/tool_renderers/todo.py

@@ -152,7 +152,9 @@ def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> Rendera
         collapsed_max_lines=0,
         style_token="error",
     )
-    return body if body.plain else None
+    if not body.plain:
+        return None
+    return body
 
 
 TODO_RENDERER = ToolRenderDefinition(