@miller-tech/uap 1.178.1 → 1.179.2

package/tools/agents/tests/test_error_loop_ignores_correctives.py

@@ -52,10 +52,12 @@ def _load_signature():
     start = src.index("_ERROR_LINE_RE = re.compile(")
     end = src.index("\n# ---", src.index("def _error_signature"))
     exec(src[start:end], ns)  # noqa: S102 - reading our own source, not input
-    return ns["_error_signature"]
+    return ns
 
 
-_error_signature = _load_signature()
+_NS = _load_signature()
+_error_signature = _NS["_error_signature"]
+_error_signature_for_result = _NS["_error_signature_for_result"]
 
 
 class TestHarnessCorrectivesAreNotFailures(unittest.TestCase):
@@ -164,3 +166,90 @@ class TestDeniedFailuresInPlainProse(unittest.TestCase):
             "2 tests failed",
         ):
             assert _error_signature(line) != "", line
+
+
+# The source file the model was reading when ERROR-LOOP fired on 2026-07-31.
+# Nothing failed; this is a file's CONTENTS, delivered as a successful Read.
+SOURCE_FILE_READ = '''def _load_state() -> dict:
+    try:
+        data = json.loads(_state_path().read_text())
+        return data if isinstance(data, dict) else {}
+    except Exception:  # noqa: BLE001 - unreadable state must not break the tool call
+        return {}
+'''
+
+
+class TestIsErrorFlagBeatsKeywords(unittest.TestCase):
+    """A file that CONTAINS "Exception" is not a failure.
+
+    Keyword sniffing cannot tell a program reporting a failure from a file that
+    merely mentions one. Reading a file is the most common thing an agent does,
+    so any source containing `Exception`, `error` or `not found` could
+    manufacture a streak — and did: three reads of one file produced three
+    identical signatures, and ERROR-LOOP told the model to re-read the file it
+    had just read.
+    """
+
+    def test_a_successful_read_never_produces_a_signature(self):
+        self.assertEqual(_error_signature_for_result(SOURCE_FILE_READ, False), "")
+
+    def test_three_successful_reads_cannot_arm_the_guard(self):
+        # Three was the threshold, and re-reading a file is not a failure streak.
+        sigs = {_error_signature_for_result(SOURCE_FILE_READ, False) for _ in range(3)}
+        self.assertEqual(sigs, {""})
+
+    def test_is_error_false_wins_over_a_real_looking_traceback(self):
+        # `cat` of a log file full of tracebacks is still a successful read.
+        text = "Traceback (most recent call last):\nTypeError: x is not a function"
+        self.assertEqual(_error_signature_for_result(text, False), "")
+
+    def test_is_error_true_still_produces_a_signature(self):
+        text = "ERROR: TypeError: x is not a function at /a/b.js:12"
+        self.assertNotEqual(_error_signature_for_result(text, True), "")
+
+    def test_is_error_true_with_an_unfamiliar_shape_still_forms_a_streak(self):
+        # The client declared a failure; losing it because no keyword matched
+        # would be the opposite mistake — a real repeated failure going untracked.
+        text = "the frobnicator declined\nmore detail here"
+        sig = _error_signature_for_result(text, True)
+        self.assertNotEqual(sig, "")
+        self.assertEqual(sig, _error_signature_for_result(text, True))  # stable
+
+    def test_without_the_flag_the_old_heuristics_still_apply(self):
+        # Clients that never send is_error must keep working exactly as before.
+        self.assertNotEqual(_error_signature_for_result("ERROR: SyntaxError: bad", None), "")
+        self.assertEqual(_error_signature_for_result("all tests passed", None), "")
+        self.assertEqual(
+            _error_signature_for_result(SOURCE_FILE_READ, None), _error_signature(SOURCE_FILE_READ)
+        )
+
+    def test_an_empty_declared_error_does_not_crash(self):
+        self.assertEqual(_error_signature_for_result("", True), "")
+        self.assertEqual(_error_signature_for_result("   \n\n ", True), "")
+
+
+class TestTheFlagIsActuallyWiredThrough(unittest.TestCase):
+    """The logic above is worthless if the caller never passes the flag.
+
+    That was the whole bug: the request handler computed `_latest_err` from the
+    tool_result blocks and then called `note_tool_result_error(_latest_tr)`,
+    dropping it. Every unit test passed. Reverting the call site to the one-arg
+    form — i.e. restoring the live bug exactly — still passes the entire suite,
+    which is why this asserts on the source.
+    """
+
+    def test_the_request_handler_passes_the_is_error_flag(self):
+        src = PROXY.read_text()
+        assert "_latest_err" in src, "the handler no longer computes the is_error flag"
+        assert re.search(r"note_tool_result_error\(\s*_latest_tr\s*,\s*_latest_err\s*\)", src), (
+            "note_tool_result_error is called without the is_error flag — reading a file that "
+            "contains the word 'Exception' will manufacture a failure streak again"
+        )
+
+    def test_the_signature_helper_is_the_one_being_used(self):
+        # A refactor that quietly points the monitor back at _error_signature
+        # would reinstate the keyword-only behaviour.
+        src = PROXY.read_text()
+        assert re.search(
+            r"sig = _error_signature_for_result\(latest_result_text or \"\", result_error\)", src
+        ), "note_tool_result_error no longer routes through _error_signature_for_result"

