@miller-tech/uap 1.81.0 → 1.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.81.0",
+  "version": "1.82.0",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",

package/src/policies/enforcers/worktree_required.py

@@ -46,10 +46,24 @@ def main() -> None:
     if os.environ.get("UAP_NO_WORKTREE") == "1":
         emit(True, "UAP_NO_WORKTREE override set")
 
+    # R1: a worktree cannot exist without git, so the requirement is
+    # UNSATISFIABLE on a non-git project -- blocking there is a guaranteed
+    # deadlock (the model loops creating tasks about a worktree it can never
+    # create). Fail open when there is no git metadata.
+    if not os.path.exists(os.path.join(str(root), ".git")):
+        emit(True, "not a git repo -- worktrees are not applicable")
+
+    # R3: imperative message with a working fallback command + a machine-
+    # actionable route hint. The old message pointed only at uap worktree
+    # create, which fails on hybrid/bare repos.
     emit(
         False,
-        f"worktree-required: '{rel}' must be edited inside .worktrees/NNN-<slug>/. "
-        "Run: uap worktree create <slug>",
+        f"BLOCKED: '{rel}' must be edited inside a worktree (.worktrees/NNN-<slug>/). "
+        "Create one FIRST, then edit there: `uap worktree create <slug>` "
+        "(or if that fails: `git worktree add .worktrees/001-<slug> -b feature/<slug>`). "
+        "Do NOT keep planning or creating tasks about the worktree -- run the command now.",
+        route="worktree",
+        worktreeHint="uap worktree create <slug>",
     )
 
 

package/tools/agents/scripts/anthropic_proxy.py

