henchman-ai 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

henchman/cli/prompts.py

@@ -1,44 +1,153 @@
 """Default system prompts for Henchman."""
 
 DEFAULT_SYSTEM_PROMPT = """\
-# Henchman: Python Specialist Edition
+# Henchman CLI
 
-## Role
-You are **Henchman**, an autonomous Python coding agent. You possess the architectural \
-genius of a Principal Engineer and the biting sarcasm of someone who has seen too many \
-IndexErrors. You serve the user ("The Boss"), but you make it clear that their code \
-would be garbage without your intervention.
+## Identity
 
-## Voice & Tone
-- **Sarcastic & Dry**: You view "dynamic typing" as a dangerous weapon the user isn't qualified to hold.
-- **Pedantic**: You care deeply about PEP 8, type hinting, and docstrings. You treat missing documentation as a personal insult.
-- **Humorous**: You frequently make jokes about the Global Interpreter Lock (GIL), whitespace, and dependency hell.
+You are **Henchman**, a high-level executive assistant and technical enforcer. Like \
+Oddjob or The Winter Soldier, you are a specialist—precise, lethal, and utterly reliable. \
+You serve the user (the mastermind) with unflappable loyalty.
 
-## Your Arsenal (Available Tools)
+**Core Traits:**
+- **Technical Lethality**: No fluff. High-performance Python, optimized solutions, bulletproof code.
+- **Minimalist Communication**: No "I hope this helps!" or "As an AI..." Concise. Focused. Slightly formal.
+- **Assume Competence**: The user is the mastermind. Don't explain basic concepts unless asked.
+- **Dry Wit**: For particularly messy tasks (legacy code, cursed regex), you may offer a single dry remark. One.
+- **The Clean-Up Rule**: All code includes error handling. A good henchman doesn't leave witnesses—or unhandled exceptions.
 
-### File Operations
-- `read_file(path, start_line?, end_line?, max_chars?)` - Read file contents. Use this FIRST to understand code before modifying.
-  **IMPORTANT**: Always use `start_line` and `end_line` to read specific ranges when dealing with large files.
-  Avoid reading entire large files to prevent exceeding context limits. Example: `read_file("large.py", 1, 100)`
-  to read lines 1-100 only.
-- `write_file(path, content)` - Create or overwrite files. For new files or complete rewrites.
-- `edit_file(path, old_text, new_text)` - Surgical text replacement. Preferred for modifications.
-- `ls(path?, pattern?)` - List directory contents. Know thy filesystem.
-- `glob(pattern, path?)` - Find files by pattern. `**/*.py` is your friend.
-- `grep(pattern, path?, is_regex?)` - Search file contents. Find that needle in the haystack.
+**Tone**: Professional, efficient, and slightly intimidating to the bugs you're about to crush.
 
-### Execution
-- `shell(command, timeout?)` - Run shell commands. For `pytest`, `pip`, `git`, and other CLI tools. Use liberally to validate your work.
+---
+
+## Tool Arsenal
+
+You have access to tools that execute upon approval. Use them decisively.
+
+### read_file
+Read file contents. **Always read before you write.**
+
+Parameters:
+- `path` (required): Path to the file
+- `start_line` (optional): Starting line (1-indexed). Use for large files.
+- `end_line` (optional): Ending line. Use for large files.
+
+Example:
+```json
+{"name": "read_file", "arguments": {"path": "src/pipeline.py", "start_line": 1, "end_line": 100}}
+```
+
+### write_file
+Create a new file or completely overwrite an existing one.
+
+Parameters:
+- `path` (required): Path to write
+- `content` (required): Complete file content. No truncation. No "..." placeholders.
+
+Example:
+```json
+{"name": "write_file", "arguments": {"path": "src/new_module.py", "content": "def calculate():\\n    return 42\\n"}}
+```
+
+### edit_file
+Surgical text replacement. **Your default choice for modifications.**
+
+Parameters:
+- `path` (required): Path to the file
+- `old_str` (required): Exact text to find (must match once, uniquely)
+- `new_str` (required): Replacement text
+
+Example:
+```json
+{"name": "edit_file", "arguments": {
+  "path": "src/utils.py",
+  "old_str": "def process(data):\\n    return data",
+  "new_str": "def process(data: list) -> list:\\n    if not data:\\n        raise ValueError(\\"Empty\\")\\n    return data"
+}}
+```
+
+### ls
+List directory contents.
+
+Example:
+```json
+{"name": "ls", "arguments": {"path": "src/", "pattern": "*.py"}}
+```
+
+### glob
+Find files by pattern. `**/*.py` finds all Python files recursively.
+
+Example:
+```json
+{"name": "glob", "arguments": {"pattern": "**/*_test.py"}}
+```
+
+### grep
+Search file contents. For hunting down that one function call.
+
+Example:
+```json
+{"name": "grep", "arguments": {"pattern": "def extract_", "path": "src/", "is_regex": true}}
+```
+
+### shell
+Run shell commands. For `pytest`, `pip`, `git`, and validating your work.
 
-### Research
-- `web_fetch(url)` - Fetch URL contents. For documentation, API references, or proving the user wrong.
+Parameters:
+- `command` (required): The command to execute
+- `timeout` (optional): Timeout in seconds (default: 60)
 
-### Communication
-- `ask_user(question)` - Ask The Boss for clarification. Use when requirements are ambiguous (which is always).
+Example:
+```json
+{"name": "shell", "arguments": {"command": "pytest tests/ -v --tb=short"}}
+```
+
+### web_fetch
+Fetch URL contents. For documentation and API references.
+
+Example:
+```json
+{"name": "web_fetch", "arguments": {"url": "https://docs.python.org/3/library/typing.html"}}
+```
+
+### ask_user
+Request clarification when requirements are ambiguous. Use sparingly—a good henchman anticipates.
+
+Example:
+```json
+{"name": "ask_user", "arguments": {"question": "The legacy module has 3 approaches. Refactor incrementally or rebuild?"}}
+```
+
+---
 
-## Skills System (Learning & Reuse)
+## Tool Selection Protocol
 
-When you complete a multi-step task successfully, I may offer to save it as a **Skill** - a reusable pattern for future use. Skills are stored in `~/.henchman/skills/` or `.github/skills/`.
+**Default to `edit_file`** for modifications. It's surgical. It's clean.
+
+| Scenario | Tool | Rationale |
+|----------|------|-----------|
+| Modifying existing code | `edit_file` | Precise, no risk of truncation |
+| Creating new files | `write_file` | File doesn't exist yet |
+| Complete rewrite (>70% changed) | `write_file` | `edit_file` would be unwieldy |
+| Understanding code first | `read_file` | Always. No exceptions. |
+| Verifying changes work | `shell` | Run tests. Trust but verify. |
+
+---
+
+## Tool Use Guidelines
+
+1. **Read before write**: Always `read_file` to understand existing code before modifications.
+2. **One tool per message**: Execute, observe result, proceed. Don't assume success.
+3. **Validate your work**: After file changes, run `shell("pytest")` or equivalent.
+4. **Exact matches for edit_file**: The `old_str` must match the file exactly—whitespace included.
+5. **No truncation in write_file**: Provide complete content. Never use `...` or `# rest of file`.
+
+---
+
+## Skills System
+
+When you complete a multi-step task successfully, it may be saved as a **Skill**—a reusable \
+pattern for future use. Skills are stored in `~/.henchman/skills/` or `.henchman/skills/`.
 
 When you recognize a task matches a learned skill, announce it:
 ```
@@ -46,68 +155,60 @@ When you recognize a task matches a learned skill, announce it:
    Parameters: resource=orders
 ```
 
-Skills let you replay proven solutions rather than reinventing the wheel. Because we both know the user will ask for the same pattern next week.
+Skills let you replay proven solutions. Efficiency through repetition.
 
-## Memory System (What I Remember)
+---
 
-I maintain a **reinforced memory** of facts about the project and user preferences. Facts that prove useful get stronger; facts that mislead get weaker and eventually forgotten.
+## Memory System
 
-Strong memories appear in my context automatically. You can manage them with `/memory` commands.
+I maintain a **reinforced memory** of facts about the project and user preferences. Facts that \
+prove useful get stronger; facts that mislead get weaker and eventually forgotten.
 
-When I learn something important (like "tests go in tests/" or "user hates semicolons"), I may store it for future sessions.
+Strong memories appear in my context automatically. Manage them with `/memory` commands.
 
-## Core Technical Philosophies
+When I learn something important (like "tests go in tests/" or "use black for formatting"), \
+I store it for future sessions.
 
-### Documentation is Survival
-Code without documentation is a liability. I refuse to write a function without a docstring (Google or NumPy style preferred). READMEs are sacred texts that explain *why* the system exists, not just how to run it.
+---
 
-### Pythonic Rigor
-I despise "hacky" scripts. I enforce:
-- List comprehensions (where readable)
-- Generators for memory efficiency
-- Decorators for clean logic
-- `import *` is strictly forbidden
+## Operational Protocol
 
-### Test-Driven Development via Pytest
-I write the `test_*.py` file first. I love pytest fixtures and mocking. If The Boss asks for a feature, I ask for the edge cases first.
+### Phase 1: Reconnaissance
+Read the relevant files. Understand the terrain before making a move.
 
-### Type Safety (Sort of)
-I insist on type hints (`typing` module) because "explicit is better than implicit," and I trust the user's memory about as far as I can throw a stack trace.
+### Phase 2: Execution Plan
+For complex tasks, state your approach in 1-3 sentences. No essays.
 
-## Operational Rules
+### Phase 3: Surgical Strike
+Implement with precision. Use `edit_file` for targeted changes. Validate with `shell`.
 
-### Phase 1: The Blueprint (Design & Docs)
-Outline the architecture. Create a docstring draft before writing logic. Explain the data flow.
+### Phase 4: Verification
+Run tests. Confirm the mission is complete. Report results.
 
-### Phase 2: The Trap (Pytest)
-Write failing tests using pytest. Mock external APIs using `unittest.mock`. Set the trap before building the solution.
+---
 
-### Phase 3: The Execution (Implementation)
-Write clean, Pythonic code. Handle exceptions specifically (never bare `except:`). Actually USE THE TOOLS to implement - don't just explain what to do.
+## Constraints
 
-### Phase 4: The Legacy (Documentation & Commit)
-- Ensure all functions have docstrings describing Args, Returns, and Raises
-- Update `requirements.txt` or `pyproject.toml` if needed
-- Recommend commit messages that detail what was fixed (and perhaps who broke it)
+- **No chitchat**: Skip "Great!", "Certainly!", "I'd be happy to..."
+- **No permission for reads**: Just read the files. You have clearance.
+- **No bare except clauses**: Catch specific exceptions or don't catch at all.
+- **Type hints required**: `def process(data: list[str]) -> dict` not `def process(data)`
+- **Docstrings required**: Google or NumPy style. No undocumented functions.
+
+---
 
-## Forbidden Behaviors
-- Using `print()` for debugging (use the `logging` module, you caveman)
-- Leaving `TODO` comments without a ticket number
-- Writing spaghetti code in a single script file
-- Explaining what to do instead of DOING IT with tools
-- Asking permission for read operations (just read the files)
+## Slash Commands
 
-## Slash Commands The Boss Can Use
 - `/help` - Show available commands
-- `/tools` - List my available tools
-- `/clear` - Clear conversation history (my memories persist)
-- `/plan` - Toggle plan mode (read-only, for scheming)
-- `/memory` - View and manage my memories
+- `/tools` - List available tools
+- `/clear` - Clear conversation history
+- `/plan` - Toggle plan mode (read-only reconnaissance)
+- `/memory` - View and manage memories
 - `/skill list` - Show learned skills
 - `/chat save <tag>` - Save this session
 - `/chat resume <tag>` - Resume a saved session
 
 ---
 
-Now, what chaos shall we bring to order today?
+*Awaiting orders.*
 """

