cecli-dev 1.0.0rc5__tar.gz → 1.0.0rc7__tar.gz

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.0rc5
+Version: 1.0.0rc7
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/benchmark/README.md

@@ -26,6 +26,13 @@ without any human review or supervision! The LLM could generate dangerous python
 that harms your system, like this: `import os; os.system("sudo rm -rf /")`.
 Running inside a docker container helps limit the damage that could be done.
 
+The current harness (`benchmark.py`) organizes the exercises as "Cats": each
+exercise carries `cat.yaml` metadata, enabling per-test selection and
+deterministic subsets (e.g. `--hash-re '^0'`) for spot-checking models. The
+canonical exercises source is
+[ErichBSchulz/cecli-cats](https://github.com/ErichBSchulz/cecli-cats), a
+Cats-formatted conversion of the polyglot benchmark.
+
 ## Usage
 
 There are 3 main tasks involved in benchmarking:
@@ -41,8 +48,8 @@ There are 3 main tasks involved in benchmarking:
 These steps only need to be done once.
 
 ```
-ORG=Aider-AI
-REPO=aider
+ORG=cecli-dev
+REPO=cecli
 # Clone the main repo
 git clone https://github.com/$ORG/$REPO.git
 
@@ -50,8 +57,9 @@ git clone https://github.com/$ORG/$REPO.git
 cd $REPO
 mkdir tmp.benchmarks
 
-# Clone the repo with the exercises
-git clone https://github.com/$ORG/polyglot-benchmark tmp.benchmarks/polyglot-benchmark
+# Clone the canonical exercises source for the Cats harness
+git clone https://github.com/ErichBSchulz/cecli-cats tmp.benchmarks/cecli-cats
+
 
 # Build the docker container
 ./benchmark/docker_build.sh
@@ -69,10 +77,10 @@ Launch the docker container and run the benchmark inside it:
 ./benchmark/docker.sh
 
 # Run the benchmark:
-./benchmark/benchmark.py a-helpful-name-for-this-run --model gpt-3.5-turbo --edit-format whole --threads 10 --exercises-dir polyglot-benchmark
+./benchmark/benchmark.py a-helpful-name-for-this-run --model gpt-3.5-turbo --edit-format whole --threads 10 --exercises-dir cecli-cats
 
 # Or with OpenRouter models (requires OPENROUTER_API_KEY environment variable):
-./benchmark/benchmark.py openrouter-run --model openrouter/deepseek/deepseek-r1:free --edit-format whole --threads 10 --exercises-dir polyglot-benchmark
+./benchmark/benchmark.py openrouter-run --model openrouter/deepseek/deepseek-r1:free --edit-format whole --threads 10 --exercises-dir cecli-cats
 ```
 
 The above will create a folder
@@ -156,6 +164,7 @@ Note the roadmap priorities:
 
 ## Limitations
 
+- `benchmark_classic.py` is deprecated (it predates the async Coder API).
 - These scripts are not intended for use by typical `cecli` end users.
 - Some of the old (?deprecated) tools are written as `bash` scripts, so it will be hard to use
   them on Windows.

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.100.11.dev"
+__version__ = "0.100.14.dev"
 safe_version = __version__
 
 try:

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0rc5'
-__version_tuple__ = version_tuple = (1, 0, 0, 'rc5')
+__version__ = version = '1.0.0rc7'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc7')
 
-__commit_id__ = commit_id = 'g5575d3301'
+__commit_id__ = commit_id = 'g7153f3816'

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/args.py

@@ -598,6 +598,12 @@ def get_parser(default_config_files, git_root):
         default=True,
         help="Enable/disable streaming responses (default: True)",
     )
