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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythinker-code
-Version: 0.8.0
+Version: 0.10.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,17 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.8.0
+## 🆕 What's New in 0.10.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.
+- **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.
 
-- **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.10.0`.
 
 
 ---

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

@@ -50,18 +50,17 @@ It speaks the [**Agent Client Protocol (ACP)**](https://github.com/agentclientpr
 
 ---
 
-## 🆕 What's New in 0.8.0
+## 🆕 What's New in 0.10.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.
+- **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.
 
-- **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.10.0`.
 
 
 ---

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

@@ -1,6 +1,6 @@
 [project]
 name = "pythinker-code"
-version = "0.8.0"
+version = "0.10.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.10.0/src/pythinker_code/CHANGELOG.md

@@ -0,0 +1,106 @@
+# Changelog
+
+All notable changes to `pythinker-code` are tracked in this file.
+
+Pythinker Code uses a `0.MINOR.PATCH` version scheme. `MINOR` is a release
+counter that continues advancing with each release. `PATCH` is reserved for
+hotfixes against an already-released `MINOR`. There is no `1.0.0` milestone
+planned on this line.
+
+Releases earlier than `0.8.0` were published as `pythinker-code` 1.x/2.x
+under a different scheme. The full pre-`0.8.0` history is preserved in
+[`docs/history/CHANGELOG-pre-0.8.0.md`](docs/history/CHANGELOG-pre-0.8.0.md).
+All 1.x and 2.x releases have been yanked from PyPI and removed from the
+GitHub Releases page; `0.8.0` is the new starting line.
+
+## Unreleased
+
+## 0.10.0 (2026-05-22)
+
+### What changed in this release
+
+- **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.
+
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.10.0`.
+
+## 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. `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` 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.
+- **Tag scheme standardised** on `v<MAJOR>.<MINOR>.<PATCH>`. The
+  `release-pythinker-cli.yml` workflow trigger now matches `v[0-9]+.[0-9]+.[0-9]+`
+  and `scripts/check_version_tag.py` strips the leading `v` before comparing the
+  tag to `pyproject.toml`.
+- **Release gate preserved.** The `What's New in <version>` section,
+  `pythinker-code==<version>` install snippet, and `## <version> (YYYY-MM-DD)`
+  CHANGELOG entry are still required for every tag — only the version values
+  change.
+- **CHANGELOG restart.** Pre-`0.8.0` history archived to
+  `docs/history/CHANGELOG-pre-0.8.0.md`; this file starts fresh at `0.8.0`.
+- **README "What's New" trimmed.** The cascading 2.x "What's New" wall is
+  replaced by a single `0.8.0` section. Past release notes live in the archived
+  CHANGELOG and the per-tag GitHub Releases (from `v0.8.0` onward).
+- **Test refactor.** `tests/telemetry/test_otel_resource.py` now reads the
+  expected service version from `importlib.metadata.version("pythinker-code")`
+  instead of a hard-coded string, so future version bumps don't require a test
+  edit.
+
+### Included in 0.8.0
+
+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` /
+`debugger` subagent roles, hardened review-output validation, and the
+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 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.10.0}/src/pythinker_code/app.py

@@ -41,6 +41,27 @@ if TYPE_CHECKING:
 _CWD_LOCK = asyncio.Lock()
 
 
+def _safe_git_branch(cwd: str | Path | HostPath) -> 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,
+            encoding="utf-8",
+            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 +744,22 @@ 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(HostPath.unsafe_from_local_path(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.10.0/src/pythinker_code/file_restore.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import base64
+import time
+import uuid
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from pythinker_code.session import Session
+from pythinker_code.utils.io import atomic_json_write
+
+_RESTORE_DIR = "file_restore_points"
+
+
+class FileRestorePoint(BaseModel):
+    id: str
+    created_at: float
+    tool_name: str
+    path: Path
+    existed: bool
+    content_b64: str | None = None
+
+
+def _restore_dir(session: Session) -> Path:
+    path = session.dir / _RESTORE_DIR
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _restore_file(session: Session, restore_id: str) -> Path:
+    return _restore_dir(session) / f"{restore_id}.json"
+
+
+def create_file_restore_point(
+    session: Session,
+    *,
+    tool_name: str,
+    path: str | Path,
+) -> FileRestorePoint:
+    target = Path(path)
+    existed = target.exists()
+    content_b64 = None
+    if existed and target.is_file():
+        content_b64 = base64.b64encode(target.read_bytes()).decode("utf-8")
+
+    point = FileRestorePoint(
+        id=f"{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}",
+        created_at=time.time(),
+        tool_name=tool_name,
+        path=target,
+        existed=existed,
+        content_b64=content_b64,
+    )
+    atomic_json_write(point.model_dump(mode="json"), _restore_file(session, point.id))
+    return point
+
+
+def list_file_restore_points(
+    session: Session, *, limit: int | None = None
+) -> list[FileRestorePoint]:
+    points: list[FileRestorePoint] = []
+    for path in _restore_dir(session).glob("*.json"):
+        try:
+            points.append(FileRestorePoint.model_validate_json(path.read_text(encoding="utf-8")))
+        except Exception:
+            continue
+    points.sort(key=lambda point: (point.created_at, point.id), reverse=True)
+    return points[:limit] if limit is not None else points
+
+
+def restore_file_restore_point(session: Session, restore_id: str) -> FileRestorePoint:
+    point = FileRestorePoint.model_validate_json(
+        _restore_file(session, restore_id).read_text(encoding="utf-8")
+    )
+    if not point.existed:
+        point.path.unlink(missing_ok=True)
+        return point
+
+    point.path.parent.mkdir(parents=True, exist_ok=True)
+    content = base64.b64decode(point.content_b64 or "")
+    point.path.write_bytes(content)
+    return point

{pythinker_code-0.8.0 → pythinker_code-0.10.0}/src/pythinker_code/session_state.py

@@ -18,6 +18,17 @@ class ApprovalStateData(BaseModel):
     auto_approve_actions: set[str] = Field(default_factory=set)
 
 
+class TrustStateData(BaseModel):
+    trusted: bool = False
+    safe_mode: bool = True
+
+
+class AccessibilityStateData(BaseModel):
+    plain_output: bool = False
+    animations: bool = True
+    symbols: Literal["unicode", "ascii"] = "unicode"
+
+
 class TodoItemState(BaseModel):
     """A single todo item stored in session or subagent state."""
 
@@ -28,6 +39,8 @@ class TodoItemState(BaseModel):
 class SessionState(BaseModel):
     version: int = 1
     approval: ApprovalStateData = Field(default_factory=ApprovalStateData)
+    trust: TrustStateData = Field(default_factory=TrustStateData)
+    accessibility: AccessibilityStateData = Field(default_factory=AccessibilityStateData)
     additional_dirs: list[str] = Field(default_factory=list)
     custom_title: str | None = None
     title_generated: bool = False

{pythinker_code-0.8.0 → pythinker_code-0.10.0}/src/pythinker_code/soul/agent.py

@@ -288,6 +288,9 @@ class Runtime:
 
         # Merge invocation flags with persisted session state.
         effective_yolo = yolo or session.state.approval.yolo
+        # An explicit --yolo invocation is already a deliberate trust decision for
+        # this run, so it must not deadlock non-interactive/e2e flows behind safe mode.
+        effective_safe_mode = False if yolo else session.state.trust.safe_mode
         if auto and not session.state.approval.auto:
             session.state.approval.auto = True
             session.save_state()
@@ -297,12 +300,14 @@ class Runtime:
             session.state.approval.yolo = approval_state.yolo
             session.state.approval.auto = approval_state.auto
             session.state.approval.auto_approve_actions = set(approval_state.auto_approve_actions)
+            session.state.trust.safe_mode = approval_state.safe_mode
             session.save_state()
 
         approval_state = ApprovalState(
             yolo=effective_yolo,
             auto=session.state.approval.auto,
             runtime_auto=runtime_auto,
+            safe_mode=effective_safe_mode,
             auto_approve_actions=saved_actions,
             on_change=_on_approval_change,
         )

{pythinker_code-0.8.0 → pythinker_code-0.10.0}/src/pythinker_code/soul/approval.py

@@ -58,6 +58,7 @@ class ApprovalState:
         yolo: bool = False,
         auto: bool = False,
         runtime_auto: bool = False,
+        safe_mode: bool = False,
         auto_approve_actions: set[str] | None = None,
         on_change: Callable[[], None] | None = None,
     ):
@@ -69,6 +70,8 @@ class ApprovalState:
         """
         self.runtime_auto = runtime_auto
         """Invocation-only auto flag, e.g. ``--auto`` or ``--print``. Not persisted."""
+        self.safe_mode = safe_mode
+        """When true, all auto-approval paths are suppressed."""
         self.auto_approve_actions: set[str] = auto_approve_actions or set()
         """Set of action names that should automatically be approved."""
         self._on_change = on_change
@@ -120,12 +123,18 @@ class Approval:
         """Toggle invocation-only auto mode without persisting it."""
         self._state.runtime_auto = auto
 
+    def set_safe_mode(self, safe_mode: bool) -> None:
+        self._state.safe_mode = safe_mode
+        self._state.notify_change()
+
     def is_auto_approve(self) -> bool:
         """True when tool calls should be auto-approved.
 
         Auto mode implies auto-approve, so this returns True whenever either the
         explicit yolo flag or auto mode is set.
         """
+        if self._state.safe_mode:
+            return False
         return self._state.yolo or self.is_auto()
 
     def is_yolo(self) -> bool:

{pythinker_code-0.8.0 → pythinker_code-0.10.0}/src/pythinker_code/soul/pythinkersoul.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import re
 import time
 import uuid
 from collections.abc import Awaitable, Callable, Sequence
@@ -20,7 +21,7 @@ from pythinker_core.chat_provider import (
     APITimeoutError,
     RetryableChatProvider,
 )
-from pythinker_core.message import Message
+from pythinker_core.message import Message, ToolCall
 from tenacity import RetryCallState, retry_if_exception, stop_after_attempt, wait_exponential_jitter
 
 from pythinker_code.approval_runtime import (
@@ -166,6 +167,54 @@ def classify_api_error(e: Exception) -> tuple[str, int | None]:
 type StepStopReason = Literal["no_tool_calls", "tool_rejected"]
 
 
+_MISSING_REQUIRED_FIELD_RE = re.compile(
+    r"^\s*(?P<field>[A-Za-z_][A-Za-z0-9_\-.]*)\s*\n\s+Field required",
+    re.MULTILINE,
+)
+
+
+def _missing_required_fields_from_validation_error(message: str) -> list[str]:
+    """Extract field names from Pydantic's missing-field validation text."""
+    if "Error validating JSON arguments:" not in message:
+        return []
+    return [match.group("field") for match in _MISSING_REQUIRED_FIELD_RE.finditer(message)]
+
+
+def _is_empty_tool_arguments(tool_call: ToolCall) -> bool:
+    raw = tool_call.function.arguments
+    return raw is None or raw.strip() in {"", "{}"}
+
+
+def _malformed_empty_tool_call_summary(
+    tool_calls: Sequence[ToolCall], tool_results: Sequence[ToolResult]
+) -> str | None:
+    """Return a concise summary when a step only produced empty invalid tool calls.
+
+    Some models can get stuck emitting `{}`/empty arguments for tools with required
+    fields. Continuing the agent loop just floods the UI with repeated validation
+    cards. Detect that dead-end shape and stop after the first invalid batch.
+    """
+    if not tool_calls or len(tool_calls) != len(tool_results):
+        return None
+
+    calls_by_id = {call.id: call for call in tool_calls}
+    missing_by_tool: list[str] = []
+    for result in tool_results:
+        call = calls_by_id.get(result.tool_call_id)
+        if call is None or not _is_empty_tool_arguments(call):
+            return None
+        if not result.return_value.is_error:
+            return None
+        fields = _missing_required_fields_from_validation_error(result.return_value.message)
+        if not fields:
+            return None
+        missing_by_tool.append(f"{call.function.name}.{', '.join(fields)}")
+
+    if not missing_by_tool:
+        return None
+    return "; ".join(missing_by_tool)
+
+
 @dataclass(frozen=True, slots=True)
 class StepOutcome:
     stop_reason: StepStopReason
@@ -1249,6 +1298,23 @@ class PythinkerSoul:
             await asyncio.shield(grow_context_task)
             raise
 
+        if invalid_summary := _malformed_empty_tool_call_summary(result.tool_calls, results):
+            message = Message(
+                role="assistant",
+                content=[
+                    TextPart(
+                        text=(
+                            "I couldn't continue because the model emitted malformed empty "
+                            "tool calls with missing required arguments: "
+                            f"{invalid_summary}. Please retry the request, or switch models "
+                            "if this repeats."
+                        )
+                    )
+                ],
+            )
+            await self._context.append_message(message)
+            return StepOutcome(stop_reason="no_tool_calls", assistant_message=message)
+
         rejected_errors = [
             result.return_value
             for result in results

{pythinker_code-0.8.0 → pythinker_code-0.10.0}/src/pythinker_code/tools/file/replace.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field
 from pythinker_core.tooling import CallableTool2, ToolError, ToolReturnValue
 from pythinker_host.path import HostPath
 
+from pythinker_code.file_restore import create_file_restore_point
 from pythinker_code.soul.agent import Runtime
 from pythinker_code.soul.approval import Approval
 from pythinker_code.soul.permission import check_file_mutation_allowed
@@ -172,6 +173,8 @@ class StrReplaceFile(CallableTool2[Params]):
                 if not result:
                     return result.rejection_error()
 
+            create_file_restore_point(self._runtime.session, tool_name=self.name, path=str(p))
+
             # Write the modified content back to the file
             await p.write_text(content, encoding="utf-8", errors="replace")
 

{pythinker_code-0.8.0 → pythinker_code-0.10.0}/src/pythinker_code/tools/file/write.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field
 from pythinker_core.tooling import CallableTool2, ToolError, ToolReturnValue
 from pythinker_host.path import HostPath
 
+from pythinker_code.file_restore import create_file_restore_point
 from pythinker_code.soul.agent import Runtime
 from pythinker_code.soul.approval import Approval
 from pythinker_code.soul.permission import check_file_mutation_allowed
@@ -158,6 +159,8 @@ class WriteFile(CallableTool2[Params]):
                 if not result:
                     return result.rejection_error()
 
+            create_file_restore_point(self._runtime.session, tool_name=self.name, path=str(p))
+
             # Write content to file
             match params.mode:
                 case "overwrite":

{pythinker_code-0.8.0 → pythinker_code-0.10.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.10.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 == "":
@@ -122,7 +134,6 @@ def format_bash_command_for_header(command: str, *, expanded: bool) -> str:
 
 
 def _status_header(state: BashExecutionState) -> Text:
-    accent = _accent_style(state)
     if state.status in ("pending", "running"):
         header = _pulsing_marker()
         header.append("Running", style=tui_rich_style("muted") + RichStyle(bold=True))
@@ -136,11 +147,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"))