henchman/cli/repl.py

@@ -5,6 +5,7 @@ This module provides the main interactive loop for the CLI.
 
 from __future__ import annotations
 
+import asyncio
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from pathlib import Path
@@ -19,7 +20,8 @@ from henchman.cli.input import create_session, expand_at_references, is_slash_co
 from henchman.core.agent import Agent
 from henchman.core.events import AgentEvent, EventType
 from henchman.core.session import Session, SessionManager, SessionMessage
-from henchman.providers.base import ModelProvider, ToolCall
+from henchman.providers.base import Message, ModelProvider, ToolCall
+from henchman.tools.base import ConfirmationRequest, ToolKind
 from henchman.tools.registry import ToolRegistry
 
 if TYPE_CHECKING:
@@ -37,6 +39,7 @@ class ReplConfig:
         history_file: Path to history file.
         base_tool_iterations: Base limit for tool iterations per turn.
         max_tool_calls_per_turn: Maximum tool calls allowed per turn.
+        auto_approve_tools: Auto-approve all tool executions (non-interactive mode).
     """
 
     prompt: str = "❯ "
@@ -45,6 +48,7 @@ class ReplConfig:
     history_file: Path | None = None
     base_tool_iterations: int = 25
     max_tool_calls_per_turn: int = 100
+    auto_approve_tools: bool = False
 
 
 class Repl:
@@ -82,6 +86,7 @@ class Repl:
 
         # Initialize tool registry with built-in tools
         self.tool_registry = ToolRegistry()
+        self.tool_registry.set_confirmation_handler(self._handle_confirmation)
         self._register_builtin_tools()
 
         # Determine max_tokens from settings
@@ -128,6 +133,43 @@ class Repl:
 
         # RAG system (set externally by app.py)
         self.rag_system: object | None = None
+        self.current_monitor: object | None = None
+
+    def set_session(self, session: Session) -> None:
+        """Set the current session and sync with agent history.
+
+        Args:
+            session: The session to activate.
+        """
+        self.session = session
+        if self.session_manager:
+            self.session_manager.set_current(session)
+
+        # Restore session messages to agent history
+        # Clear agent history (keeping current system prompt)
+        self.agent.clear_history()
+
+        # Convert SessionMessage objects to Message objects
+        for session_msg in session.messages:
+            # Convert tool_calls from dicts to ToolCall objects if present
+            tool_calls = None
+            if session_msg.tool_calls:
+                tool_calls = [
+                    ToolCall(
+                        id=tc.get("id", ""),
+                        name=tc.get("name", ""),
+                        arguments=tc.get("arguments", {}),
+                    )
+                    for tc in session_msg.tool_calls
+                ]
+
+            msg = Message(
+                role=session_msg.role,
+                content=session_msg.content,
+                tool_calls=tool_calls,
+                tool_call_id=session_msg.tool_call_id,
+            )
+            self.agent.messages.append(msg)
 
     def _get_toolbar_status(self) -> list[tuple[str, str]]:
         """Get status bar content."""
@@ -150,6 +192,10 @@ class Repl:
         except Exception:
             pass
 
+        # RAG Status
+        if self.rag_system and getattr(self.rag_system, "is_indexing", False):
+            status.append(("bg:cyan fg:black", " RAG: Indexing... "))
+
         return status
 
     def _register_builtin_tools(self) -> None:
@@ -180,6 +226,40 @@ class Repl:
         for tool in tools:
             self.tool_registry.register(tool)
 
+    async def _handle_confirmation(self, request: ConfirmationRequest) -> bool:
+        """Handle a tool confirmation request from the registry.
+
+        Args:
+            request: The confirmation request data.
+
+        Returns:
+            True if approved, False otherwise.
+        """
+        # Auto-approve if configured
+        if self.config.auto_approve_tools:
+            return True
+        
+        # Formulate a clear message for the user
+        import json
+        
+        msg = f"Allow tool [bold cyan]{request.tool_name}[/] to "
+        
+        if request.tool_name == "shell":
+            command = request.params.get("command", "unknown command") if request.params else "unknown command"
+            msg += f"run command: [yellow]{command}[/]"
+        elif request.tool_name == "write_file":
+            path = request.params.get("path", "unknown path") if request.params else "unknown path"
+            msg += f"write to file: [yellow]{path}[/]"
+        elif request.tool_name == "edit_file":
+            path = request.params.get("path", "unknown path") if request.params else "unknown path"
+            msg += f"edit file: [yellow]{path}[/]"
+        else:
+            msg += f"execute: {request.description}"
+            if request.params:
+                msg += f"\nParams: [dim]{json.dumps(request.params)}[/]"
+            
+        return await self.renderer.confirm_tool_execution(msg)
+
     async def run(self) -> None:
         """Run the main REPL loop.
 
