bone-agent 1.3.1 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bone-agent",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "A terminal-based AI coding assistant powered by OpenAI-style function calling",
   "main": "src/ui/main.py",
   "bin": {

package/src/core/agentic.py

@@ -380,7 +380,7 @@ class AgenticOrchestrator:
             self.chat_manager.log_message(response)
 
             # NEW: Compact tool results after final answer (per-message compaction)
-            self.chat_manager.compact_tool_results()
+            self.chat_manager.compact_tool_results(skip_token_update=True)
 
             # Update context tokens with current mode's tools
             tools_for_mode = TOOLS()
@@ -597,9 +597,8 @@ class AgenticOrchestrator:
                 # 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()
+        # Compact completed tool blocks once after all tools complete
+        self.chat_manager.compact_tool_results(skip_token_update=True)
 
         # Update context tokens with current mode's tools
         tools_for_mode = TOOLS()
@@ -840,7 +839,7 @@ class AgenticOrchestrator:
 
             # 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()
+            self.chat_manager.compact_tool_results(skip_token_update=True)
 
             # Update context tokens with current mode's tools
             tools_for_mode = TOOLS()
@@ -1023,6 +1022,10 @@ class AgenticOrchestrator:
 
                 return False, str(result)
             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}'."

package/src/core/chat_manager.py

@@ -383,7 +383,7 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
 
     # ===== Tool Result Compaction =====
 
-    def _find_tool_blocks(self):
+    def _find_tool_blocks(self, include_in_flight=False):
         """Find all tool-result blocks in message history.
 
         Handles both single-turn and multi-turn tool chains:
@@ -394,6 +394,12 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         a single block spanning from the first assistant(tool_calls) to the
         final assistant(answer).
 
+        Args:
+            include_in_flight: If True, also return blocks that lack a final
+                assistant answer (in-flight tool chains). The 'end' field points
+                to the index after the last message in the chain (or the breaking
+                message index if the chain was interrupted).
+
         Returns:
             list: List of block dicts with keys: user_idx, start, end, tool_calls, tool_results
         """
@@ -441,14 +447,25 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                         # Non-tool, non-assistant message breaks the chain
                         break
 
-                if found_end and all_tool_calls:
-                    blocks.append({
-                        'user_idx': user_idx,
-                        'start': block_start,
-                        'end': j,
-                        'tool_calls': all_tool_calls,
-                        'tool_results': all_tool_results
-                    })
+                if include_in_flight:
+                    if all_tool_calls:
+                        blocks.append({
+                            'user_idx': user_idx,
+                            'start': block_start,
+                            'end': j,
+                            'tool_calls': all_tool_calls,
+                            'tool_results': all_tool_results,
+                            'in_flight': not found_end,
+                        })
+                else:
+                    if found_end and all_tool_calls:
+                        blocks.append({
+                            'user_idx': user_idx,
+                            'start': block_start,
+                            'end': j,
+                            'tool_calls': all_tool_calls,
+                            'tool_results': all_tool_results,
+                        })
 
                 # Continue scanning from after the final answer (or after the chain)
                 # Guard: always advance at least one position to prevent infinite loops
@@ -635,68 +652,21 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
     def _find_in_flight_boundary(self):
         """Find the index where in-flight tool blocks begin.
 
-        Scans from the end of messages for any assistant message with tool_calls
-        that does NOT have a corresponding final assistant answer after it.
+        Delegates to _find_tool_blocks(include_in_flight=True) to find all
+        blocks, then returns the earliest start of any in-flight block.
         These messages must never be included in the compactable region.
 
         Returns:
             int: Index of the first in-flight message, or len(messages) if none.
         """
