@miller-tech/uap 2.36.1 → 2.39.0

package/examples/workflows/team-solve-deliver/workflow.yaml

@@ -0,0 +1,74 @@
+# team-solve-deliver — the team directs the deliver convergence loop.
+#
+# The combination of the two engines: team-solve's role structure and ledger
+# discipline (fresh contexts, files as the only channel, cross-correction)
+# wrapped around deliver's convergence machinery (tools + the project's real
+# completion gates). Roles think; loops build and verify.
+#
+#   plan ──┬── ideate-a ──┬── solve ── review ── repair ── verify
+#          └── ideate-b ──┘   (loop)   (judge)    (loop)    (loop, gates-only)
+#
+# solve/repair/verify are `kind: loop` steps — they execute through a
+# CALLER-INJECTED convergence loop (uap deliver wires its own machinery and
+# auto-engages this workflow for high/critical missions). A standalone
+# `uap workflow run team-solve-deliver` fails closed: no loop provider.
+name: team-solve-deliver
+description: >
+  team-solve directing the deliver convergence loop for repo missions: an
+  approach plan, two parallel ideations from different engineering families,
+  a gates-driven solve loop, a fresh-context review, a review-seeded repair
+  loop, and a verify-only verdict. Auto-engaged by `uap deliver` on
+  high/critical complexity; force with `uap deliver --team-solve`.
+parallel: 2
+# 0 engine-level step retries: the solve/repair loops already converge
+# internally (until-delivered + escalation inside the mission dispatch), and
+# a workflow-level retry of `solve` would re-run the ENTIRE mission dispatch
+# after it already burned its turn budget — doubling the hardest-tier spend
+# and bypassing this workflow's own review→repair discipline.
+maxRepairsPerStep: 0
+steps:
+  - id: plan
+    kind: agent
+    title: Approach planner (judge rail)
+    prompt: steps/plan.md
+    writes: [plan.md]
+    requires: []
+  - id: ideate-a
+    kind: agent
+    title: Ideator A (minimal-change family)
+    prompt: steps/ideate-a.md
+    reads: [plan.md]
+    writes: [proposal-a.md]
+    requires: [plan]
+  - id: ideate-b
+    kind: agent
+    title: Ideator B (structural family)
+    prompt: steps/ideate-b.md
+    reads: [plan.md]
+    writes: [proposal-b.md]
+    requires: [plan]
+  - id: solve
+    kind: loop
+    title: Solve (convergence loop, project gates)
+    prompt: steps/solve.md
+    reads: [plan.md, proposal-a.md, proposal-b.md]
+    requires: [ideate-a, ideate-b]
+  - id: review
+    kind: agent
+    title: Fresh-context reviewer (judge rail)
+    prompt: steps/review.md
+    reads: [plan.md]
+    writes: [repair.md]
+    requires: [solve]
+  - id: repair
+    kind: loop
+    title: Repair (convergence loop, review-seeded)
+    prompt: steps/repair.md
+    reads: [repair.md]
+    requires: [review]
+  - id: verify
+    kind: loop
+    title: Verdict (gates only)
+    prompt: steps/verify.md
+    verifyOnly: true
+    requires: [repair]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "2.36.1",
+  "version": "2.39.0",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",
@@ -116,6 +116,7 @@
     "dist",
     "web",
     "docs",
+    "examples",
     "config",
     "templates",
     "src/policies/schemas/policies",

package/tools/agents/scripts/anthropic_proxy.py

@@ -697,6 +697,24 @@ _FAILURE_DECLARATION_RE = re.compile(
     re.IGNORECASE,
 )
 
