drydock-cli 2.7.10__tar.gz → 2.7.16__tar.gz

drydock_cli-2.7.16/.auto_release.lock

@@ -0,0 +1 @@
+238585

drydock_cli-2.7.16/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"facd51cc-fa47-4911-afc8-14485ae9caf3","pid":711220,"acquiredAt":1775966390914}

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.10
+Version: 2.7.16
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/admiral/detectors_proposed.py

@@ -43,11 +43,18 @@ def _tool_result_errored(m: LLMMessage) -> bool:
     """Heuristic: does this tool-role message look like a failure?
 
     Conservative — we only want high-precision firing on actual errors.
-    Scanned the first 800 chars of the result content.
+    Scanned the first 200 chars of the result content (tightened from 800
+    to avoid false positives when matched file content contains words like
+    "error" or "failed" — grep results starting with "matches:" are always
+    successful).
     """
     if m.role is not Role.tool:
         return False
-    content = str(getattr(m, "content", "") or "")[:800].lower()
+    raw = str(getattr(m, "content", "") or "")
+    # Successful grep results start with "matches:" — never treat as error.
+    if raw.lstrip().startswith("matches:"):
+        return False
+    content = raw[:200].lower()
     return any(marker in content for marker in _TOOL_ERROR_MARKERS)
 
 

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/core/agent_loop.py