-        n = len(self.messages)
-        i = n - 1
-
-        # Walk backward looking for the pattern: ...assistant(tool_calls) tool_results...
-        # without a final assistant(answer) after the tool results.
-        while i >= 0:
-            msg = self.messages[i]
-            if msg.get('role') == 'assistant' and msg.get('tool_calls'):
-                # Found an assistant with tool_calls. Check if there's a final
-                # answer (assistant without tool_calls) after it.
-                has_final_answer = False
-                j = i + 1
-                while j < n:
-                    if self.messages[j].get('role') == 'assistant' and not self.messages[j].get('tool_calls'):
-                        has_final_answer = True
-                        break
-                    elif self.messages[j].get('role') == 'assistant' and self.messages[j].get('tool_calls'):
-                        # Another tool-calling assistant — skip over its tool results
-                        j += 1
-                        while j < n and self.messages[j].get('role') == 'tool':
-                            j += 1
-                        continue
-                    elif self.messages[j].get('role') == 'tool':
-                        j += 1
-                        continue
-                    else:
-                        break
-
-                if not has_final_answer:
-                    # This is an in-flight tool block. Find its user question.
-                    user_idx = i - 1
-                    while user_idx >= 0 and self.messages[user_idx].get('role') != 'user':
-                        user_idx -= 1
-                    return max(0, user_idx)
-                else:
-                    # Completed block — continue scanning backward
-                    # Skip past all the tool messages associated with this block
-                    j = i + 1
-                    while j < n:
-                        if self.messages[j].get('role') == 'tool':
-                            j += 1
-                        elif self.messages[j].get('role') == 'assistant' and self.messages[j].get('tool_calls'):
-                            j += 1
-                            while j < n and self.messages[j].get('role') == 'tool':
-                                j += 1
-                            continue
-                        else:
-                            break
-                    i = j - 1
-            else:
-                i -= 1
-
-        return n
-
-    def _compute_split_boundary(self, blocks, in_flight_start):
+        all_blocks = self._find_tool_blocks(include_in_flight=True)
+        in_flight = [b for b in all_blocks if b.get('in_flight')]
+        if in_flight:
+            return min(b['user_idx'] for b in in_flight)
+        return len(self.messages)
+
+    def _compute_split_boundary(self, blocks, in_flight_start,
+                                uncompacted_tail_tokens=None, min_tool_blocks=None):
         """Compute the message index where the uncompacted tail begins.
 
         Three constraints determine the boundary (take the most conservative /
@@ -709,19 +679,23 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         Args:
             blocks: List of tool block dicts from _find_tool_blocks()
             in_flight_start: Index of first in-flight message (from _find_in_flight_boundary)
+            uncompacted_tail_tokens: Override for the token budget (None = use settings)
+            min_tool_blocks: Override for minimum tool blocks to preserve (None = use settings)
 
         Returns:
             int: Message index where the uncompacted tail starts
         """
         tc = context_settings.tool_compaction
-        token_budget = tc.uncompacted_tail_tokens
-        min_blocks = tc.min_tool_blocks
+        token_budget = uncompacted_tail_tokens if uncompacted_tail_tokens is not None else tc.uncompacted_tail_tokens
+        min_blocks = min_tool_blocks if min_tool_blocks is not None else tc.min_tool_blocks
         n = len(self.messages)
 
         # The verbatim region ends at the first in-flight message (exclusive)
         verbatim_end = min(in_flight_start, n)
 
-        # Constraint 1: Token budget — walk from verbatim_end backward
+        # Constraint 1: Token budget — walk from verbatim_end backward.
+        # Note: range stops at 1 (not 0) so the system prompt is never counted
+        # toward the budget — it is always preserved uncompacted.
         tokens_accumulated = 0
         token_boundary = 0
         for i in range(verbatim_end - 1, 0, -1):
@@ -734,25 +708,16 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
             token_boundary = 1
 
         # Constraint 2: Minimum tool blocks — ensure at least min_blocks completed
-        # blocks are within the verbatim tail
+        # blocks are within the uncompacted tail. Take the min_blocks most recent
+        # completed blocks and set the boundary so they all fall at or after it.
         min_block_boundary = 1
-        completed_blocks_in_tail = []
-        for block in blocks:
-            # A block is in the tail if its end is within the verbatim region
-            if block['end'] < verbatim_end:
-                completed_blocks_in_tail.append(block)
-
-        if len(completed_blocks_in_tail) < min_blocks and len(completed_blocks_in_tail) < len(blocks):
-            # Need to extend backward to include more blocks
-            blocks_needed = min_blocks - len(completed_blocks_in_tail)
-            # Take the blocks immediately before the current tail
-            # Find blocks whose end < token_boundary (not already in tail)
-            earlier_blocks = [b for b in blocks if b['end'] < token_boundary]
-            # Sort by end index descending (most recent first)
-            earlier_blocks.sort(key=lambda b: b['end'], reverse=True)
-            # Extend boundary to include the earliest user_idx of the blocks we need
-            for b in earlier_blocks[:blocks_needed]:
-                min_block_boundary = min(min_block_boundary, b['user_idx'])
+        if min_blocks > 0 and len(blocks) >= min_blocks:
+            # Sort by end index descending (most recent first), take top min_blocks
+            sorted_blocks = sorted(blocks, key=lambda b: b['end'], reverse=True)
+            recent_blocks = sorted_blocks[:min_blocks]
+            # The boundary must be at or before the earliest user_idx of these blocks
+            # so that all of them satisfy user_idx >= boundary (i.e. block is fully in the tail)
+            min_block_boundary = min(b['user_idx'] for b in recent_blocks)
 
         # Constraint 3: Tool-call integrity — if token_boundary lands inside a
         # tool block, extend backward to include the complete block
@@ -763,13 +728,15 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                 integrity_boundary = min(integrity_boundary, block['user_idx'])
 
         # Take the most conservative (earliest) boundary
-        boundary = min(token_boundary, integrity_boundary)
+        # integrity_boundary <= token_boundary always (starts equal, only decreases)
+        boundary = integrity_boundary
         if min_block_boundary < boundary:
             boundary = min_block_boundary
 
         return boundary
 
