tunacode-cli 0.0.53__tar.gz → 0.0.55__tar.gz

tunacode_cli-0.0.55/CLAUDE.md

@@ -0,0 +1,78 @@
+### Documentation
+
+- update the documents @documentation and in .claude after any update.
+
+
+-  use the subagent tech-docs-maintainer to update the documentation you MUST instruct the subagent to keep doc updates short you will be PUNISHED for not telling the documentation agent to keep it to only the most distilled information
+
+- always follow best practices with git commits naming and gh cli workflows
+
+- commit frequently
+
+- always be on the side of safety, if you have any question consult the user
+
+### Python Coding Standards
+
+- Use type hints (PEP 484) for all function signatures
+- Prefer f-strings (PEP 498) over %-formatting or .format()
+- Use pathlib.Path instead of os.path for filesystem operations
+- Structure imports: stdlib → third-party → local (PEP 8)
+- Use dataclasses (PEP 557) for simple data containers
+- Prefer context managers (with) for resource handling
+- Use structural pattern matching (PEP 634) for complex
+- run ruff frequently
+
+### Testing
+
+- "make test" command the entire testing suite
+
+- anytime a new feature or refactor is done, we MUST find or make the golden/character test FIRST as a baseline standaard BEFORE starting, under no circumstance are you to not follow this pattern
+
+### Workflow
+
+- before any updates make a git commit rollback point, clearly labeled for future agents
+
+- the clear outline of the objective MUST be established before we begin ANY coding, do not under any circumstance begin any updates untill this is clearly understood, if you have any ambiuguity or quesiton, the user can be brought in or use best practises
+
+- use scratchpad-multi.sh as you work, after the MD file is done being used sort it to the approate directory
+
+- the MD file created by the bash file MUST be used for the duiration of the task you will be PUNISHED if you do not update this file as you work.
+
+- any key logic or file's must be inlcuded here in the following format if this format is not followed you will STOP reasses, and begin again
+
+### Scratchpad Template Example
+
+```
+# Implementing Authentication Module
+_Started: 2025-08-06 10:00:00_
+_Agent: default_
+
+[1] Found auth logic in src/auth/handler.py:45
+[2] Key dependencies: jwt, bcrypt, session_manager
+[3] Modified login function to add rate limiting
+[3~1] Fixed edge case for empty passwords
+```
+
+- General documentation → archive to @documentation/
+- Developer/tunacode-specific → archive to @ .claude
+- Organize archives by category (agent/development/ etc)
+- In general the scratchpad should never go in any other dirs ececpt the two above
+
+- if a task at hand is to big to handle as a one off use the taskmaster MCP but in general this should only be used as needed, usually it will not be needed
+
+- grep documentation and .claude as needed BOTH of these have a README.md that ahs a direcoty map, you MUST read these before any bigger grep or context searches
+
+- in general gather as much context as needed, unless specified by the user
+
+- this is the most important part of this prompt: Synthesis context aggressively and heuristically AS NEEDED ONLY You can deploy the appropriate subagent for complex tasks agents list below
+
+## Available Agents:
+
+1. **bug-context-analyzer** - Investigates precise context around bugs without suggesting fixes
+2. **code-synthesis-analyzer** - Analyzes recent code changes to identify issues needing fixes
+3. **documentation-synthesis-qa** - Creates comprehensive docs via multi-agent orchestration
+4. **expert-debugger** - Debugs issues using strategic logging and root cause analysis
+5. **phased-task-processor** - Breaks down markdown tasks into max 5 actionable phases
+6. **prompt-engineer** - Optimizes prompts using 26 documented engineering principles
+7. **rapid-code-synthesis-qa** - Quick quality assessment with confidence scores (1-5 scale)
+8. **tech-docs-maintainer** - Updates docs in @documentation and .claude directories

