codeplain 0.3.11.dev21__py3-none-any.whl → 0.3.11.dev22__py3-none-any.whl

tests/test_fix_unit_tests_conformance_context.py

@@ -12,44 +12,25 @@ import pytest
 
 import plain_spec
 from memory_management import MemoryManager
+from render_machine.actions import fix_unit_tests as fix_unit_tests_module
 from render_machine.actions.fix_conformance_test import FixConformanceTest
 from render_machine.actions.fix_unit_tests import FixUnitTests
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
-from render_machine.render_context import RenderContext
-from render_machine.render_types import ConformanceTestsRunningContext, ScriptExecutionHistory, UnitTestsRunningContext
+from render_machine.render_types import ConformanceTestsRunningContext, UnitTestsRunningContext
 
 
 class FakeCodeplainAPI:
-    """Conformance fixes return a scripted response; every agent session submits a fix on its first turn."""
-
-    def __init__(self, conformance_fix_response=None):
+    def __init__(self, conformance_fix_response=None, unittests_fix_response=None):
         self.conformance_fix_response = conformance_fix_response
-        self.agent_calls = []
-        self.sessions_started = 0
+        self.unittests_fix_response = unittests_fix_response or {}
+        self.unittests_fix_calls = []
 
     def fix_conformance_tests_issue(self, *args, **kwargs):
         return self.conformance_fix_response
 
-    def agent_start(self, task_type, task_params, frid, module_name, run_state):
-        self.sessions_started += 1
-        self.agent_calls.append(("start", task_params))
-        return self._submit(f"s{self.sessions_started}")
-
-    def agent_continue(self, session_id, tool_results, frid, module_name, run_state):
-        self.agent_calls.append(("continue", session_id, tool_results))
-        return self._submit(session_id)
-
-    def _submit(self, session_id):
-        call_id = f"submit-{len(self.agent_calls)}"
-        return {
-            "session_id": session_id,
-            "status": "tool_calls",
-            "calls": [{"id": call_id, "name": "submit_fix", "args": {"changes_made": "fixed"}}],
-        }
-
-
-class FakeRenderContext(SimpleNamespace):
-    unit_tests_agent_session = RenderContext.unit_tests_agent_session
+    def fix_unittests_issue(self, *args, **kwargs):
+        self.unittests_fix_calls.append(kwargs)
+        return self.unittests_fix_response
 
 
 class FakeConformanceTests:
@@ -78,11 +59,7 @@ def memory_folder():
 def isolate_from_git_and_console(monkeypatch):
     monkeypatch.setattr(ImplementationCodeHelpers, "get_code_diff", staticmethod(lambda *args: {}))
     monkeypatch.setattr(plain_spec, "collect_linked_resources", lambda *args: None)
-    monkeypatch.setattr(
-        plain_spec,
-        "get_specifications_for_frid",
-        lambda tree, frid: ({plain_spec.FUNCTIONAL_REQUIREMENTS: ["- Add numbers."]}, None),
-    )
+    monkeypatch.setattr(fix_unit_tests_module.render_utils, "print_inputs", lambda *args: None)
 
 
 def make_conformance_context():
@@ -99,7 +76,7 @@ def make_conformance_context():
 
 
 def make_render_context(api, build_folder, memory_folder, conformance_tests_running_context):