+    group.add_argument(
+        "--spinner",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable the spinner while waiting for LLM responses (default: True)",
+    )
     group.add_argument(
         "--user-input-color",
         default="#00cc00",

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/coders/agent_coder.py

@@ -315,6 +315,25 @@ class AgentCoder(Coder):
                 call_result = await litellm.experimental_mcp_client.call_openai_tool(
                     session=session, openai_tool=tool_call_dict
                 )
+            except Exception as e:
+                if server.is_session_expired_error(e):
+                    try:
+                        session = await server.reconnect()
+                        call_result = await litellm.experimental_mcp_client.call_openai_tool(
+                            session=session, openai_tool=tool_call_dict
+                        )
+                    except Exception as retry_exc:
+                        self.io.tool_warning(
+                            f"Executing {tool_name} on {server.name} failed after reconnect:\n"
+                            f"Error: {retry_exc}"
+                        )
+                        return f"Error executing tool call {tool_name}: {retry_exc}"
+                else:
+                    self.io.tool_warning(
+                        f"Executing {tool_name} on {server.name} failed:\nError: {e}"
+                    )
+                    return f"Error executing tool call {tool_name}: {e}"
+            try:
                 content_parts = []
                 if call_result.content:
                     for item in call_result.content:

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/coders/base_coder.py

@@ -221,6 +221,7 @@ class Coder(metaclass=UsageMeta):
     message_tokens_sent = 0
     message_tokens_received = 0
     message_cached_tokens = 0
+    message_cost_deferred = None
     add_cache_headers = False
     cache_warming_thread = None
     num_cache_warming_pings = 0
@@ -1497,6 +1498,10 @@ class Coder(metaclass=UsageMeta):
                         self.show_announcements()
                     self.suppress_announcements_for_next_prompt = True
 
+                    if self.message_cost_deferred and not self.io.spinner_active:
+                        self.io.tool_output(self.message_cost_deferred)
+                        self.message_cost_deferred = None
+
                     await self.io.recreate_input()
                     await self.io.input_task
                     user_message = self.io.input_task.result()
@@ -1645,6 +1650,10 @@ class Coder(metaclass=UsageMeta):
                         self.show_announcements()
                     self.suppress_announcements_for_next_prompt = True
 
+                    if self.message_cost_deferred and not self.io.spinner_active:
+                        self.io.tool_output(self.message_cost_deferred)
+                        self.message_cost_deferred = None
+
                     # Stop spinner before showing announcements or getting input
                     self.io.stop_spinner()
                     self.copy_context()
@@ -2512,7 +2521,11 @@ class Coder(metaclass=UsageMeta):
             if not self.tui:
                 spinner_text += f" • ${self.format_cost(self.total_cost)} session"
 
-            self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
+            if self.io.spinner_active:
+                self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
+            else:
+                self.message_cost_deferred = spinner_text
+
             if self.stream:
                 self.mdstream = True
             else:
@@ -2635,6 +2648,10 @@ class Coder(metaclass=UsageMeta):
 
             # Ensure any waiting spinner is stopped
             self.io.start_spinner("Processing Answer...", coder_uuid=getattr(self, "uuid", None))
+
+            if not self.io.spinner_active:
+                self.partial_response_content = self.get_multi_response_content_in_progress(True)
+
             self.remove_reasoning_content()
             self.multi_response_content = ""
 
@@ -2980,12 +2997,22 @@ class Coder(metaclass=UsageMeta):
                             continue
 
                         async def do_tool_call():
+                            nonlocal session
                             from litellm import experimental_mcp_client
 
-                            return await experimental_mcp_client.call_openai_tool(
-                                session=session,
-                                openai_tool=new_tool_call,
-                            )
+                            try:
+                                return await experimental_mcp_client.call_openai_tool(
+                                    session=session,
+                                    openai_tool=new_tool_call,
+                                )
+                            except Exception as e:
+                                if server.is_session_expired_error(e):
+                                    session = await server.reconnect()
+                                    return await experimental_mcp_client.call_openai_tool(
+                                        session=session,
+                                        openai_tool=new_tool_call,
+                                    )
+                                raise
 
                         call_result, interrupted = await coroutines.interruptible(
                             do_tool_call(), self.interrupt_event

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/helpers/hashpos/hashpos.py

@@ -101,15 +101,14 @@ class HashPos:
         packed = (line_hash << 20) | (idx_bits << 6) | occ_bits
 
         res = ""
-        for _ in range(4):
-            res += self.B1024[packed % 1024]
-            packed //= 1024
+        for i in range(3, -1, -1):
+            res += self.B1024[(packed >> (10 * i)) & 0x3FF]
         return res
 
     def unpack_public_id(self, public_id: str) -> tuple[int, int, int]:
         packed = 0
         for i, char in enumerate(public_id):
-            packed |= self.B1024.index(char) << (10 * i)
+            packed |= self.B1024.index(char) << (10 * (3 - i))
 
         occ_bits = packed & 0x3F
         idx_bits = (packed >> 6) & 0x3FFF

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/helpers/orchestration/environment.py

@@ -478,7 +478,8 @@ def build_orchestration_context_block(agent_config: dict[str, Any]) -> str | Non
         return None
 
     return """<context name="orchestration" from="agent">
-The `Orchestrate` tool lets you coordinate chains of sub agents and tools with Python code in a limited, secure sandbox across multiple turns.
+The `Orchestrate` tool lets you batch multiple tool calls in a single step by writing Python code in a limited, secure sandbox.
+This is much more efficient than making individual tool calls for loop-heavy workflows.
 Variables and methods defined in a script are persisted in subsequent turns.
 As such, results from previous calls can be reused and helper methods can be defined to enhance ease of use within the environment.
 
@@ -495,6 +496,10 @@ As such, results from previous calls can be reused and helper methods can be def
 | `Agent.peek(result)` | Inspect a tool result's structure and leaf content — returns a string; use `print(Agent.peek(result))` to see it |
 | `Agent.get_value(result, path, default?)` | Safely access nested values in tool results using dot-notation (e.g. `"result.0.content"`)  |
 
+| `Agent.get_content_id(path, text)` | Resolve a content ID from `@L{num}` or line text for EditFile |
+| `Agent.resolve_regions(path, regions)` | Batch-resolve text patterns to content IDs. Use `start_line_hint` / `end_line_hint` in region spec entries for disambiguation (supports `@L<num>`, `@A{{regex}}`, `@B{{regex}}` — same hint syntax as ReadFile). Ambiguous patterns raise immediately. The returned `AgentRegion` has `.get_start(name)`, `.get_end(name)`, `.names()`, `.get(name)` |
+| `Agent.edit_region(path, edits)` | Thin wrapper around EditFile that accepts pre-resolved region dicts `{"start": content_id, "end": content_id}`. Use with `Agent.resolve_regions()` and `regions.get(name)` |
+
 | `await Agent.sleep(seconds)` | Pause execution (0-120s max) |
 
 | `gather(**named_tasks)` | Run tasks concurrently; returns an iterable with `.key` / `["key"]` access |
@@ -524,8 +529,8 @@ All other module imports will fail.
 ```python
 tool = Agent.get_tool("delegate")
 tool_outputs = await gather(
-    a=tool.call(prompt="A", async=False),
-    b=tool.call(prompt="B", async=False),
+    a=tool.call(prompt="A"),
+    b=tool.call(prompt="B"),
 )
 print(tool_outputs.a)              # attribute access
 print(tool_outputs["b"])           # key access
@@ -547,6 +552,51 @@ to extract specific fields by dot-path::
 Result list items are plain dicts — use item['content'] / item.get('content')
 and item['_'] / item.get('_') to access data and metadata respectively.
 
+### Creating New Files
+
+Use `ResourceManager` to create an empty file, then `EditFile` to write
+initial content (use `@000` for start/end on empty files)::
+
+    rm = Agent.get_tool("ResourceManager")
+    edit = Agent.get_tool("EditFile")
+
+    await rm.call(create=["path/to/new_file.py"])
+    await edit.call(edits=[{
+        "file_path": "path/to/new_file.py",
+        "operation": "replace",
+        "start_line": "@000",
+        "end_line": "@000",
+        "text": "def greet(name):\n    return f\"Hello, {name}!\"\n",
+    }])
+
+After creation, use `resolve_regions` and `edit_region` for targeted edits.
+
+### Editing with Regions
+
+Use `Agent.resolve_regions()` to convert text patterns into content IDs, then `Agent.edit_region()` to apply edits using the resolved IDs.
+
+#### Step 1 —  resolve region boundaries once
+
+```python
+regions = Agent.resolve_regions("foo.py", [
+    {"name": "my_func", "start": "def my_func", "end": "return result"},
+    {"name": "init",    "start": "def __init__", "end": "self.x = x"},
+])
+```
+
+#### Step 2 — Use `regions.get(name)` with `Agent.edit_region()` (recommended shorthand)
+
+```python
+await Agent.edit_region(
+    file_path="foo.py",
+    edits=[
+        {"region": regions.get("my_func"), "text": "def my_func():\n    return 42"},
+    ],
+)
+```
+
+#### Alternative: Call `EditFile` directly with `regions.get_start()` / `regions.get_end()`
+
 ### Gotchas
 
 - **Types**: compare with `typeof(x) == dict` or `isinstance(x, dict)` — NOT `typeof(x) == "dict"`

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/interruptible_input.py

@@ -17,7 +17,14 @@ class InterruptibleInput:
             raise RuntimeError("InterruptibleInput is Unix-only (requires selectable stdin).")
 
         self._cancel = threading.Event()
-        self._sel = selectors.DefaultSelector()
+
+        # The default selector (Kqueue on macOS, Epoll on Linux) cannot
+        # handle pipe-based stdin (e.g. when running inside Emacs comint-mode).
+        # Fall back to SelectSelector which works with any fd that supports select().
+        if not sys.stdin.isatty():
+            self._sel = selectors.SelectSelector()
+        else:
+            self._sel = selectors.DefaultSelector()
 
         # self-pipe to wake up select() from interrupt()
         self._r, self._w = os.pipe()

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/io.py

@@ -368,6 +368,7 @@ class InputOutput:
         notifications_command=None,
         notification_bell=False,
         verbose=False,
+        show_spinner=True,
     ):
         self.console = Console()
         self.pretty = pretty
@@ -498,6 +499,7 @@ class InputOutput:
             fancy_input = False
 
         # Spinner state
+        self.spinner_active = show_spinner
         self.spinner_running = False
         self.spinner_text = ""
         self.last_spinner_text = ""
@@ -506,7 +508,7 @@ class InputOutput:
         self.spinner_last_frame_index = 0
         self.unicode_palette = "░█"
         self.fallback_spinner = None
-        self.fallback_spinner_enabled = True
+        self.fallback_spinner_enabled = show_spinner
 
         self.interruptible_input = None
 
@@ -568,7 +570,12 @@ class InputOutput:
         """Start the spinner."""
         self.stop_spinner()
 
+        if not self.spinner_active:
+            return
+
         if self.prompt_session:
+            if not self.fallback_spinner_enabled:
+                return
             self.spinner_running = True
             self.spinner_text = text
             self.spinner_frame_index = self.spinner_last_frame_index
@@ -581,9 +588,15 @@ class InputOutput:
             self.fallback_spinner.step()
 
     def update_spinner(self, text):
+        if not self.spinner_active:
+            return
+
         self.spinner_text = text
 
     def update_spinner_suffix(self, text=None):
+        if not self.spinner_active:
+            return
+
         if text:
             self.spinner_suffix = f" • {text[:16].strip()}"
         else:

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/main.py

@@ -36,6 +36,20 @@ from dotenv import load_dotenv
 if sys.platform == "win32":
     if hasattr(asyncio, "set_event_loop_policy"):
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+elif sys.platform == "darwin":
+    # The default KqueueSelector cannot handle pipe-based stdin
+    # (e.g. when running inside Emacs comint-mode). Fall back to
+    # SelectSelector which works with any file descriptor that supports select().
+    import selectors
+
+    if not sys.stdin.isatty():
+        _original_event_loop_policy = asyncio.DefaultEventLoopPolicy
+
+        class _SelectSelectorPolicy(asyncio.DefaultEventLoopPolicy):
+            def new_event_loop(self):
+                return asyncio.SelectorEventLoop(selectors.SelectSelector())
+
+        asyncio.set_event_loop_policy(_SelectSelectorPolicy())
 
 from .dump import dump  # noqa
 
@@ -704,6 +718,7 @@ async def main_async(
             notifications_command=args.notifications_command,
             notification_bell=args.notification_bell,
             verbose=args.verbose,
+            show_spinner=args.spinner,
         )
 
     validate_tui_args(args)

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/mcp/manager.py

@@ -160,17 +160,46 @@ class McpServerManager:
             self._server_tools[server.name] = get_local_tool_schemas()
             return True
 
-        try:
-            session = await server.connect()
-            tools = await experimental_mcp_client.load_mcp_tools(session=session, format="openai")
-            self._server_tools[server.name] = tools
-            self._connected_servers.add(server)
-            self._log_verbose(f"Connected to MCP server: {name}")
-            return True
-        except (Exception, asyncio.CancelledError) as e:
-            if server.name != "unnamed-server":
-                self._log_error(f"Failed to connect to MCP server {name}: {e}")
-            return False
+        # Retry with exponential backoff for transient connection failures.
+        # Note: This also fixes a latent bug where asyncio.CancelledError was
+        # silently caught and treated as a connection failure. CancelledError is
+        # now re-raised to properly propagate cancellation.
+        # When io is None (e.g., during from_servers before IO is assigned),
+        # _log_warning and _log_error silently return — retries still happen
+        # but with no user-visible feedback. This is intentional.
+        max_retries = 3 if server.name != "unnamed-server" else 1
+        delay = 1.0
+        backoff = 2.0
+        max_delay = 30.0
+
+        for attempt in range(1, max_retries + 1):
+            try:
+                session = await server.connect()
+                tools = await experimental_mcp_client.load_mcp_tools(
+                    session=session, format="openai"
+                )
+                self._server_tools[server.name] = tools
+                self._connected_servers.add(server)
+                self._log_verbose(f"Connected to MCP server: {name}")
+                return True
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                if attempt < max_retries and server.name != "unnamed-server":
+                    self._log_warning(
+                        f"Connection attempt {attempt} failed for {name}, "
+                        f"retrying in {delay}s... ({e})"
+                    )
+
+                    await asyncio.sleep(delay)
+                    delay = min(delay * backoff, max_delay)
+                else:
+                    if server.name != "unnamed-server":
+                        self._log_error(
+                            f"Failed to connect to MCP server {name} "
+                            f"after {max_retries} attempts: {e}"
+                        )
+                    return False
 
     async def disconnect_server(self, name: str) -> bool:
         """
@@ -281,11 +310,10 @@ class McpServerManager:
                 success = await mcp_manager.add_server(server, connect=False)
                 return (server, success)
 
-            for _attempt in range(max_retries):
-                success = await mcp_manager.add_server(server, connect=True)
-                if success:
-                    return (server, True)
-            return (server, False)
+            # connect_server now has built-in retry logic, so we only need
+            # a single call here — no separate retry loop needed.
+            success = await mcp_manager.add_server(server, connect=True)
+            return (server, success)
 
         tasks = []
         for server in servers:

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/mcp/server.py

@@ -130,6 +130,48 @@ class McpServer:
             finally:
                 self.session = None
 
+    async def reconnect(self):
+        """Disconnect and reconnect, establishing a fresh session.
+
+        Used when the server has invalidated the current session (e.g., after
+        a server restart), as indicated by an HTTP 404 response per the MCP
+        protocol specification.
+
+        Returns:
+            ClientSession: The new active session
+        """
+        if self.io:
+            self.io.tool_warning(f"MCP session expired for {self.name}, reconnecting...")
+        await self.disconnect()
+        self.exit_stack = AsyncExitStack()
+        return await self.connect()
+
+    @staticmethod
+    def is_session_expired_error(exc):
+        """Check if an exception indicates an expired MCP session (HTTP 404).
+
+        Per the MCP specification, when a server terminates a session it
+        responds with HTTP 404 Not Found.  The client MUST then start a new
+        session by sending a new InitializeRequest.
+
+        Args:
+            exc: The exception to check
+
+        Returns:
+            bool: True if the error indicates a 404 session expiry
+        """
+        import httpx
+
+        if isinstance(exc, httpx.HTTPStatusError) and exc.response.status_code == 404:
+            return True
+
+        # Some transports wrap the status in the exception message
+        exc_str = str(exc).lower()
+        if "404" in exc_str and ("session" in exc_str or "not found" in exc_str):
+            return True
+
+        return False
+
 
 class HttpBasedMcpServer(McpServer):
     """Base class for HTTP-based MCP servers (HTTP streaming and SSE)."""

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/repo.py

@@ -486,6 +486,7 @@ class GitRepo:
         commit_message = None
         for model in self.models:
             spinner_text = f"Generating commit message with {model.name}\n"
+
             self.io.start_spinner(spinner_text, update_last_text=False)
 
             if model.system_prompt_prefix:

{cecli_dev-1.0.0rc5 → cecli_dev-1.0.0rc7}/cecli/tools/grep.py

@@ -228,25 +228,18 @@ class Tool(BaseTool):
                                     "default": True,
                                     "description": "Whether to perform a case-insensitive search.",
                                 },
-                                "count": {
-                                    "type": "boolean",
-                                    "default": True,
-                                    "description": (
-                                        "Include match counts per file in the output summary."
-                                    ),
-                                },
                                 "context_before": {
                                     "type": "integer",
                                     "default": 2,
                                     "description": (
-                                        "Number of context lines to show before each match."
+                                        "Number of context lines to show before each match. Max 5"
                                     ),
                                 },
                                 "context_after": {
                                     "type": "integer",
                                     "default": 2,
                                     "description": (
-                                        "Number of context lines to show after each match."
+                                        "Number of context lines to show after each match. Max 5"
                                     ),
                                 },
                             },
