The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Whole-file knowledge survives what does not change it.
A narrower reread of unchanged bytes keeps the write_file baseline, and so does the task's
own patch of a file it knew in full: ``write_file -> read_file -> patch -> write_file`` used
to refuse the last write although the same task made the only change. The baseline survives
the patch exactly when the task held one for the pre-patch bytes and the patch's write is what
is on disk. A blind patch, a sibling or external writer, or an incomplete paged read stays
refused.
"""
import json
import os
import pytest
from tools import file_operations
from tools.file_tools import clear_file_ops_cache
from tools.file_tools_read_tracking import reset_file_dedup
from tools.registry import registry
_BLIND = "Your patch changed this file"
def _call(name, path, task_id, **arguments):
result = registry.dispatch(name, {"path": str(path), **arguments}, task_id=task_id)
assert isinstance(result, str)
return json.loads(result)
def test_partial_reread_keeps_an_unchanged_full_read_or_write(tmp_path):
original = "first\nsecond\nthird\n"
for source in ("read", "write", "pages"):
task = f"known-{source}"
path = tmp_path / f"{source}.txt"
try:
if source == "write":
assert "error" not in _call("write_file", path, task, content=original)
else:
path.write_text(original, encoding="utf-8")
if source == "pages":
for offset in (1, 2, 3):
assert "error" not in _call("read_file", path, task, offset=offset, limit=1)
else:
assert "error" not in _call("read_file", path, task)
assert "error" not in _call("read_file", path, task, offset=2, limit=2)
written = _call("write_file", path, task, content="replacement\n")
assert "error" not in written, (source, written)
assert path.read_text(encoding="utf-8") == "replacement\n"
finally:
clear_file_ops_cache(task)
def test_partial_read_cannot_refresh_a_changed_full_baseline(tmp_path):
original = "first\nsecond\nthird\n"
for source in ("write", "pages"):
path = tmp_path / f"changed-{source}.txt"
task = f"snapshot-{source}"
try:
if source == "write":
assert "error" not in _call("write_file", path, task, content=original)
else:
path.write_text(original, encoding="utf-8")
assert "error" not in _call("read_file", path, task, offset=1, limit=1)
stamp = path.stat()
path.write_text("other\nsecond\nthird\n", encoding="utf-8")
# mtime alone cannot identify bytes: editors/copy tools can preserve it.
os.utime(path, ns=(stamp.st_atime_ns, stamp.st_mtime_ns))
assert "error" not in _call("read_file", path, task, offset=2, limit=2)
refused = _call("write_file", path, task, content="replacement\n")
assert refused.get("stale_write_blocked"), (source, refused)
assert path.read_text(encoding="utf-8") == "other\nsecond\nthird\n"
# Reading all of the new version is recovery, not a bypass.
assert "error" not in _call("read_file", path, task)
assert "error" not in _call("write_file", path, task, content="merged\n")
assert path.read_text(encoding="utf-8") == "merged\n"
finally:
clear_file_ops_cache(task)
# A page that hides part of a line never supplies whole-file knowledge.
from tools.tool_output_limits import get_max_line_length
path = tmp_path / "clamped.txt"
path.write_text("x" * (get_max_line_length() + 10) + "\nlast\n", encoding="utf-8")
try:
assert "error" not in _call("read_file", path, "clamped")
refused = _call("write_file", path, "clamped", content="replacement\n")
assert refused.get("stale_write_blocked"), refused
assert path.read_text(encoding="utf-8").startswith("x" * (get_max_line_length() + 10))
finally:
clear_file_ops_cache("clamped")
def _dispatch(name, task_id, **arguments):
result = registry.dispatch(name, arguments, task_id=task_id)
assert isinstance(result, str)
return json.loads(result)
def _ok(result):
assert "error" not in result, result
return result
def _write(path, task_id, content):
return _dispatch("write_file", task_id, path=str(path), content=content)
def _read(path, task_id, **paging):
return _ok(_dispatch("read_file", task_id, path=str(path), **paging))
def _replace(path, task_id, old, new):
return _ok(_dispatch("patch", task_id, path=str(path), old_string=old, new_string=new))
def _v4a(task_id, *updates):
body = "".join(f"*** Update File: {p}\n@@\n-{old}\n+{new}\n" for p, old, new in updates)
return _ok(_dispatch("patch", task_id, mode="patch", patch=f"*** Begin Patch\n{body}*** End Patch"))
def _blocked(result):
assert result.get("stale_write_blocked") is True, result
return result["error"]
@pytest.fixture
def task(request):
task_id = f"own-patch-{request.node.name}"
yield task_id
clear_file_ops_cache(task_id)
def test_own_replace_patch_after_full_read_keeps_the_baseline(tmp_path, task):
path = tmp_path / "probe.txt"
_ok(_write(path, task, "first=old\nsecond=old\n"))
_read(path, task)
_replace(path, task, "first=old", "first=new")
written = _write(path, task, "first=new\nsecond=new\n")
assert "error" not in written and not written.get("stale_write_blocked"), written
assert path.read_text() == "first=new\nsecond=new\n"
def test_own_patch_after_own_write_keeps_the_baseline(tmp_path, task):
path = tmp_path / "written.txt"
_ok(_write(path, task, "a=1\nb=1\n"))
_replace(path, task, "a=1", "a=2")
_replace(path, task, "b=1", "b=2")
_ok(_write(path, task, "a=3\nb=3\n"))
assert path.read_text() == "a=3\nb=3\n"
def test_own_v4a_patch_keeps_the_baseline_for_every_file(tmp_path, task):
one, two = tmp_path / "one.txt", tmp_path / "two.txt"
for p in (one, two):
p.write_text("alpha\nbeta\n")
_read(p, task)
_v4a(task, (one, "alpha", "ALPHA"))
_ok(_write(one, task, "single\n"))
assert one.read_text() == "single\n"
_read(one, task)
_v4a(task, (one, "single", "SINGLE"), (two, "alpha", "ALPHA"))
for p in (one, two):
_ok(_write(p, task, f"replaced {p.name}\n"))
assert p.read_text() == f"replaced {p.name}\n"
# Two operations on one file chain: the second reads what the first wrote.
_v4a(task, (one, f"replaced {one.name}", "first"), (one, "first", "second"))
assert one.read_text() == "second\n"
_ok(_write(one, task, "chained\n"))
# A file the patch created holds only bytes the task wrote, like write_file creating it.
added = tmp_path / "added.txt"
_ok(_dispatch("patch", task, mode="patch",
patch=f"*** Begin Patch\n*** Add File: {added}\n+created\n*** End Patch"))
_ok(_write(added, task, "replaced\n"))
assert added.read_text() == "replaced\n"
def test_own_patch_keeps_crlf_and_bom_files_writable(tmp_path, task):
path = tmp_path / "crlf.txt"
path.write_bytes(b"\xef\xbb\xbfone\r\ntwo\r\n")
_read(path, task)
_replace(path, task, "one", "ONE")
assert path.read_bytes() == b"\xef\xbb\xbfONE\r\ntwo\r\n"
_ok(_write(path, task, "three\n"))
def test_blind_patch_never_gains_a_baseline(tmp_path, task):
path = tmp_path / "blind.txt"
path.write_text("one\ntwo\nthree\n")
_replace(path, task, "one", "ONE")
error = _blocked(_write(path, task, "x\n"))
assert _BLIND in error
assert path.read_text() == "ONE\ntwo\nthree\n"
# A partial view is not full knowledge either.
path.write_text("one\ntwo\nthree\n")
_read(path, task, offset=1, limit=1)
_replace(path, task, "two", "TWO")
assert _BLIND in _blocked(_write(path, task, "x\n"))
assert path.read_text() == "one\nTWO\nthree\n"
# Recovery: read every line, then the overwrite lands.
_read(path, task)
_ok(_write(path, task, "merged\n"))
assert path.read_text() == "merged\n"
def test_sibling_patch_voids_the_other_task_and_gives_the_patcher_nothing(tmp_path, task):
path = tmp_path / "shared.txt"
path.write_text("left\nright\n")
sibling = f"{task}-sibling"
try:
_read(path, task)
_replace(path, sibling, "right", "RIGHT")
mine = _blocked(_write(path, task, "mine\n"))
assert _BLIND not in mine and sibling in mine
assert _BLIND in _blocked(_write(path, sibling, "theirs\n"))
assert path.read_text() == "left\nRIGHT\n"
_read(path, task)
_ok(_write(path, task, "mine\n"))
_read(path, sibling)
_ok(_write(path, sibling, "theirs\n"))
assert path.read_text() == "theirs\n"
finally:
clear_file_ops_cache(sibling)
@pytest.mark.parametrize("preserve_mtime", [False, True], ids=["mtime-moves", "mtime-restored"])
def test_external_edit_after_own_patch_is_refused(tmp_path, task, preserve_mtime):
path = tmp_path / "external.txt"
path.write_text("one\ntwo\n")
_read(path, task)
_replace(path, task, "one", "ONE")
stamp = path.stat()
path.write_text("ONE\nEXTERNAL\n")
if preserve_mtime:
os.utime(path, ns=(stamp.st_atime_ns, stamp.st_mtime_ns))
else:
os.utime(path, ns=(stamp.st_atime_ns, stamp.st_mtime_ns + 1_000_000_000))
error = _blocked(_write(path, task, "clobber\n"))
assert _BLIND not in error
assert path.read_text() == "ONE\nEXTERNAL\n"
_read(path, task)
_ok(_write(path, task, "merged\n"))
assert path.read_text() == "merged\n"
def test_write_landing_after_the_patch_write_gives_no_baseline(tmp_path, task, monkeypatch):
path = tmp_path / "raced-after.txt"
path.write_text("one\ntwo\n")
original = file_operations.ShellFileOperations.patch_replace
def patch_then_external_write(self, *args, **kwargs):
result = original(self, *args, **kwargs)
stamp = os.stat(path)
path.write_text("ONE\nRACED\n")
os.utime(path, ns=(stamp.st_atime_ns, stamp.st_mtime_ns))
return result
_read(path, task)
monkeypatch.setattr(file_operations.ShellFileOperations, "patch_replace", patch_then_external_write)
_replace(path, task, "one", "ONE")
monkeypatch.undo()
_blocked(_write(path, task, "clobber\n"))
assert path.read_text() == "ONE\nRACED\n"
def test_write_landing_before_the_patch_read_gives_no_baseline(tmp_path, task, monkeypatch):
"""The patch applied its delta to bytes the task never saw in full."""
path = tmp_path / "raced-before.txt"
path.write_text("one\ntwo\n")
original = file_operations.ShellFileOperations.patch_replace
def external_write_then_patch(self, *args, **kwargs):
path.write_text("one\nUNSEEN\n")
return original(self, *args, **kwargs)
_read(path, task)
monkeypatch.setattr(file_operations.ShellFileOperations, "patch_replace", external_write_then_patch)
_replace(path, task, "one", "ONE")
monkeypatch.undo()
assert path.read_text() == "ONE\nUNSEEN\n"
_blocked(_write(path, task, "clobber\n"))
assert path.read_text() == "ONE\nUNSEEN\n"
def test_paged_read_carries_only_when_every_page_was_read(tmp_path, task):
content = "".join(f"line {i}\n" for i in range(1, 2501))
complete, missing = tmp_path / "complete.txt", tmp_path / "missing.txt"
for p in (complete, missing):
p.write_text(content)
assert _read(p, task).get("truncated")
_read(complete, task, offset=2001)
for p in (complete, missing):
_replace(p, task, "line 1\n", "LINE 1\n")
_ok(_write(complete, task, "merged\n"))
assert complete.read_text() == "merged\n"
assert _BLIND in _blocked(_write(missing, task, "merged\n"))
assert missing.read_text().startswith("LINE 1\nline 2\n")
@pytest.mark.parametrize("reread", [False, True], ids=["no-reread", "reread"])
def test_own_patch_after_compaction_keeps_the_baseline(tmp_path, task, reread):
path = tmp_path / "compacted.txt"
path.write_text("one\ntwo\n")
_read(path, task)
reset_file_dedup(task)
if reread:
_read(path, task)
_replace(path, task, "one", "ONE")
_ok(_write(path, task, "merged\n"))
assert path.read_text() == "merged\n"
def test_third_patch_failure_hint_requires_a_full_reread_before_write_file(tmp_path, task):
path = tmp_path / "anchor.txt"
path.write_text("alpha\n")
for _ in range(3):
failed = _dispatch("patch", task, path=str(path), old_string="missing", new_string="x")
hint = failed["_hint"]
assert "failure #3" in hint
assert "re-read the file in full, then use write_file to replace it" in hint
assert "use write_file to replace the entire file" not in hint