pythinker-code 0.45.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

pythinker_code/CHANGELOG.md

@@ -15,6 +15,14 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.46.0 (2026-06-14)
+
+- **Startup auto-update now picks up new releases within half an hour instead of up to a day.** The background update check was throttled to once every 24h, so a freshly published release could go unnoticed for a full day after the last check; the interval is now 30 minutes. The silent installer also no longer marks the throttle *before* the network call — a transient startup network error returns `FAILED` and is retried on the next launch instead of suppressing updates for the whole window.
+- **The welcome banner now keeps the robot mark visible in compact terminals.** Below ~68 columns the robot was dropped (it could not sit beside the welcome copy); it now stacks centered above the copy instead, so the mark stays on screen at any width that can render its Unicode glyphs. ASCII-only terminals are unaffected.
+- **A persistent update notice now sits directly under the prompt input.** When a newer release is available the footer shows a yellow `↑ Update available — vX · /update` line; once a release has been installed in the background it switches to a restart-to-apply message instead of pointing at `/update`, and it clears after you restart onto the new version. The line is suppressed for dismissed versions, disabled auto-update, and source checkouts.
+
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.46.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
+
 ## 0.45.0 (2026-06-14)
 
 - **Agent-tracing dashboard.** Added `pythinker dashboard` — a local web UI for inspecting sessions, wire events, context messages, tool statistics, and usage over time. It is also reachable from the interactive shell via the `/reports` slash command (aliased `/dashboard`).

pythinker_code/ui/shell/__init__.py

@@ -81,6 +81,7 @@ from pythinker_code.ui.shell.update import (
 )
 from pythinker_code.ui.shell.update_orchestrator import (
     SMOKE_CHECK_FAILED_PREFIX,
+    UpdateJobState,
     read_update_status,
     run_update_job,
 )
@@ -565,6 +566,10 @@ class Shell:
         self._prefill_text = prefill_text
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._prompt_session: CustomPromptSession | None = None
+        # (timestamp, text) memo for the under-input update line; refreshed on a
+        # short TTL so the hot toolbar render path does not stat the update
+        # cache on every repaint (mirrors the footer's git-branch TTL).
+        self._update_notice_cache: tuple[float, str | None] = (0.0, None)
         self._running_input_handler: Callable[[UserInput], None] | None = None
         self._running_interrupt_handler: Callable[[], None] | None = None
         self._active_approval_sink: Any | None = None
@@ -916,6 +921,7 @@ class Shell:
             status_block_provider=_mcp_status_block,
             fast_refresh_provider=_mcp_status_loading,
             background_task_count_provider=_bg_task_counts,