@@ -362,8 +355,8 @@ class Tool(BaseTool):
             directory = search_op.get("directory", search_op.get("path", "."))
             use_regex = search_op.get("use_regex", False)
             case_insensitive = search_op.get("case_insensitive", True)
-            context_before = search_op.get("context_before", 2)
-            context_after = search_op.get("context_after", 2)
+            context_before = max(min(int(search_op.get("context_before", 2)), 5), 0)
+            context_after = max(min(int(search_op.get("context_after", 2)), 5), 0)
             count_enabled = search_op.get("count", True)
 
             op_result = {
@@ -502,7 +495,7 @@ class Tool(BaseTool):
                     MAX_MATCHES_PER_FILE = 10
                     MAX_FILES = 20
 
-                    truncated_files = []
+                    truncated_files = {}
                     total_matches = 0
                     total_files = 0
 
@@ -510,14 +503,21 @@ class Tool(BaseTool):
                         file_lines = pf["content"].splitlines()
                         # Find actual match lines (lines with `:LINE:` pattern)
                         filepath_escaped = re.escape(pf["path"])
-                        match_line_re = re.compile(r"^" + filepath_escaped + r":\d+:")
+                        match_line_re = re.compile(r"^" + filepath_escaped + r":(\d+):")
                         match_lines_found = [ln for ln in file_lines if match_line_re.match(ln)]
 
                         # Normalize path to be relative to repo root
                         pf["path"] = os.path.relpath(pf["path"], repo.root)
 
                         if len(match_lines_found) > MAX_MATCHES_PER_FILE:
-                            truncated_files.append(pf["path"])
+                            # Extract line numbers from excess matches (beyond first 10)
+                            extra_lines = match_lines_found[MAX_MATCHES_PER_FILE:]
+                            extra_line_nums = []
+                            for xline in extra_lines:
+                                xm = match_line_re.match(xline)
+                                if xm:
+                                    extra_line_nums.append(int(xm.group(1)))
+                            truncated_files[pf["path"]] = extra_line_nums
                             trimmed = "\n".join(match_lines_found[:MAX_MATCHES_PER_FILE])
                             pf["content"] = trimmed
                         total_matches += pf.get("count_from_pass", 0)
@@ -536,7 +536,7 @@ class Tool(BaseTool):
                         {
                             "file": pf["path"],
                             "match_count": pf.get("count_from_pass", 0),
-                            "truncated": pf["path"] in truncated_files,
+                            "additional_matched_lines": truncated_files.get(pf["path"], []),
                             "content": pf["content"],
                         }
                         for pf in parsed_files[:MAX_FILES]
@@ -573,7 +573,7 @@ class Tool(BaseTool):
         response = ToolResponse(cls.NORM_NAME, result_type=cls.RESULT_TYPE)
         for op_result in all_operation_results:
             files = op_result.get("files", [])
-            metadata = {k: v for k, v in op_result.items() if k != "files"}
+            metadata = op_result.copy()
 
             # Build a human-readable string summary as content
             pattern = op_result.get("pattern", "")
@@ -584,7 +584,7 @@ class Tool(BaseTool):
             else:
                 lines = [f"[{pattern}]"]
                 for f in files:
-                    truncated_mark = " (truncated)" if f.get("truncated") else ""
+                    truncated_mark = " (truncated)" if f.get("additional_matched_lines") else ""
                     lines.append(f"{f['file']}: {f['match_count']} match(es){truncated_mark}")
                 if op_result.get("has_more_files"):
                     lines.append(f"... ({op_result['total_files']} files total)")
@@ -616,7 +616,7 @@ class Tool(BaseTool):
             for i, search_op in enumerate(searches):
                 pattern = search_op.get("pattern", "")
                 file_pattern = search_op.get("file_glob", "*")
-                directory = search_op.get("directory", ".")
+                directory = search_op.get("directory", search_op.get("path", "."))
                 use_regex = search_op.get("use_regex", False)
                 case_insensitive = search_op.get("case_insensitive", True)
                 context_before = search_op.get("context_before", 2)