bone-agent 1.4.0 → 2.0.1

package/src/core/agentic.py

@@ -1,1085 +0,0 @@
-"""Agent tool-calling loop."""
-
-import json
-import logging
-from pathlib import Path
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-from rich.markdown import Markdown
-from rich.text import Text
-
-from utils.settings import MAX_TOOL_CALLS, MonokaiDarkBGStyle, left_align_headings
-from tools import (
-    read_file,
-    list_directory,
-    create_file,
-    TOOLS,
-)
-from utils.settings import tool_settings
-
-from llm.config import get_provider_config
-from utils.result_parsers import extract_exit_code
-from core.retry import (
-    RETRY_MAX_ATTEMPTS,
-    RETRY_DELAYS,
-    is_retryable_error,
-    wait_with_cancel_message,
-)
-from core.tool_approval import (
-    handle_edit_approval,
-    handle_command_approval,
-    resolve_edit_preview,
-)
-from exceptions import (
-    LLMError,
-    LLMResponseError,
-)
-
-from core.tool_feedback import (
-    vault_root_str,
-    _print_or_append,
-    strip_leading_task_list_echo,
-    build_read_file_label,
-    build_tool_label,
-    display_tool_feedback,
-)
-from ui.sub_agent_panel import SubAgentPanel
-from tools.helpers.path_resolver import extract_boundary_path, is_boundary_error, set_full_filesystem_access
-
-
-def _handle_empty_response(empty_response_count, console):
-    """Handle empty response from model.
-
-    Returns:
-        tuple: (should_continue, updated_count)
-    """
-    empty_response_count += 1
-    if empty_response_count >= 2:
-        console.print("[red]Error: model returned empty response with no tool calls.[/red]")
-        return False, empty_response_count
-    return True, empty_response_count
-
-
-
-def _handle_tool_limit_reached(chat_manager, console):
-    """Handle case when tool call limit is exceeded.
-
-    Returns:
-        bool: True if handled successfully, False if error
-    """
-    chat_manager.messages.append({
-        "role": "user",
-        "content": "Tool limit reached. Provide your answer without calling tools."
-    })
-
-    try:
-        response = chat_manager.client.chat_completion(
-            chat_manager.messages, stream=False, tools=None
-        )
-    except LLMError as e:
-        console.print(f"[red]LLM Error: {e}[/red]")
-        return False
-
-    if isinstance(response, dict) and 'usage' in response:
-        provider_cfg = get_provider_config(chat_manager.client.provider)
-        chat_manager.token_tracker.add_usage(
-            response,
-            model_name=provider_cfg.get("model", ""),
-        )
-    try:
-        final_message = response["choices"][0]["message"]
-    except (KeyError, IndexError):
-        console.print("[red]Error: invalid response from model[/red]")
-        return False
-
-    content = final_message.get("content", "").strip()
-    if content:
-        md = Markdown(left_align_headings(content), code_theme=MonokaiDarkBGStyle, justify="left")
-        console.print(md)
-        chat_manager.messages.append(final_message)
-        console.print()
-        return True
-
-    console.print("[red]Error: model returned empty response after tool limit reached.[/red]")
-    return False
-
-class AgenticOrchestrator:
-    """Orchestrates the agentic tool-calling loop.
-
-    This class encapsulates the complex logic of coordinating LLM interactions
-    with tool calling, providing a cleaner, more maintainable structure.
-    """
-
-    def __init__(self, chat_manager, repo_root, rg_exe_path, console, debug_mode, suppress_result_display=False, is_sub_agent=False, panel_updater=None, force_parallel_execution=False, cron_job_id=None, cron_allowlist=None, cron_interactive=False):
-        """Initialize the orchestrator.
-
-        Args:
-            chat_manager: ChatManager instance for state management
-            repo_root: Path to repository root
-            rg_exe_path: Path to rg.exe
-            console: Rich console for output
-            debug_mode: Whether to show debug output
-            suppress_result_display: If True, suppress final LLM response display (for research agent)
-            is_sub_agent: If True, running as sub-agent (for visual framing)
-            panel_updater: Optional SubAgentPanel callback for live panel updates
-            force_parallel_execution: If True, force parallel execution (for sub-agent)
-            cron_job_id: Optional cron job ID for command allow list gating
-            cron_allowlist: Optional CronAllowlist instance for cron command gating
-            cron_interactive: If True, cron job is running in interactive test mode
-        """
-        self.chat_manager = chat_manager
-        self.repo_root = repo_root
-        self.rg_exe_path = rg_exe_path
-        self.console = console
-        self.debug_mode = debug_mode
-        self.suppress_result_display = suppress_result_display
-        self.is_sub_agent = is_sub_agent
-        self.panel_updater = panel_updater
-        self.force_parallel_execution = force_parallel_execution
-        self.cron_job_id = cron_job_id
-        self.cron_allowlist = cron_allowlist
-        self.cron_interactive = cron_interactive
-        self.tool_calls_count = 0
-        self.empty_response_count = 0
-        self.gitignore_spec = chat_manager.get_gitignore_spec(repo_root)
-        # For parallel execution: temporary console override
-        self._parallel_context = {}
-        # Initialize vault session with known repo_root (for project folder derivation)
-        try:
-            from tools.obsidian import init_session
-            init_session(repo_root)
-        except Exception as e:
-            logger.warning("Failed to initialize vault session: %s", e)
-        # Bootstrap memory system (creates ~/.bone/ and .bone/ dirs + files if missing)
-        try:
-            from core.memory import MemoryManager
-            MemoryManager.get_instance(repo_root).ensure_exists()
-        except Exception as e:
-            logger.warning("Failed to initialize memory system: %s", e)
-
-
-    def _get_console(self):
-        """Get the console for output, respecting parallel execution context.
-
-        Returns:
-            Console object or None if suppressed during parallel execution
-        """
-        # Check if we're in a parallel context with suppressed console
-        return self._parallel_context.get('console', self.console)
-
-    def _get_effective_tools(self, allowed_tools=None, allow_active_plugins=False):
-        """Return tool schemas allowed for the current run."""
-        from tools.helpers.base import ToolRegistry
-
-        tools = TOOLS()
-        if allowed_tools is None:
-            return tools
-
-        effective_names = set(allowed_tools)
-        if allow_active_plugins:
-            effective_names.update(ToolRegistry.active_plugin_names())
-
-        if not effective_names:
-            return []
-
-        return [tool for tool in tools if tool["function"]["name"] in effective_names]
-
-    def run(self, user_input, thinking_indicator=None, allowed_tools=None, allow_active_plugins=False):
-        """Main orchestration loop.
-
-        Args:
-            user_input: User's input message
-            thinking_indicator: Optional ThinkingIndicator instance
-            allowed_tools: Optional list of allowed tool names (for research)
-            allow_active_plugins: Whether to include active plugin tools in restricted runs
-        """
-        self._current_allowed_tools = allowed_tools
-        self._current_allow_active_plugins = allow_active_plugins
-
-        # Append user message
-        self.chat_manager.messages.append({"role": "user", "content": user_input})
-
-        # Log user message
-        self.chat_manager.log_message({"role": "user", "content": user_input})
-
-        from tools.helpers.base import ToolRegistry
-
-        while True:
-            # Decrement plugin TTLs after previous iteration's tool execution.
-            # Evicted plugins are excluded from the next LLM call's context window.
-            evicted = ToolRegistry.decrement_plugin_ttls()
-            if evicted and self.debug_mode:
-                self.console.print(f"[dim]Plugins evicted (TTL expired): {evicted}[/dim]")
-
-            # Get response from LLM
-            response = self._get_llm_response(
-                allowed_tools=allowed_tools,
-                allow_active_plugins=allow_active_plugins,
-            )
-            if response is None:
-                return
-
-            # Auto-compact if over token threshold (applies to both main agent and subagent)
-            self.chat_manager.maybe_auto_compact()
-
-            # Check for tool calls
-            tool_calls = response.get("tool_calls")
-
-            if not tool_calls:
-                if self._handle_final_response(response, thinking_indicator):
-                    return
-            else:
-                should_exit = self._handle_tool_calls(
-                    response,
-                    thinking_indicator,
-                    allowed_tools,
-                    allow_active_plugins=allow_active_plugins,
-                )
-                if should_exit:
-                    return
-
-    def _get_llm_response(self, allowed_tools=None, allow_active_plugins=False):
-        """Get next LLM response with tool definitions.
-
-        Includes automatic retry with live countdown for timeout/connection errors.
-        Retries up to 3 times with a 5-second countdown between attempts.
-
-        Args:
-            allowed_tools: Optional list of allowed tool names (overrides mode-based filtering)
-            allow_active_plugins: Whether to include active plugin tools in restricted runs
-
-        Returns:
-            Response dict from LLM, or None if error occurred
-        """
-        # Pre-send guard: ensure context fits before the LLM call
-        self.chat_manager.ensure_context_fits(console=self.console)
-
-        # Use allowed_tools if provided, otherwise use mode-based filtering
-        if allowed_tools is not None and not allowed_tools and not allow_active_plugins:
-            self.console.print("[red]Error: allowed_tools is empty[/red]")
-            return None
-
-        tools = self._get_effective_tools(
-            allowed_tools=allowed_tools,
-            allow_active_plugins=allow_active_plugins,
-        )
-        if allowed_tools is not None and self.debug_mode:
-            tool_names = [t["function"]["name"] for t in tools]
-            self.console.print(f"[dim]Available tools: {tool_names}[/dim]")
-
-        # Retry loop for timeout/connection errors
-        last_error = None
-        for attempt in range(1, RETRY_MAX_ATTEMPTS + 1):
-            try:
-                response = self.chat_manager.client.chat_completion(
-                    self.chat_manager.messages, stream=False, tools=tools
-                )
-            except LLMError as e:
-                last_error = e
-
-                # Check if this error is retryable
-                if is_retryable_error(e) and attempt < RETRY_MAX_ATTEMPTS:
-                    delay = RETRY_DELAYS[min(attempt - 1, len(RETRY_DELAYS) - 1)]
-                    wait_ok = wait_with_cancel_message(self.console, delay)
-                    if not wait_ok:
-                        return None
-                    continue
-                else:
-                    # Non-retryable error or final attempt exhausted
-                    detail_lines = []
-                    for key, value in getattr(e, "details", {}).items():
-                        value_str = str(value)
-                        if "\n" in value_str or key == "original_error":
-                            detail_lines.append(f"{key}: {value_str}")
-                    detailed_error = str(e)
-                    if detail_lines:
-                        detailed_error += "\n\n" + "\n\n".join(detail_lines)
-
-                    if self.is_sub_agent:
-                        raise LLMError(detailed_error, details=getattr(e, "details", {}))
-
-                    self.console.print(f"[red]LLM Error: {e}[/red]")
-                    if detail_lines:
-                        self.console.print(f"[dim]{detail_lines[0]}[/dim]", markup=False)
-                    return None
-
-            # Successful response — parse and return
-            # Extract and track usage data
-            if isinstance(response, dict) and 'usage' in response:
-                provider_cfg = get_provider_config(self.chat_manager.client.provider)
-                self.chat_manager.token_tracker.add_usage(
-                    response,
-                    model_name=provider_cfg.get("model", ""),
-                )
-
-            try:
-                message = response["choices"][0]["message"]
-            except (KeyError, IndexError):
-                self.console.print("[red]Error: invalid response from model[/red]")
-                return None
-
-            return message
-
-        # Should not reach here, but handle gracefully
-        self.console.print(f"[red]LLM Error: {last_error}[/red]")
-        return None
-
-    def _handle_final_response(self, response, thinking_indicator=None):
-        """Handle non-tool-call response (final answer).
-
-        Args:
-            response: Message dict from LLM
-            thinking_indicator: Optional ThinkingIndicator instance to clear before displaying
-
-        Returns:
-            True if handled successfully, False if should continue looping
-        """
-        content = response.get("content", "")
-        content = strip_leading_task_list_echo(
-            content,
-            getattr(self.chat_manager, "task_list", None) or [],
-            getattr(self.chat_manager, "task_list_title", None),
-        )
-        # Strip leading "Assistant: " prefix that some models may output
-        if content.startswith("Assistant: "):
-            content = content[len("Assistant: "):]
-        content = content.lstrip()
-        if content and content.strip():
-            # Clear thinking indicator before printing response to avoid flash
-            if thinking_indicator:
-                thinking_indicator.stop(reset=True)
-            # Only display to user if result display is not suppressed
-            if not self.suppress_result_display:
-                md = Markdown(left_align_headings(content), code_theme=MonokaiDarkBGStyle, justify="left")
-                self.console.print(md)
-            # Always append to message history (AI needs the result regardless)
-            response = dict(response)
-            response["content"] = content
-            self.chat_manager.messages.append(response)
-            # Log assistant response
-            self.chat_manager.log_message(response)
-
-            # NEW: Compact tool results after final answer (per-message compaction)
-            self.chat_manager.compact_tool_results(skip_token_update=True)
-
-            # Update context tokens with current run's effective tools
-            tools_for_mode = self._get_effective_tools(
-                allowed_tools=getattr(self, "_current_allowed_tools", None),
-                allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
-            )
-            self.chat_manager._update_context_tokens(tools_for_mode)
-
-            self.console.print()
-            return True
-
-        # Empty response with no tools
-        should_continue, self.empty_response_count = _handle_empty_response(
-            self.empty_response_count, self.console
-        )
-        return not should_continue
-
-    def _handle_tool_calls(self, response, thinking_indicator, allowed_tools=None, allow_active_plugins=False):
-        """Process tool calls and display accompanying content.
-
-        Args:
-            response: Full message dict from LLM (includes content and tool_calls)
-            thinking_indicator: Optional ThinkingIndicator instance
-            allowed_tools: Optional list of allowed tool names
-            allow_active_plugins: Whether to allow active plugin tools in restricted runs
-
-        Returns:
-            True if should exit the orchestration loop
-        """
-        # Extract tool_calls from response
-        tool_calls = response.get("tool_calls")
-        if not tool_calls:
-            return False  # Should not happen if called correctly
-
-        # Append assistant message with ALL tool calls (include content if present)
-        # This must happen BEFORE filtering so the LLM sees its original intent
-        content = (response.get("content") or "").strip()
-        assistant_msg = {"role": "assistant", "tool_calls": tool_calls}
-        if response.get("_responses_output"):
-            assistant_msg["_responses_output"] = response["_responses_output"]
-        if content:
-            assistant_msg["content"] = content
-        self.chat_manager.messages.append(assistant_msg)
-        # Log assistant tool call message
-        self.chat_manager.log_message(assistant_msg)
-
-        # NEW: Filter out non-allowed tools BEFORE execution
-        # This silently removes unknown tools or tools not in the allowed whitelist
-        # to prevent error messages from reaching the user while allowing the agent
-        # to continue with alternative tools.
-        from tools.helpers.base import ToolRegistry
-
-        filtered_calls = []
-        filtered_tool_ids = []  # Track filtered tool IDs to provide feedback
-
-        for tool_call in tool_calls:
-            function_name = tool_call.get("function", {}).get("name")
-
-            # Check if tool exists in registry
-            if not ToolRegistry.get(function_name):
-                # Silent fail - skip this tool call entirely
-                # Agent will receive empty result and can retry with correct tool
-                if self.debug_mode:
-                    self.console.print(f"[dim]Silently filtered unknown tool: {function_name}[/dim]")
-                filtered_tool_ids.append(tool_call.get("id"))
-                continue
-
-            # Check if tool is in the effective allowlist for this run.
-            effective_allowed_tools = None
-            if allowed_tools is not None:
-                effective_allowed_tools = set(allowed_tools)
-                if allow_active_plugins:
-                    effective_allowed_tools.update(ToolRegistry.active_plugin_names())
-
-            if effective_allowed_tools is not None and function_name not in effective_allowed_tools:
-                # Silent fail - skip this tool
-                if self.debug_mode:
-                    self.console.print(f"[dim]Silently filtered non-allowed tool: {function_name}[/dim]")
-                filtered_tool_ids.append(tool_call.get("id"))
-                continue
-
-            filtered_calls.append(tool_call)
-
-        # Replace with filtered list
-        tool_calls = filtered_calls
-
-        # Provide feedback to agent for filtered tools
-        # This allows the agent to understand which tools were not available
-        # without showing error messages to the user
-        if filtered_tool_ids:
-            for tool_id in filtered_tool_ids:
-                tool_msg = {
-                    "role": "tool",
-                    "tool_call_id": tool_id,
-                    "content": "exit_code=1\nTool not available. Please use the available tools from the function list."
-                }
-                self.chat_manager.messages.append(tool_msg)
-                self.chat_manager.log_message(tool_msg)
-
-        # If all tools were filtered, return early
-        if not tool_calls:
-            if self.debug_mode:
-                self.console.print("[dim]All tool calls were filtered, continuing...[/dim]")
-            return False
-
-        self.empty_response_count = 0
-        self.tool_calls_count += 1
-
-        if self.tool_calls_count > MAX_TOOL_CALLS:
-            return not _handle_tool_limit_reached(self.chat_manager, self.console)
-
-        # Display conversational content if present
-        # Skip if calling sub_agent OR if we ARE a sub-agent (sub-agent panel provides context)
-        is_calling_sub_agent = any(
-            tool.get("function", {}).get("name") == "sub_agent"
-            for tool in tool_calls
-        )
-        # Route to panel if we're a sub-agent with a panel_updater, otherwise print to console
-        if content:
-            if self.is_sub_agent and self.panel_updater:
-                # Sub-agent: send thinking to panel instead of console
-                self.panel_updater.append(content)
-            elif not is_calling_sub_agent:
-                # Main agent: print to console (unless calling sub_agent)
-                md = Markdown(left_align_headings(content), code_theme=MonokaiDarkBGStyle, justify="left")
-                self.console.print(md)
-                self.console.print()
-
-        # Check if we should use parallel execution
-        use_parallel = (
-            tool_settings.enable_parallel_execution and
-            len(tool_calls) > 1
-        )
-
-        # Force sequential if any edit_file or execute_command in the batch (safety)
-        if use_parallel:
-            for tool_call in tool_calls:
-                tool_name = tool_call.get("function", {}).get("name")
-                if tool_name == "edit_file":
-                    use_parallel = False
-                    if self.debug_mode:
-                        self.console.print("[dim]Forcing sequential execution (edit_file detected)[/dim]")
-                    break
-                elif tool_name == "execute_command":
-                    use_parallel = False
-                    if self.debug_mode:
-                        self.console.print("[dim]Forcing sequential execution (execute_command detected)[/dim]")
-                    break
-                elif tool_name == "sub_agent":
-                    use_parallel = False
-                    if self.debug_mode:
-                        self.console.print("[dim]Forcing sequential execution (sub_agent detected)[/dim]")
-                    break
-                elif tool_name == "select_option":
-                    use_parallel = False
-                    if self.debug_mode:
-                        self.console.print("[dim]Forcing sequential execution (select_option detected)[/dim]")
-                    break
-
-        if use_parallel and self.debug_mode:
-            self.console.print(f"[#5F9EA0]Executing {len(tool_calls)} tools in parallel[/#5F9EA0]")
-
-        # Lock compaction during tool execution to prevent orphaning tool_call_ids
-        self.chat_manager.set_compaction_lock(True)
-
-        if use_parallel:
-            result = self._execute_tools_parallel(tool_calls, thinking_indicator)
-        else:
-            result = self._execute_tools_sequential(tool_calls, thinking_indicator)
-
-        # Unlock compaction after all tool results are appended
-        self.chat_manager.set_compaction_lock(False)
-
-        return result
-
-    def _execute_tools_sequential(self, tool_calls, thinking_indicator):
-        """Execute tools one at a time (original behavior).
-
-        Args:
-            tool_calls: List of tool call dicts from LLM
-            thinking_indicator: Optional ThinkingIndicator instance
-
-        Returns:
-            True if should exit the orchestration loop
-        """
-        end_loop = False
-
-        for tool_call in tool_calls:
-            tool_id = tool_call["id"]
-            should_exit, tool_result = self._process_single_tool_call(
-                tool_call, thinking_indicator
-            )
-
-            if should_exit:
-                # Cancel was selected - append this result and break immediately
-                if tool_result is not None and tool_result is not False:
-                    if isinstance(tool_result, Text):
-                        content_for_agent = f"exit_code=0\n{str(tool_result)}"
-                    else:
-                        content_for_agent = str(tool_result)
-                    tool_msg = {
-                        "role": "tool",
-                        "tool_call_id": tool_id,
-                        "content": content_for_agent
-                    }
-                    self.chat_manager.messages.append(tool_msg)
-                    self.chat_manager.log_message(tool_msg)
-                return True  # Exit orchestration loop immediately
-
-            # Append tool result if not skipped (guidance mode)
-            if tool_result is not None and tool_result is not False:
-                # Add exit_code prefix for agent consumption
-                if isinstance(tool_result, Text):
-                    # Rich Text object = successful edit (exit_code=0)
-                    content_for_agent = f"exit_code=0\n{str(tool_result)}"
-                else:
-                    content_for_agent = str(tool_result)
-                tool_msg = {
-                    "role": "tool",
-                    "tool_call_id": tool_id,
-                    "content": content_for_agent
-                }
-                self.chat_manager.messages.append(tool_msg)
-                # Log tool result
-                self.chat_manager.log_message(tool_msg)
-
-        # Compact completed tool blocks once after all tools complete
-        self.chat_manager.compact_tool_results(skip_token_update=True)
-
-        # Update context tokens with current run's effective tools
-        tools_for_mode = self._get_effective_tools(
-            allowed_tools=getattr(self, "_current_allowed_tools", None),
-            allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
-        )
-        self.chat_manager._update_context_tokens(tools_for_mode)
-
-        # Pre-send guard: ensure context fits before next LLM call
-        self.chat_manager.ensure_context_fits(console=self.console)
-
-        return end_loop
-
-    def _execute_tools_parallel(self, tool_calls, thinking_indicator):
-        """Execute multiple tools concurrently.
-
-        Args:
-            tool_calls: List of tool call dicts from LLM (already filtered)
-            thinking_indicator: Optional ThinkingIndicator instance
-
-        Returns:
-            True if should exit the orchestration loop
-        """
-        if not tool_calls:
-            return False
-        from tools.helpers.parallel_executor import ParallelToolExecutor, ToolCall
-
-        # Suppress console output in handlers during parallel execution
-        # We'll display results ourselves in order below
-        self._parallel_context['console'] = None
-
-        try:
-            # Prepare context
-            context = {
-                'thinking_indicator': thinking_indicator,
-                'repo_root': self.repo_root,
-                'chat_manager': self.chat_manager,
-                'rg_exe_path': self.rg_exe_path,
-                'debug_mode': self.debug_mode,
-                'gitignore_spec': self.gitignore_spec,
-                'panel_updater': self.panel_updater,
-                'vault_root': vault_root_str(),
-            }
-
-            # Convert to ToolCall objects
-            tool_call_objs = []
-            for i, tc in enumerate(tool_calls):
-                try:
-                    arguments = json.loads(tc["function"]["arguments"])
-                except json.JSONDecodeError:
-                    # Invalid JSON - handle inline for this tool
-                    tool_msg = {
-                        "role": "tool",
-                        "tool_call_id": tc["id"],
-                        "content": "exit_code=1\nInvalid JSON arguments"
-                    }
-                    self.chat_manager.messages.append(tool_msg)
-                    self.chat_manager.log_message(tool_msg)
-                    continue
-
-                tool_call_objs.append(
-                    ToolCall(
-                        tool_id=tc["id"],
-                        function_name=tc["function"]["name"],
-                        arguments=arguments,
-                        call_index=i
-                    )
-                )
-
-            if not tool_call_objs:
-                # All tools had invalid arguments
-                return False
-
-            # Create executor
-            executor = ParallelToolExecutor(
-                max_workers=tool_settings.max_parallel_workers
-            )
-
-            # Execute in parallel
-            results, _ = executor.execute_tools(
-                tool_call_objs,
-                context
-            )
-
-            # Display results with labels (staggered: label → feedback, like sequential mode)
-            for result in results:
-                if result.success:
-                    # Get tool call info
-                    tool_call = tool_calls[result.call_index]
-                    function_name = tool_call.get("function", {}).get("name", "")
-                    arguments = tool_call.get("function", {}).get("arguments", "{}")
-                    args_dict = json.loads(arguments) if isinstance(arguments, str) else arguments
-
-                    # Label builders
-                    label_builders = {
-                        "rg": lambda a: f"rg: {a.get('pattern', '')[:40]}",
-                        "read_file": lambda a: build_read_file_label(
-                            a.get('path_str', ''),
-                            a.get('start_line'),
-                            a.get('max_lines'),
-                            with_colon=True
-                        ),
-                        "list_directory": lambda a: f"list_directory: {a.get('path_str', '')}",
-                        "search_plugins": lambda a: f"search_plugins: {a.get('query', '')}",
-                        "create_file": lambda a: f"create_file: {a.get('path_str', '')}",
-                        "web_search": lambda a: f"web search | {a.get('query', '')}",
-                        "create_task_list": lambda a: "create_task_list",
-                        "complete_task": lambda a: "complete_task",
-                        "show_task_list": lambda a: "show_task_list",
-                    }
-
-                    # Print the label first (staggered output: label → feedback)
-                    label_builder = label_builders.get(function_name, lambda a: function_name)
-                    try:
-                        label = label_builder(args_dict)
-                        
-                        # Print the label before feedback (matches sequential path)
-                        if not self.panel_updater and function_name not in ("create_task_list", "complete_task", "show_task_list"):
-                            label_text = f"[grey]{label}[/grey]" if not function_name.startswith("web search") else f"[bold #5F9EA0]{label}[/bold #5F9EA0]"
-                            self.console.print(label_text, highlight=False)
-                            self.console.file.flush()
-                        
-                        # For task list tools: only show the task list, no label duplication
-                        # Skip the feedback display below since we already showed it
-                        continue_flag = False
-                        if function_name in ("create_task_list", "complete_task", "show_task_list"):
-                            exit_code = extract_exit_code(result.result)
-                            if exit_code == 0 or exit_code is None:
-                                rendered = result.result
-                                if rendered.startswith("exit_code="):
-                                    rendered = "\n".join(rendered.splitlines()[1:])
-                                if self.panel_updater:
-                                    self.panel_updater.append(rendered.strip())
-                                else:
-                                    self.console.print(rendered.strip(), markup=True)
-                                    self.console.print()
-                            else:
-                                first_two = "\n".join(result.result.splitlines()[:2]).strip()
-                                if self.panel_updater:
-                                    self.panel_updater.append(first_two or result.result.strip())
-                                else:
-                                    self.console.print(first_two or result.result.strip(), markup=False)
-                                    self.console.print()
-                            continue_flag = True
-                            label = function_name
-                    except Exception:
-                        label_text = f"[grey]{function_name}[/grey]"
-                        if not self.panel_updater:
-                            self.console.print(label_text, highlight=False)
-                            self.console.file.flush()
-                        label = function_name  # Fallback for error path
-                        continue_flag = False
-
-                    # Display feedback immediately after label (no buffering)
-                    # Skip for task list tools since they handled their own display
-                    if continue_flag:
-                        continue
-                    try:
-                        if function_name == "edit_file" and result.requires_approval:
-                            # Handle approval workflow for edit_file in parallel mode
-                            thinking_indicator = context.get('thinking_indicator')
-                            preview, is_valid = resolve_edit_preview(result.result)
-                            if is_valid:
-                                approved_result, should_exit = handle_edit_approval(
-                                    preview, args_dict.get('path', ''), args_dict,
-                                    self.console, thinking_indicator,
-                                    self.chat_manager.approve_mode,
-                                    lambda: self.chat_manager.cycle_approve_mode(),
-                                    self.repo_root, self.gitignore_spec,
-                                    vault_root_str)
-                                result.result = approved_result
-                                if should_exit:
-                                    result.should_exit = True
-                        elif label:
-                            display_tool_feedback(label, result.result, self.console, panel_updater=self.panel_updater)
-                            # Force flush to ensure immediate output
-                            if not self.panel_updater:
-                                self.console.file.flush()
-                        else:
-                            completion_text = f"[dim]{function_name} completed[/dim]"
-                            if self.panel_updater:
-                                self.panel_updater.append(completion_text)
-                            else:
-                                self.console.print(completion_text, highlight=False)
-                                self.console.file.flush()
-                    except Exception:
-                        completion_text = f"[dim]{function_name} completed[/dim]"
-                        if self.panel_updater:
-                            self.panel_updater.append(completion_text)
-                        else:
-                            self.console.print(completion_text, highlight=False)
-                            self.console.file.flush()
-                else:
-                    error_msg = result.error or result.result
-                    error_text = f"[red]{error_msg}[/red]"
-                    if self.panel_updater:
-                        self.panel_updater.append(error_text)
-                    else:
-                        self.console.print(error_text)
-                        self.console.file.flush()
-
-            # Display summary
-            success_count = sum(1 for r in results if r.success)
-            if self.debug_mode:
-                self.console.print(
-                    f"[dim]Parallel execution: {success_count}/{len(results)} succeeded[/dim]"
-                )
-
-            # Append all results to chat history
-            end_loop = False
-            for result in results:
-                if result.success:
-                    # Check if tool requested exit
-                    if result.should_exit:
-                        end_loop = True
-
-                    # Add exit_code prefix for agent consumption (Rich Text = success)
-                    if isinstance(result.result, Text):
-                        content_for_agent = f"exit_code=0\n{str(result.result)}"
-                    else:
-                        content_for_agent = str(result.result)
-                    tool_msg = {
-                        "role": "tool",
-                        "tool_call_id": result.tool_id,
-                        "content": content_for_agent
-                    }
-                    self.chat_manager.messages.append(tool_msg)
-                    # Log tool result
-                    self.chat_manager.log_message(tool_msg)
-                else:
-                    # Tool failed
-                    error_msg = result.error or result.result
-                    tool_msg = {
-                        "role": "tool",
-                        "tool_call_id": result.tool_id,
-                        "content": f"exit_code=1\n{error_msg}"
-                    }
-                    self.chat_manager.messages.append(tool_msg)
-                    # Log tool result
-                    self.chat_manager.log_message(tool_msg)
-
-            # Mid-loop compaction: compact older completed tool blocks
-            # after all parallel results are appended (safe — only compacts completed blocks)
-            self.chat_manager.compact_tool_results(skip_token_update=True)
-
-            # Update context tokens with current run's effective tools
-            tools_for_mode = self._get_effective_tools(
-                allowed_tools=getattr(self, "_current_allowed_tools", None),
-                allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
-            )
-            self.chat_manager._update_context_tokens(tools_for_mode)
-
-            # Pre-send guard: ensure context fits before next LLM call
-            self.chat_manager.ensure_context_fits(console=self.console)
-
-            return end_loop
-        finally:
-            # Restore console output
-            self._parallel_context['console'] = self.console
-
-    def _boundary_prompt(self, path_str):
-        """Prompt the user to grant filesystem access for a path outside boundaries.
-
-        Called after a tool returns a boundary error. If the user grants access,
-        the caller retries the tool with the boundary lifted.
-
-        Args:
-            path_str: The path that triggered the boundary violation.
-
-        Returns:
-            True if user granted access, False if denied.
-        """
-        if self.is_sub_agent:
-            return False
-
-        console = self._get_console()
-        if console is None:
-            return False
-
-        from ui.tool_confirmation import ToolConfirmationPanel
-        panel = ToolConfirmationPanel(
-            'Grant filesystem access',
-            reason=f'Agent requested access outside project boundary: {path_str}',
-            is_edit_tool=False
-        )
-        action, _ = panel.run()
-
-        if action == "accept":
-            console.print("[yellow]Full filesystem access granted[/yellow]\n")
-            return True
-        return False
-
-    def _process_single_tool_call(self, tool_call, thinking_indicator):
-        """Process a single tool call.
-
-        Args:
-            tool_call: Tool call dict from LLM
-            thinking_indicator: Optional ThinkingIndicator instance
-
-        Returns:
-            Tuple of (should_exit, tool_result)
-            - should_exit: True if should exit orchestration loop
-            - tool_result: Result string, or None if already appended, False if skipped
-        """
-        tool_id = tool_call["id"]
-        function_name = tool_call["function"]["name"]
-
-        # Parse arguments
-        try:
-            args_str = tool_call["function"]["arguments"]
-            if args_str is None:
-                return False, "Error: Tool arguments are missing."
-            arguments = json.loads(args_str)
-        except (json.JSONDecodeError, TypeError):
-            return False, "Error: Invalid JSON arguments."
-
-        # Create SubAgentPanel for sub_agent tool calls
-        panel_to_use = self.panel_updater
-        if function_name == "sub_agent":
-            query = arguments.get("query", "")
-            panel_to_use = SubAgentPanel(query, self.console)
-
-        # Execute via tool registry
-        from tools.helpers.base import ToolRegistry, build_context
-
-        tool = ToolRegistry.get(function_name)
-        if tool:
-            # Reset TTL for plugin-tier tools when they are actually called
-            if ToolRegistry.is_plugin_active(function_name):
-                ToolRegistry.touch_plugin(function_name)
-            try:
-                context = build_context(
-                    repo_root=self.repo_root,
-                    console=self.console,
-                    gitignore_spec=self.gitignore_spec,
-                    debug_mode=self.debug_mode,
-                    chat_manager=self.chat_manager,
-                    rg_exe_path=self.rg_exe_path,
-                    panel_updater=panel_to_use,
-                    vault_root=vault_root_str()
-                )
-                # Determine terminal policy for thinking indicator management
-                from tools.helpers.base import get_terminal_policy, TERMINAL_YIELD
-                policy = get_terminal_policy(function_name)
-
-                # Check if tool requires approval
-                if tool.requires_approval:
-                    # For edit_file: validate path then request approval
-                    if function_name == "edit_file":
-                        edit_path = arguments.get("path", "")
-                        if not edit_path:
-                            return False, "Error: path is required for edit_file."
-
-                        # Normal edit: generate preview and request approval
-                        result = tool.execute(arguments, context)
-
-                        # Display preview
-                        console = self._get_console()
-                        if console:
-                            preview, is_valid = resolve_edit_preview(result)
-                            if is_valid:
-                                approved_result, should_exit = handle_edit_approval(
-                                    preview, arguments.get('path', ''), arguments,
-                                    console, thinking_indicator,
-                                    self.chat_manager.approve_mode,
-                                    lambda: self.chat_manager.cycle_approve_mode(),
-                                    self.repo_root, self.gitignore_spec,
-                                    vault_root_str)
-                                if should_exit:
-                                    return True, approved_result
-                                result = approved_result
-                        return False, str(result)
-                    elif function_name == "execute_command":
-                        console = self._get_console()
-                        command = arguments.get('command', '')
-                        result, should_exit, command_executed = handle_command_approval(
-                            command, arguments, tool, context, console,
-                            thinking_indicator, self.chat_manager.approve_mode,
-                            self.debug_mode,
-                            cron_job_id=self.cron_job_id,
-                            cron_allowlist=self.cron_allowlist,
-                            cron_interactive=self.cron_interactive)
-                        if should_exit:
-                            return True, result
-
-                        # Display execute_command output when command actually ran
-                        if command_executed:
-                            label = build_tool_label(function_name, arguments)
-                            label_text = f"[grey]{label}[/grey]"
-                            if not self.panel_updater:
-                                console.print(label_text, highlight=False)
-                                console.file.flush()
-                            display_tool_feedback(label, result, console, indent=self.is_sub_agent, panel_updater=self.panel_updater)
-                        return False, result
-                    else:
-                        # Other tools with requires_approval can be handled here in the future
-                        result = tool.execute(arguments, context)
-                else:
-                    # No approval required - execute normally
-                    # Handle thinking indicator based on tool's terminal policy
-                    if policy == TERMINAL_YIELD and thinking_indicator:
-                        thinking_indicator.pause()
-                        # Force print to clear the status line
-                        temp_console = self._get_console()
-                        temp_console.print()
-                        temp_console.file.flush()
-                    
-                    result = tool.execute(arguments, context)
-                    
-                    # Resume thinking indicator for yield policy
-                    if policy == TERMINAL_YIELD and thinking_indicator:
-                        thinking_indicator.resume()
-
-                # Boundary escalation: if the tool result is a path boundary
-                # violation, prompt the user to grant session-wide access.
-                result_str = str(result)
-                if is_boundary_error(result_str):
-                    path_arg = arguments.get("path", arguments.get("path_str", ""))
-                    if not path_arg:
-                        path_arg = extract_boundary_path(result_str)
-                    granted = self._boundary_prompt(path_arg)
-                    if granted:
-                        set_full_filesystem_access(True)
-                        # Retry with the boundary now lifted
-                        result = tool.execute(arguments, context)
-                        result_str = str(result)
-
-                # Display result for registry tools
-                # Skip display for tools that take over the terminal (they handle their own display)
-                if policy != TERMINAL_YIELD:
-                    console = self._get_console()
-                    if console:
-                        # Build label with arguments for better display
-                        label = build_tool_label(function_name, arguments)
-
-                        # For task list tools: only show the task list, no label duplication
-                        if function_name in ("create_task_list", "complete_task", "show_task_list"):
-                            # Extract and format task list directly
-                            exit_code = extract_exit_code(result)
-                            if exit_code == 0 or exit_code is None:
-                                rendered = result
-                                if rendered.startswith("exit_code="):
-                                    rendered = "\n".join(rendered.splitlines()[1:])
-                                _print_or_append(rendered.strip(), console, self.panel_updater, markup=True)
-                            else:
-                                first_two = "\n".join(result.splitlines()[:2]).strip()
-                                _print_or_append(first_two or result.strip(), console, self.panel_updater, markup=False)
-                            if not self.panel_updater:
-                                console.print()
-                        else:
-                            # Print label first (like parallel mode)
-                            label_text = f"[grey]{label}[/grey]" if not function_name.startswith("web search") else f"[bold #5F9EA0]{label}[/bold #5F9EA0]"
-                            if not self.panel_updater:
-                                console.print(label_text, highlight=False)
-                                console.file.flush()
-
-                            # Then display feedback
-                            display_tool_feedback(label, result, console, indent=self.is_sub_agent, panel_updater=self.panel_updater)
-
-                return False, result_str
-            except Exception as e:
-                # If thinking_indicator was paused (TERMINAL_YIELD) and tool
-                # raised, resume it so the spinner reappears for the next iteration
-                if policy == TERMINAL_YIELD and thinking_indicator:
-                    thinking_indicator.resume()
-                return False, f"Error executing tool '{function_name}': {str(e)}"
-
-        return False, f"Error: Unknown tool '{function_name}'."
-
-def agentic_answer(chat_manager, user_input, console, repo_root, rg_exe_path, debug_mode, thinking_indicator=None):
-    """Main agent loop using OpenAI-style function calling.
-
-    This is a convenience wrapper that creates an AgenticOrchestrator
-    and runs it with the provided parameters.
-
-    Args:
-        chat_manager: ChatManager instance
-        user_input: User's input message
-        console: Rich console for output
-        repo_root: Path to repository root
-        rg_exe_path: Path to rg.exe
-        debug_mode: Whether to show debug output
-        thinking_indicator: Optional ThinkingIndicator instance
-    """
-    orchestrator = AgenticOrchestrator(
-        chat_manager=chat_manager,
-        repo_root=repo_root,
-        rg_exe_path=rg_exe_path,
-        console=console,
-        debug_mode=debug_mode,
-    )
-    orchestrator.run(user_input, thinking_indicator)