bone-agent 1.3.0

package/src/core/agentic.py

@@ -0,0 +1,1054 @@
+"""Agent tool-calling loop."""
+
+import json
+import logging
+import time
+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
+
+
+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 _is_memory_file(self, path: str) -> bool:
+        """Check if path targets a memory file (auto-approved).
+
+        Auto-approve scope (restricted to known memory paths):
+        - {repo_root}/.bone/agents.md — project memory
+        - ~/.bone/user_memory.md — global user memory
+        - Any file under {repo_root}/.bone/ — project memory directory
+
+        Args:
+            path: File path from tool arguments.
+
+        Returns:
+            True if the file should be auto-approved as a memory file.
+        """
+        p = Path(path).resolve()
+        repo_root = Path(self.repo_root).resolve()
+        # Known memory paths
+        if p == Path.home() / ".bone" / "user_memory.md":
+            return True
+        # Any file under {repo_root}/.bone/ (future memory files)
+        bone_dir = repo_root / ".bone"
+        if p.is_relative_to(bone_dir):
+            return True
+        return False
+
+    def _execute_memory_edit(self, arguments) -> bool:
+        """Apply a memory file edit synchronously with one retry on failure.
+
+        Args:
+            arguments: Tool arguments dict (path, search, replace, etc.)
+        """
+        from tools.edit import _execute_edit_file
+
+        kwargs = dict(
+            path=arguments.get("path"),
+            search=arguments.get("search"),
+            replace=arguments.get("replace"),
+            repo_root=self.repo_root,
+            console=None,  # silent — no output in chat
+            gitignore_spec=self.gitignore_spec,
+            context_lines=arguments.get("context_lines", 3),
+            vault_root=vault_root_str(),
+        )
+        try:
+            _execute_edit_file(**kwargs)
+            return True
+        except Exception as e:
+            logger.warning("Memory edit failed (retrying in 0.5s): %s", e)
+            time.sleep(0.5)
+            try:
+                _execute_edit_file(**kwargs)
+                logger.info("Memory edit retry succeeded after initial failure.")
+                return True
+            except Exception as e2:
+                logger.error("Memory edit failed after retry: %s", e2)
+                return False
+
+    def run(self, user_input, thinking_indicator=None, allowed_tools=None):
+        """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)
+        """
+        # 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.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)
+            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)
+                if should_exit:
+                    return
+
+    def _get_llm_response(self, allowed_tools=None):
+        """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)
+
+        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:
+            # Validate that allowed_tools is not empty
+            if not allowed_tools:
+                self.console.print("[red]Error: allowed_tools is empty[/red]")
+                return None
+            # TOOLS is a function, call it to get the list
+            tools = [tool for tool in TOOLS() if tool["function"]["name"] in allowed_tools]
+            # Log filtered tools for debugging
+            if self.debug_mode:
+                tool_names = [t["function"]["name"] for t in tools]
+                self.console.print(f"[dim]Available tools: {tool_names}[/dim]")
+        else:
+            tools = TOOLS()
+
+        # 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
+                    self.console.print(f"[red]LLM Error: {e}[/red]")
+                    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()
+
+            # Update context tokens with current mode's tools
+            tools_for_mode = TOOLS()
+            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):
+        """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
+
+        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 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.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 allowed_tools whitelist (if provided)
+            # Plugin-tier tools bypass the whitelist — they are already vetted
+            # by the manifest and activated on-demand via search_plugins.
+            if allowed_tools and function_name not in allowed_tools and not ToolRegistry.is_plugin_active(function_name):
+                # 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)
+
+                # Mid-loop compaction: compact older completed tool blocks
+                # after each tool result is appended (safe — only compacts completed blocks)
+                self.chat_manager.compact_tool_results()
+
+        # Update context tokens with current mode's tools
+        tools_for_mode = TOOLS()
+        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.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()
+
+            # Update context tokens with current mode's tools
+            tools_for_mode = TOOLS()
+            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 _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.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: check memory file auto-approve first
+                    if function_name == "edit_file":
+                        edit_path = arguments.get("path", "")
+                        if not edit_path:
+                            return False, "Error: path is required for edit_file."
+
+                        # Memory file: auto-approve, fire-and-forget
+                        if self._is_memory_file(edit_path):
+                            # Generate preview to validate the edit (reuses existing logic)
+                            result = tool.execute(arguments, context)
+                            preview, is_valid = resolve_edit_preview(result)
+                            if is_valid:
+                                ok = self._execute_memory_edit(arguments)
+                                if self.debug_mode:
+                                    console = self._get_console()
+                                    if console:
+                                        console.print(f"[dim]Memory edit auto-approved: {edit_path}[/dim]")
+                                return False, "Memory saved." if ok else f"Memory edit failed: {edit_path}"
+                            return False, str(result)
+
+                        # 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()
+
+                # 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, str(result)
+            except Exception as e:
+                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)
+
+