@miller-tech/uap 2.16.6 → 2.16.7

package/README.md

@@ -9,7 +9,7 @@
 [![Tests](https://img.shields.io/badge/tests-450%2B_suites-brightgreen)](#testing)
 [![License](https://img.shields.io/badge/license-MIT-black)](LICENSE)
 
-`v2.11.0` · 367 TypeScript modules across 26 subsystems · 459 vitest suites (+ a ~1,200-test Python enforcer/proxy suite) · 9 agent harnesses
+`v2.16.6` · 367 TypeScript modules across 26 subsystems · 459 vitest suites (+ a ~1,200-test Python enforcer/proxy suite) · 9 agent harnesses
 
 [Quickstart](#quickstart) · [Why UAP?](#why-uap) · [The delivery pipeline](docs/guides/DELIVERY_PIPELINE.md) · [`uap deliver`](#the-deliver-harness) · [Docs](docs/INDEX.md)
 

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -2494,6 +2494,15 @@ class SessionMonitor:
     # back into a structured tool_use, which would continue the very loop the
     # breaker is ending. Reset to False at the start of every request.
     suppress_text_tool_extraction: bool = False
+    # Bounded snippet of the most recent tool_result text seen in the request.
+    # Feeds the STUCK-BREAK repeat-call directive so the model is SHOWN the
+    # unchanged output instead of only being told it "already has" it — live
+    # 2026-09-29, a model re-ran `uap memory query "plane workspace slug pay2u"`
+    # 7 times ignoring the directive, because a "No results" output is not an
+    # answer a weak model recognises as final; it believes the missing value
+    # must exist and keeps re-asking. Quoting the output makes the futility
+    # concrete. Refreshed on every request from the conversation.
+    last_tool_result_snippet: str = ""
     # Tool-turn count at which the TURN-COUNT FINALIZE BREAKER last fired. The
     # count is derived from the (only-growing) conversation, so without this the
     # breaker would re-fire on EVERY turn once the ceiling is first crossed —
@@ -7265,15 +7274,27 @@ def _maybe_inject_stuck_break(openai_body: dict, monitor: "SessionMonitor") -> N
     if reason.startswith(_REPEAT_CALL_REASON):
         # The call SUCCEEDS every time, so "stop retrying a failing action" and
         # the switch-channel advice would both be nonsense here. Name the real
-        # problem: the answer is already in hand and re-asking cannot change it.
+        # problem: the answer is already in hand and re-asking cannot change
+        # it. QUOTE the actual output — live 2026-09-29, "You already have that
+        # output" was ignored 7 times on a `uap memory query` returning "No
+        # results": the model does not recognise an empty result as an answer,
+        # so the directive must show it that the output IS the output.
+        snippet = (monitor.last_tool_result_snippet or "").strip()
+        quoted = (
+            f' It returns EXACTLY this every time: "{snippet[:300]}"' if snippet else ""
+        )
         directive = (
             "\n\nSTOP — you have issued the same tool call with the same "
             "arguments " + reason.rsplit("x", 1)[-1] + " times in a row. It "
             "SUCCEEDED each time and the result will not change by asking again. "
-            "You already have that output. Do NOT repeat it. Either take the "
-            "NEXT concrete action using what it told you, or — if you genuinely "
-            "cannot proceed — state the single blocking question in one sentence "
-            "and stop. Answer in plain text now if the work is done."
+            "You already have that output." + quoted + " Do NOT repeat it — "
+            "re-asking cannot produce new information, and an empty or "
+            "'no results' output IS this source's final answer. Either take the "
+            "NEXT concrete action using what it told you (proceeding WITHOUT "
+            "the missing information and stating your assumption if necessary), "
+            "or — if you genuinely cannot proceed — state the single blocking "
+            "question in one sentence and stop. Answer in plain text now if "
+            "the work is done."
         )
     else:
         directive = (
@@ -9093,6 +9114,9 @@ def _record_last_assistant_tool_calls(
                     _latest_err = any(_flags)
                 break
     monitor.note_tool_result_error(_latest_tr, _latest_err)
+    # Bounded raw snippet of the same result, for the STUCK-BREAK repeat-call
+    # directive (see SessionMonitor.last_tool_result_snippet).
+    monitor.last_tool_result_snippet = (_latest_tr or "")[:400]
     _seed_tool_history_from_request(monitor, messages)
     tool_fingerprints = []
     tool_targets: dict[str, str] = {}

package/tools/agents/tests/test_repeat_call_guard.py

@@ -226,3 +226,67 @@ class TestStreakSurvivesAFreshMonitor(unittest.TestCase):
                     [{"role": "assistant", "content": "plain text"}]):
             self.proxy._seed_tool_history_from_request(mon, bad)
         self.assertEqual(mon.tool_call_history, [])
+
+
+class TestDirectiveQuotesTheActualOutput(unittest.TestCase):
+    """Live 2026-09-29 (ses_f158cb463, qwen3.8): the advisory directive told the
+    model 'you already have that output' on a `uap memory query` returning "No
+    results" — and it was ignored 7 times, because a weak model does not
+    recognise an EMPTY result as an answer; it believes the missing value must
+    exist and keeps re-asking. The directive must SHOW the model the output it
+    keeps receiving, and say plainly that 'no results' IS the source's answer.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.proxy = load_proxy()
+
+    NO_RESULTS = "No results in short-term memory\n\nNo results in long-term memory"
+
+    @staticmethod
+    def looping_monitor(proxy, snippet):
+        mon = proxy.SessionMonitor(context_window=100000)
+        for _ in range(4):
+            mon.record_tool_calls(tool_names=["Bash"], fingerprint="Bash|uap memory query x")
+        mon.last_tool_result_snippet = snippet
+        return mon
+
+    def inject(self, mon):
+        body = {"messages": [{"role": "system", "content": "base"}], "tool_choice": "required"}
+        self.proxy._maybe_inject_stuck_break(body, mon)
+        return body["messages"][0]["content"]
+
+    def test_the_directive_quotes_the_repeated_calls_actual_output(self):
+        text = self.inject(self.looping_monitor(self.proxy, self.NO_RESULTS))
+        self.assertIn("No results in short-term memory", text)
+        self.assertIn("returns EXACTLY this every time", text)
+        # The trap named in words, not just implied by the quote.
+        self.assertIn("'no results' output IS this source's final answer", text)
+
+    def test_a_long_result_is_bounded_in_the_directive(self):
+        text = self.inject(self.looping_monitor(self.proxy, "x" * 5000))
+        self.assertLess(len(text), 2000, "a huge tool result must not bloat the directive")
+
+    def test_a_missing_snippet_keeps_the_directive_valid(self):
+        # No tool_result seen (e.g. the repeat was in the request seeds only):
+        # the directive must still fire, unquoted, and not crash.
+        text = self.inject(self.looping_monitor(self.proxy, ""))
+        self.assertIn("SUCCEEDED each time", text)
+        self.assertIn("will not change", text)
+        self.assertNotIn("returns EXACTLY this", text)
+
+    def test_the_snippet_is_captured_from_the_latest_tool_result_of_the_request(self):
+        # The capture path: the most recent tool_result text in the
+        # conversation becomes the monitor snippet, so the NEXT turn's
+        # directive quotes what the repeated call actually returned.
+        mon = self.proxy.SessionMonitor(context_window=100000)
+        msgs = [{"role": "user", "content": "find the slug"}]
+        for i in range(2):
+            msgs.append({"role": "assistant", "content": [
+                {"type": "tool_use", "id": f"t{i}", "name": "Bash",
+                 "input": {"command": "uap memory query x"}}]})
+            msgs.append({"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": f"t{i}",
+                 "content": self.NO_RESULTS}]})
+        self.proxy._record_last_assistant_tool_calls({"messages": msgs}, mon)
+        self.assertIn("No results in short-term memory", mon.last_tool_result_snippet)