+            update_notice_provider=self._update_notice_text,
             model_capabilities=self.soul.model_capabilities or set(),
             model_name=model_display_name(
                 self.soul.model_name,
@@ -2110,9 +2116,13 @@ class Shell:
         """Install a newer release silently in the background at startup."""
         if not _should_auto_check_for_updates():
             return
-        _mark_auto_update_check_attempt()
 
         result = await self._run_silent_update_job()
+        # Throttle only after a completed round-trip. Marking before the network
+        # call (or after a FAILED one) would suppress updates for the whole
+        # interval on a transient startup blip — mirrors _refresh_update_cache.
+        if result is not None and result is not UpdateResult.FAILED:
+            _mark_auto_update_check_attempt()
         if result is UpdateResult.UPDATED:
             self._surface_installed_update_notice()
         elif result is UpdateResult.UPDATE_AVAILABLE:
@@ -2180,6 +2190,42 @@ class Shell:
         if self._prompt_session is not None:
             self._prompt_session.invalidate()
 
+    def _update_notice_text(self) -> str | None:
+        """Persistent under-input update line, or None when up to date.
+
+        Memoized on a short TTL (5s) so the hot toolbar render path doesn't stat
+        the update cache on every repaint; the background updater invalidates the
+        prompt when it changes the cache, so the line still appears promptly.
+        """
+        now = time.monotonic()
+        cached_at, cached = self._update_notice_cache
+        if now - cached_at < 5.0:
+            return cached
+        text = self._compute_update_notice()
+        self._update_notice_cache = (now, text)
+        return text
+
+    def _compute_update_notice(self) -> str | None:
+        target = welcome_update_target()
+        if not target:
+            return None
+        # A release already installed this session needs a restart, not /update —
+        # keep this line in agreement with the install toast instead of telling
+        # the user to re-run an update that has already landed.
+        status = read_update_status()
+        installed = (
+            status is not None
+            and status.state is UpdateJobState.UPDATED
+            and status.target_version == target
+        )
+        if installed and not self._installed_update_smoke_check_failed():
+            text = self._installed_update_restart_notice()
+        else:
+            text = f"↑ Update available — v{target} · /update"
+        if ascii_glyphs_enabled():
+            text = text.translate(_WELCOME_ASCII_FALLBACKS)
+        return text
+
     def _schedule_startup_update_task(self) -> None:
         """Pick the startup update behavior and schedule it (non-blocking).
 
@@ -2559,7 +2605,11 @@ def _print_welcome_info(
 
     show_logo = not ascii_mode
     use_columns = bool(tips) and content_width >= _WELCOME_COLUMNS_MIN_WIDTH
-    logo_rendered = show_logo and (use_columns or content_width >= 68)
+    # The robot sits beside the copy when there's room (~68 cells); in a compact
+    # terminal it stacks centered above the copy instead of being dropped, so the
+    # mark stays visible at any width that can render its Unicode glyphs.
+    logo_beside_copy = show_logo and not use_columns and content_width >= 68
+    logo_rendered = show_logo  # columns-centered, beside, or stacked — only ASCII hides it
 
     version_title = Text.assemble(
         ("Pythinker Code", tui_rich_style("muted")),
@@ -2608,7 +2658,7 @@ def _print_welcome_info(
             columns.add_row(Group(*left_rows), _tips_block(tips_width, with_rule=True))
             rows.append(columns)
         else:
-            if logo_rendered:
+            if logo_beside_copy:
                 # Logo on the left; the text block centers vertically against
                 # the robot so the lines sit beside the face while the antenna
                 # floats above.
@@ -2617,6 +2667,10 @@ def _print_welcome_info(
                 table.add_column(justify="left", vertical="middle", no_wrap=True)
                 table.add_row(_logo_text(), Group(head, strapline, help_text))
                 rows.append(table)
+            elif show_logo:
+                # Compact terminal: too narrow to seat the robot beside the
+                # copy, so stack it centered above instead of dropping it.
+                rows.extend([Align.center(_logo_text()), Text(""), head, strapline, help_text])
             else:
                 rows.extend([head, strapline, help_text])
 

pythinker_code/ui/shell/prompt.py

@@ -2126,6 +2126,7 @@ class CustomPromptSession:
         status_block_provider: Callable[[int], AnyFormattedText | None] | None = None,
         fast_refresh_provider: Callable[[], bool] | None = None,
         background_task_count_provider: Callable[[], BgTaskCounts] | None = None,
+        update_notice_provider: Callable[[], str | None] | None = None,
         model_capabilities: set[ModelCapability],
         model_name: str | None,
         thinking: bool,
@@ -2173,6 +2174,7 @@ class CustomPromptSession:
         self._status_block_provider = status_block_provider
         self._fast_refresh_provider = fast_refresh_provider
         self._background_task_count_provider = background_task_count_provider
+        self._update_notice_provider = update_notice_provider
         self._editor_command_provider = editor_command_provider
         self._turn_recaps_provider = turn_recaps_provider
         self._plan_mode_toggle_callback = plan_mode_toggle_callback
@@ -3711,6 +3713,23 @@ class CustomPromptSession:
                 error=exc,
             )
 
+    def _prepend_update_notice(self, fragments: list[tuple[str, str]], columns: int) -> None:
+        """Prepend a persistent yellow 'update available' line above the footer
+        separator, so it renders directly under the prompt input. No-op when no
+        update is pending; style-agnostic across both toolbar layouts."""
+        provider = getattr(self, "_update_notice_provider", None)
+        if provider is None:
+            return
+        text = provider()
+        if not text:
+            return
+        line = _truncate_right(text, max(0, columns - 1))
+        if not line:
+            return
+        tokens = _get_tui_tokens()
+        style = f"fg:{tokens.warning or 'ansiyellow'} bold"
+        fragments[:0] = [(style, line), ("", "\n")]
+
     def _render_bottom_toolbar(self) -> FormattedText:
         if (
             hasattr(self, "_session")
@@ -3733,6 +3752,7 @@ class CustomPromptSession:
         fragments: list[tuple[str, str]] = []
         tc = get_toolbar_colors()
 
+        self._prepend_update_notice(fragments, columns)
         fragments.append((self._prompt_separator_style(tc.separator), _prompt_rule(columns)))
         fragments.append(("", "\n"))
 
@@ -3963,6 +3983,7 @@ class CustomPromptSession:
         secondary_style = f"fg:{tokens.muted}"
 
         fragments: list[tuple[str, str]] = []
+        self._prepend_update_notice(fragments, columns)
         fragments.append((self._prompt_separator_style(tc.separator), _prompt_rule(columns)))
         fragments.append(("", "\n"))
 

pythinker_code/ui/shell/update.py

@@ -64,7 +64,13 @@ LATEST_VERSION_ETAG_FILE = get_share_dir() / "latest_version.etag"
 LAST_UPDATE_CHECK_FILE = get_share_dir() / "last_update_check.txt"
 DISMISSED_VERSION_FILE = get_share_dir() / "dismissed_update_version.txt"
 LAST_SEEN_VERSION_FILE = get_share_dir() / "last_seen_version.txt"
-AUTO_UPDATE_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+# ponytail: 30m throttle so a freshly-pushed release is picked up on the next
+# restart instead of up to a day later. The check is unauthenticated, so each
+# poll costs one of GitHub's 60 req/hr/IP budget regardless of the cached ETag
+# (304s are only rate-limit-free when authenticated) — at ~2 polls/hr/startup
+# that is a wide margin. A throttle miss fails safe: a transient error returns
+# FAILED, which skips the mark and retries next launch.
+AUTO_UPDATE_CHECK_INTERVAL_SECONDS = 30 * 60
 PROMPT_UPDATE_REFRESH_TIMEOUT_SECONDS = 2.0
 WINDOWS_UPDATE_STAGING_MAX_AGE_SECONDS = 7 * 24 * 60 * 60
 UPGRADE_COMMAND_TIMEOUT_SECONDS = 30 * 60

pythinker_code/web/static/assets/architecture-7EHR7CIX-DuYWmQ8n.js

@@ -0,0 +1 @@
+import"./chunk-NNHCCRGN-DmZbXBJw.js";import{x as e}from"./mermaid-parser.core-C_SVA4S7.js";export{e as createArchitectureServices};