+# The harness's own zero-exit envelope: the tool CALL succeeded, whatever the
+# output QUOTES. Droid/BYOK appends "[Process exited with code N]" to every
+# Execute result; other harnesses print their own form. Decisive in the
+# flag-ABSENT path only (a client that declares is_error True still wins):
+# 2026-10-26, cognition-engine fdc94474 -- two ERROR-LOOP hard stops were
+# served on SIX successful state-checks whose `git diff` output quoted the
+# session's own in-flight `eprintln!("pg-server: metrics: failed to bind
+# ...")` line; the keyword sniff turned each clean diff into the same
+# "failure" signature and the streak escalated to a 400.
+_ZERO_EXIT_ENVELOPE_RE = re.compile(
+    r"\[process exited with code 0\]"  # Droid / BYOK Execute result footer
+    r"|\bexited with code 0\b"         # generic harness prose
+    r"|\bexit (?:code|status)\s*[:=]?\s*0\b"  # 'exit code 0' / 'exit status: 0'
+    r"|\bexit_code=0\b"                # python subprocess env style
+    r"|\bEXIT=0\b",                   # shell-echoed status
+    re.IGNORECASE,
+)
+
 
 def _is_successful_result(text: str) -> bool:
     """True when the payload structurally declares success.
@@ -867,10 +885,25 @@ def _error_signature_for_result(text: str, result_error: bool | None = None) ->
                         (_first_meaningful_signature), so an unfamiliar error
                         shape still forms a streak; a wrapper-only payload
                         stays unnameable -- DOUBLING-DOWN owns that shape.
-      absent         -> fall back to the keyword heuristics as before.
+      absent         -> keyword heuristics as before, EXCEPT a payload that
+                        carries the harness's zero-exit envelope
+                        (_ZERO_EXIT_ENVELOPE_RE): the call succeeded, so
+                        failure-shaped words it merely QUOTES (a git diff of
+                        in-flight edits, a grep over source) cannot anchor a
+                        streak. 2026-10-26: two ERROR-LOOP hard stops on six
+                        clean state-checks whose git-diff output quoted the
+                        session's own `eprintln!("...failed to bind...")`
+                        source line; a declared True flag still wins over
+                        the envelope.
     """
     if result_error is False:
         return ""
+    if result_error is None and _ZERO_EXIT_ENVELOPE_RE.search(text or ""):
+        # Flag-ABSENT and the harness's own footer says the call exited 0:
+        # the result is clean whatever the bytes quote. Only the heuristic
+        # path is narrowed -- is_error True/False keep their declared
+        # precedence above.
+        return ""
     sig = _error_signature(text)
     if sig or result_error is not True:
         return sig