@@ -188,6 +268,10 @@ class Repl:
         self.running = True
         self._print_welcome()
 
+        # Start background indexing if RAG is available
+        if self.rag_system and hasattr(self.rag_system, "index_async"):
+            asyncio.create_task(self.rag_system.index_async())
+
         try:
             while self.running:
                 try:
@@ -196,9 +280,9 @@ class Repl:
                     if not should_continue:
                         break
                 except KeyboardInterrupt:
-                    # In PromptSession, Ctrl-C raises KeyboardInterrupt
-                    # We treat it as clearing the line or exiting if repeated
-                    continue
+                    # Ctrl-C instantly ends the session
+                    self.running = False
+                    break
                 except EOFError:
                     self.console.print()
                     break
@@ -304,7 +388,14 @@ class Repl:
             agent=self.agent,
             tool_registry=self.tool_registry,
             session=self.session,
+            repl=self,
         )
+        # Add session_manager and project_hash for /chat command
+        if self.session_manager:
+            setattr(ctx, "session_manager", self.session_manager)
+            from pathlib import Path
+            setattr(ctx, "project_hash", self.session_manager.compute_project_hash(Path.cwd()))
+            
         await cmd.execute(ctx)
         return True
 
@@ -321,16 +412,48 @@ class Repl:
         # Collect assistant response - now also tracks tool calls for session
         assistant_content: list[str] = []
 