-    return FakeRenderContext(
+    return SimpleNamespace(
         codeplain_api=api,
         build_folder=build_folder,
         memory_manager=MemoryManager(api, memory_folder),
@@ -109,11 +86,9 @@ def make_render_context(api, build_folder, memory_folder, conformance_tests_runn
         plain_source_tree={},
         module_name="mod",
         required_modules=None,
-        frid_context=SimpleNamespace(frid="1", linked_resources={}, changed_files=set()),
+        frid_context=SimpleNamespace(frid="1", linked_resources={}),
         get_required_modules_functionalities=lambda: {},
         run_state=SimpleNamespace(render_id="test-render-id", unittest_batch_id=1),
-        unittests_script=None,
-        script_execution_history=ScriptExecutionHistory(),
     )
 
 
@@ -216,104 +191,34 @@ def test_implementation_fix_with_no_files_is_not_remembered(build_folder, memory
     assert ctx.implementation_code_fixes == []
 
 
-def run_unit_tests_fix(render_context, issue="1 failed"):
-    return FixUnitTests().execute(render_context, {"previous_unittests_issue": issue})
-
-
-def start_new_unit_test_loop(render_context):
-    """What RenderContext.start_unittests_processing does when the unit tests are run again."""
-    render_context.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
-
-
-def conformance_fix(number):
-    return {
-        "hypothesis": f"hypothesis {number}",
-        "approach": f"approach {number}",
-        "code_diff": {"app.py": f"+{number}"},
-    }
+def run_unit_tests_fix(render_context):
+    return FixUnitTests().execute(render_context, {"previous_unittests_issue": "1 failed"})
 
 
-def test_first_unit_test_loop_of_conformance_phase_seeds_the_session_with_the_fixes(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
+def test_unit_tests_fix_forwards_conformance_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI(unittests_fix_response={"test_app.py": "def test_add(): pass\n"})
     ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
+    ctx.implementation_code_fixes.append(
+        {"hypothesis": "off by one", "approach": "add one", "code_diff": {"app.py": "+    return a + b + 1"}}
+    )
     render_context = make_render_context(api, build_folder, memory_folder, ctx)
 
     outcome, _ = run_unit_tests_fix(render_context)
 
     assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
-    kind, task_params = api.agent_calls[0]
-    assert kind == "start"
-    assert task_params["conformance_tests_fixes"] == ctx.implementation_code_fixes
+    assert len(api.unittests_fix_calls) == 1
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] == ctx.implementation_code_fixes
     # The forwarded list is a copy, so later conformance fixes do not mutate what was sent.
-    assert task_params["conformance_tests_fixes"] is not ctx.implementation_code_fixes
-    # The file the conformance fix changed is seeded although the FRID did not change it.
-    assert "app.py" in task_params["relevant_files"]
-    assert ctx.unit_tests_agent_session.session_id == "s1"
-
-
-def test_next_unit_test_loop_of_conformance_phase_continues_the_session_with_only_new_fixes(
-    build_folder, memory_folder
-):
-    api = FakeCodeplainAPI()
-    ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
-    render_context = make_render_context(api, build_folder, memory_folder, ctx)
-    run_unit_tests_fix(render_context)
-
-    # The fix was accepted; the conformance tests fixer changes the code again and the unit tests fail again.
-    ctx.implementation_code_fixes.append(conformance_fix(2))
-    start_new_unit_test_loop(render_context)
-    run_unit_tests_fix(render_context, issue="2 failed")
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is not ctx.implementation_code_fixes
 
-    assert api.sessions_started == 1
-    kind, session_id, tool_results = api.agent_calls[1]
-    assert (kind, session_id) == ("continue", "s1")
-    submit_answer = tool_results[-1]
-    assert submit_answer["call_id"] == "submit-1"
-    assert submit_answer["output"].startswith("Your fix was accepted: the unit tests passed.")
-    assert "Conformance Tests Fix below" in submit_answer["output"]
-    assert submit_answer["conformance_tests_fixes"] == [conformance_fix(2)]
-    assert submit_answer["test_output"] == "2 failed"
 
-
-def test_retry_within_a_unit_test_loop_says_the_fix_did_not_work(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
-    ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
-    render_context = make_render_context(api, build_folder, memory_folder, ctx)
-    run_unit_tests_fix(render_context)
-
-    run_unit_tests_fix(render_context, issue="still failing")
-
-    submit_answer = api.agent_calls[1][2][-1]
-    assert "still fail" in submit_answer["output"]
-    # Fix 1 was already shown to the session, so it is not sent again.
-    assert "conformance_tests_fixes" not in submit_answer
-
-
-def test_new_conformance_phase_starts_a_new_session(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
-    render_context = make_render_context(api, build_folder, memory_folder, make_conformance_context())
-    run_unit_tests_fix(render_context)
-
-    # E.g. the functionality is re-rendered from scratch: the conformance tests running context is recreated.
-    render_context.conformance_tests_running_context = make_conformance_context()
-    start_new_unit_test_loop(render_context)
-    run_unit_tests_fix(render_context)
-
-    assert [call[0] for call in api.agent_calls] == ["start", "start"]
-
-
-def test_unit_tests_outside_conformance_phase_get_no_fixes_and_a_session_per_loop(build_folder, memory_folder):
+def test_unit_tests_fix_outside_conformance_phase_sends_no_fixes(build_folder, memory_folder):
     api = FakeCodeplainAPI()
     render_context = make_render_context(api, build_folder, memory_folder, None)
-    run_unit_tests_fix(render_context)
-    start_new_unit_test_loop(render_context)
+
     run_unit_tests_fix(render_context)
 
-    assert [call[0] for call in api.agent_calls] == ["start", "start"]
-    assert all("conformance_tests_fixes" not in call[1] for call in api.agent_calls)
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None
 
 
 def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_sends_no_fixes(build_folder, memory_folder):
@@ -322,4 +227,4 @@ def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_send
 
     run_unit_tests_fix(render_context)
 
-    assert "conformance_tests_fixes" not in api.agent_calls[0][1]
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None

render_machine/agent_tools.py

@@ -1,270 +0,0 @@
-"""Client-side implementations of the tools a server-side agent can call.
-
-The server declares the tools to the LLM (codeplain-api: src/agent/tools.py) and forwards
-the model's calls; this module executes them against the local build folder and returns
-plain-text results. Relative paths resolve against the build folder. Reads are allowed only in the
-build folder and the full test logs the agent was pointed to; writes only inside the build folder.
-"""
-
-import glob
-import json
-import os
-import subprocess
-import tempfile
-from typing import Callable
-
-from plain2code_console import console
-from render_machine import render_utils
-from render_machine.render_context import RenderContext
-
-DEFAULT_READ_LIMIT = 200
-MAX_LINE_CHARS = 10_000
-MAX_OUTPUT_CHARS = 30_000
-EDIT_SNIPPET_CONTEXT_LINES = 3
-MAX_EDIT_SNIPPET_LINES = 60
-MAX_GREP_CONTEXT_LINES = 20
-# Tools without side effects; repeating one while no file changed returns a pointer instead.
-READ_ONLY_TOOLS = ("read_file", "grep", "ls_files")
-GREP_EXCLUDED_DIRS = (".git", "__pycache__", "node_modules", ".venv", "target", "dist", "build")
-
-
-def _build_folder(render_context: RenderContext) -> str:
-    return os.path.normpath(os.path.abspath(render_context.build_folder))
-
-
-def _resolve(file_path: str, render_context: RenderContext) -> str:
-    if os.path.isabs(file_path):
-        return os.path.normpath(file_path)
-    return os.path.normpath(os.path.join(_build_folder(render_context), file_path))
-
-
-def _within(path: str, folder: str) -> bool:
-    return path == folder or path.startswith(folder + os.sep)
-
-
-def _readable(path: str, render_context: RenderContext) -> bool:
-    return (
-        _within(path, _build_folder(render_context))
-        or path in render_context.unit_tests_agent_session.readable_log_paths
-    )
-
-
-def register_log_path(log_path: str, render_context: RenderContext) -> None:
-    """Allow read_file/grep on a full test log the agent is pointed to."""
-    render_context.unit_tests_agent_session.readable_log_paths.add(os.path.normpath(os.path.abspath(log_path)))
-
-
-def _writable(path: str, render_context: RenderContext) -> bool:
-    return _within(path, _build_folder(render_context))
-
-
-def _bound(text: str) -> str:
-    """Cap very long lines and the total size so one tool result cannot flood the context."""
-    lines = [
-        line if len(line) <= MAX_LINE_CHARS else line[:MAX_LINE_CHARS] + "... [line truncated]"
-        for line in text.split("\n")
-    ]
-    text = "\n".join(lines)
-    if len(text) > MAX_OUTPUT_CHARS:
-        head, tail = int(MAX_OUTPUT_CHARS * 0.6), int(MAX_OUTPUT_CHARS * 0.4)
-        text = text[:head] + f"\n\n... [truncated {len(text) - head - tail:,} chars] ...\n\n" + text[-tail:]
-    return text
-
-
-def _track_change(full_path: str, render_context: RenderContext) -> None:
-    context = render_context.unit_tests_running_context
-    context.changed_files.add(os.path.relpath(full_path, _build_folder(render_context)))
-    context.verified_passing, context.verified_passing_log_path = False, None
-    context.tool_result_cache.clear()
-
-
-def read_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    if not _readable(full_path, render_context):
-        return f"Error: read access denied for '{full_path}' (readable: build folder and test logs)."
-    if not os.path.isfile(full_path):
-        return f"Error: file not found: '{full_path}'."
-    with open(full_path, "r", encoding="utf-8", errors="replace") as f:
-        lines = f.read().split("\n")
-    offset = max(int(args.get("offset") or 1), 1)
-    limit = int(args.get("limit") or DEFAULT_READ_LIMIT)
-    selected = lines[offset - 1 : offset - 1 + limit]
-    if not selected:
-        return f"Error: offset {offset} is past the end of the file ({len(lines)} lines)."
-    numbered = "\n".join(f"{offset + i}: {line}" for i, line in enumerate(selected))
-    last = offset - 1 + len(selected)
-    note = (
-        f"\n[showing lines {offset}-{last} of {len(lines)}; use offset={last + 1} to continue]"
-        if last < len(lines)
-        else ""
-    )
-    return _bound(numbered) + note
-
-
-def grep(args: dict, render_context: RenderContext) -> str:
-    pattern = args.get("pattern", "")
-    if not pattern:
-        return "Error: pattern is required."
-    target = _resolve(args.get("file_path") or ".", render_context)
-    if not _readable(target, render_context):
-        return f"Error: read access denied for '{target}'."
-    if not os.path.exists(target):
-        return f"Error: path not found: '{target}'."
-    # Run from the build folder so matches inside it come back as build-relative paths, which
-    # is the form the other tools accept; a test log outside it is passed by absolute path.
-    cwd = _build_folder(render_context)
-    options = [f"--exclude-dir={d}" for d in GREP_EXCLUDED_DIRS]
-    context_lines = min(max(int(args.get("context_lines") or 0), 0), MAX_GREP_CONTEXT_LINES)
-    if context_lines:
-        options.append(f"-C{context_lines}")
-    if args.get("include"):
-        options.append(f"--include={args['include']}")
-    command = ["grep", "-rnI", *options, "-e", pattern, "--"]
-    command.append(os.path.relpath(target, cwd) if _within(target, cwd) else target)
-    result = subprocess.run(command, capture_output=True, text=True, cwd=cwd)
-    if result.returncode == 1:
-        return f"No matches for '{pattern}' in '{target}'."
-    if result.returncode != 0:
-        return f"Error: grep failed: {result.stderr.strip()}"
-    lines = [line[2:] if line.startswith("./") else line for line in result.stdout.rstrip("\n").split("\n")]
-    return _bound("\n".join(lines))
-
-
-def ls_files(args: dict, render_context: RenderContext) -> str:
-    target = _resolve(args.get("pattern") or ".", render_context)
-    if not _readable(target, render_context):
-        return f"Error: read access denied for '{target}'."
-    if os.path.isdir(target):
-        entries = sorted(os.listdir(target))
-        listing = [entry + "/" if os.path.isdir(os.path.join(target, entry)) else entry for entry in entries]
-        return f"{target}:\n" + ("\n".join(listing) if listing else "(empty)")
-    matches = sorted(glob.glob(target, recursive=True))
-    return _bound("\n".join(matches)) if matches else f"No files match '{target}'."
-
-
-def edit_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    search, replace = args.get("search", ""), args.get("replace", "")
-    if not search:
-        return "Error: search is required."
-    if not _writable(full_path, render_context):
-        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
-    if not os.path.isfile(full_path):
-        return f"Error: file not found: '{full_path}'. Use write_file to create new files."
-    with open(full_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    occurrences = content.count(search)
-    if occurrences != 1:
-        return (
-            f"Error: search text found {occurrences} times in '{full_path}'; it must appear exactly once. "
-            "Read the file and use a larger, unique snippet."
-        )
-    with open(full_path, "w", encoding="utf-8") as f:
-        f.write(content.replace(search, replace, 1))
-    _track_change(full_path, render_context)
-    return f"Edited '{full_path}'. The edited region now reads:\n" + _edit_snippet(content, search, replace)
-
-
-def _edit_snippet(content: str, search: str, replace: str) -> str:
-    """Numbered lines of the replacement plus a little context, so the edit needs no re-read."""
-    lines = content.replace(search, replace, 1).split("\n")
-    first = content[: content.index(search)].count("\n")
-    last = first + replace.count("\n")
-    start = max(first - EDIT_SNIPPET_CONTEXT_LINES, 0)
-    end = min(last + EDIT_SNIPPET_CONTEXT_LINES + 1, len(lines), start + MAX_EDIT_SNIPPET_LINES)
-    snippet = "\n".join(f"{start + i + 1}: {line}" for i, line in enumerate(lines[start:end]))
-    return _bound(snippet)
-
-
-def write_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    if not _writable(full_path, render_context):
-        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
-    os.makedirs(os.path.dirname(full_path), exist_ok=True)
-    with open(full_path, "w", encoding="utf-8") as f:
-        f.write(args.get("content", ""))
-    _track_change(full_path, render_context)
-    return f"Wrote '{full_path}'."
-
-
-def delete_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    if not _writable(full_path, render_context):
-        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
-    if not os.path.isfile(full_path):
-        return f"Error: file not found: '{full_path}'."
-    os.remove(full_path)
-    _track_change(full_path, render_context)
-    return f"Deleted '{full_path}'."
-
-
-def full_log_pointer(log_file_path: str | None) -> str:
-    return f" Full log: {log_file_path} (search it with grep, passing that path as file_path)." if log_file_path else ""
-
-
-def run_unit_tests(_args: dict, render_context: RenderContext) -> dict:
-    """Returns a result dict: a short header in `output` and the raw failure output in
-    `test_output`, which the server condenses (summarizing it when it is long)."""
-    exit_code, output, log_file_path = render_utils.execute_script(
-        os.path.normpath(render_context.unittests_script),
-        [render_context.build_folder],
-        "Unit Tests",
-        timeout=render_context.test_script_timeout,
-        stop_event=render_context.stop_event,
-    )
-    context = render_context.unit_tests_running_context
-    if exit_code == 0:
-        context.verified_passing, context.verified_passing_log_path = True, log_file_path
-        return {"output": "All unit tests passed."}
-    if not log_file_path and output:
-        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".unittest_output") as f:
-            f.write(output)
-            log_file_path = f.name
-    if log_file_path:
-        register_log_path(log_file_path, render_context)
-    return {
-        "output": f"Unit tests failed (exit code {exit_code}).{full_log_pointer(log_file_path)}",
-        "test_output": output,
-    }
-
-
-TOOLS: dict[str, Callable[[dict, RenderContext], str | dict]] = {
-    "read_file": read_file,
-    "grep": grep,
-    "ls_files": ls_files,
-    "edit_file": edit_file,
-    "write_file": write_file,
-    "delete_file": delete_file,
-    "run_unit_tests": run_unit_tests,
-}
-
-
-def execute_calls(calls: list[dict], render_context: RenderContext) -> list[dict]:
-    """Execute the agent's tool calls in order; every call gets a result, errors included.
-
-    A repeated read-only call (same tool and arguments, no file changed in between) is not
-    re-executed: its result is already in the conversation, so a short pointer is returned."""
-    cache = render_context.unit_tests_running_context.tool_result_cache
-    results = []
-    for call in calls:
-        tool = TOOLS.get(call["name"])
-        cache_key = json.dumps([call["name"], call.get("args") or {}], sort_keys=True)
-        result: dict
-        if tool is None:
-            result = {"output": f"Error: unknown tool '{call['name']}'."}
-        elif call["name"] in READ_ONLY_TOOLS and cache_key in cache:
-            result = {
-                "output": "Same call as an earlier one and no file has changed since; "
-                "its result is unchanged (see the earlier result above)."
-            }
-        else:
-            try:
-                output = tool(call.get("args") or {}, render_context)
-                result = output if isinstance(output, dict) else {"output": output}
-            except Exception as e:
-                result = {"output": f"Error: tool '{call['name']}' failed: {type(e).__name__}: {e}"}
-            if call["name"] in READ_ONLY_TOOLS and not result["output"].startswith("Error"):
-                cache[cache_key] = result["output"]
-        console.debug(f"Agent tool {call['name']}({call.get('args')}) -> {result['output'][:200]!r}")
-        results.append({"call_id": call["id"], **result})
-    return results

tests/test_agent_tools.py

@@ -1,166 +0,0 @@
-"""Tests for the client-side agent tool implementations."""
-
-import os
-from types import SimpleNamespace
-
-import pytest
-
-from render_machine import agent_tools
-from render_machine.render_context import RenderContext
-from render_machine.render_types import UnitTestsRunningContext
-
-
-class FakeRenderContext(SimpleNamespace):
-    unit_tests_agent_session = RenderContext.unit_tests_agent_session
-
-
-@pytest.fixture
-def project(tmp_path, monkeypatch):
-    build = tmp_path / "plain_modules" / "m"
-    build.mkdir(parents=True)
-    (build / "app.py").write_text("def add(a, b):\n    return a - b\n\n\ndef sub(a, b):\n    return a - b\n")
-    (tmp_path / "outside.txt").write_text("outside\n")
-    monkeypatch.chdir(tmp_path)
-    render_context = FakeRenderContext(
-        build_folder=str(build),
-        unit_tests_running_context=UnitTestsRunningContext(fix_attempts=1),
-        conformance_tests_running_context=None,
-        unittests_script=None,
-        test_script_timeout=None,
-        stop_event=None,
-    )
-    return SimpleNamespace(root=tmp_path, build=build, rc=render_context)
-
-
-def test_read_file_resolves_relative_to_build_folder_with_paging(project):
-    out = agent_tools.read_file({"file_path": "app.py", "offset": 2, "limit": 1}, project.rc)
-    assert out.startswith("2:     return a - b")
-    assert "use offset=3 to continue" in out
-
-
-def test_read_is_confined_to_build_folder(project):
-    outside = str(project.root / "outside.txt")
-    assert agent_tools.read_file({"file_path": outside}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.read_file({"file_path": "../../outside.txt"}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.grep({"pattern": "outside", "file_path": outside}, project.rc).startswith("Error: read access")
-    assert agent_tools.ls_files({"pattern": str(project.root)}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.read_file({"file_path": "/etc/hosts"}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.read_file({"file_path": "missing.py"}, project.rc).startswith("Error: file not found")
-
-
-def test_edit_file_requires_unique_match_and_tracks_change(project):
-    ambiguous = agent_tools.edit_file({"file_path": "app.py", "search": "return a - b", "replace": "x"}, project.rc)
-    assert "found 2 times" in ambiguous
-    assert project.rc.unit_tests_running_context.changed_files == set()
-
-    ok = agent_tools.edit_file(
-        {
-            "file_path": "app.py",
-            "search": "def add(a, b):\n    return a - b",
-            "replace": "def add(a, b):\n    return a + b",
-        },
-        project.rc,
-    )
-    assert ok.startswith("Edited")
-    assert "return a + b" in (project.build / "app.py").read_text()
-    assert project.rc.unit_tests_running_context.changed_files == {"app.py"}
-
-
-def test_write_and_delete_are_confined_to_build_folder(project):
-    denied = agent_tools.write_file({"file_path": str(project.root / "evil.py"), "content": "x"}, project.rc)
-    assert denied.startswith("Error: write access denied")
-    assert not (project.root / "evil.py").exists()
-
-    assert agent_tools.write_file({"file_path": "pkg/new.py", "content": "print(1)\n"}, project.rc).startswith("Wrote")
-    assert (project.build / "pkg" / "new.py").read_text() == "print(1)\n"
-    assert agent_tools.delete_file({"file_path": "pkg/new.py"}, project.rc).startswith("Deleted")
-    assert not (project.build / "pkg" / "new.py").exists()
-    assert project.rc.unit_tests_running_context.changed_files == {os.path.join("pkg", "new.py")}
-
-
-def test_grep_and_ls(project):
-    hits = agent_tools.grep({"pattern": "def sub"}, project.rc)
-    assert hits == "app.py:5:def sub(a, b):"
-    assert agent_tools.grep({"pattern": "nope"}, project.rc).startswith("No matches")
-    assert agent_tools.grep({"pattern": ""}, project.rc).startswith("Error")
-
-    assert agent_tools.ls_files({}, project.rc).splitlines()[1:] == ["app.py"]
-    assert agent_tools.ls_files({"pattern": "**/*.py"}, project.rc).endswith("app.py")
-
-
-def test_execute_calls_answers_every_call_and_captures_errors(project, monkeypatch):
-    def boom(_args, _rc):
-        raise RuntimeError("kaput")
-
-    monkeypatch.setitem(agent_tools.TOOLS, "boom", boom)
-    results = agent_tools.execute_calls(
-        [
-            {"id": "1", "name": "read_file", "args": {"file_path": "app.py", "limit": 1}},
-            {"id": "2", "name": "unknown_tool", "args": {}},
-            {"id": "3", "name": "boom"},
-        ],
-        project.rc,
-    )
-    assert [r["call_id"] for r in results] == ["1", "2", "3"]
-    assert results[0]["output"].startswith("1: def add")
-    assert results[1]["output"] == "Error: unknown tool 'unknown_tool'."
-    assert results[2]["output"] == "Error: tool 'boom' failed: RuntimeError: kaput"
-
-
-def test_run_unit_tests_reports_pass_and_failure(project, monkeypatch):
-    log = project.root.parent / "log.txt"
-    log.write_text("FAILED test_x\nCaused by: boom\n")
-    outcomes = iter([(0, "", "/tmp/pass.txt"), (1, "FAILED test_x", str(log))])
-    monkeypatch.setattr(agent_tools.render_utils, "execute_script", lambda *a, **k: next(outcomes))
-    project.rc.unittests_script = "run_tests.sh"
-    context = project.rc.unit_tests_running_context
-
-    assert agent_tools.run_unit_tests({}, project.rc) == {"output": "All unit tests passed."}
-    assert context.verified_passing and context.verified_passing_log_path == "/tmp/pass.txt"
-
-    failure = agent_tools.run_unit_tests({}, project.rc)
-    assert failure["output"].startswith(f"Unit tests failed (exit code 1). Full log: {log}")
-    # raw output goes to the server for condensing, not truncated here
-    assert failure["test_output"] == "FAILED test_x"
-    # the full log is outside the build folder but greppable
-    assert agent_tools.grep({"pattern": "Caused by", "file_path": str(log)}, project.rc).endswith("Caused by: boom")
-
-
-def test_file_change_invalidates_verified_pass_and_read_cache(project):
-    context = project.rc.unit_tests_running_context
-    context.verified_passing = True
-    first = agent_tools.execute_calls([{"id": "1", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
-    repeat = agent_tools.execute_calls([{"id": "2", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
-    assert first[0]["output"].startswith("1: def add")
-    assert repeat[0]["output"].startswith("Same call as an earlier one")
-
-    agent_tools.write_file({"file_path": "other.py", "content": "y = 1\n"}, project.rc)
-    assert context.verified_passing is False
-    again = agent_tools.execute_calls([{"id": "3", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
-    assert again[0]["output"].startswith("1: def add")
-
-
-def test_edit_file_returns_the_edited_region(project):
-    out = agent_tools.edit_file(
-        {
-            "file_path": "app.py",
-            "search": "def sub(a, b):\n    return a - b",
-            "replace": "def sub(a, b):\n    return b",
-        },
-        project.rc,
-    )
-    assert out.startswith("Edited") and "5: def sub(a, b):\n6:     return b" in out
-    assert "2:     return a - b" in out and "1: def add" not in out
-
-
-def test_grep_context_lines_and_include(project):
-    (project.build / "notes.txt").write_text("def sub is documented here\n")
-    hits = agent_tools.grep({"pattern": "def sub", "context_lines": 1, "include": "*.py"}, project.rc)
-    assert "notes.txt" not in hits
-    assert "app.py-4-" in hits and "app.py:5:def sub(a, b):" in hits and "app.py-6-" in hits
-
-
-def test_bound_truncates_long_lines_and_large_output():
-    bounded = agent_tools._bound("a" * (agent_tools.MAX_LINE_CHARS + 5) + "\n" + "b\n" * 40_000)
-    assert "[line truncated]" in bounded and "[truncated" in bounded
-    assert len(bounded) < agent_tools.MAX_OUTPUT_CHARS + 200