package/tools/agents/tests/test_validate_plan_inside_project.py

@@ -0,0 +1,106 @@
+"""validate-plan-on-change: only track what `uap plan validate` can validate.
+
+The enforcer recorded ANY plan-named file it saw written, including paths
+outside the project. `uap plan validate` refuses those ("explicit plan file must
+live under the project directory"), so the entry could never be cleared: every
+build in the repo blocked, and the remedy the refusal named declined the file.
+Observed live with a memory note at
+~/.claude/projects/<slug>/memory/plan_gate_before_build.md — not a plan at all,
+matched only because its filename contains "plan".
+
+The rename case is the one to guard hardest. `mv PLAN.md PLAN2.md` is not an
+edit op, so no new pending entry is recorded; auto-forgiving the old key on the
+build path would make a rename a silent, unattended gate bypass with the plan
+content fully intact. An earlier draft of this change did exactly that.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ENFORCER = Path(__file__).resolve().parents[3] / "src" / "policies" / "enforcers" / "validate_plan_on_change.py"
+
+
+def run(cwd: str, op: str, args: dict) -> str:
+    proc = subprocess.run(
+        [sys.executable, str(ENFORCER), "--operation", op, "--args", json.dumps(args)],
+        capture_output=True,
+        text=True,
+        cwd=cwd,
+    )
+    return proc.stdout + proc.stderr
+
+
+def state(cwd: str) -> dict:
+    path = Path(cwd) / ".uap" / "plan_state.json"
+    return json.loads(path.read_text()) if path.exists() else {}
+
+
+class TestPlanGateTracksOnlyProjectFiles(unittest.TestCase):
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self.cwd = self._tmp.name
+        os.makedirs(os.path.join(self.cwd, "docs", "plans"), exist_ok=True)
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def test_outside_project_plan_is_not_tracked(self) -> None:
+        out = run(self.cwd, "Write", {"file_path": "/tmp/elsewhere/stray-plan.md"})
+        self.assertIn("outside the project", out)
+        self.assertEqual(state(self.cwd).get("pending", {}), {})
+
+    def test_in_project_plan_is_still_tracked(self) -> None:
+        Path(self.cwd, "docs", "plans", "real-plan.md").write_text("# real")
+        run(self.cwd, "Write", {"file_path": "docs/plans/real-plan.md"})
+        self.assertIn("docs/plans/real-plan.md", state(self.cwd).get("pending", {}))
+
+    def test_build_is_blocked_and_names_the_recovery_command(self) -> None:
+        Path(self.cwd, "docs", "plans", "real-plan.md").write_text("# real")
+        run(self.cwd, "Write", {"file_path": "docs/plans/real-plan.md"})
+        out = run(self.cwd, "Bash", {"command": "npm run build"})
+        self.assertIn("never validated", out)
+        # A wedged agent must not be sent to the one command that declines the file.
+        self.assertIn("uap plan clear", out)
+
+    def test_renaming_a_pending_plan_does_not_forgive_it(self) -> None:
+        plan = Path(self.cwd, "docs", "plans", "real-plan.md")
+        plan.write_text("# real")
+        run(self.cwd, "Write", {"file_path": "docs/plans/real-plan.md"})
+        plan.rename(Path(self.cwd, "docs", "plans", "real-plan-v2.md"))
+
+        out = run(self.cwd, "Bash", {"command": "npm run build"})
+        self.assertIn("never validated", out)
+        self.assertIn("docs/plans/real-plan.md", state(self.cwd).get("pending", {}))
+
+    def test_legacy_outside_entry_is_pruned_and_audited(self) -> None:
+        Path(self.cwd, "docs", "plans", "real-plan.md").write_text("# real")
+        run(self.cwd, "Write", {"file_path": "docs/plans/real-plan.md"})
+        st = state(self.cwd)
+        st.setdefault("pending", {})["/home/somewhere/legacy-plan.md"] = 1
+        Path(self.cwd, ".uap", "plan_state.json").write_text(json.dumps(st))
+
+        run(self.cwd, "Bash", {"command": "npm run build"})
+        st = state(self.cwd)
+        self.assertNotIn("/home/somewhere/legacy-plan.md", st.get("pending", {}))
+        # The in-project plan still gates the build.
+        self.assertIn("docs/plans/real-plan.md", st.get("pending", {}))
+        # A shrinking blocking set must leave a trail.
+        cleared = st.get("cleared", [])
+        self.assertEqual(len(cleared), 1)
+        self.assertEqual(cleared[0]["key"], "/home/somewhere/legacy-plan.md")
+        self.assertIn("outside the project", cleared[0]["reason"])
+
+    def test_non_plan_writes_are_untouched(self) -> None:
+        out = run(self.cwd, "Write", {"file_path": "src/index.ts"})
+        self.assertIn("not a plan artifact", out)
+        self.assertEqual(state(self.cwd).get("pending", {}), {})
+
+
+if __name__ == "__main__":
+    unittest.main()