feat(tui): static-grey input border with a top-right effort label

Stop recoloring the whole input border by thinking effort. The border is now
one static frame grey at every level; the effort signal moves to a small
label flushed right on the input's top border — a level-colored dot
(off->max: slate->blue->teal->amber->orange->red) plus the muted level word.

The dot carries the cold->hot color at full strength (it's a single glyph),
while the word uses a muted class so it never competes with the typed text.
The label is hidden for native-thinking models (always_thinking with no user
dial) and non-thinking models, and the rule auto-shortens by the measured
label width so the top line never wraps.

_prompt_separator_style no longer borrows thinking_frame_style, so all input
separators (top border and footer) render the same static frame grey.

Author: elkaix

CHANGELOG.md

@@ -15,6 +15,7 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+- **Thinking effort moved off the input border into a top-right label.** The input box border is now one static frame grey at every effort level instead of recoloring the whole bar cold→hot. The effort is shown as a small label flushed to the right of the input's top border — a level-colored dot (slate→blue→teal→amber→orange→red as `off→max`) plus the muted level word — so the dial is still glanceable without tinting the typing area. The label is hidden entirely for native-thinking models (`always_thinking`, no user dial) and non-thinking models, and the rule auto-shortens by the label width so the line never wraps.
 - **Reasoning-effort control for Qwen native-thinking models on OpenCode Go.** Qwen3.x/3.7 models (e.g. `qwen3.7-max`) served through the OpenCode Go Anthropic-shaped route now carry the controllable `thinking` capability, so their reasoning effort is user-selectable instead of fixed. Effort maps onto the standard Anthropic `thinking` block (`{"type": "enabled", "budget_tokens": N}` / `{"type": "disabled"}`) that Alibaba Model Studio's Anthropic-compatible endpoint accepts, clamping to the budget-safe `low`/`medium`/`high` range. The Alibaba plan already exposed Qwen thinking effort; this brings the OpenCode Go plan to parity. Unlike GLM/MiniMax (always-on reasoning), Qwen is hybrid, so effort can also be turned off.
 - **TUI enhancements: adaptive theme, layout, and agent prompt overhaul.** Adaptive terminal-background probe + color-depth blending; reference-CLI layout and palette refinements; unified todo-list renderer; white running-task titles with consistent diff palette; elapsed/tokens/t-s metadata on the background status line; transcript-row bullet fix; renderer guards and markdown fence table unwrapping. All default agent prompts restructured with explicit Mission / Hard Constraints / Workflow / Output Contract sections. Background manager and subagent runner hardened with stale-record reconciliation and resume contract enforcement. Automatic turn recaps disabled by default.
 

src/pythinker_code/ui/shell/prompt.py

@@ -80,7 +80,7 @@
 )
 from pythinker_code.ui.shell.spacing import ensure_prompt_newline
 from pythinker_code.ui.shell.spinner_words import spinner_message
-from pythinker_code.ui.theme import get_prompt_style, get_toolbar_colors, thinking_frame_style
+from pythinker_code.ui.theme import get_prompt_style, get_toolbar_colors, thinking_dot_style
 from pythinker_code.ui.theme import get_tui_tokens as _get_tui_tokens
 from pythinker_code.ui.tui_config import is_card_style
 from pythinker_code.utils.clipboard import (
@@ -2441,12 +2441,47 @@ def _supports_thinking_effort(self) -> bool:
     def _prompt_separator_style(self, fallback: str) -> str:
         if getattr(self, "_mode", PromptMode.AGENT) != PromptMode.AGENT:
             return fallback
-        if not self._supports_thinking_effort():
-            # Non-effort models use the standard input frame color (#3A506D in dark mode)
-            # instead of borrowing a thinking level color.
-            return "class:compact-input.frame"
+        # The input border is one static frame color regardless of thinking
+        # effort; the effort signal lives in the top-border label instead
+        # (see _effort_label_fragments) rather than recoloring the whole bar.
+        return "class:compact-input.frame"
+
+    def _effort_label_fragments(self) -> list[tuple[str, str]]:
+        """Dot + level label shown at the right end of the input's top border.
+
+        Returns ``[]`` when there is no effort to choose: non-AGENT modes,
+        non-thinking models, and native-thinking models (``always_thinking``
+        without a user 'thinking' dial). The dot carries the cold→hot level
+        color; the word stays muted so it never competes with the input.
+        """
+        if getattr(self, "_mode", PromptMode.AGENT) != PromptMode.AGENT:
+            return []
+        if self._uses_native_thinking() or not self._supports_thinking_effort():
+            return []
         level = self._current_thinking_effort()
-        return thinking_frame_style(level) or fallback
+        return [
+            (thinking_dot_style(level), "● "),
+            ("class:compact-input.effort", level),
+        ]
+
+    def _render_input_top_border(self, columns: int, fallback: str) -> list[tuple[str, str]]:
+        """Static-grey top border for the input card, effort label flushed right.
+
+        The rule is shortened by the measured label width so the line never
+        wraps; when no label applies it spans the full rule like before.
+        """
+        border_style = self._prompt_separator_style(fallback)
+        rule = _prompt_rule(columns)
+        label = self._effort_label_fragments()
+        if not label:
+            return [(border_style, rule)]
+        gap = 2
+        label_width = sum(get_cwidth(ch) for _, text in label for ch in text)
+        rule_width = max(0, len(rule) - gap - label_width)
+        return [
+            (border_style, "─" * rule_width + " " * gap),
+            *label,
+        ]
 
     def _thinking_footer_label(self) -> str:
         if self._uses_native_thinking():
@@ -2719,7 +2754,7 @@ def _render_agent_prompt_message(self) -> FormattedText:
         if is_card_style():
             ensure_prompt_newline(fragments)
             tc = get_toolbar_colors()
-            fragments.append((self._prompt_separator_style(tc.separator), _prompt_rule(columns)))
+            fragments.extend(self._render_input_top_border(columns, tc.separator))
             fragments.append(("", "\n"))
             fragments.append(("", _card_side_indent()))
         else:

src/pythinker_code/ui/theme.py

@@ -166,6 +166,8 @@ def _task_browser_style_light() -> PTKStyle:
     "compact-input": "",
     "compact-input.prompt": "fg:#F4F4F5 bold",
     "compact-input.frame": "fg:#3A506D",
+    # Muted level word in the top-border effort label (the dot carries the color).
+    "compact-input.effort": "fg:#A3A3A3",
     "running-prompt-placeholder": "fg:#A3A3A3 italic",
     "running-prompt-separator": "fg:#2B3A52",
     # Slash completion menu — selected row gets the same selected-bg as cards.
@@ -204,6 +206,8 @@ def _task_browser_style_light() -> PTKStyle:
     "compact-input": "",
     "compact-input.prompt": "fg:#213853 bold",
     "compact-input.frame": "fg:#495F7C",
+    # Muted level word in the top-border effort label (the dot carries the color).
+    "compact-input.effort": "fg:#666666",
     "running-prompt-placeholder": "fg:#666666 italic",
     "running-prompt-separator": "fg:#C8BEC0",
     "slash-completion-menu": "",
@@ -647,3 +651,16 @@ def thinking_frame_style(level: str, *, theme: ThemeName | None = None) -> str:
         pole = (255, 255, 255) if name == "light" else (0, 0, 0)
         color = to_hex_color(blend(rgb, pole, 0.7))
     return f"fg:{color}"
+
+
+def thinking_dot_style(level: str, *, theme: ThemeName | None = None) -> str:
+    """prompt_toolkit style for the small effort *dot* on the input top border.
+
+    Unlike :func:`thinking_frame_style` (which dims the color because it paints
+    a full-width bar), the dot is a single glyph, so it carries the level color
+    at full strength — the one intentional accent on an otherwise static-grey
+    border. Returns ``""`` when colors are disabled.
+    """
+    if colors_disabled():
+        return ""
+    return f"fg:{thinking_frame_color(level, theme=theme)}"

tests/ui_and_conv/test_prompt_tips.py

@@ -605,8 +605,11 @@ def get_size() -> Any:
     ) in fragments
 
 