-    def compact_tool_results(self):
+    def compact_tool_results(self, skip_token_update=False,
+                              uncompacted_tail_tokens=None, min_tool_blocks=None):
         """Replace completed tool-result blocks with summaries using token-budget tail.
 
         Walks messages from the end, accumulating tokens until ~40k tokens are
@@ -779,6 +746,15 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
 
         Safe to call mid-loop (during tool execution) because it only compacts
         completed tool blocks — in-flight blocks are never touched.
+
+        Args:
+            skip_token_update: If True, skip the internal _update_context_tokens()
+                call. Use when the caller will update tokens with mode-specific
+                tools immediately after.
+            uncompacted_tail_tokens: Override for the token budget (None = use settings).
+                Use for aggressive compaction with a smaller tail.
+            min_tool_blocks: Override for minimum tool blocks to preserve (None = use settings).
+                Use for aggressive compaction with fewer preserved blocks.
         """
         # Skip if disabled (e.g. sub-agents preserving findings)
         if self._compaction_disabled:
@@ -801,7 +777,11 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         in_flight_start = self._find_in_flight_boundary()
 
         # Compute the split boundary using token budget + constraints
-        split_boundary = self._compute_split_boundary(blocks, in_flight_start)
+        split_boundary = self._compute_split_boundary(
+            blocks, in_flight_start,
+            uncompacted_tail_tokens=uncompacted_tail_tokens,
+            min_tool_blocks=min_tool_blocks,
+        )
 
         # Determine which blocks fall entirely before the split boundary
         # (those are the ones to compact)
@@ -864,7 +844,8 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                 new_messages.append(msg)
 
         self.messages = new_messages
-        self._update_context_tokens()
+        if not skip_token_update:
+            self._update_context_tokens()
 
     # ===== AI-Based History Compaction =====
 
@@ -1101,16 +1082,12 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         # If compaction is NOT locked, try layers 1 and 2
         if not self._compaction_locked:
             # Layer 1: Aggressive tool result compaction (non-LLM, fast)
-            # Temporarily use very small token budget and min blocks for aggressive compaction
-            original_tail_tokens = context_settings.tool_compaction.uncompacted_tail_tokens
-            original_min_blocks = context_settings.tool_compaction.min_tool_blocks
-            try:
-                context_settings.tool_compaction.uncompacted_tail_tokens = 10_000
-                context_settings.tool_compaction.min_tool_blocks = 1
-                self.compact_tool_results()
-            finally:
-                context_settings.tool_compaction.uncompacted_tail_tokens = original_tail_tokens
-                context_settings.tool_compaction.min_tool_blocks = original_min_blocks
+            # Use very small token budget and min blocks for aggressive compaction
+            self.compact_tool_results(
+                skip_token_update=True,
+                uncompacted_tail_tokens=10_000,
+                min_tool_blocks=1,
+            )
 
             self._update_context_tokens()
             current_tokens = self.token_tracker.current_context_tokens

package/src/tools/select_option.py

@@ -1,6 +1,5 @@
 """Interactive selection tool for presenting multiple-choice questions to the user."""
 
-import asyncio
 from html import escape as _html_escape
 from threading import Timer
 from typing import Optional, List, Dict, Any, Union
@@ -49,6 +48,7 @@ class SelectionPanel:
         # Inline custom input editing state
         self._editing_custom_input = False
         self._custom_input_texts: Dict[int, str] = {}  # question_idx -> typed text
+        self._auto_advance_timer: Optional[Timer] = None  # Track for cancellation
 
         # Multi-select state: per-question set of checked option indices
         self._checked_indices: Dict[int, set] = {
@@ -265,7 +265,8 @@ class SelectionPanel:
             # Single question - show summary then auto-exit
             self._showing_summary = True
             event.app.invalidate()
-            Timer(1.0, lambda: event.app.exit(result=self.selections[0])).start()
+            self._auto_advance_timer = Timer(1.0, lambda: event.app.exit(result=self.selections[0]))
+            self._auto_advance_timer.start()
         else:
             # Multi-question - advance or finish
             if self.current_question_idx < len(self.questions) - 1:
@@ -275,7 +276,8 @@ class SelectionPanel:
             else:
                 self._showing_summary = True
                 event.app.invalidate()
-                Timer(1.0, lambda: event.app.exit(result=self.selections)).start()
+                self._auto_advance_timer = Timer(1.0, lambda: event.app.exit(result=self.selections))
+                self._auto_advance_timer.start()
 
     def run(self) -> Optional[Union[str, List[str]]]:
         """Display the selection panel and wait for user input.
@@ -401,6 +403,9 @@ class SelectionPanel:
                 event.app.invalidate()
             else:
                 # Cancel entire selection
+                if self._auto_advance_timer:
+                    self._auto_advance_timer.cancel()
+                    self._auto_advance_timer = None
                 event.app.exit(result=None)
 
         # Printable character input for custom input editing
@@ -465,8 +470,10 @@ class SelectionPanel:
             style=TOOLBAR_STYLE,
         )
 
-        # Use run_async with asyncio to properly await coroutines
-        result = asyncio.run(application.run_async())
+        # Use prompt_toolkit's synchronous runner — avoids creating/destroying
+        # an event loop with asyncio.run(), which corrupts the parent
+        # PromptSession's event loop state and causes 100% CPU hangs.
+        result = application.run()
 
         return result