{tunacode_cli-0.0.53/src/tunacode_cli.egg-info → tunacode_cli-0.0.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.53
+Version: 0.0.55
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License: MIT

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "tunacode-cli"
 
-version = "0.0.53"
+version = "0.0.55"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"
@@ -129,3 +129,20 @@ skips = ["B404", "B603", "B101", "B607", "B110", "B324", "B103", "B604", "B602",
 # B604: shell=True (validated usage in REPL)
 # B602: subprocess with shell=True (security utils)
 # B108: hardcoded tmp paths (test fixtures)
+
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true
+warn_return_any = false
+warn_unused_configs = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+check_untyped_defs = false
+disallow_untyped_decorators = false
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = false
+warn_no_return = true
+follow_imports = "silent"
+# Allow CLAUDE_ANCHOR comments in docstrings
+disable_error_code = ["annotation-unchecked"]

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/cli/commands/__init__.py

@@ -7,6 +7,8 @@ This package provides a modular command system with:
 
 The main public API provides backward compatibility with the original
 commands.py module while enabling better organization and maintainability.
+
+CLAUDE_ANCHOR[commands-module]: Command registry and dispatch system
 """
 
 # Import base classes and infrastructure

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/cli/commands/registry.py

@@ -1,4 +1,7 @@
-"""Command registry and factory for TunaCode CLI commands."""
+"""Command registry and factory for TunaCode CLI commands.
+
+CLAUDE_ANCHOR[command-registry]: Central command registration and execution
+"""
 
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/cli/repl.py

@@ -3,6 +3,8 @@ Module: tunacode.cli.repl
 
 Interactive REPL (Read-Eval-Print Loop) implementation for TunaCode.
 Handles user input, command processing, and agent interaction in an interactive shell.
+
+CLAUDE_ANCHOR[repl-module]: Core REPL loop and user interaction handling
 """
 
 # ============================================================================
@@ -41,7 +43,7 @@ MSG_TOOL_INTERRUPTED = "Tool execution was interrupted"
 MSG_REQUEST_CANCELLED = "Request cancelled"
 MSG_SESSION_ENDED = "Session ended. Happy coding!"
 MSG_AGENT_BUSY = "Agent is busy, press Ctrl+C to interrupt."
-MSG_HIT_CTRL_C = "Hit Ctrl+C again to exit"
+MSG_HIT_ABORT_KEY = "Hit ESC or Ctrl+C again to exit"
 SHELL_ENV_VAR = "SHELL"
 DEFAULT_SHELL = "bash"
 
@@ -94,7 +96,10 @@ async def _handle_command(command: str, state_manager: StateManager) -> CommandR
 
 
 async def process_request(text: str, state_manager: StateManager, output: bool = True):
-    """Process input using the agent, handling cancellation safely."""
+    """Process input using the agent, handling cancellation safely.
+
+    CLAUDE_ANCHOR[process-request-repl]: REPL's main request processor with error handling
+    """
     import uuid
 
     # Generate a unique ID for this request for correlated logging
@@ -245,7 +250,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
 async def repl(state_manager: StateManager):
     """Main REPL loop that handles user interaction and input processing."""
     action = None
-    ctrl_c_pressed = False
+    abort_pressed = False
+    last_abort_time = 0.0
 
     model_name = state_manager.session.current_model
     max_tokens = (
@@ -270,16 +276,26 @@ async def repl(state_manager: StateManager):
             try:
                 line = await ui.multiline_input(state_manager, _command_registry)
             except UserAbortError:
-                if ctrl_c_pressed:
+                import time
+
+                current_time = time.time()
+
+                # Reset if more than 3 seconds have passed
+                if current_time - last_abort_time > 3.0:
+                    abort_pressed = False
+
+                if abort_pressed:
                     break
-                ctrl_c_pressed = True
-                await ui.warning(MSG_HIT_CTRL_C)
+
+                abort_pressed = True
+                last_abort_time = current_time
+                await ui.warning(MSG_HIT_ABORT_KEY)
                 continue
 
             if not line:
                 continue
 
-            ctrl_c_pressed = False
+            abort_pressed = False
 
             if line.lower() in ["exit", "quit"]:
                 break

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/cli/repl_components/tool_executor.py

@@ -43,8 +43,9 @@ async def tool_handler(part, state_manager: StateManager):
     if tool_handler_instance.should_confirm(part.tool_name):
         await ui.info(f"Tool({part.tool_name})")
 
-    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-        state_manager.session.spinner.stop()
+    # Keep spinner running during tool execution - it will be updated with tool status
+    # if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+    #     state_manager.session.spinner.stop()
 
     streaming_panel = None
     if state_manager.session.is_streaming_active and hasattr(
@@ -80,5 +81,6 @@ async def tool_handler(part, state_manager: StateManager):
         if streaming_panel and tool_handler_instance.should_confirm(part.tool_name):
             await streaming_panel.start()
 
-        if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-            state_manager.session.spinner.start()
+        # Spinner continues running - no need to restart
+        # if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        #     state_manager.session.spinner.start()

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.53"
+APP_VERSION = "0.0.55"
 
 
 # File patterns

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/core/agents/agent_components/__init__.py

@@ -1,6 +1,17 @@
 """Agent components package for modular agent functionality."""
 
 from .agent_config import get_or_create_agent
+from .agent_helpers import (
+    create_empty_response_message,
+    create_fallback_response,
+    create_progress_summary,
+    create_user_message,
+    format_fallback_output,
+    get_recent_tools_context,
+    get_tool_description,
+    get_tool_summary,
+    get_user_prompt_part_class,
+)
 from .json_tool_parser import extract_and_execute_tool_calls, parse_json_tool_calls
 from .message_handler import get_model_messages, patch_tool_messages
 from .node_processor import _process_node
@@ -24,4 +35,13 @@ __all__ = [
     "check_task_completion",
     "ToolBuffer",
     "execute_tools_parallel",
+    "create_empty_response_message",
+    "create_fallback_response",
+    "create_progress_summary",
+    "create_user_message",
+    "format_fallback_output",
+    "get_recent_tools_context",
+    "get_tool_description",
+    "get_tool_summary",
+    "get_user_prompt_part_class",
 ]

tunacode_cli-0.0.55/src/tunacode/core/agents/agent_components/agent_helpers.py

@@ -0,0 +1,219 @@
+"""Helper functions for agent operations to reduce code duplication."""
+
+from typing import Any
+
+from tunacode.core.state import StateManager
+from tunacode.types import FallbackResponse
+
+
+class UserPromptPartFallback:
+    """Fallback class for UserPromptPart when pydantic_ai is not available."""
+
+    def __init__(self, content: str, part_kind: str):
+        self.content = content
+        self.part_kind = part_kind
+
+
+# Cache for UserPromptPart class
+_USER_PROMPT_PART_CLASS = None
+
+
+def get_user_prompt_part_class():
+    """Get UserPromptPart class with caching and fallback for test environment."""
+    global _USER_PROMPT_PART_CLASS
+
+    if _USER_PROMPT_PART_CLASS is not None:
+        return _USER_PROMPT_PART_CLASS
+
+    try:
+        import importlib
+
+        messages = importlib.import_module("pydantic_ai.messages")
+        _USER_PROMPT_PART_CLASS = getattr(messages, "UserPromptPart", None)
+
+        if _USER_PROMPT_PART_CLASS is None:
+            _USER_PROMPT_PART_CLASS = UserPromptPartFallback
+    except Exception:
+        _USER_PROMPT_PART_CLASS = UserPromptPartFallback
+
+    return _USER_PROMPT_PART_CLASS
+
+
+def create_user_message(content: str, state_manager: StateManager):
+    """Create a user message and add it to the session messages."""
+    from .message_handler import get_model_messages
+
+    model_request_cls = get_model_messages()[0]
+    UserPromptPart = get_user_prompt_part_class()
+    user_prompt_part = UserPromptPart(content=content, part_kind="user-prompt")
+    message = model_request_cls(parts=[user_prompt_part], kind="request")
+    state_manager.session.messages.append(message)
+    return message
+
+
+def get_tool_summary(tool_calls: list[dict[str, Any]]) -> dict[str, int]:
+    """Generate a summary of tool usage from tool calls."""
+    tool_summary: dict[str, int] = {}
+    for tc in tool_calls:
+        tool_name = tc.get("tool", "unknown")
+        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
+    return tool_summary
+
+
+def get_tool_description(tool_name: str, tool_args: dict[str, Any]) -> str:
+    """Get a descriptive string for a tool call."""
+    tool_desc = tool_name
+    if tool_name in ["grep", "glob"] and isinstance(tool_args, dict):
+        pattern = tool_args.get("pattern", "")
+        tool_desc = f"{tool_name}('{pattern}')"
+    elif tool_name == "read_file" and isinstance(tool_args, dict):
+        path = tool_args.get("file_path", tool_args.get("filepath", ""))
+        tool_desc = f"{tool_name}('{path}')"
+    return tool_desc
+
+
+def get_recent_tools_context(tool_calls: list[dict[str, Any]], limit: int = 3) -> str:
+    """Get a context string describing recent tool usage."""
+    if not tool_calls:
+        return "No tools used yet"
+
+    last_tools = []
+    for tc in tool_calls[-limit:]:
+        tool_name = tc.get("tool", "unknown")
+        tool_args = tc.get("args", {})
+        tool_desc = get_tool_description(tool_name, tool_args)
+        last_tools.append(tool_desc)
+
+    return f"Recent tools: {', '.join(last_tools)}"
+
+
+def create_empty_response_message(
+    message: str,
+    empty_reason: str,
+    tool_calls: list[dict[str, Any]],
+    iteration: int,
+    state_manager: StateManager,
+) -> str:
+    """Create an aggressive message for handling empty responses."""
+    tools_context = get_recent_tools_context(tool_calls)
+
+    content = f"""FAILURE DETECTED: You returned {("an " + empty_reason if empty_reason != "empty" else "an empty")} response.
+
+This is UNACCEPTABLE. You FAILED to produce output.
+
+Task: {message[:200]}...
+{tools_context}
+Current iteration: {iteration}
+
+TRY AGAIN RIGHT NOW:
+
+1. If your search returned no results → Try a DIFFERENT search pattern
+2. If you found what you need → Use TUNACODE_TASK_COMPLETE
+3. If you're stuck → EXPLAIN SPECIFICALLY what's blocking you
+4. If you need to explore → Use list_dir or broader searches
+
+YOU MUST PRODUCE REAL OUTPUT IN THIS RESPONSE. NO EXCUSES.
+EXECUTE A TOOL OR PROVIDE SUBSTANTIAL CONTENT.
+DO NOT RETURN ANOTHER EMPTY RESPONSE."""
+
+    return content
+
+
+def create_progress_summary(tool_calls: list[dict[str, Any]]) -> tuple[dict[str, int], str]:
+    """Create a progress summary from tool calls."""
+    tool_summary = get_tool_summary(tool_calls)
+
+    if tool_summary:
+        summary_str = ", ".join([f"{name}: {count}" for name, count in tool_summary.items()])
+    else:
+        summary_str = "No tools used yet"
+
+    return tool_summary, summary_str
+
+
+def create_fallback_response(
+    iterations: int,
+    max_iterations: int,
+    tool_calls: list[dict[str, Any]],
+    messages: list[Any],
+    verbosity: str = "normal",
+) -> FallbackResponse:
+    """Create a comprehensive fallback response when iteration limit is reached."""
+    fallback = FallbackResponse(
+        summary="Reached maximum iterations without producing a final response.",
+        progress=f"Completed {iterations} iterations (limit: {max_iterations})",
+    )
+
+    # Extract context from messages
+    tool_calls_summary = []
+    files_modified = set()
+    commands_run = []
+
+    for msg in messages:
+        if hasattr(msg, "parts"):
+            for part in msg.parts:
+                if hasattr(part, "part_kind") and part.part_kind == "tool-call":
+                    tool_name = getattr(part, "tool_name", "unknown")
+                    tool_calls_summary.append(tool_name)
+
+                    # Track specific operations
+                    if tool_name in ["write_file", "update_file"] and hasattr(part, "args"):
+                        if isinstance(part.args, dict) and "file_path" in part.args:
+                            files_modified.add(part.args["file_path"])
+                    elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
+                        if isinstance(part.args, dict) and "command" in part.args:
+                            commands_run.append(part.args["command"])
+
+    if verbosity in ["normal", "detailed"]:
+        # Add what was attempted
+        if tool_calls_summary:
+            tool_counts: dict[str, int] = {}
+            for tool in tool_calls_summary:
+                tool_counts[tool] = tool_counts.get(tool, 0) + 1
+
+            fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
+            for tool, count in sorted(tool_counts.items()):
+                fallback.issues.append(f"  • {tool}: {count}x")
+
+        if verbosity == "detailed":
+            if files_modified:
+                fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
+                for f in sorted(files_modified)[:5]:
+                    fallback.issues.append(f"  • {f}")
+                if len(files_modified) > 5:
+                    fallback.issues.append(f"  • ... and {len(files_modified) - 5} more")
+
+            if commands_run:
+                fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
+                for cmd in commands_run[:3]:
+                    display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
+                    fallback.issues.append(f"  • {display_cmd}")
+                if len(commands_run) > 3:
+                    fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
+
+    # Add helpful next steps
+    fallback.next_steps.append("The task may be too complex - try breaking it into smaller steps")
+    fallback.next_steps.append("Check the output above for any errors or partial progress")
+    if files_modified:
+        fallback.next_steps.append("Review modified files to see what changes were made")
+
+    return fallback
+
+
+def format_fallback_output(fallback: FallbackResponse) -> str:
+    """Format a fallback response into a comprehensive output string."""
+    output_parts = [fallback.summary, ""]
+
+    if fallback.progress:
+        output_parts.append(f"Progress: {fallback.progress}")
+
+    if fallback.issues:
+        output_parts.append("\nWhat happened:")
+        output_parts.extend(fallback.issues)
+
+    if fallback.next_steps:
+        output_parts.append("\nSuggested next steps:")
+        for step in fallback.next_steps:
+            output_parts.append(f"  • {step}")
+
+    return "\n".join(output_parts)

{tunacode_cli-0.0.53 → tunacode_cli-0.0.55}/src/tunacode/core/agents/agent_components/node_processor.py

@@ -6,10 +6,12 @@ from typing import Any, Awaitable, Callable, Optional, Tuple
 from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
 from tunacode.types import UsageTrackerProtocol
+from tunacode.ui.tool_descriptions import get_batch_description, get_tool_description
 
 from .response_state import ResponseState
 from .task_completion import check_task_completion
 from .tool_buffer import ToolBuffer
+from .truncation_checker import check_for_truncation
 
 logger = get_logger(__name__)
 
@@ -171,7 +173,7 @@ async def _process_node(
             # Check for truncation patterns
             if all_content_parts:
                 combined_content = " ".join(all_content_parts).strip()
-                appears_truncated = _check_for_truncation(combined_content)
+                appears_truncated = check_for_truncation(combined_content)
 
             # If we only got empty content and no tool calls, we should NOT consider this a valid response
             # This prevents the agent from stopping when it gets empty responses
@@ -229,79 +231,6 @@ async def _process_node(
     return False, None
 
 
-def _check_for_truncation(combined_content: str) -> bool:
-    """Check if content appears to be truncated."""
-    if not combined_content:
-        return False
-
-    # Truncation indicators:
-    # 1. Ends with "..." or "…" (but not part of a complete sentence)
-    # 2. Ends mid-word (no punctuation, space, or complete word)
-    # 3. Contains incomplete markdown/code blocks
-    # 4. Ends with incomplete parentheses/brackets
-
-    # Check for ellipsis at end suggesting truncation
-    if combined_content.endswith(("...", "…")) and not combined_content.endswith(("....", "….")):
-        return True
-
-    # Check for mid-word truncation (ends with letters but no punctuation)
-    if combined_content and combined_content[-1].isalpha():
-        # Look for incomplete words by checking if last "word" seems cut off
-        words = combined_content.split()
-        if words:
-            last_word = words[-1]
-            # Common complete word endings vs likely truncations
-            complete_endings = (
-                "ing",
-                "ed",
-                "ly",
-                "er",
-                "est",
-                "tion",
-                "ment",
-                "ness",
-                "ity",
-                "ous",
-                "ive",
-                "able",
-                "ible",
-            )
-            incomplete_patterns = (
-                "referen",
-                "inte",
-                "proces",
-                "analy",
-                "deve",
-                "imple",
-                "execu",
-            )
-
-            if any(last_word.lower().endswith(pattern) for pattern in incomplete_patterns):
-                return True
-            elif len(last_word) > 2 and not any(
-                last_word.lower().endswith(end) for end in complete_endings
-            ):
-                # Likely truncated if doesn't end with common suffix
-                return True
-
-    # Check for unclosed markdown code blocks
-    code_block_count = combined_content.count("```")
-    if code_block_count % 2 != 0:
-        return True
-
-    # Check for unclosed brackets/parentheses (more opens than closes)
-    open_brackets = (
-        combined_content.count("[") + combined_content.count("(") + combined_content.count("{")
-    )
-    close_brackets = (
-        combined_content.count("]") + combined_content.count(")") + combined_content.count("}")
-    )
-    if open_brackets > close_brackets:
-        return True
-
-    return False
-
-
 async def _display_raw_api_response(node: Any, ui: Any) -> None:
     """Display raw API response data when thoughts are enabled."""
 
@@ -382,6 +311,14 @@ async def _process_tool_calls(
                 if tool_buffer is not None and part.tool_name in READ_ONLY_TOOLS:
                     # Add to buffer instead of executing immediately
                     tool_buffer.add(part, node)
+
+                    # Update spinner to show we're collecting tools
+                    buffered_count = len(tool_buffer.read_only_tasks)
+                    await ui.update_spinner_message(
+                        f"[bold #00d7ff]Collecting tools ({buffered_count} buffered)...[/bold #00d7ff]",
+                        state_manager,
+                    )
+
                     if state_manager.session.show_thoughts:
                         await ui.muted(
                             f"⏸️ BUFFERED: {part.tool_name} (will execute in parallel batch)"
@@ -399,6 +336,13 @@ async def _process_tool_calls(
 
                         start_time = time.time()
 
+                        # Update spinner message for batch execution
+                        tool_names = [part.tool_name for part, _ in buffered_tasks]
+                        batch_msg = get_batch_description(len(buffered_tasks), tool_names)
+                        await ui.update_spinner_message(
+                            f"[bold #00d7ff]{batch_msg}...[/bold #00d7ff]", state_manager
+                        )
+
                         # Enhanced visual feedback for parallel execution
                         await ui.muted("\n" + "=" * 60)
                         await ui.muted(
@@ -452,9 +396,30 @@ async def _process_tool_calls(
                             f"(~{speedup:.1f}x faster than sequential)\n"
                         )
 
+                        # Reset spinner message back to thinking
+                        from tunacode.constants import UI_THINKING_MESSAGE
+
+                        await ui.update_spinner_message(UI_THINKING_MESSAGE, state_manager)
+
                     # Now execute the write/execute tool
                     if state_manager.session.show_thoughts:
                         await ui.warning(f"⚠️ SEQUENTIAL: {part.tool_name} (write/execute tool)")
+
+                    # Update spinner for sequential tool
+                    tool_args = getattr(part, "args", {}) if hasattr(part, "args") else {}
+                    # Parse args if they're a JSON string
+                    if isinstance(tool_args, str):
+                        import json
+
+                        try:
+                            tool_args = json.loads(tool_args)
+                        except (json.JSONDecodeError, TypeError):
+                            tool_args = {}
+                    tool_desc = get_tool_description(part.tool_name, tool_args)
+                    await ui.update_spinner_message(
+                        f"[bold #00d7ff]{tool_desc}...[/bold #00d7ff]", state_manager
+                    )
+
                     await tool_callback(part, node)
 
     # Track tool calls in session