@@ -1703,10 +1703,10 @@ class AgentLoop:
         Runs every turn but is a no-op when nothing exceeds the caps.
         Truncation is in-place and idempotent.
         """
-        KEEP_RECENT = 6              # last N tool messages stay full
-        SOFT_CAP_BYTES = 800         # tool result longer than this gets shrunk
-        HEAD_BYTES = 400             # bytes kept from the head
-        TAIL_BYTES = 100             # bytes kept from the tail
+        KEEP_RECENT = 4              # last N tool messages stay full
+        SOFT_CAP_BYTES = 500         # tool result longer than this gets shrunk
+        HEAD_BYTES = 200             # bytes kept from the head
+        TAIL_BYTES = 60              # bytes kept from the tail
 
         if len(self.messages) < KEEP_RECENT + 4:
             return
@@ -2334,7 +2334,16 @@ class AgentLoop:
                 if replace_last_tool:
                     msg.content = f"[SYSTEM: {text}]"
                 else:
-                    msg.content = (msg.content or "") + f"\n\n[SYSTEM: {text}]"
+                    content = msg.content or ""
+                    # Cap at 2 accumulated system notes per message; replace the
+                    # last one when the limit is exceeded so repeated admiral
+                    # interventions don't unboundedly bloat the context.
+                    _SYS_PREFIX = "\n\n[SYSTEM: "
+                    if content.count(_SYS_PREFIX) >= 2:
+                        last_idx = content.rfind(_SYS_PREFIX)
+                        msg.content = content[:last_idx] + _SYS_PREFIX + text + "]"
+                    else:
+                        msg.content = content + _SYS_PREFIX + text + "]"
                 return
 
         # Second try: append to last user message

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/core/llm/format.py

@@ -367,6 +367,32 @@ class APIToolFormatHandler:
                 continue
 
             args_model, _ = tool_class._get_tool_args_results()
+
+            # Detect when model copied truncated-history args (our truncation
+            # code replaces large tool-call args with {_truncated, _original_bytes,
+            # path}).  Return a clear advisory instead of a pydantic traceback so
+            # the model re-does the call with real arguments rather than retrying
+            # the truncated form.
+            if (isinstance(parsed_call.raw_args, dict)
+                    and parsed_call.raw_args.get("_truncated")):
+                path_hint = (parsed_call.raw_args.get("path")
+                             or parsed_call.raw_args.get("file_path")
+                             or "")
+                hint = f" Re-read `{path_hint}` with read_file first." if path_hint else ""
+                failed_calls.append(
+                    FailedToolCall(
+                        tool_name=parsed_call.tool_name,
+                        call_id=parsed_call.call_id,
+                        error=(
+                            f"{parsed_call.tool_name}: your call used a "
+                            f"truncated history entry as a template (it contained "
+                            f"'_truncated'/'_original_bytes' instead of real "
+                            f"arguments).{hint} Provide the full required arguments."
+                        ),
+                    )
+                )
+                continue
+
             try:
                 validated_args = args_model.model_validate(parsed_call.raw_args)
                 resolved_calls.append(
@@ -378,11 +404,25 @@ class APIToolFormatHandler:
                     )
                 )
             except ValidationError as e:
+                error_str = str(e)
+                if (
+                    parsed_call.tool_name == "write_file"
+                    and "path" in error_str
+                    and "Field required" in error_str
+                ):
+                    error_msg = (
+                        "write_file: missing required `path` parameter. "
+                        "You must pass BOTH `path` AND `content` as separate arguments. "
+                        'Fix: write_file(path="your/file.py", content="..."). '
+                        "Do NOT omit `path`."
+                    )
+                else:
+                    error_msg = f"Invalid arguments: {e}"
                 failed_calls.append(
                     FailedToolCall(
                         tool_name=parsed_call.tool_name,
                         call_id=parsed_call.call_id,
-                        error=f"Invalid arguments: {e}",
+                        error=error_msg,
                     )
                 )
 

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/core/tools/builtins/bash.py

@@ -404,13 +404,38 @@ class Bash(
         self, *, command: str, stdout: str, stderr: str, returncode: int
     ) -> BashResult:
         if returncode != 0:
-            error_msg = f"Command failed: {command!r}\n"
-            error_msg += f"Return code: {returncode}"
-            if stderr:
-                error_msg += f"\nStderr: {stderr}"
-            if stdout:
-                error_msg += f"\nStdout: {stdout}"
-            raise ToolError(error_msg.strip())
+            # ADVISORY ONLY — never raise ToolError for non-zero exit codes.
+            # Raising blocks the model: it gets <tool_error> with no useful
+            # output, doesn't know if exit 1 means "no matches" (grep) or a
+            # real failure, and retries identically.  Same pattern as the
+            # timeout handler above.  Include a clear exit-code annotation so
+            # the model can reason about what happened.
+            # See feedback_no_tool_errors_for_loop_detection.md.
+            annotation = f"[Exit code {returncode}]"
+            if returncode < 0:
+                # Negative returncode means killed by a Unix signal.
+                try:
+                    sig_name = signal.Signals(-returncode).name
+                except ValueError:
+                    sig_name = f"signal {-returncode}"
+                annotation += (
+                    f" — process killed by {sig_name}."
+                    " If this command starts a server or long-running process,"
+                    " background it with `command &` and verify ports with `ss -tlnp`."
+                )
+            elif not stdout and not stderr:
+                annotation += " (no output)"
+                if returncode == 1:
+                    annotation += (
+                        " — for grep/find, exit code 1 means no matches found"
+                    )
+            annotated_stdout = (stdout + "\n" + annotation).strip() if stdout else annotation
+            return BashResult(
+                command=command,
+                stdout=annotated_stdout,
+                stderr=stderr,
+                returncode=returncode,
+            )
 
         return BashResult(
             command=command, stdout=stdout, stderr=stderr, returncode=returncode
@@ -445,7 +470,39 @@ class Bash(
                 )
             except TimeoutError:
                 await _kill_process_tree(proc)
-                raise self._build_timeout_error(args.command, timeout)
+                # ADVISORY ONLY — never raise ToolError on timeout; raising
+                # causes the model to retry the exact same command (loop).
+                # Track repeat timeouts per command and escalate the hint.
+                # See feedback_no_tool_errors_for_loop_detection.md.
+                timeout_state = self.state.__dict__.setdefault(
+                    "_bash_timeout_history", {}
+                )
+                count = timeout_state.get(args.command, 0) + 1
+                timeout_state[args.command] = count
+                if count == 1:
+                    hint = (
+                        "The command was killed. If it starts a server or "
+                        "long-running process, background it with `command &` "
+                        "instead of running it in the foreground."
+                    )
+                else:
+                    hint = (
+                        f"[TIMEOUT #{count}] You have timed out {count}x on "
+                        f"this exact command. Running it again will produce the "
+                        f"same result. STOP retrying. Background servers with "
+                        f"`&`, check existing listeners with `ss -tlnp`, or fix "
+                        f"the underlying cause before re-running."
+                    )
+                yield BashResult(
+                    command=args.command,
+                    stdout=(
+                        f"Command timed out after {timeout}s: {args.command!r}\n"
+                        f"{hint}"
+                    ),
+                    stderr="",
+                    returncode=124,
+                )
+                return
 
             encoding = _get_subprocess_encoding()
             stdout = (

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/core/tools/builtins/read_file.py

@@ -237,12 +237,45 @@ class ReadFile(
                 f"Security error: Cannot read path '{file_path}' outside of the project directory '{Path.cwd()}'."
             )
         except FileNotFoundError:
-            raise ToolError(f"File not found at: {file_path}")
+            raise ToolError(self._not_found_msg(file_path))
 
         if not resolved_path.exists():
-            raise ToolError(f"File not found at: {file_path}")
+            raise ToolError(self._not_found_msg(file_path))
         if resolved_path.is_dir():
-            raise ToolError(f"Path is a directory, not a file: {file_path}")
+            raise ToolError(self._is_dir_msg(file_path, resolved_path))
+
+    @staticmethod
+    def _not_found_msg(file_path: Path) -> str:
+        """Return 'File not found' error with parent directory listing for context."""
+        parent = file_path.parent if file_path.parent != file_path else Path(".")
+        try:
+            entries = sorted(p.name for p in parent.iterdir())
+            if entries:
+                listing = "\n".join(f"  {e}" for e in entries[:30])
+                suffix = f"\n  ... ({len(entries) - 30} more)" if len(entries) > 30 else ""
+                return (
+                    f"File not found at: {file_path}\n"
+                    f"Contents of {parent}/:\n{listing}{suffix}"
+                )
+        except (PermissionError, OSError):
+            pass
+        return f"File not found at: {file_path}"
+
+    @staticmethod
+    def _is_dir_msg(file_path: Path, resolved_path: Path) -> str:
+        """Return 'is a directory' error with directory listing so model can pick a file."""
+        try:
+            entries = sorted(p.name for p in resolved_path.iterdir())
+            if entries:
+                listing = "\n".join(f"  {e}" for e in entries[:30])
+                suffix = f"\n  ... ({len(entries) - 30} more)" if len(entries) > 30 else ""
+                return (
+                    f"Path is a directory, not a file: {file_path}\n"
+                    f"Contents of {file_path}/:\n{listing}{suffix}"
+                )
+        except (PermissionError, OSError):
+            pass
+        return f"Path is a directory, not a file: {file_path}"
 
     @classmethod
     def format_call_display(cls, args: ReadFileArgs) -> ToolCallDisplay:

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/core/tools/builtins/search_replace.py

@@ -97,6 +97,12 @@ class SearchReplace(
     @classmethod
     def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
         if isinstance(event.result, SearchReplaceResult):
+            if event.result.blocks_applied == 0:
+                return ToolResultDisplay(
+                    success=False,
+                    message=event.result.content[:120].split("\n")[0],
+                    warnings=event.result.warnings,
+                )
             return ToolResultDisplay(
                 success=True,
                 message=f"Applied {event.result.blocks_applied} block{'' if event.result.blocks_applied == 1 else 's'}",
@@ -218,30 +224,42 @@ class SearchReplace(
                                     f"\n-----FILE TAIL (last 800 chars)-----\n{tail}\n"
                                     if tail else ""
                                 )
-                                raise ToolError(
-                                    f"{base_msg}\n\n[LOOP-BREAKER: this is the "
-                                    f"#{refused_entry['count']} consecutive REFUSED on "
-                                    f"{target.name}. Stop sending the same raw content. "
-                                    f"Actual file content (first 1500 chars of "
-                                    f"{existing_size} bytes):\n"
-                                    f"-----FILE HEAD-----\n{head}\n-----FILE END HEAD-----"
-                                    f"{tail_block}\n"
-                                    f"Choose ONE: (a) call write_file with overwrite=True "
-                                    f"to replace the whole file with your raw content, OR "
-                                    f"(b) send a proper SEARCH/REPLACE block anchored on "
-                                    f"text from the file head/tail above.]"
+                                yield SearchReplaceResult(
+                                    file=str(target),
+                                    blocks_applied=0,
+                                    lines_changed=0,
+                                    content=(
+                                        f"{base_msg}\n\n[LOOP-BREAKER: this is the "
+                                        f"#{refused_entry['count']} consecutive REFUSED on "
+                                        f"{target.name}. Stop sending the same raw content. "
+                                        f"Actual file content (first 1500 chars of "
+                                        f"{existing_size} bytes):\n"
+                                        f"-----FILE HEAD-----\n{head}\n-----FILE END HEAD-----"
+                                        f"{tail_block}\n"
+                                        f"Choose ONE: (a) call write_file with overwrite=True "
+                                        f"to replace the whole file with your raw content, OR "
+                                        f"(b) send a proper SEARCH/REPLACE block anchored on "
+                                        f"text from the file head/tail above.]"
+                                    ),
                                 )
-                            raise ToolError(
-                                f"{base_msg} To add new code, use a SEARCH/REPLACE "
-                                f"block anchored on the last line of the file:\n"
-                                f"<<<<<<< SEARCH\n"
-                                f"[the file's actual final line, copied exactly]\n"
-                                f"=======\n"
-                                f"[the same final line]\n\n"
-                                f"[your new code]\n"
-                                f">>>>>>> REPLACE\n"
-                                f"If you intended a full rewrite, use write_file instead."
+                                return
+                            yield SearchReplaceResult(
+                                file=str(target),
+                                blocks_applied=0,
+                                lines_changed=0,
+                                content=(
+                                    f"{base_msg} To add new code, use a SEARCH/REPLACE "
+                                    f"block anchored on the last line of the file:\n"
+                                    f"<<<<<<< SEARCH\n"
+                                    f"[the file's actual final line, copied exactly]\n"
+                                    f"=======\n"
+                                    f"[the same final line]\n\n"
+                                    f"[your new code]\n"
+                                    f">>>>>>> REPLACE\n"
+                                    f"If you intended a full rewrite, use write_file instead."
+                                ),
                             )
+                            return
                         _log.getLogger(__name__).info(
                             "search_replace: no blocks — overwriting %s", target,
                         )
@@ -380,21 +398,46 @@ class SearchReplace(
                 except Exception:
                     pass
 
-            raise ToolError(error_message)
-        else:
-            # Success → reset the fail counter for this file
-            state = self.state.__dict__.setdefault("_sr_fail_history", {})
-            state.pop(str(file_path), None)
-            refused_state = self.state.__dict__.setdefault(
-                "_sr_refused_raw_history", {}
+            # Return advisory result instead of raising ToolError.
+            # Hard ToolError blocks cause their own retry loops on longer tasks
+            # (model panics and re-calls the same failing search_replace). The
+            # advisory result delivers the same guidance message + file head
+            # without triggering the panic-retry pattern.
+            yield SearchReplaceResult(
+                file=str(file_path),
+                blocks_applied=0,
+                lines_changed=0,
+                content=error_message,
             )
-            refused_state.pop(str(file_path), None)
+            return
+        # Success → reset the fail counter for this file
+        state = self.state.__dict__.setdefault("_sr_fail_history", {})
+        state.pop(str(file_path), None)
+        refused_state = self.state.__dict__.setdefault(
+            "_sr_refused_raw_history", {}
+        )
+        refused_state.pop(str(file_path), None)
 
         modified_content = block_result.content
 
         # Calculate line changes
         if modified_content == original_content:
             lines_changed = 0
+            # The SEARCH text was found and the REPLACE was identical — nothing
+            # actually changed. Tell the model clearly so it doesn't retry.
+            yield SearchReplaceResult(
+                file=str(file_path),
+                blocks_applied=block_result.applied,
+                lines_changed=0,
+                warnings=block_result.warnings,
+                content=(
+                    f"{file_path.name}: ALREADY CORRECT — the search text was found "
+                    f"but the replacement is identical to the current content. "
+                    f"No change was written. The file already has the desired state. "
+                    f"Move on to the next task."
+                ),
+            )
+            return
         else:
             original_lines = len(original_content.splitlines())
             new_lines = len(modified_content.splitlines())
@@ -511,7 +554,16 @@ class SearchReplace(
             )
 
         if not content:
-            raise ToolError("Empty content provided")
+            raise ToolError(
+                "Empty content provided. You must include SEARCH/REPLACE blocks.\n"
+                "Format:\n"
+                "<<<<<<< SEARCH\n"
+                "exact text to find\n"
+                "=======\n"
+                "replacement text\n"
+                ">>>>>>> REPLACE\n"
+                "If you want to create a new file instead, use write_file."
+            )
 
         project_root = Path.cwd()
         file_path = Path(file_path_str).expanduser()

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/drydock/core/tools/builtins/write_file.py

@@ -483,6 +483,23 @@ class WriteFile(
                                 f"from your plan, or run `bash` with `python3 -m "
                                 f"{file_path.parent.name} --help` to verify."
                             )
+                            # Also surface missing imports so the model knows
+                            # which file to write next instead of re-looping.
+                            if file_path.suffix == ".py":
+                                try:
+                                    import ast as _ast
+                                    _tree = _ast.parse(args.content)
+                                    missing = _check_missing_sibling_imports(
+                                        _tree, file_path
+                                    )
+                                    if missing:
+                                        body += (
+                                            f" This file imports modules that don't "
+                                            f"exist yet: {sorted(missing)}. "
+                                            f"Write those files next."
+                                        )
+                                except Exception:
+                                    pass
                         except Exception:
                             body += "Move to the NEXT file in your plan."
                     else:

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.10"
+version = "2.7.16"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/scripts/auto_release.sh

@@ -85,8 +85,16 @@ rm -rf dist/
 $PYTHON -m build 2>/dev/null
 
 # Publish to PyPI
+# PYTHONNOUSERSITE=1 avoids a jaraco.functools circular-import that occurs
+# when ~/.local/lib/python3.12/site-packages/setuptools conflicts with the
+# miniconda3 vendored copy; set +e so a twine failure doesn't kill the
+# script before the local-wheel fallback can run.
 PYPI_TOKEN=$(cat ~/.config/drydock/pypi_token)
-$PYTHON -m twine upload dist/drydock_cli-${NEW_VERSION}* -u __token__ -p "$PYPI_TOKEN" 2>/dev/null
+set +e
+TWINE_OUT=$(PYTHONNOUSERSITE=1 $PYTHON -m twine upload dist/drydock_cli-${NEW_VERSION}* -u __token__ -p "$PYPI_TOKEN" 2>&1)
+TWINE_EXIT=$?
+set -e
+echo "[$(date)] twine exit=$TWINE_EXIT: $TWINE_OUT" >> "$DRYDOCK/logs/auto_release.log"
 
 # Deploy to GitHub — NOT silent. If the token is invalid this should scream.
 TMPDIR=$(mktemp -d)
@@ -126,11 +134,23 @@ else
 fi
 cd "$DRYDOCK"
 
-# Install on user's env (retry PyPI propagation)
-for i in 1 2 3; do
-    sleep 60
-    /home/bobef/miniforge3/envs/drydock/bin/pip install --force-reinstall --no-deps --no-cache-dir "drydock-cli==$NEW_VERSION" 2>/dev/null && break
-done
+# Install on user's env — try PyPI first, fall back to local wheel
+INSTALLED=0
+if [ $TWINE_EXIT -eq 0 ]; then
+    for i in 1 2 3; do
+        sleep 60
+        /home/bobef/miniforge3/envs/drydock/bin/pip install --force-reinstall --no-deps --no-cache-dir "drydock-cli==$NEW_VERSION" 2>/dev/null && INSTALLED=1 && break
+    done
+fi
+if [ $INSTALLED -eq 0 ]; then
+    # PyPI upload failed or propagation timed out — install from local wheel
+    LOCAL_WHEEL="$DRYDOCK/dist/drydock_cli-${NEW_VERSION}-py3-none-any.whl"
+    if [ -f "$LOCAL_WHEEL" ]; then
+        /home/bobef/miniforge3/envs/drydock/bin/pip install --force-reinstall --no-deps "$LOCAL_WHEEL" 2>/dev/null \
+            && echo "[$(date)] Installed v$NEW_VERSION from local wheel (PyPI upload failed)" >> "$DRYDOCK/logs/auto_release.log" \
+            || echo "[$(date)] ERROR: local wheel install also failed for v$NEW_VERSION" >> "$DRYDOCK/logs/auto_release.log"
+    fi
+fi
 
 # Tag
 git tag "v$NEW_VERSION" 2>/dev/null || true

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/scripts/stress_babysitter.sh

@@ -28,8 +28,8 @@ PID_FILE=/tmp/stress_pid.txt
 # /tmp/stress_2000_*.log. Avoids the stale-log bug where babysitter reported
 # COMPLETE for hours while the real harness kept processing (2026-04-25).
 # Falls back to the prior hardcoded path if no match exists yet.
-STRESS_LOG=/tmp/stress_2000_v10_restart_1777237201.log
-STRESS_LOG=/tmp/stress_2000_v10_restart_1777237201.log
+STRESS_LOG=$(ls -t /tmp/stress_2000_*.log 2>/dev/null | head -1)
+STRESS_LOG=${STRESS_LOG:-/tmp/stress_2000_v10_restart_1777237201.log}
 NOTIFY=/data3/drydock/scripts/notify_release.py
 PY_CONDA=/home/bobef/miniconda3/bin/python3
 PY_DRYDOCK=/home/bobef/miniforge3/envs/drydock/bin/python3

{drydock_cli-2.7.10 → drydock_cli-2.7.16}/tests/test_admiral_proposed.py

@@ -119,6 +119,25 @@ def test_retry_after_error_does_not_fire_when_previous_succeeded() -> None:
     assert detect_retry_after_error(msgs) is None
 
 
+def test_retry_after_error_does_not_fire_on_grep_matches_with_error_word() -> None:
+    # grep returns a successful match whose content contains the word "error"
+    # (e.g. matched a line with "error handling"). This must NOT be treated
+    # as an errored result — false positive was observed in stress runs where
+    # tool_agent_memory.json lines contained "content": "error ...".
+    grep_args = '{"pattern": "def .*read.*\\\\(.*\\\\)"}'
+    grep_result = (
+        'matches: ./.tool_agent_memory/default.json:20:    "content": '
+        '"error handling for missing keys"'
+    )
+    msgs = [
+        _user("go"),
+        _tool("grep", grep_args),
+        _tool_result("grep", grep_result),
+        _tool("grep", grep_args),
+    ]
+    assert detect_retry_after_error(msgs) is None
+
+
 # --- run_proposed_detectors ---------------------------------------------
 
 

drydock_cli-2.7.16/tests/test_read_file_not_found_listing.py

@@ -0,0 +1,70 @@
+"""Regression test: read_file includes parent directory listing on file-not-found.
+
+Admiral logs showed 'retry_after_error:read_file' firing when the model retries
+a missing-file path instead of checking what files actually exist nearby.
+Fix: _not_found_msg() lists the parent directory so the model sees valid
+neighbours and picks the right one without needing the admiral to intervene.
+"""
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import pytest
+
+from drydock.core.tools.base import BaseToolState, ToolError
+from drydock.core.tools.builtins.read_file import ReadFile, ReadFileArgs, ReadFileToolConfig
+
+
+def _make_tool(tmp_path: Path) -> ReadFile:
+    config = ReadFileToolConfig()
+    state = BaseToolState()
+    return ReadFile(config=config, state=state)
+
+
+def test_not_found_includes_parent_listing(tmp_path: Path) -> None:
+    """Error message includes sibling files when path does not exist."""
+    (tmp_path / "server.py").write_text("# server")
+    (tmp_path / "cli.py").write_text("# cli")
+    missing = tmp_path / "nonexistent.py"
+
+    tool = _make_tool(tmp_path)
+    msg = tool._not_found_msg(missing)
+
+    assert "File not found" in msg
+    assert "server.py" in msg
+    assert "cli.py" in msg
+
+
+def test_not_found_empty_dir(tmp_path: Path) -> None:
+    """Empty parent directory: still returns a 'File not found' message."""
+    missing = tmp_path / "ghost.py"
+    tool = _make_tool(tmp_path)
+    msg = tool._not_found_msg(missing)
+    assert "File not found" in msg
+
+
+def test_not_found_truncates_long_listing(tmp_path: Path) -> None:
+    """Listings longer than 30 entries are truncated with a '... (N more)' suffix."""
+    for i in range(35):
+        (tmp_path / f"file_{i:02d}.py").write_text("")
+    missing = tmp_path / "missing.py"
+
+    tool = _make_tool(tmp_path)
+    msg = tool._not_found_msg(missing)
+
+    assert "more)" in msg
+
+
+def test_validate_path_raises_with_listing(tmp_path: Path, monkeypatch) -> None:
+    """_validate_path raises ToolError whose message includes directory listing."""
+    (tmp_path / "sibling.py").write_text("x=1")
+    missing = tmp_path / "nope.py"
+
+    tool = _make_tool(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(ToolError) as exc_info:
+        tool._validate_path(missing)
+
+    assert "sibling.py" in str(exc_info.value)