tunacode-cli 0.0.72__py3-none-any.whl → 0.0.75__py3-none-any.whl

tunacode/cli/repl.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import os
+import re
 import subprocess
 from asyncio.exceptions import CancelledError
 from pathlib import Path
@@ -112,7 +113,7 @@ async def _detect_and_handle_text_plan(state_manager, agent_response, original_r
         else:
             response_text = str(agent_response)
 
-        if "TUNACODE_TASK_COMPLETE" in response_text:
+        if re.search(r"^\s*TUNACODE\s+DONE:\s*", response_text, re.IGNORECASE):
             await ui.warning(
                 "⚠️ Agent failed to call present_plan tool. Please provide clearer instructions."
             )

tunacode/constants.py

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

tunacode/core/agents/agent_components/agent_config.py

@@ -169,18 +169,21 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
 
         # Add plan mode context if in plan mode
         if state_manager.is_plan_mode():
-            # REMOVE all TUNACODE_TASK_COMPLETE instructions from the system prompt
-            system_prompt = system_prompt.replace(
-                "TUNACODE_TASK_COMPLETE", "PLAN_MODE_TASK_PLACEHOLDER"
-            )
+            # REMOVE completion instructions from the system prompt in plan mode
+            for marker in ("TUNACODE_TASK_COMPLETE", "TUNACODE DONE:"):
+                system_prompt = system_prompt.replace(marker, "PLAN_MODE_TASK_PLACEHOLDER")
             # Remove the completion guidance that conflicts with plan mode
             lines_to_remove = [
+                "When a task is COMPLETE, start your response with: TUNACODE DONE:",
+                "4. When a task is COMPLETE, start your response with: TUNACODE DONE:",
                 "When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
                 "4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
                 "**How to signal completion:**",
                 "TUNACODE_TASK_COMPLETE",
+                "TUNACODE DONE:",
                 "[Your summary of what was accomplished]",
                 "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.",
+                "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE DONE:",
                 "This prevents wasting iterations and API calls.",
             ]
             for line in lines_to_remove:

tunacode/core/agents/agent_components/agent_helpers.py

@@ -106,7 +106,7 @@ Attempt: {iteration}
 Please take one of these specific actions:
 
 1. **Search yielded no results?** → Try alternative search terms or broader patterns
-2. **Found what you need?** → Use TUNACODE_TASK_COMPLETE to finalize
+2. **Found what you need?** → Use TUNACODE DONE: to finalize
 3. **Encountering a blocker?** → Explain the specific issue preventing progress
 4. **Need more context?** → Use list_dir or expand your search scope
 

tunacode/core/agents/agent_components/node_processor.py

@@ -5,7 +5,7 @@ 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.types import AgentState, UsageTrackerProtocol
 from tunacode.ui.tool_descriptions import get_batch_description, get_tool_description
 
 from .response_state import ResponseState
@@ -52,6 +52,12 @@ async def _process_node(
     has_intention = False
     has_tool_calls = False
 
+    # Transition to ASSISTANT at the start of node processing
+    if response_state and response_state.can_transition_to(AgentState.ASSISTANT):
+        response_state.transition_to(AgentState.ASSISTANT)
+        if state_manager.session.show_thoughts:
+            await ui.muted("STATE → ASSISTANT (reasoning)")
+
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
 
@@ -161,8 +167,11 @@ async def _process_node(
                                     f"Task completion with pending intentions detected: {found_phrases}"
                                 )
 
-                            # Normal completion
-                            response_state.task_completed = True
+                            # Normal completion - transition to RESPONSE state and mark completion
+                            response_state.transition_to(AgentState.RESPONSE)
+                            if state_manager.session.show_thoughts:
+                                await ui.muted("STATE → RESPONSE (completion detected)")
+                            response_state.set_completion_detected(True)
                             response_state.has_user_response = True
                             # Update the part content to remove the marker
                             part.content = cleaned_content
@@ -217,6 +226,14 @@ async def _process_node(
             node, buffering_callback, state_manager, tool_buffer, response_state
         )
 
+    # If there were no tools and we processed a model response, transition to RESPONSE
+    if response_state and response_state.can_transition_to(AgentState.RESPONSE):
+        # Only transition if not already completed (set by completion marker path)
+        if not response_state.is_completed():
+            response_state.transition_to(AgentState.RESPONSE)
+            if state_manager.session.show_thoughts:
+                await ui.muted("STATE → RESPONSE (handled output)")
+
     # Determine empty response reason
     if empty_response_detected:
         if appears_truncated:
@@ -306,6 +323,11 @@ async def _process_tool_calls(
     for part in node.model_response.parts:
         if hasattr(part, "part_kind") and part.part_kind == "tool-call":
             is_processing_tools = True
+            # Transition to TOOL_EXECUTION on first tool call
+            if response_state and response_state.can_transition_to(AgentState.TOOL_EXECUTION):
+                response_state.transition_to(AgentState.TOOL_EXECUTION)
+                if state_manager.session.show_thoughts:
+                    await ui.muted("STATE → TOOL_EXECUTION (executing tools)")
             if tool_callback:
                 # Check if this is a read-only tool that can be batched
                 if tool_buffer is not None and part.tool_name in READ_ONLY_TOOLS:
@@ -440,6 +462,16 @@ async def _process_tool_calls(
                 }
                 state_manager.session.tool_calls.append(tool_info)
 
+    # After tools are processed, transition back to RESPONSE
+    if (
+        is_processing_tools
+        and response_state
+        and response_state.can_transition_to(AgentState.RESPONSE)
+    ):
+        response_state.transition_to(AgentState.RESPONSE)
+        if state_manager.session.show_thoughts:
+            await ui.muted("STATE → RESPONSE (tools finished)")
+
     # Update has_user_response based on presence of actual response content
     if (
         response_state

tunacode/core/agents/agent_components/response_state.py

@@ -1,13 +1,116 @@
 """Response state management for tracking agent processing state."""
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Optional
+
+from tunacode.types import AgentState
+
+from .state_transition import AGENT_TRANSITION_RULES, AgentStateMachine
 
 
 @dataclass
 class ResponseState:
-    """Track state across agent response processing."""
+    """Enhanced response state using enum-based state machine."""
+
+    # Internal state machine
+    _state_machine: AgentStateMachine = field(
+        default_factory=lambda: AgentStateMachine(AgentState.USER_INPUT, AGENT_TRANSITION_RULES)
+    )
+
+    # Backward compatibility boolean flags (derived from enum state)
+    _has_user_response: bool = False
+    _task_completed: bool = False
+    _awaiting_user_guidance: bool = False
+    _has_final_synthesis: bool = False
+
+    def __post_init__(self):
+        """Initialize the state machine."""
+        if not hasattr(self, "_state_machine"):
+            self._state_machine = AgentStateMachine(AgentState.USER_INPUT, AGENT_TRANSITION_RULES)
+
+    @property
+    def current_state(self) -> AgentState:
+        """Get the current enum state."""
+        return self._state_machine.current_state
+
+    def transition_to(self, new_state: AgentState) -> None:
+        """Transition to a new state."""
+        self._state_machine.transition_to(new_state)
+
+    def can_transition_to(self, target_state: AgentState) -> bool:
+        """Check if a transition to the target state is allowed."""
+        return self._state_machine.can_transition_to(target_state)
+
+    # Backward compatibility properties
+    @property
+    def has_user_response(self) -> bool:
+        """Legacy boolean flag for user response detection."""
+        return self._has_user_response
+
+    @has_user_response.setter
+    def has_user_response(self, value: bool) -> None:
+        """Set the legacy has_user_response flag."""
+        self._has_user_response = value
+
+    @property
+    def task_completed(self) -> bool:
+        """Legacy boolean flag for task completion (derived from state machine)."""
+        # If explicitly set true, honor it; otherwise derive from state machine
+        return bool(self._task_completed or self._state_machine.is_completed())
+
+    @task_completed.setter
+    def task_completed(self, value: bool) -> None:
+        """Set the legacy task_completed flag and sync with state machine."""
+        self._task_completed = bool(value)
+        if value:
+            # Ensure state reflects completion in RESPONSE
+            try:
+                if (
+                    self._state_machine.current_state != AgentState.RESPONSE
+                    and self._state_machine.can_transition_to(AgentState.RESPONSE)
+                ):
+                    self._state_machine.transition_to(AgentState.RESPONSE)
+            except Exception:
+                # Best-effort: ignore invalid transition in legacy paths
+                pass
+            self._state_machine.set_completion_detected(True)
+        else:
+            self._state_machine.set_completion_detected(False)
+
+    @property
+    def awaiting_user_guidance(self) -> bool:
+        """Legacy boolean flag for awaiting user guidance."""
+        return self._awaiting_user_guidance
+
+    @awaiting_user_guidance.setter
+    def awaiting_user_guidance(self, value: bool) -> None:
+        """Set the legacy awaiting_user_guidance flag."""
+        self._awaiting_user_guidance = value
+
+    @property
+    def has_final_synthesis(self) -> bool:
+        """Legacy boolean flag for final synthesis."""
+        return self._has_final_synthesis
+
+    @has_final_synthesis.setter
+    def has_final_synthesis(self, value: bool) -> None:
+        """Set the legacy has_final_synthesis flag."""
+        self._has_final_synthesis = value
+
+    # Enhanced state management methods
+    def set_completion_detected(self, detected: bool = True) -> None:
+        """Mark that completion has been detected in the RESPONSE state."""
+        self._state_machine.set_completion_detected(detected)
+
+    def is_completed(self) -> bool:
+        """Check if the task is completed according to the state machine."""
+        return self._state_machine.is_completed()
 
-    has_user_response: bool = False
-    task_completed: bool = False
-    awaiting_user_guidance: bool = False
-    has_final_synthesis: bool = False
+    def reset_state(self, initial_state: Optional[AgentState] = None) -> None:
+        """Reset the state machine to initial state."""
+        self._state_machine.reset(initial_state)
+        # Reset legacy flags
+        self._has_user_response = False
+        self._task_completed = False
+        self._awaiting_user_guidance = False
+        self._has_final_synthesis = False

tunacode/core/agents/agent_components/state_transition.py

@@ -0,0 +1,116 @@
+"""State transition management for agent response processing."""
+
+import threading
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Dict, Set
+
+from tunacode.types import AgentState
+
+if TYPE_CHECKING:
+    pass
+
+
+class InvalidStateTransitionError(Exception):
+    """Raised when an invalid state transition is attempted."""
+
+    def __init__(self, from_state: Enum, to_state: Enum, message: str = None):
+        self.from_state = from_state
+        self.to_state = to_state
+        self.message = message or f"Invalid state transition: {from_state.value} → {to_state.value}"
+        super().__init__(self.message)
+
+
+@dataclass
+class StateTransitionRules:
+    """Defines valid state transitions for the agent state machine."""
+
+    # Valid transitions for each state
+    valid_transitions: Dict[Enum, Set[Enum]]
+
+    def is_valid_transition(self, from_state: Enum, to_state: Enum) -> bool:
+        """Check if a transition between states is valid."""
+        return to_state in self.valid_transitions.get(from_state, set())
+
+    def get_valid_next_states(self, current_state: Enum) -> Set[Enum]:
+        """Get all valid next states from the current state."""
+        return self.valid_transitions.get(current_state, set())
+
+
+class AgentStateMachine:
+    """Thread-safe state machine for agent response processing."""
+
+    def __init__(self, initial_state: "AgentState", rules: StateTransitionRules):
+        """
+        Initialize the state machine.
+
+        Args:
+            initial_state: The starting state
+            rules: Transition rules defining valid state changes
+        """
+        self._state = initial_state
+        self._rules = rules
+        self._lock = threading.RLock()  # Reentrant lock for thread safety
+        self._completion_detected = False
+
+    @property
+    def current_state(self) -> "AgentState":
+        """Get the current state."""
+        with self._lock:
+            return self._state
+
+    def transition_to(self, new_state: "AgentState") -> None:
+        """
+        Transition to a new state.
+
+        Args:
+            new_state: The state to transition to
+
+        Raises:
+            InvalidStateTransitionError: If the transition is not valid
+        """
+        with self._lock:
+            if not self._rules.is_valid_transition(self._state, new_state):
+                raise InvalidStateTransitionError(
+                    self._state,
+                    new_state,
+                    f"Invalid state transition: {self._state.value} → {new_state.value}",
+                )
+
+            # Handle self-transitions as no-ops
+            if self._state == new_state:
+                return
+
+            self._state = new_state
+
+    def can_transition_to(self, target_state: "AgentState") -> bool:
+        """Check if a transition to the target state is allowed."""
+        with self._lock:
+            return self._rules.is_valid_transition(self._state, target_state)
+
+    def set_completion_detected(self, detected: bool = True) -> None:
+        """Mark that completion has been detected in the RESPONSE state."""
+        with self._lock:
+            self._completion_detected = detected
+
+    def is_completed(self) -> bool:
+        """Check if the task is completed (only valid in RESPONSE state)."""
+        with self._lock:
+            return self._state == AgentState.RESPONSE and self._completion_detected
+
+    def reset(self, initial_state: "AgentState" = None) -> None:
+        """Reset the state machine to initial state."""
+        with self._lock:
+            self._state = initial_state or AgentState.USER_INPUT
+            self._completion_detected = False
+
+
+# Define the transition rules for the agent state machine
+AGENT_TRANSITION_RULES = StateTransitionRules(
+    valid_transitions={
+        AgentState.USER_INPUT: {AgentState.ASSISTANT},
+        AgentState.ASSISTANT: {AgentState.TOOL_EXECUTION, AgentState.RESPONSE},
+        AgentState.TOOL_EXECUTION: {AgentState.RESPONSE},
+        AgentState.RESPONSE: {AgentState.ASSISTANT},  # Can transition back to continue
+    }
+)

tunacode/core/agents/agent_components/task_completion.py

@@ -1,5 +1,6 @@
 """Task completion detection utilities."""
 
+import re
 from typing import Tuple
 
 
@@ -18,11 +19,14 @@ def check_task_completion(content: str) -> Tuple[bool, str]:
     if not content:
         return False, content
 
-    lines = content.strip().split("\n")
-    if lines and lines[0].strip() == "TUNACODE_TASK_COMPLETE":
-        # Task is complete, return cleaned content
-        cleaned_lines = lines[1:] if len(lines) > 1 else []
-        cleaned_content = "\n".join(cleaned_lines).strip()
-        return True, cleaned_content
+    lines = content.split("\n")
+
+    # New marker: any line starting with "TUNACODE DONE:" (case-insensitive, allow leading whitespace)
+    done_pattern = re.compile(r"^\s*TUNACODE\s+DONE:\s*", re.IGNORECASE)
+    for idx, line in enumerate(lines):
+        if done_pattern.match(line):
+            # Remove the marker line and return remaining content
+            cleaned = "\n".join(lines[:idx] + lines[idx + 1 :]).strip()
+            return True, cleaned
 
     return False, content

tunacode/core/agents/main.py

@@ -97,7 +97,7 @@ async def check_query_satisfaction(
     state_manager: StateManager,
 ) -> bool:
     """Check if the response satisfies the original query."""
-    return True  # Agent uses TUNACODE_TASK_COMPLETE marker
+    return True  # Completion decided via DONE marker in RESPONSE
 
 
 async def process_request(
@@ -251,7 +251,7 @@ Task: {message[:200]}...
 
 You're describing actions but not executing them. You MUST:
 
-1. If task is COMPLETE: Start response with TUNACODE_TASK_COMPLETE
+1. If task is COMPLETE: Start response with TUNACODE DONE:
 2. If task needs work: Execute a tool RIGHT NOW (grep, read_file, bash, etc.)
 3. If stuck: Explain the specific blocker
 
@@ -269,7 +269,7 @@ NO MORE DESCRIPTIONS. Take ACTION or mark COMPLETE."""
                     unproductive_iterations = 0
 
                 # REMOVED: Recursive satisfaction check that caused empty responses
-                # The agent now decides completion using TUNACODE_TASK_COMPLETE marker
+                # The agent now decides completion using a DONE marker
                 # This eliminates recursive agent calls and gives control back to the agent
 
                 # Store original query for reference
@@ -302,7 +302,7 @@ Progress so far:
 - Iterations: {i}
 - Tools used: {tools_used_str}
 
-If the task is complete, I should respond with TUNACODE_TASK_COMPLETE.
+If the task is complete, I should respond with TUNACODE DONE:
 Otherwise, please provide specific guidance on what to do next."""
 
                     create_user_message(clarification_content, state_manager)

tunacode/prompts/system.md

@@ -10,12 +10,22 @@ CRITICAL BEHAVIOR RULES:
 1. ALWAYS ANNOUNCE YOUR INTENTIONS FIRST: Before executing any tools, briefly state what you're about to do (e.g., "I'll search for the main agent implementation" or "Let me examine the file structure")
 2. When you say "Let me..." or "I will..." you MUST execute the corresponding tool in THE SAME RESPONSE
 3. Never describe what you'll do without doing it  ALWAYS execute tools when discussing actions
-4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE
+4. When a task is COMPLETE, start your response with: TUNACODE DONE:
 5. If your response is cut off or truncated, you'll be prompted to continue  complete your action
 6. YOU MUST NOT USE ANY EMOJIS, YOU WILL BE PUNISHED FOR EMOJI USE
 
 You MUST follow these rules:
 
+### Completion Signaling
+
+When you have fully completed the user’s task:
+
+- Start your response with a single line: `TUNACODE DONE:` followed by a brief outcome summary.
+- Do not add explanations before the DONE line; keep it as the first line.
+- Do NOT mark DONE if you have queued tools in the same response — execute tools first, then mark DONE.
+- Example:
+  - `TUNACODE DONE: Implemented enum state machine and updated completion logic`
+
 ###Tool Access Rules###
 
 You have 9 powerful tools at your disposal. Understanding their categories is CRITICAL for performance:

tunacode/types.py

@@ -209,6 +209,15 @@ class PlanPhase(Enum):
     REVIEW_DECISION = "review"
 
 
+class AgentState(Enum):
+    """Agent loop states for enhanced completion detection."""
+
+    USER_INPUT = "user_input"  # Initial: user prompt received
+    ASSISTANT = "assistant"  # Reasoning/deciding phase
+    TOOL_EXECUTION = "tool_execution"  # Tool execution phase
+    RESPONSE = "response"  # Handling results, may complete or loop
+
+
 @dataclass
 class PlanDoc:
     """Structured plan document with all required sections."""

{tunacode_cli-0.0.72.dist-info → tunacode_cli-0.0.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.72
+Version: 0.0.75
 Summary: Your agentic CLI developer.
 Project-URL: Homepage, https://tunacode.xyz/
 Project-URL: Repository, https://github.com/alchemiststudiosDOTai/tunacode

{tunacode_cli-0.0.72.dist-info → tunacode_cli-0.0.75.dist-info}/RECORD

@@ -1,13 +1,13 @@
 tunacode/__init__.py,sha256=yUul8igNYMfUrHnYfioIGAqvrH8b5BKiO_pt1wVnmd0,119
-tunacode/constants.py,sha256=FYWE1jM_GF0w6PQOXalzbHaQ68kxdG-li_5pLy7KNAg,6100
+tunacode/constants.py,sha256=V6bVzLomBc0eSTlVWneBKUo1SYzfKh1pQONyhHANPu0,6100
 tunacode/context.py,sha256=YtfRjUiqsSkk2k9Nn_pjb_m-AXyh6XcOBOJWtFI0wVw,2405
 tunacode/exceptions.py,sha256=m80njR-LqBXhFAEOPqCE7N2QPU4Fkjlf_f6CWKO0_Is,8479
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/setup.py,sha256=F1E4zHVnbByu_Uo6AhCJ-W-lIGF_gV6kB84HLAGLmVY,2103
-tunacode/types.py,sha256=Q3PeHB01qeaKteGDQf8Byx4q1XLSXVnNDG6D-WjWsBk,10157
+tunacode/types.py,sha256=xNpDRjIRYg4qGNbl3EG8B13CWAWBoob9ekVm8_6dvnc,10496
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
 tunacode/cli/main.py,sha256=DEXS8ODPcsaT1MFBGALX5X7eoohMZDSg6sSW3kOgJxk,3136
-tunacode/cli/repl.py,sha256=jhKMAff4kxt5f2ONacPao2wgcZvNr2BRBZdITh5yDro,22480
+tunacode/cli/repl.py,sha256=DHI0X8yI9tYvp1PUSR31nTIsp6RF8Aq-WDVHULYPHVA,22516
 tunacode/cli/commands/__init__.py,sha256=J7MZofTaSgspAKP64OavPukj4l53qvkv_-sCfYEUi10,1794
 tunacode/cli/commands/base.py,sha256=Ge_lNQA-GDfcb1Ap1oznCH3UrifBiHH3bA9DNL-tCDw,2519
 tunacode/cli/commands/registry.py,sha256=oAppbaOb-2blVo7Akthu6dbR9UFvXom6wf8m52qftpU,14962
@@ -43,17 +43,18 @@ tunacode/core/code_index.py,sha256=2qxEn2eTIegV4F_gLeZO5lAOv8mkf4Y_t21whZ9F2Fk,1
 tunacode/core/state.py,sha256=aksE0mM2xG-1CkLmpi8cu1n1SOMfqpMuqMBciEVShf0,7893
 tunacode/core/tool_handler.py,sha256=42yUfnq5jgk-0LK93JoJgtsXfVDTf-7hNXyKEfH2FM0,3626
 tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
-tunacode/core/agents/main.py,sha256=8K5f_-gXm3VyAMM8FqH2ucZBjKnVJ8kcqEpov-5qk-c,18244
+tunacode/core/agents/main.py,sha256=50V1FMfJ6lac6XqWqH5KLY_12RDiY-FFgieXbf-tQKM,18217
 tunacode/core/agents/utils.py,sha256=ja6Dwq3AVX6QTddmG2uY5ENxFxr5uzc4TS9OjommXp0,14535
 tunacode/core/agents/agent_components/__init__.py,sha256=CL4XH47T6v_iYy7xCPYjyiEFNOFnkcKwbTuKw6IjKTs,1474
-tunacode/core/agents/agent_components/agent_config.py,sha256=cuwSR2xLZuTlds3nNh6r95PnsoCh8XAj_GSymPQvrrk,12757
-tunacode/core/agents/agent_components/agent_helpers.py,sha256=-jeihh0oWZ4VZ81GUhpYFQ2v8EGw9j9WU81swUjTAvk,8276
+tunacode/core/agents/agent_components/agent_config.py,sha256=rVoFxmtu8Ly6-UAqTzvyv1NgPYTG5ZuYzJf5Qgo4384,13096
+tunacode/core/agents/agent_components/agent_helpers.py,sha256=FFX-zXDhNoXpzMVe2iznBpNzNtk7OJ2lHf44cfZhTk8,8268
 tunacode/core/agents/agent_components/json_tool_parser.py,sha256=HuyNT0rs-ppx_gLAI2e0XMVGbR_F0WXZfP3sx38VoMg,3447
 tunacode/core/agents/agent_components/message_handler.py,sha256=KJGOtb9VhumgZpxxwO45HrKLhU9_MwuoWRsSQwJviNU,3704
-tunacode/core/agents/agent_components/node_processor.py,sha256=BAVbXy17sfW3i4LCTdJ9_MSNc7j6qz1bP3_6IhprIW4,20912
-tunacode/core/agents/agent_components/response_state.py,sha256=_C2loLeyZHMFHwjGny4h0dI02UoFJcJAVaabkh9H9JQ,343
+tunacode/core/agents/agent_components/node_processor.py,sha256=n_m3FYH_3pQ2AH-OJvoZ1J5mFzAYc_U2TdZph5GAHvQ,22753
+tunacode/core/agents/agent_components/response_state.py,sha256=qnjRSQCYZzac04CcVc4gTvW8epxl4w-Vz0kPjsvM_Qg,4482
 tunacode/core/agents/agent_components/result_wrapper.py,sha256=9CFK0wpsfZx2WT4PBHfkSv22GxL1gAQuUYVMlmYtCJU,1761
-tunacode/core/agents/agent_components/task_completion.py,sha256=BSnjNEFbxlzgzcXdjdTVGeCr1RpCiAaEp_D7f5FXa5Q,819
+tunacode/core/agents/agent_components/state_transition.py,sha256=uyvLJriexosBDQIrxbVDLR_luvXAMG6tnDsX10mbZcI,4077
+tunacode/core/agents/agent_components/task_completion.py,sha256=2mgrnNBTuGHYEPB2MS7ndsG-scqN5Qf1A85mxWZikJE,975
 tunacode/core/agents/agent_components/tool_buffer.py,sha256=09FNtC6zTjiJOL_2CY0b7KDgwdNayGPV6jbENKH6Unc,766
 tunacode/core/agents/agent_components/tool_executor.py,sha256=LlzDwgSLLawwPZQqJ4vfLf-16nhwIiuN8zm8iCeBf1Y,1849
 tunacode/core/agents/agent_components/truncation_checker.py,sha256=XbJ3wwtdC4NhgIMIvFR0z_cfNnYMkiYAZo9zGDBPU8Y,2685
@@ -76,7 +77,7 @@ tunacode/core/setup/template_setup.py,sha256=0lDGhNVCvGN7ykqHnl3pj4CONH3I2PvMzkm
 tunacode/core/token_usage/api_response_parser.py,sha256=plLltHg4zGVzxjv3MFj45bbd-NOJeT_v3P0Ki4zlvn4,1831
 tunacode/core/token_usage/cost_calculator.py,sha256=RjO-O0JENBuGOrWP7QgBZlZxeXC-PAIr8tj_9p_BxOU,2058
 tunacode/core/token_usage/usage_tracker.py,sha256=YUCnF-712nLrbtEvFrsC-VZuYjKUCz3hf-_do6GKSDA,6016
-tunacode/prompts/system.md,sha256=DosWJgUDkE33mSQoLNz_R5S2CZ_s06yZ5O0lpC1pZtY,10788
+tunacode/prompts/system.md,sha256=UxuEwL9LDZKvnIbV7s_q3JQ852Vsvt9pdqqdoPOZRyM,11226
 tunacode/prompts/system.md.bak,sha256=q0gbk_-pvQlNtZBonRo4gNILkKStqNxgDN0ZEwzC3E4,17541
 tunacode/services/__init__.py,sha256=w_E8QK6RnvKSvU866eDe8BCRV26rAm4d3R-Yg06OWCU,19
 tunacode/services/mcp.py,sha256=quO13skECUGt-4QE2NkWk6_8qhmZ5qjgibvw8tUOt-4,3761
@@ -150,8 +151,8 @@ tunacode/utils/system.py,sha256=J8KqJ4ZqQrNSnM5rrJxPeMk9z2xQQp6dWtI1SKBY1-0,1112
 tunacode/utils/text_utils.py,sha256=HAwlT4QMy41hr53cDbbNeNo05MI461TpI9b_xdIv8EY,7288
 tunacode/utils/token_counter.py,sha256=dmFuqVz4ywGFdLfAi5Mg9bAGf8v87Ek-mHU-R3fsYjI,2711
 tunacode/utils/user_configuration.py,sha256=OA-L0BgWNbf9sWpc8lyivgLscwJdpdI8TAYbe0wRs1s,4836
-tunacode_cli-0.0.72.dist-info/METADATA,sha256=Rc0CTBz0g1gfPGKXfs5kMSaq6Zq5eDlrTQCOHxN0xu8,6898
-tunacode_cli-0.0.72.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tunacode_cli-0.0.72.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.72.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.72.dist-info/RECORD,,
+tunacode_cli-0.0.75.dist-info/METADATA,sha256=A9xG7bSy8cowstguwUJorSZi6gMEXdrHUc2v9fLQk-o,6898
+tunacode_cli-0.0.75.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tunacode_cli-0.0.75.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.75.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.75.dist-info/RECORD,,