-def test_card_toolbar_separator_matches_thinking_prompt_color(monkeypatch: Any) -> None:
-    from pythinker_code.ui.theme import set_active_theme, thinking_frame_style
+def test_card_toolbar_separator_is_static_grey_regardless_of_effort(monkeypatch: Any) -> None:
+    # The input border no longer borrows the thinking-effort color; every
+    # separator is the one static frame grey (the effort signal moved to the
+    # top-border label instead).
+    from pythinker_code.ui.theme import set_active_theme
 
     prompt_session = _make_toolbar_session(
         model_name="fast-model", model_capabilities={"thinking"}, tips=[]
@@ -631,11 +634,52 @@ def get_size() -> Any:
     fragments = list(prompt_session._render_bottom_toolbar())
 
     assert fragments[0] == (
-        thinking_frame_style("xhigh", theme="dark"),
+        "class:compact-input.frame",
         shell_prompt._prompt_rule(120),
     )
 
 
+def test_input_top_border_shows_effort_label() -> None:
+    from prompt_toolkit.utils import get_cwidth
+
+    from pythinker_code.ui.theme import set_active_theme, thinking_dot_style
+
+    set_active_theme("dark")
+    session = _make_toolbar_session(
+        model_name="fast-model", model_capabilities={"thinking"}, tips=[]
+    )
+    session._thinking = True
+    session._thinking_effort = "high"
+
+    fragments = session._render_input_top_border(80, "class:fallback")
+
+    # Border stays static grey; effort color lives only in the trailing dot.
+    assert fragments[0][0] == "class:compact-input.frame"
+    assert fragments[-2] == (thinking_dot_style("high", theme="dark"), "● ")
+    assert fragments[-1] == ("class:compact-input.effort", "high")
+    # The whole line stays within the rule budget so it never wraps.
+    total = sum(get_cwidth(ch) for _, text in fragments for ch in text)
+    assert total == len(shell_prompt._prompt_rule(80))
+
+
+def test_input_top_border_hides_effort_label_for_native_and_nonthinking() -> None:
+    # Native-thinking model (always_thinking, no user dial): no label.
+    native = _make_toolbar_session(
+        model_name="MiniMax M2.7", model_capabilities={"always_thinking"}, tips=[]
+    )
+    assert native._effort_label_fragments() == []
+    assert native._render_input_top_border(80, "class:fallback") == [
+        ("class:compact-input.frame", shell_prompt._prompt_rule(80))
+    ]
+
+    # Non-thinking model: no label either.
+    plain = _make_toolbar_session(model_name="fast-model", model_capabilities=set(), tips=[])
+    assert plain._effort_label_fragments() == []
+    assert plain._render_input_top_border(80, "class:fallback") == [
+        ("class:compact-input.frame", shell_prompt._prompt_rule(80))
+    ]
+
+
 def test_card_toolbar_separator_uses_standard_frame_for_non_thinking_models(
     monkeypatch: Any,
 ) -> None: