@miller-tech/uap 1.196.0 → 1.197.0

package/tools/agents/tests/test_fastpath_config.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""How big a "trivial" edit is, is a project decision — so it belongs in the repo.
+
+The fast-path budgets (per-edit threshold, cumulative chars, cumulative edits)
+were read from the environment only. That meant only whoever launched the agent
+could size them, and the choice left no trace: nothing in the repo recorded that
+this project had decided a bigger budget, so the next session silently got the
+default again.
+
+They now come from `.uap.json` (`delivery.trivialEditChars`,
+`delivery.cumulativeChars`, `delivery.cumulativeEdits`), with the environment
+still winning where it is set, so a one-session operator override still works.
+
+Both halves of the gate read the SAME setting: the hook that decides fast-path,
+and the enforcer that decides refusal. Two numbers for one question would mean
+the hook fast-paths an edit the enforcer then refuses.
+"""
+
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[3]
+HOOK = ROOT / "templates" / "hooks" / "fastpath_gate.py"
+
+
+def _load(path: Path, name: str):
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec and spec.loader
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+hook = _load(HOOK, "fastpath_gate")
+enf = _load(ROOT / "src" / "policies" / "enforcers" / "delivery_enforcement.py", "denf")
+
+
+class Project:
+    def __init__(self, delivery: dict | None = None, raw: str | None = None):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        if raw is not None:
+            (self.root / ".uap.json").write_text(raw)
+        elif delivery is not None:
+            (self.root / ".uap.json").write_text(json.dumps({"version": 1, "delivery": delivery}))
+
+    def close(self):
+        self.tmp.cleanup()
+
+
+class HookReadsTheProjectConfig(unittest.TestCase):
+    def setUp(self):
+        self.saved = {k: os.environ.get(k) for k in ("TRIVIAL", "CUM_CHARS", "CUM_EDITS", "UAP_MAIN_ROOT")}
+        for k in self.saved:
+            os.environ.pop(k, None)
+
+    def tearDown(self):
+        for k, v in self.saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+
+    def test_uses_the_documented_default_when_nothing_is_configured(self):
+        p = Project()
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 240)
+        self.assertEqual(hook._configured("cumulativeChars", "CUM_CHARS", 800), 800)
+        p.close()
+
+    def test_reads_the_value_committed_in_uap_json(self):
+        p = Project({"trivialEditChars": 800, "cumulativeChars": 6000})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 800)
+        self.assertEqual(hook._configured("cumulativeChars", "CUM_CHARS", 800), 6000)
+        p.close()
+
+    def test_the_environment_still_wins_over_the_project(self):
+        # An operator sizing one session must not have to edit the repo.
+        p = Project({"trivialEditChars": 800})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        os.environ["TRIVIAL"] = "50"
+        self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 50)
+        p.close()
+
+    def test_a_malformed_override_falls_through_instead_of_crashing(self):
+        p = Project({"trivialEditChars": 800})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        os.environ["TRIVIAL"] = "not-a-number"
+        self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 800)
+        p.close()
+
+    def test_a_broken_config_does_not_break_the_gate(self):
+        # A gate that throws on a malformed config is a gate that blocks all work.
+        for raw in ("{not json", "[]", '{"delivery": "nope"}', '{"delivery": {"trivialEditChars": "big"}}'):
+            p = Project(raw=raw)
+            os.environ["UAP_MAIN_ROOT"] = str(p.root)
+            self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 240, raw)
+            p.close()
+
+    def test_a_boolean_is_not_a_budget(self):
+        # True would otherwise arrive as 1, making every edit non-trivial.
+        p = Project({"trivialEditChars": True})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 240)
+        p.close()
+
+    def test_a_negative_budget_clamps_rather_than_inverting_the_gate(self):
+        p = Project({"cumulativeChars": -5})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(hook._configured("cumulativeChars", "CUM_CHARS", 800), 0)
+        p.close()
+
+    def test_a_missing_config_file_is_normal_not_an_error(self):
+        p = Project()
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(hook._configured("cumulativeEdits", "CUM_EDITS", 6), 6)
+        p.close()
+
+
+class BothHalvesAgree(unittest.TestCase):
+    """The hook decides fast-path; the enforcer decides refusal. One number."""
+
+    def setUp(self):
+        self.saved = {k: os.environ.get(k) for k in
+                      ("TRIVIAL", "UAP_DELIVER_TRIVIAL_EDIT_CHARS", "UAP_MAIN_ROOT")}
+        for k in self.saved:
+            os.environ.pop(k, None)
+
+    def tearDown(self):
+        for k, v in self.saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+
+    def test_enforcer_and_hook_read_the_same_project_value(self):
+        p = Project({"trivialEditChars": 900})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(enf._trivial_edit_chars(), 900)
+        self.assertEqual(hook._configured("trivialEditChars", "TRIVIAL", 240), 900)
+        p.close()
+
+    def test_enforcer_honours_its_own_env_override_first(self):
+        p = Project({"trivialEditChars": 900})
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        os.environ["UAP_DELIVER_TRIVIAL_EDIT_CHARS"] = "120"
+        self.assertEqual(enf._trivial_edit_chars(), 120)
+        p.close()
+
+    def test_enforcer_falls_back_to_the_same_default(self):
+        p = Project()
+        os.environ["UAP_MAIN_ROOT"] = str(p.root)
+        self.assertEqual(enf._trivial_edit_chars(), 240)
+        p.close()
+
+
+class TheDecisionActuallyUsesIt(unittest.TestCase):
+    """Testing the reader is not testing the gate.
+
+    `_configured` can be perfect while the call sites still read the raw
+    environment — the decision is what ships, so drive the real entry point.
+    """
+
+    def _decide(self, root: Path, payload: dict, env: dict) -> int:
+        e = dict(os.environ)
+        for k in ("TRIVIAL", "CUM_CHARS", "CUM_EDITS"):
+            e.pop(k, None)
+        e["UAP_MAIN_ROOT"] = str(root)
+        e.update(env)
+        r = subprocess.run([sys.executable, str(HOOK)], input=json.dumps(payload),
+                           capture_output=True, text=True, cwd=str(root), env=e)
+        return r.returncode
+
+    def test_a_project_sized_threshold_changes_the_verdict(self):
+        # 400 changed chars: routed under the 240 default, fast-pathed under a
+        # project that has decided 800.
+        edit = {"file_path": "src/app.ts", "old_string": "x" * 200, "new_string": "y" * 200}
+        strict = Project({"trivialEditChars": 240, "cumulativeChars": 100000})
+        loose = Project({"trivialEditChars": 800, "cumulativeChars": 100000})
+        try:
+            self.assertEqual(self._decide(strict.root, edit, {}), 1, "should ROUTE under 240")
+            self.assertEqual(self._decide(loose.root, edit, {}), 0, "should FAST-PATH under 800")
+        finally:
+            strict.close()
+            loose.close()
+
+    def test_a_project_sized_cumulative_budget_changes_the_verdict(self):
+        # Same small edit repeated: the cumulative budget decides when it routes.
+        edit = {"file_path": "src/app.ts", "old_string": "x" * 50, "new_string": "y" * 50}
+        tight = Project({"trivialEditChars": 240, "cumulativeChars": 150, "cumulativeEdits": 99})
+        roomy = Project({"trivialEditChars": 240, "cumulativeChars": 100000, "cumulativeEdits": 99})
+        try:
+            self.assertEqual(self._decide(tight.root, edit, {}), 0, "first edit fits")
+            self.assertEqual(self._decide(tight.root, edit, {}), 1, "second crosses 150 chars")
+            self.assertEqual(self._decide(roomy.root, edit, {}), 0)
+            self.assertEqual(self._decide(roomy.root, edit, {}), 0, "still inside a big budget")
+        finally:
+            tight.close()
+            roomy.close()
+
+    def test_the_environment_still_overrides_the_project_end_to_end(self):
+        edit = {"file_path": "src/app.ts", "old_string": "x" * 200, "new_string": "y" * 200}
+        p = Project({"trivialEditChars": 800, "cumulativeChars": 100000})
+        try:
+            self.assertEqual(self._decide(p.root, edit, {}), 0)
+            self.assertEqual(self._decide(p.root, edit, {"TRIVIAL": "100"}), 1)
+        finally:
+            p.close()
+
+
+class EveryInstalledCopyCarriesIt(unittest.TestCase):
+    """Hook template drift: a fix that never reaches templates/ is reverted the
+    next time a worktree is created, and a fix only in templates/ never runs."""
+
+    def test_all_copies_read_the_config(self):
+        # Filter on the path RELATIVE to the root: this test may itself be
+        # running inside .worktrees/, so matching the absolute path excluded
+        # every copy and the assertion silently passed on an empty list.
+        copies = []
+        for p in ROOT.rglob("fastpath_gate.py"):
+            rel = str(p.relative_to(ROOT))
+            if "node_modules" in rel or rel.startswith(".worktrees"):
+                continue
+            copies.append(p)
+        self.assertGreater(len(copies), 1, "expected a template plus installed copies")
+        for p in copies:
+            self.assertIn("_configured(", p.read_text(), f"{p} still reads env only")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tools/agents/tests/test_live_deliver_kill.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Killing a RUNNING deliver run is the blocker, not planning.
+
+Measured 2026-08-11: three consecutive runs reached turn 3, turn 8 and turn 10
+and every one was terminated from outside. The proxy journal caught the shape —
+a kill of the run's own pid, followed by a cooperative stop request, five
+minutes after launch. Both halves are the caller trying to stop a run; only the
+second keeps the work. The first drops the turn in flight with the lock still
+held, and it is why "deliver never gets past planning" was believed while the
+runs were in fact working.
+
+The rule has to be NARROW: killing anything else stays allowed, because a
+blanket refusal on `kill` would block ordinary process cleanup for no gain.
+"""
+
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+
+def _load():
+    p = Path(__file__).resolve().parents[3] / "src" / "policies" / "enforcers" / "enforcement_self_protect.py"
+    spec = importlib.util.spec_from_file_location("esp", p)
+    assert spec and spec.loader
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+esp = _load()
+
+
+class LiveRunFixture:
+    """A real sleeping process, recorded as a running deliver run."""
+
+    def __init__(self, root: Path, run_id: str = "run-20260811T091247-84d1f1", pid: int | None = None):
+        self.root = root
+        self.run_id = run_id
+        self.proc = None
+        if pid is None:
+            # argv must contain "deliver" — the rule verifies against /proc so a
+            # recycled pid cannot be mistaken for a run.
+            self.proc = subprocess.Popen(
+                [sys.executable, "-c", "import time,sys; sys.argv.append('deliver'); time.sleep(30)", "deliver"]
+            )
+            pid = self.proc.pid
+        self.pid = pid
+        d = root / ".uap" / "deliver-runs" / run_id
+        d.mkdir(parents=True, exist_ok=True)
+        (d / "state.json").write_text(json.dumps({
+            "runId": run_id, "instruction": "replace the lateral joins",
+            "presetId": "p", "projectRoot": str(root), "status": "running",
+            "createdAt": "2026-08-11T09:12:47Z", "updatedAt": "2026-08-11T09:15:00Z",
+            "pid": self.pid,
+        }))
+
+    def close(self):
+        if self.proc:
+            self.proc.kill()
+            self.proc.wait()
+
+
+class KillsLiveDeliverRun(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.fx = LiveRunFixture(self.root)
+
+    def tearDown(self):
+        self.fx.close()
+        self.tmp.cleanup()
+
+    def test_refuses_the_exact_command_from_the_journal(self):
+        cmd = f"kill {self.fx.pid} 2>/dev/null; touch {self.root}/.uap/deliver-runs/STOP"
+        self.assertEqual(esp._kills_live_deliver_run(cmd, self.root), self.fx.run_id)
+
+    def test_refuses_kill_9_and_explicit_signals(self):
+        for cmd in (f"kill -9 {self.fx.pid}", f"kill -TERM {self.fx.pid}", f"kill -15 {self.fx.pid}"):
+            self.assertTrue(esp._kills_live_deliver_run(cmd, self.root), cmd)
+
+    def test_ALLOWS_kill_0_because_that_is_a_liveness_PROBE(self):
+        # Refusing this would break the very check that tells a caller whether
+        # the run is still alive — and push it back toward killing blindly.
+        self.assertEqual(esp._kills_live_deliver_run(f"kill -0 {self.fx.pid}", self.root), "")
+
+    def test_ALLOWS_killing_an_unrelated_process(self):
+        other = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)"])
+        try:
+            self.assertEqual(esp._kills_live_deliver_run(f"kill {other.pid}", self.root), "")
+        finally:
+            other.kill()
+            other.wait()
+
+    def test_refuses_a_pattern_kill_that_would_match_the_run(self):
+        self.assertTrue(esp._kills_live_deliver_run("pkill -f deliver", self.root))
+
+    def test_ALLOWS_a_pattern_kill_that_matches_nothing_of_ours(self):
+        self.assertEqual(esp._kills_live_deliver_run("pkill -f 'http.server 8765'", self.root), "")
+
+    def test_a_recycled_pid_is_not_treated_as_a_live_run(self):
+        # The PID-reuse trap that once deadlocked the deliver lock: the record
+        # says running, but the process at that pid is something else entirely.
+        other = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)"])
+        try:
+            fx = LiveRunFixture(self.root, run_id="run-stale-aaaaaa", pid=other.pid)
+            self.assertEqual(esp._kills_live_deliver_run(f"kill {other.pid}", self.root), "")
+        finally:
+            other.kill()
+            other.wait()
+
+    def test_a_dead_pid_is_not_a_live_run(self):
+        dead = subprocess.Popen([sys.executable, "-c", "pass"])
+        dead.wait()
+        time.sleep(0.05)
+        LiveRunFixture(self.root, run_id="run-dead-bbbbbb", pid=dead.pid)
+        self.assertEqual(esp._kills_live_deliver_run(f"kill {dead.pid}", self.root), "")
+
+    def test_a_FINISHED_run_is_not_protected_even_if_its_process_lingers(self):
+        # Only a run that is still RUNNING has work to lose. One marked
+        # delivered or failed has finished; its process may be winding down, and
+        # refusing to kill that would block ordinary cleanup for no benefit.
+        for status in ("delivered", "failed", "interrupted"):
+            d = self.root / ".uap" / "deliver-runs" / self.fx.run_id
+            data = json.loads((d / "state.json").read_text())
+            data["status"] = status
+            (d / "state.json").write_text(json.dumps(data))
+            self.assertEqual(
+                esp._kills_live_deliver_run(f"kill {self.fx.pid}", self.root), "", status
+            )
+
+    def test_a_run_that_already_recorded_an_exit_is_not_live(self):
+        d = self.root / ".uap" / "deliver-runs" / self.fx.run_id
+        data = json.loads((d / "state.json").read_text())
+        data["exit"] = {"at": "2026-08-11T09:18:10Z", "reason": "killed by SIGTERM"}
+        (d / "state.json").write_text(json.dumps(data))
+        self.assertEqual(esp._kills_live_deliver_run(f"kill {self.fx.pid}", self.root), "")
+
+    def test_costs_nothing_when_the_command_is_not_a_kill(self):
+        self.assertEqual(esp._kills_live_deliver_run("uap deliver --await-run", self.root), "")
+        self.assertEqual(esp._kills_live_deliver_run("", self.root), "")
+
+    def test_survives_a_project_with_no_runs_at_all(self):
+        with tempfile.TemporaryDirectory() as empty:
+            self.assertEqual(esp._kills_live_deliver_run("kill 1", Path(empty)), "")
+
+    def test_survives_unreadable_run_state(self):
+        (self.root / ".uap" / "deliver-runs" / "run-junk-cccccc").mkdir(parents=True)
+        (self.root / ".uap" / "deliver-runs" / "run-junk-cccccc" / "state.json").write_text("{not json")
+        self.assertEqual(esp._kills_live_deliver_run(f"kill {self.fx.pid}", self.root), self.fx.run_id)
+
+
+class RefusalIsActionable(unittest.TestCase):
+    """A refusal that does not name the alternative is how a loop survives a guard."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.fx = LiveRunFixture(self.root)
+
+    def tearDown(self):
+        self.fx.close()
+        self.tmp.cleanup()
+
+    def test_the_enforcer_refuses_end_to_end_and_names_the_cooperative_stop(self):
+        env = dict(os.environ)
+        env.pop("UAP_SELF_PROTECT_OFF", None)
+        env["CLAUDE_PROJECT_DIR"] = str(self.root)
+        enforcer = Path(__file__).resolve().parents[3] / "src" / "policies" / "enforcers" / "enforcement_self_protect.py"
+        r = subprocess.run(
+            [sys.executable, str(enforcer), "--operation", "Bash",
+             "--args", json.dumps({"command": f"kill {self.fx.pid} 2>/dev/null"})],
+            capture_output=True, text=True, cwd=str(self.root), env=env)
+        out = r.stdout + r.stderr
+        self.assertIn("RUNNING", out, out[:400])
+        self.assertIn("deliver-runs/STOP", out, out[:400])
+        self.assertIn("--await-run", out, out[:400])
+
+
+if __name__ == "__main__":
+    unittest.main()