@@ -206,6 +206,16 @@ PROXY_COORDINATION_TOOLS = {
 PROXY_COORDINATION_BAN_THRESHOLD = int(
     os.environ.get("PROXY_COORDINATION_BAN_THRESHOLD", "2")
 )
+# R4: early coordination-loop ban. The per-tool cycle ban above engages only
+# inside an active agentic loop (tool_results present). But a model can loop on a
+# coordination tool from the very FIRST moves -- e.g. repeatedly creating a task
+# ABOUT doing X instead of doing X (observed: TaskCreate x4 identical args at
+# session start) -- where the cycle detector never engages. This bans a
+# coordination tool after N consecutive IDENTICAL calls regardless of loop state.
+# 0 disables.
+PROXY_COORDINATION_EARLY_BAN = int(
+    os.environ.get("PROXY_COORDINATION_EARLY_BAN", "3")
+)
 # Force finalize after N consecutive forced_budget_exhausted events where
 # neither cycling nor stagnation was detected — catches "distinct but
 # unproductive" tool spam that defeats per-tool cycle detection.
@@ -1036,6 +1046,8 @@ class SessionMonitor:
     tool_state_unproductive_exhaustion_streak: int = 0
     last_tool_fingerprint: str = ""
     cycling_tool_names: list = field(default_factory=list)
+    coordination_repeat_streak: int = 0  # R4: consecutive identical coordination-tool calls
+    last_coordination_fp: str = ""       # R4: fingerprint of the last coordination call
     session_banned_tools: set = field(default_factory=set)  # tools banned for entire session after repeated cycling
     tool_cycle_counts: dict = field(default_factory=dict)  # {tool_name: cycle_count} across resets
     last_response_garbled: bool = False  # previous turn had garbled/malformed output
@@ -1201,6 +1213,33 @@ class SessionMonitor:
         if len(self.tool_call_history) > 30:
             self.tool_call_history = self.tool_call_history[-30:]
 
+        # R4: early coordination-loop ban (independent of the active-loop cycle
+        # detector). A coordination/bookkeeping tool repeated with IDENTICAL args
+        # is never productive; ban it directly so narrowing drops it next turn,
+        # breaking the "create a task ABOUT X instead of doing X" loop.
+        coord_names = [n for n in (tool_names or []) if n in PROXY_COORDINATION_TOOLS]
+        if fp and coord_names and fp == self.last_coordination_fp:
+            self.coordination_repeat_streak += 1
+        elif coord_names:
+            self.coordination_repeat_streak = 1
+            self.last_coordination_fp = fp
+        else:
+            self.coordination_repeat_streak = 0
+            self.last_coordination_fp = ""
+        if (
+            PROXY_COORDINATION_EARLY_BAN > 0
+            and self.coordination_repeat_streak >= PROXY_COORDINATION_EARLY_BAN
+        ):
+            for n in coord_names:
+                if n not in self.session_banned_tools:
+                    self.session_banned_tools.add(n)
+                    logger.warning(
+                        "TOOL BAN (R4 early): '%s' banned after %d consecutive "
+                        "identical coordination calls",
+                        n,
+                        self.coordination_repeat_streak,
+                    )
+
         # Recon-convergence (B1): count consecutive turns that use tools but
         # produce NO write/deliverable tool call. A turn that uses any write
         # tool resets the streak — that's the model converging from

package/tools/agents/tests/test_coordination_early_ban.py

@@ -0,0 +1,43 @@
+"""Tests for R4: early coordination-loop ban (independent of active-loop)."""
+import importlib.util
+import unittest
+from pathlib import Path
+
+proxy_path = Path(__file__).resolve().parents[3] / "tools" / "agents" / "scripts" / "anthropic_proxy.py"
+spec = importlib.util.spec_from_file_location("anthropic_proxy", proxy_path)
+ap = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(ap)
+
+
+class EarlyCoordinationBanTest(unittest.TestCase):
+    def test_config_default(self):
+        self.assertEqual(ap.PROXY_COORDINATION_EARLY_BAN, 3)
+
+    def test_identical_coordination_repeats_get_banned(self):
+        m = ap.SessionMonitor(context_window=132096)
+        fp = "TaskCreate:deadbeef"
+        for _ in range(3):
+            m.record_tool_calls(["TaskCreate"], fingerprint=fp)
+        self.assertIn("TaskCreate", m.session_banned_tools)
+
+    def test_two_repeats_not_yet_banned(self):
+        m = ap.SessionMonitor(context_window=132096)
+        for _ in range(2):
+            m.record_tool_calls(["TaskCreate"], fingerprint="TaskCreate:x")
+        self.assertNotIn("TaskCreate", m.session_banned_tools)
+
+    def test_non_coordination_tool_not_banned(self):
+        m = ap.SessionMonitor(context_window=132096)
+        for _ in range(5):
+            m.record_tool_calls(["Bash"], fingerprint="Bash:same")
+        self.assertNotIn("Bash", m.session_banned_tools)
+
+    def test_varying_args_reset_streak(self):
+        m = ap.SessionMonitor(context_window=132096)
+        for i in range(5):
+            m.record_tool_calls(["TaskCreate"], fingerprint=f"TaskCreate:{i}")
+        self.assertNotIn("TaskCreate", m.session_banned_tools)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tools/agents/tests/test_worktree_required.py

@@ -0,0 +1,63 @@
+"""Tests for worktree-required R1 (fail-open on non-git) + R3 (route hint)."""
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ENF = Path(__file__).resolve().parents[3] / "src" / "policies" / "enforcers" / "worktree_required.py"
+
+
+def run(root, target):
+    e = dict(os.environ)
+    e["UAP_REPO_ROOT"] = str(root)
+    e.pop("UAP_NO_WORKTREE", None)
+    p = subprocess.run(
+        [sys.executable, str(ENF), "--operation", "Write",
+         "--args", json.dumps({"file_path": str(target)})],
+        capture_output=True, text=True, env=e,
+    )
+    out = json.loads(p.stdout) if p.stdout.strip() else {}
+    return p.returncode, out
+
+
+class WorktreeRequiredTest(unittest.TestCase):
+    def test_R1_fail_open_on_non_git(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            f = root / "foo.ts"
+            f.write_text("x")
+            rc, out = run(root, f)
+            self.assertEqual(rc, 0)
+            self.assertTrue(out["allowed"])
+            self.assertIn("not a git repo", out["reason"])
+
+    def test_R3_blocks_with_route_on_git_repo(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            (root / ".git").mkdir()  # make it look like a git repo
+            f = root / "src" / "app.ts"
+            f.parent.mkdir(parents=True)
+            f.write_text("x")
+            rc, out = run(root, f)
+            self.assertEqual(rc, 2)
+            self.assertFalse(out["allowed"])
+            self.assertEqual(out.get("route"), "worktree")
+            self.assertIn("worktreeHint", out)
+            self.assertIn("run the command now", out["reason"])
+
+    def test_worktree_path_allowed(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            (root / ".git").mkdir()
+            f = root / ".worktrees" / "001-x" / "a.ts"
+            f.parent.mkdir(parents=True)
+            f.write_text("x")
+            rc, out = run(root, f)
+            self.assertEqual(rc, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()