@@ -2423,6 +2456,31 @@ PROXY_ATTRACTOR_TEMP_OVERRIDE = float(
 PROXY_ATTRACTOR_FINALIZE_THRESHOLD = max(1, int(
     os.environ.get("PROXY_ATTRACTOR_FINALIZE_THRESHOLD", "2")
 ))
+# Post-contamination low-temp clamp exemption. The standard contamination
+# reset clamps the next tool turn to temperature 0.10 (Cycle 15 Option 2:
+# deterministic output repairs malformed JSON). For DEGENERATE-CONTENT faults
+# (garbled args) determinism is exactly wrong: temp ~0 re-enters the same
+# degenerate attractor that triggered the reset (live 2026-10-30: 9
+# contamination-forced finalize stops in one day, the 0.10 clamp active on
+# every post-reset turn). Reset causes listed here keep the normal
+# PROXY_TOOL_TURN_TEMPERATURE instead of the 0.10 clamp. Empty string
+# disables the exemption entirely (always clamp).
+PROXY_CONTAMINATION_LOW_TEMP_EXEMPT_KINDS = {
+    k.strip()
+    for k in os.environ.get(
+        "PROXY_CONTAMINATION_LOW_TEMP_EXEMPT_KINDS", "invalid_tool_args"
+    ).split(",")
+    if k.strip()
+}
+# Late garbled-retry output cap. The deployed env pins
+# PROXY_TOOL_TURN_MAX_TOKENS_GARBLED high (32768, raised 2026-04-22 so legit
+# multi-file heredoc edits don't truncate), which also gives a degenerate
+# generation maximum room to run. From this retry attempt onward the budget
+# drops to this cap: the observed legit commands (~4.5K tokens) still fit,
+# while runaway degeneration is starved of room (live 2026-10-30: every
+# garbled call was a long inline heredoc; short commands never garbled).
+# 0 disables the late cap.
+PROXY_GARBLE_LATE_CAP = int(os.environ.get("PROXY_GARBLE_LATE_CAP", "8192"))
 PROXY_AGENTIC_SUPPLEMENT_MODE = (
     os.environ.get("PROXY_AGENTIC_SUPPLEMENT_MODE", "clean").strip().lower()
 )
@@ -3086,6 +3144,7 @@ class SessionMonitor:
     invalid_tool_call_streak: int = 0  # consecutive invalid tool arg payloads
     required_tool_miss_streak: int = 0  # required tool turns with no tool call
     contamination_resets: int = 0  # how many contamination resets were applied
+    contamination_cause: str = ""  # dominant streak behind the last reset ("invalid_tool_args"/"malformed_payload"/"required_tool_miss"/"generic")
     last_fault_excerpt_hash: str = ""  # hash of last TOOL RESPONSE ISSUE excerpt (attractor detection)
     attractor_correction_active: bool = False  # next turn uses high-temp escape sampling
     forced_auto_cooldown_turns: int = 0  # temporary auto override turns remaining
@@ -9789,13 +9848,24 @@ def build_openai_request(
                 client_temp,
             )
         else:
-            if monitor.contamination_resets > 0:
+            # Cycle 15 Option 2: lower temperature after contamination resets —
+            # EXCEPT when the reset was driven by an exempt cause: for
+            # degenerate-content faults (garbled args) determinism re-enters
+            # the same attractor that triggered the reset (live 2026-10-30).
+            if (
+                monitor.contamination_resets > 0
+                and monitor.contamination_cause
+                not in PROXY_CONTAMINATION_LOW_TEMP_EXEMPT_KINDS
+            ):
                 target_temp = min(target_temp, 0.1)
             if client_temp is None or client_temp > target_temp:
                 openai_body["temperature"] = target_temp
                 extra = ""
                 if monitor.contamination_resets > 0:
-                    extra = f" (post-contamination reset, resets={monitor.contamination_resets})"
+                    extra = (
+                        f" (post-contamination reset, resets={monitor.contamination_resets},"
+                        f" cause={monitor.contamination_cause or 'generic'})"
+                    )
                 logger.info(
                     "TOOL TURN TEMP: forcing temperature=%.2f (was %s) for tool-enabled request%s",
                     target_temp,
@@ -10684,6 +10754,68 @@ def _hash_fault_excerpt(excerpt: str) -> str:
     return hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:16]
 
 
+def _fault_fingerprint(
+    excerpt: str, arg_excerpt: str, fault_tool_names: list[str]
+) -> str:
+    """Stable fingerprint of a tool-response fault for attractor-repeat detection.
+
+    Tool-call faults carry NO assistant text (every observed garble incident
+    logged text_len=0), so hashing only the text excerpt yielded "" — falsy —
+    and the attractor detector (hard reset + temp escape + lowered finalize
+    threshold) never fired for the dominant fault class (live 2026-10-30:
+    9 contamination-forced finalize stops, none attractor-detected). Fall
+    back to the garbled-args excerpt — its stable command head survives
+    normalization, so the same degenerate approach hashes equal across
+    resets — then the failing tool names.
+    """
+    if excerpt:
+        return _hash_fault_excerpt(excerpt)
+    if arg_excerpt:
+        return _hash_fault_excerpt(arg_excerpt)
+    if fault_tool_names:
+        return _hash_fault_excerpt(
+            "tool:" + ",".join(sorted(set(fault_tool_names)))
+        )
+    return ""
+
+
+def _retry_temperature(attempt: int, is_garbled: bool) -> float:
+    """Retry temperature ladder for malformed/garbled tool-call retries.
+
+    Attempt 1: configured retry temp (deterministic first try).
+    Attempt 2: 0.5 — escape the degenerate local minimum (Cycle 15 Option 3).
+    Attempt 3+ garbled (degenerate CONTENT): attractor-escape temperature —
+    determinism re-enters the same degenerate trajectory (live 2026-10-30:
+    garbled attempts 1-4 all reproduced at 0.05/0.5 while short commands
+    never garbled); malformed-JSON retries keep the deterministic ladder
+    because structure repair wants determinism.
+    """
+    if is_garbled and attempt >= 3:
+        return max(
+            PROXY_ATTRACTOR_TEMP_OVERRIDE, PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE
+        )
+    if attempt > 1:
+        return 0.5
+    return PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE
+
+
+def _contamination_reset_cause(monitor: "SessionMonitor") -> str:
+    """Dominant output-quality streak behind a contamination reset.
+
+    Drives the post-reset temperature policy: degenerate-content faults
+    (invalid_tool_args) are EXEMPT from the 0.10 low-temp clamp (see
+    PROXY_CONTAMINATION_LOW_TEMP_EXEMPT_KINDS) because determinism re-enters
+    the same attractor; malformed-JSON repairs keep the clamp.
+    """
+    if monitor.invalid_tool_call_streak > monitor.malformed_tool_streak:
+        return "invalid_tool_args"
+    if monitor.malformed_tool_streak > 0:
+        return "malformed_payload"
+    if monitor.required_tool_miss_streak > 0:
+        return "required_tool_miss"
+    return "generic"
+
+
 def _extract_openai_tool_calls(openai_resp: dict) -> list[dict]:
     _, message = _extract_openai_choice(openai_resp)
     tool_calls = message.get("tool_calls") or []
@@ -12366,10 +12498,20 @@ def _validate_tool_call_arguments(
     allowed_tools: set[str],
 ) -> ToolResponseIssue:
     if allowed_tools and tool_name not in allowed_tools:
+        # 2026-10-30: name the kept alternatives — a narrowed retry (the
+        # garbling tool excluded) observed the model emitting the excluded
+        # tool anyway because "use the provided tool list" gave it nothing
+        # concrete to switch to.
+        known = ", ".join(sorted(allowed_tools)[:6])
         return ToolResponseIssue(
             kind="invalid_tool_args",
             reason=f"unknown tool '{tool_name}'",
-            retry_hint="Use exactly one tool from the provided tool list.",
+            retry_hint=(
+                f"'{tool_name}' is not available on this turn. "
+                f"Call exactly one of: {known}."
+                if known
+                else "Use exactly one tool from the provided tool list."
+            ),
         )
 
     if isinstance(raw_arguments, (dict, list)):
@@ -12441,7 +12583,10 @@ def _validate_tool_call_arguments(
             reason=f"arguments for '{tool_name}' contain garbled/degenerate content",
             retry_hint=(
                 f"Emit exactly one `{tool_name}` tool call with well-formed JSON arguments. "
-                "Do not repeat closing braces, brackets, or digits."
+                "Your previous arguments degenerated (repeated digit or brace runs). "
+                "SIMPLIFY and SHORTEN the operation: split the work into smaller steps, "
+                "avoid long inline heredocs and large generated numeric blocks, and "
+                "prefer short commands. Do not repeat closing braces, brackets, or digits."
             ),
         )
 
@@ -13020,12 +13165,16 @@ def _build_malformed_retry_body(
     retry_body["stream"] = False
     retry_body["tool_choice"] = tool_choice
     # Cycle 15 Option 3: vary temperature across retries to break degenerate patterns.
-    # Attempt 1: use configured retry temp (default 0.0) for deterministic first try.
-    # Attempt 2+: increase to 0.5 to escape the degenerate local minimum.
-    if total_attempts > 1 and attempt > 1:
-        retry_body["temperature"] = 0.5
-    else:
-        retry_body["temperature"] = PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE
+    # Ladder lives in _retry_temperature (garbled retries escalate to the
+    # attractor-escape temperature from attempt 3 — see its docstring).
+    retry_body["temperature"] = _retry_temperature(attempt, is_garbled)
+    if is_garbled and attempt >= 3 and PROXY_GARBLE_LATE_CAP > 0:
+        logger.info(
+            "RETRY GARBLED ESCALATION: temperature=%.2f late_cap=%d for garbled retry attempt=%d",
+            retry_body["temperature"],
+            PROXY_GARBLE_LATE_CAP,
+            attempt,
+        )
 
     if tool_choice == "required":
         retry_instruction = (
@@ -13057,7 +13206,17 @@ def _build_malformed_retry_body(
 
     # Option 1: Progressive garbled-cap within retries — use smaller max_tokens
     # when the issue involves garbled/degenerate args to limit degeneration room.
-    if is_garbled and PROXY_TOOL_TURN_MAX_TOKENS_GARBLED > 0:
+    # 2026-10-30: the deployed env pins PROXY_TOOL_TURN_MAX_TOKENS_GARBLED high
+    # (32768) so legit multi-file heredoc edits don't truncate (2026-04-22) —
+    # from attempt 3 onward, starve degeneration room with the late cap.
+    if is_garbled and attempt >= 3 and PROXY_GARBLE_LATE_CAP > 0:
+        retry_body["max_tokens"] = PROXY_GARBLE_LATE_CAP
+        logger.info(
+            "RETRY GARBLED LATE CAP: max_tokens=%d for garbled retry attempt=%d",
+            PROXY_GARBLE_LATE_CAP,
+            attempt,
+        )
+    elif is_garbled and PROXY_TOOL_TURN_MAX_TOKENS_GARBLED > 0:
         retry_body["max_tokens"] = PROXY_TOOL_TURN_MAX_TOKENS_GARBLED
         logger.info(
             "RETRY GARBLED CAP: max_tokens=%d for garbled retry attempt=%d",
@@ -13402,17 +13561,22 @@ async def _apply_malformed_tool_guardrail(
     excerpt = _openai_message_text(working_resp)[:220].replace("\n", " ")
     # Option 2: Log garbled argument content for diagnostics
     arg_excerpt = ""
+    fault_tool_names: list[str] = []
     if issue.kind == "invalid_tool_args":
         for tc in (working_resp.get("choices", [{}])[0].get("message", {}).get("tool_calls") or []):
+            fn_name = tc.get("function", {}).get("name", "")
             raw_args = tc.get("function", {}).get("arguments", "")
-            if raw_args and _is_garbled_tool_arguments(raw_args):
+            if fn_name:
+                fault_tool_names.append(fn_name)
+            if raw_args and _is_garbled_tool_arguments(raw_args) and not arg_excerpt:
                 arg_excerpt = raw_args[:200].replace("\n", " ")
-                break
     # Attractor detection — hash the normalized fault excerpt so the
     # contamination breaker can recognize the same fixed-point response
     # reappearing across consecutive resets. Whitespace-normalized so trivial
     # rendering differences don't break the match.
-    monitor.last_fault_excerpt_hash = _hash_fault_excerpt(excerpt)
+    monitor.last_fault_excerpt_hash = _fault_fingerprint(
+        excerpt, arg_excerpt, fault_tool_names
+    )
     logger.warning(
         "TOOL RESPONSE ISSUE: session=%s kind=%s reason=%s malformed=%d invalid=%d required_miss=%d excerpt=%.220s args=%.200s",
         session_id,
@@ -13768,6 +13932,7 @@ def _maybe_apply_session_contamination_breaker(
             max_contamination_resets,
         )
         monitor.set_tool_turn_phase("finalize", reason="contamination_loop")
+        monitor.contamination_cause = _contamination_reset_cause(monitor)
         monitor.contamination_resets += 1
         monitor.malformed_tool_streak = 0
         monitor.invalid_tool_call_streak = 0
@@ -13890,6 +14055,7 @@ def _maybe_apply_session_contamination_breaker(
 
     forced_before = monitor.consecutive_forced_count
     required_miss_before = monitor.required_tool_miss_streak
+    monitor.contamination_cause = _contamination_reset_cause(monitor)
     monitor.contamination_resets += 1
     # Emergency tier: the conversation itself is rewritten, so BOTH the
     # forcing-loop family (via its one policy point) and the output-quality

package/tools/agents/tests/test_signature_quality.py

@@ -55,6 +55,20 @@ WORKTREE_STATUS = (
 SHELL_SOURCE_READ = "die() { printf 'fatal: %s\\n' \"$*\" >&2; exit 1; }\n"
 
 
+# 2026-10-26, cognition-engine fdc94474: state-check output that QUOTES the
+# session's own in-flight source (a numbered read of the metrics region,
+# a git diff of the wedge fix) plus the harness's zero-exit footer. Six
+# flag-absent results of this shape manufactured both ERROR-LOOP hard stops.
+DIFF_QUOTING_SOURCE = (
+    " M src/rust-pg-ext/Cargo.toml\n"
+    " M src/rust-pg-ext/src/bin/pg-server.rs\n"
+    "2784→            eprintln!(\"pg-server: metrics: failed to bind {addr}: {e}"
+    " — metrics endpoint disabled\");\n"
+    "+            return None;\n"
+    "\n[Process exited with code 0]"
+)
+
+
 class TracebackAnchoringTests(unittest.TestCase):
     def test_decisive_line_anchors_not_the_header(self):
         sig = proxy._error_signature(TRACEBACK_FULL)
@@ -225,6 +239,43 @@ class ReadOnlyContentTests(unittest.TestCase):
         self.assertEqual(len(body["messages"]), 1)
 
 
+class ZeroExitEnvelopeTests(unittest.TestCase):
+    """A flag-ABSENT Execute result carrying the harness's zero-exit
+    envelope is a SUCCESS, whatever failure-shaped text its output QUOTES
+    (ledger 2026-10-26: two ERROR-LOOP hard stops served on six clean
+    state-checks whose output quoted an in-flight eprintln! source line)."""
+
+    def test_quoted_source_with_exit_zero_forms_no_signature(self):
+        m = proxy.SessionMonitor()
+        for _ in range(6):
+            m.note_tool_result_error(DIFF_QUOTING_SOURCE, None, tool_names=["execute"])
+        self.assertEqual(m.error_signature_streak, 0)
+        self.assertEqual(m.last_error_signature, "")
+
+    def test_exit_zero_streak_never_arms_the_guard(self):
+        m = proxy.SessionMonitor()
+        for _ in range(6):
+            m.note_tool_result_error(DIFF_QUOTING_SOURCE, None, tool_names=["execute"])
+        body = {"messages": [{"role": "user", "content": "go"}], "tool_choice": "auto"}
+        proxy._maybe_inject_error_loop_break(body, m)
+        self.assertEqual(m.error_loop_fires, 0)
+        self.assertEqual(len(body["messages"]), 1)
+
+    def test_nonzero_exit_still_keeps_heuristics(self):
+        payload = DIFF_QUOTING_SOURCE.replace(
+            "exited with code 0", "exited with code 1"
+        )
+        m = proxy.SessionMonitor()
+        m.note_tool_result_error(payload, None, tool_names=["execute"])
+        self.assertEqual(m.error_signature_streak, 1)
+        self.assertNotEqual(m.last_error_signature, "")
+
+    def test_declared_error_flag_beats_the_zero_exit_envelope(self):
+        m = proxy.SessionMonitor()
+        m.note_tool_result_error(DIFF_QUOTING_SOURCE, True, tool_names=["execute"])
+        self.assertEqual(m.error_signature_streak, 1)
+
+
 class KnownFixCoverageTests(unittest.TestCase):
     """The uncovered ledger classes now carry a KNOWN FIX."""