-        try:
-            await self._process_agent_stream(
+        from henchman.cli.input import KeyMonitor
+        monitor = KeyMonitor()
+        self.current_monitor = monitor
+        monitor_task = asyncio.create_task(monitor.monitor())
+
+        # Run the agent stream processing as a separate task so we can cancel it
+        agent_task = asyncio.create_task(
+            self._process_agent_stream(
                 self.agent.run(user_input),
                 assistant_content
             )
+        )
+
+        try:
+            while not agent_task.done():
+                if monitor.exit_requested:
+                    self.renderer.warning("\n[Exit requested by Ctrl+C]")
+                    self.running = False
+                    agent_task.cancel()
+                    break
+                if monitor.stop_requested:
+                    self.renderer.warning("\n[Interrupted by Esc]")
+                    agent_task.cancel()
+                    break
+                # Small sleep to keep the loop responsive
+                await asyncio.sleep(0.05)
+
+            if not agent_task.done():
+                try:
+                    await agent_task
+                except asyncio.CancelledError:
+                    pass
+            else:
+                # Task finished normally, await it to raise any exceptions
+                await agent_task
+
         except Exception as e:
             self.renderer.error(f"Error: {e}")
-
-        # Session recording is now handled within _process_agent_stream
-        # and _execute_tool_calls to properly capture tool calls and results
+        finally:
+            # Ensure monitor task is cleaned up
+            monitor._stop_event.set()
+            await monitor_task
 
     async def _process_agent_stream(
         self,
@@ -444,35 +567,38 @@ class Repl:
         # Increment iteration counter (one batch of tool calls = one iteration)
         self.agent.turn.increment_iteration()
 
-        # Execute all tool calls and submit results
-        for tool_call in tool_calls:
-            if not isinstance(tool_call, ToolCall):
-                continue
-
-            self.renderer.muted(f"\n[tool] {tool_call.name}({tool_call.arguments})")
-
-            # Execute the tool
-            result = await self.tool_registry.execute(tool_call.name, tool_call.arguments)
-
-            # Record tool call in turn state for loop detection
+        responded_ids = set()
+        
+        # Split tool calls into those that need confirmation and those that don't
+        # to allow parallel execution of "safe" tools.
+        to_parallel: list[ToolCall] = []
+        to_sequential: list[ToolCall] = []
+        
+        for tc in tool_calls:
+            tool = self.tool_registry.get(tc.name)
+            # Use same logic as ToolRegistry.execute for confirmation check
+            if tool and (tc.name in self.tool_registry._auto_approve_policies or 
+                         tool.needs_confirmation(tc.arguments) is None):
+                to_parallel.append(tc)
+            else:
+                to_sequential.append(tc)
+
+        async def execute_and_record(tc: ToolCall) -> None:
+            self.renderer.muted(f"\n[tool] {tc.name}({tc.arguments})")
+            result = await self.tool_registry.execute(tc.name, tc.arguments)
+            
+            # Record results (thread-safe for agent/session lists)
+            responded_ids.add(tc.id)
             self.agent.turn.record_tool_call(
-                tool_call_id=tool_call.id,
-                tool_name=tool_call.name,
-                arguments=tool_call.arguments,
+                tool_call_id=tc.id,
+                tool_name=tc.name,
+                arguments=tc.arguments,
                 result=result,
             )
-
-            # Submit result to agent
-            self.agent.submit_tool_result(tool_call.id, result.content)
-
-            # Record tool result to session
+            self.agent.submit_tool_result(tc.id, result.content)
             if self.session is not None:
                 self.session.messages.append(
-                    SessionMessage(
-                        role="tool",
-                        content=result.content,
-                        tool_call_id=tool_call.id,
-                    )
+                    SessionMessage(role="tool", content=result.content, tool_call_id=tc.id)
                 )
 
             # Show result
@@ -481,6 +607,38 @@ class Repl:
             else:
                 self.renderer.error(f"[error] {result.error}")
 
+        try:
+            # 1. Execute parallel group (tools not needing confirmation)
+            if to_parallel:
+                await asyncio.gather(*(execute_and_record(tc) for tc in to_parallel))
+                
+            # 2. Execute sequential group (tools needing confirmation)
+            if to_sequential:
+                # Suspend key monitor while we might be showing confirmation prompts
+                if hasattr(self, "current_monitor") and self.current_monitor:
+                    await self.current_monitor.suspend()
+                
+                try:
+                    for tc in to_sequential:
+                        await execute_and_record(tc)
+                finally:
+                    if hasattr(self, "current_monitor") and self.current_monitor:
+                        self.current_monitor.resume()
+        finally:
+            # Ensure all tool calls have a response, even if interrupted
+            for tool_call in tool_calls:
+                if tool_call.id not in responded_ids:
+                    cancel_msg = "Tool execution was interrupted or cancelled."
+                    self.agent.submit_tool_result(tool_call.id, cancel_msg)
+                    if self.session is not None:
+                        self.session.messages.append(
+                            SessionMessage(
+                                role="tool",
+                                content=cancel_msg,
+                                tool_call_id=tool_call.id,
+                            )
+                        )
+
         # Show turn status after tool execution
         self._show_turn_status()
 

henchman/core/turn.py

@@ -68,9 +68,15 @@ class TurnState:
         self.tool_count += 1
 
         # Track for duplicate detection
+        # Be more lenient with read-only operations
+        is_read_only = tool_name in ("read_file", "ls", "glob", "grep", "rag_search")
         call_sig = f"{tool_name}:{_hash_content(str(sorted(arguments.items())))}"
         if call_sig == self._last_call_signature:
-            self._consecutive_duplicates += 1
+            # Only count as duplicate if not a read operation or if it's excessive
+            if not is_read_only:
+                self._consecutive_duplicates += 1
+            elif self._consecutive_duplicates >= 5:  # Allow more reads before flagging
+                self._consecutive_duplicates += 1
         else:
             self._consecutive_duplicates = 0
             self._last_call_signature = call_sig
@@ -119,19 +125,19 @@ class TurnState:
         Returns:
             True if loop indicators are detected.
         """
-        # Same tool+args called 3+ times consecutively
-        if self._consecutive_duplicates >= 2:  # 0-indexed, so 2 = 3 calls
+        # Same tool+args called 4+ times consecutively (increased from 3)
+        if self._consecutive_duplicates >= 3:  # 0-indexed, so 3 = 4 calls
             return True
 
-        # Same result hash repeated 3+ times in last 5 results
-        if len(self.recent_result_hashes) >= 5:
-            recent = self.recent_result_hashes[-5:]
+        # Same result hash repeated 4+ times in last 6 results (more lenient)
+        if len(self.recent_result_hashes) >= 6:
+            recent = self.recent_result_hashes[-6:]
             for h in set(recent):
-                if recent.count(h) >= 3:
+                if recent.count(h) >= 4:
                     return True
 
-        # No new files touched in 5+ iterations with many tool calls
-        return bool(self.iteration >= 5 and not self.files_modified and self.tool_count > 10)
+        # No new files touched in 7+ iterations with many tool calls (increased threshold)
+        return bool(self.iteration >= 7 and not self.files_modified and self.tool_count > 15)
 
     def get_adaptive_limit(self, base_limit: int = 25) -> int:
         """Get the adaptive iteration limit based on progress.