@miller-tech/uap 1.220.1 → 1.220.3

package/package.json

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

package/src/policies/enforcers/delivery_enforcement.py

@@ -386,6 +386,7 @@ def _record_escalation_edit(root: Path, rel: str) -> None:
     edits = st.get("edits_since_green") if isinstance(st.get("edits_since_green"), dict) else {}
     edits[rel] = int(edits.get(rel, 0)) + 1
     st["edits_since_green"] = edits
+    st["edits_total"] = int(st.get("edits_total") or 0) + 1  # attempt counter (tracker reads it)
     st.setdefault("failures", 0)
     st["updated"] = int(_time.time())
     try:

package/templates/hooks/escalation_tracker.py

@@ -122,13 +122,74 @@ def save_state(state: dict, root: Path | None = None) -> None:
         pass  # evidence is best-effort; never wedge the hook that records it
 
 
+_SIG_LINE_RE = re.compile(
+    r"(error\[E\d+\]|^error(?:\[|:)|panicked at|^\s*FAIL\b|test result: FAILED|AssertionError|Traceback|"
+    r"\bfailed\b.*\bassert|^E\s{2,}|error TS\d+|\bERROR\b)",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+
+def failure_signature(detail: str) -> str:
+    """A stable fingerprint of WHAT failed, so two red runs can be told apart.
+
+    The first diagnostic line (rustc error code, panic site, failing test
+    name, tsc code, traceback) with volatile bits — thread ids, pids,
+    timestamps, hex addresses, durations — stripped. Falls back to the first
+    non-empty line. Same signature twice = the same wall; a different one =
+    the agent moved the problem, which is progress, not a streak."""
+    text = detail or ""
+    line = ""
+    for raw in text.splitlines():
+        if _SIG_LINE_RE.search(raw):
+            line = raw
+            break
+    if not line:
+        for raw in text.splitlines():
+            if raw.strip():
+                line = raw
+                break
+    line = re.sub(r"\(\d+\)", "", line)                      # thread/pid ids
+    line = re.sub(r"0x[0-9a-fA-F]+", "0x", line)               # addresses
+    line = re.sub(r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}\S*", "", line)
+    line = re.sub(r"\b\d+(?:\.\d+)?\s*(?:ms|s|secs?|seconds?)\b", "", line)
+    line = re.sub(r"\s+", " ", line).strip()
+    return line[:200]
+
+
 def record_fail(source: str, detail: str, root: Path | None = None) -> dict:
+    """Count a red verification toward the escalation threshold.
+
+    CONSECUTIVE means "the same failure keeps coming back". A red run whose
+    signature differs from the previous one is the agent making progress on a
+    different problem (observed live: overflow at hash.rs:130 after fixing a
+    pgrx-gated test, both counted, a one-line fix escalated to a 75-minute
+    deliver loop that did not land). Such a failure restarts the streak at 1
+    instead of extending it."""
     st = load_state(root)
-    st["failures"] = int(st.get("failures") or 0) + 1
+    sig = failure_signature(detail)
+    prev = st.get("last_failure") if isinstance(st.get("last_failure"), dict) else None
+    prev_sig = (prev or {}).get("sig")
+    edits_total = int(st.get("edits_total") or 0)
+    _ep = (prev or {}).get("edits_total")
+    edits_at_prev = int(_ep) if isinstance(_ep, (int, float)) else -1  # 0 is a real value
+    if prev_sig and sig and sig != prev_sig:
+        st["failures"] = 1
+        st["streak_reset"] = {"ts": int(time.time()), "from": prev_sig[:120], "to": sig[:120]}
+    elif prev_sig and sig == prev_sig and edits_total == edits_at_prev:
+        # The SAME failure observed again with no edit in between (idle/stop
+        # verify hooks re-run the gates every time the session pauses). That is
+        # a re-observation, not another failed attempt — the streak must not
+        # grow while the agent has not tried anything. Observed live: 4 "failures"
+        # from one red user-path test across four idle pauses.
+        st["reobserved"] = int(st.get("reobserved") or 0) + 1
+    else:
+        st["failures"] = int(st.get("failures") or 0) + 1
     st["last_failure"] = {
         "ts": int(time.time()),
         "source": source or "unknown",
         "detail": (detail or "")[-DETAIL_MAX:],
+        "sig": sig,
+        "edits_total": edits_total,
     }
     save_state(st, root)
     return st
@@ -149,6 +210,7 @@ def record_edit(rel: str, root: Path | None = None) -> dict:
     edits = st.get("edits_since_green") or {}
     edits[rel] = int(edits.get(rel, 0)) + 1
     st["edits_since_green"] = edits
+    st["edits_total"] = int(st.get("edits_total") or 0) + 1  # monotonic: "an attempt happened"
     save_state(st, root)
     return st