npm - @miller-tech/uap - Versions diffs - 1.158.0 → 1.159.0 - Mend

@miller-tech/uap 1.158.0 → 1.159.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/.tsbuildinfo +1 -1
package/dist/delivery/convergence-loop.d.ts.map +1 -1
package/dist/delivery/convergence-loop.js +11 -1
package/dist/delivery/convergence-loop.js.map +1 -1
package/dist/delivery/epic-controller.d.ts.map +1 -1
package/dist/delivery/epic-controller.js +25 -0
package/dist/delivery/epic-controller.js.map +1 -1
package/dist/delivery/user-validation.d.ts.map +1 -1
package/dist/delivery/user-validation.js +14 -2
package/dist/delivery/user-validation.js.map +1 -1
package/package.json +1 -1
package/src/policies/enforcers/__pycache__/_common.cpython-312.pyc +0 -0
package/src/policies/enforcers/enforcement_infra_protect.py +33 -0
package/templates/hooks/__pycache__/deliver_autoroute.cpython-312.pyc +0 -0
package/templates/hooks/deliver_autoroute.py +234 -15
package/tools/agents/scripts/__pycache__/toolcall_path_normalizer.cpython-312.pyc +0 -0
package/tools/agents/tests/test_deliver_autoroute.py +116 -1

package/templates/hooks/deliver_autoroute.py CHANGED Viewed

@@ -6,10 +6,16 @@ The policy-gate hook pipes a blocked enforcer's JSON output to this helper. When
 the block carries route == "deliver", the helper:
   1. Logs the blocked intent to the project's .uap pending-deliver log (so the
      intent is never lost).
-  2. If UAP_DELIVER_AUTOROUTE is on, spawns `uap deliver "<hint>"` detached in
-     the background (deduped per file so a retrying model does not fan out
+  2. If the intent is REPLAYABLE (plan D1 recorded the blocked edit's exact
+     content) and UAP_DELIVER_PENDING_REPLAY is on (default), spawns
+     `uap deliver --pending <file>` detached — a DETERMINISTIC replay that
+     writes the content to disk (no model) and runs the gates once. This is what
+     actually lands the blocked write; without it the recorded intent is never
+     applied and the model re-emits it forever (0 files change).
+  3. Else, if UAP_DELIVER_AUTOROUTE is on, spawns `uap deliver "<hint>"` detached
+     in the background (deduped per file so a retrying model does not fan out
      dozens of runs), and annotates the message.
-  3. Prints the (possibly annotated) block message on stdout for the hook to
+  4. Prints the (possibly annotated) block message on stdout for the hook to
      surface to the agent.
 Autoroute is ON by default (UAP_DELIVER_AUTOROUTE=0 to disable): the blocked
@@ -27,6 +33,30 @@ from pathlib import Path
 PENDING_LOG = "pending-deliver.jsonl"
 SEEN_FILE = "autoroute-seen"
 UAP_DIR = ".uap"
+BASH_TOOLS = {"bash", "run_bash", "shell", "execute_command"}
+# `cat > FILE << DELIM\n...body...\nDELIM` — the heredoc source-write a model
+# reaches for when its Write tool is gated. Captures path + body so the write is
+# REPLAYABLE (applied deterministically) rather than dead-ending. Overwrite form
+# only; append (`>>`) and non-heredoc writers fall through to the model-spawn
+# autoroute. Tolerates a leading env-prefix / `bash -c '...'` wrapper and a
+# quoted or unquoted path/delimiter.
+_BASH_WRITE_RE = re.compile(
+    r"cat\s*>\s*(?P<pq>['\"]?)(?P<path>[^\s'\";|&>]+)(?P=pq)\s*"
+    r"<<-?\s*(?P<dq>['\"]?)(?P<delim>\w+)(?P=dq)\s*\n"
+    r"(?P<body>.*?)\n(?P=delim)\b",
+    re.DOTALL,
+)
+def _parse_bash_write(command: str):
+    """Recover (path, content) from a heredoc file write, else (None, None)."""
+    if not command or "cat" not in command:
+        return None, None
+    m = _BASH_WRITE_RE.search(command)
+    if not m:
+        return None, None
+    return m.group("path"), m.group("body")
 def _autoroute_enabled() -> bool:
@@ -41,7 +71,8 @@ def _autoroute_enabled() -> bool:
     return v in {"1", "on", "true", "yes"}
-def decide(out: dict, tool: str, args: dict, autoroute_on: bool, seen_files: set) -> dict:
+def decide(out: dict, tool: str, args: dict, autoroute_on: bool, seen_files: set,
+           replay_on: bool = True) -> dict:
     """Pure decision: what message to show, whether to spawn, and the intent."""
     reason = out.get("reason", "")
     route = out.get("route")
@@ -61,9 +92,20 @@ def decide(out: dict, tool: str, args: dict, autoroute_on: bool, seen_files: set
         args.get("file_path") or args.get("filePath") or args.get("path")
         or args.get("target") or args.get("filename") or args.get("file") or ""
     )
+    # A bash-routed source write carries its path AND content inside the command
+    # (`cat > FILE << EOF`), not as tool args — recover both so the write becomes
+    # REPLAYABLE instead of dead-ending. Without this the model's `cat >` rewrites
+    # are blocked forever (octopus_invaders_v3, 2026-07-16: 35 min of blocked
+    # heredoc rewrites, 0 landed).
+    bash_content = None
+    if not file_path and tool.lower() in BASH_TOOLS:
+        bp, bc = _parse_bash_write(str(args.get("command") or ""))
+        if bp and bc is not None:
+            file_path = bp
+            bash_content = bc
     if route != "deliver":
-        return {"message": reason, "route": route, "spawn": False,
+        return {"message": reason, "route": route, "spawn": False, "replay": False,
                 "file_path": file_path, "hint": hint, "dedup_key": "", "intent": None}
     intent = {"ts": int(time.time()), "tool": tool, "file_path": file_path, "hint": hint}
@@ -85,20 +127,46 @@ def decide(out: dict, tool: str, args: dict, autoroute_on: bool, seen_files: set
         )
         if isinstance(v, str)
     }
+    # Recovered heredoc body overwrites the whole file — exactly what the blocked
+    # `cat > FILE` would have done — so record it as a content-intent.
+    if not edit_intent and bash_content is not None:
+        edit_intent = {"content": bash_content}
     if edit_intent:
         intent["edit"] = edit_intent
-    spawn = bool(autoroute_on and hint and dedup_key and dedup_key not in seen_files)
+    # A REPLAYABLE intent (plan D1) carries the blocked edit's exact content, so
+    # it can be applied to disk DETERMINISTICALLY via `uap deliver --pending`
+    # (writeFileSync of the captured content — no model, no blind fan-out). This
+    # is what actually LANDS the blocked write. Without it the intent is recorded
+    # but never applied: the model re-emits the same write forever, the gate
+    # re-blocks it every time, and 0 files change (observed 2026-07-16,
+    # octopus_invaders_v3 — every deliver run frozen at phase 0 with an empty
+    # project). Prefer replay over the model-spawn autoroute whenever available.
+    replayable = bool(
+        file_path
+        and edit_intent
+        and (isinstance(edit_intent.get("content"), str)
+             or isinstance(edit_intent.get("old_string"), str))
+    )
+    # Deduped like a spawn (per change), so a retrying model does not re-run
+    # `uap deliver --pending` for an identical edit — the lock only guards
+    # CONCURRENT runs, the seen-set guards repeats. `replay_on` lets an operator
+    # fall back to the model-spawn autoroute (UAP_DELIVER_PENDING_REPLAY=off).
+    unseen = bool(dedup_key and dedup_key not in seen_files)
+    replay = bool(replayable and replay_on and unseen)
+    spawn = bool(autoroute_on and not replay and hint and unseen)
     message = reason
-    if spawn:
+    if replay:
+        message = reason + " [intent recorded to .uap/pending-deliver.jsonl — auto-applying to disk via deterministic `uap deliver --pending` replay]"
+    elif spawn:
         message = reason + " [auto-routed to `uap deliver` — running in the background]"
-    elif autoroute_on and dedup_key and dedup_key in seen_files:
-        message = reason + " [already auto-routed to `uap deliver` for this change — see .uap/autoroute.log / pending-deliver.jsonl]"
+    elif dedup_key and dedup_key in seen_files and (replayable or autoroute_on):
+        message = reason + " [already auto-routed/applied for this change — see .uap/autoroute.log / pending-deliver.jsonl]"
     elif file_path:
         message = reason + (
             " [intent recorded to .uap/pending-deliver.jsonl — apply it yourself by running"
             " `uap deliver` with the exact intended change as the instruction]"
         )
-    return {"message": message, "route": route, "spawn": spawn,
+    return {"message": message, "route": route, "spawn": spawn, "replay": replay,
             "file_path": file_path, "hint": hint, "dedup_key": dedup_key, "intent": intent}
@@ -115,6 +183,29 @@ def _load_seen(root: Path) -> set:
 LOCK_FILE = "autoroute.lock"
 LOG_FILE = "autoroute.log"
+COHERENT_LOCK = "coherent-mission.lock"
+def _coherent_enabled() -> bool:
+    # PHASE 1 (coherent-mission routing): route the WHOLE mission to ONE agentic
+    # `uap deliver --epics` run (contracts -> scaffold -> fill, writes in-band)
+    # instead of landing files one at a time via the per-file replay/model-spawn
+    # side-channel — which produces syntactically-valid but NON-integrating output
+    # (index.html loading 2 of 9 scripts, mismatched module APIs; octopus, 07-16).
+    # Default OFF until epic-run phase-0 convergence is hardened; enable with
+    # UAP_DELIVER_COHERENT_MISSION=1/on/true/yes.
+    v = os.environ.get("UAP_DELIVER_COHERENT_MISSION", "off").lower()
+    return v in {"1", "on", "true", "yes"}
+def coherent_route(coherent_on: bool, route: str, has_write_intent: bool,
+                   mission: str, inflight: bool) -> str:
+    """Whether to route the whole mission to one coherent epic run. Returns
+    'spawn' (start it), 'wait' (one already in flight — suppress the per-file
+    side-channel), or '' (not applicable; fall through to replay/spawn)."""
+    if not (coherent_on and route == "deliver" and has_write_intent and mission):
+        return ""
+    return "wait" if inflight else "spawn"
 def _pid_alive(pid: int) -> bool:
@@ -176,6 +267,111 @@ def _spawn_deliver(root: Path, hint: str) -> None:
         pass
+def _replay_enabled() -> bool:
+    # Deterministic pending-intent replay is safe — it writes the recorded
+    # content to disk and runs the gate ladder once, with no model and no blind
+    # background fan-out (the exact hazard that keeps model autoroute OFF by
+    # default). ON by default; UAP_DELIVER_PENDING_REPLAY=0/off/false to disable.
+    v = os.environ.get("UAP_DELIVER_PENDING_REPLAY", "on").lower()
+    return v in {"1", "on", "true", "yes"}
+def _spawn_pending_replay(root: Path, file_arg: str) -> None:
+    """Spawn `uap deliver --pending <file>` detached: DETERMINISTICALLY replay
+    the recorded edit intent(s) for this file to disk (writeFileSync of the
+    captured content — no model), then run the required gates once. This is the
+    plan-D1 path that actually lands the blocked write. Serialized behind the
+    same one-in-flight lock as _spawn_deliver so concurrent blocked writes do
+    not pile up runs; the model's retry of any still-unwritten file re-triggers
+    a replay once the lock frees. Best-effort; never raises."""
+    import subprocess
+    if not file_arg or file_arg.startswith("-"):
+        return  # need a path, and never let one be parsed as a flag
+    if not _acquire_slot(root):
+        return  # a replay/deliver is already converging in this repo
+    try:
+        log = (root / UAP_DIR / LOG_FILE).open("a")
+    except Exception:
+        log = subprocess.DEVNULL
+    try:
+        proc = subprocess.Popen(
+            ["uap", "deliver", "--pending", file_arg],
+            cwd=str(root),
+            stdout=log, stderr=log, stdin=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        try:
+            (root / UAP_DIR / LOCK_FILE).write_text(str(proc.pid))
+        except Exception:
+            pass
+    except Exception:
+        pass
+def _recover_mission(root: Path) -> str:
+    """Best-available mission text for a coherent epic run: the completion
+    ledger's `mission`, else the newest deliver run's `instruction`. '' if none
+    (then coherent routing is skipped and the per-file paths handle the write)."""
+    try:
+        p = root / UAP_DIR / "completion-ledger.json"
+        if p.exists():
+            m = json.loads(p.read_text()).get("mission")
+            if isinstance(m, str) and m.strip():
+                return m.strip()
+    except Exception:
+        pass
+    try:
+        runs = sorted((root / UAP_DIR / "deliver-runs").glob("run-*"),
+                      key=lambda x: x.stat().st_mtime, reverse=True)
+        for r in runs:
+            try:
+                m = json.loads((r / "state.json").read_text()).get("instruction")
+                if isinstance(m, str) and m.strip():
+                    return m.strip()
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return ""
+def _coherent_inflight(root: Path) -> bool:
+    """One coherent epic run per repo; a live lock pid means one is building."""
+    lock = root / UAP_DIR / COHERENT_LOCK
+    try:
+        if lock.exists():
+            pid = int(lock.read_text().strip() or "0")
+            return bool(pid and _pid_alive(pid))
+    except Exception:
+        pass
+    return False
+def _spawn_coherent_epic(root: Path, mission: str) -> None:
+    """Spawn ONE `uap deliver --epics -- "<mission>"` (agentic, in-process) that
+    builds the whole mission COHERENTLY through the phase flow. Detached, one per
+    repo. Best-effort; never raises."""
+    import subprocess
+    if not mission or mission.startswith("-") or _coherent_inflight(root):
+        return
+    try:
+        log = (root / UAP_DIR / LOG_FILE).open("a")
+    except Exception:
+        log = subprocess.DEVNULL
+    try:
+        proc = subprocess.Popen(
+            ["uap", "deliver", "--epics", "--", mission],
+            cwd=str(root), stdout=log, stderr=log, stdin=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        try:
+            (root / UAP_DIR / COHERENT_LOCK).write_text(str(proc.pid))
+        except Exception:
+            pass
+    except Exception:
+        pass
 def main() -> None:
     ap = argparse.ArgumentParser()
     ap.add_argument("--tool", default="")
@@ -194,7 +390,7 @@ def main() -> None:
         args = {}
     root = Path(ns.root)
-    d = decide(out, ns.tool, args, _autoroute_enabled(), _load_seen(root))
+    d = decide(out, ns.tool, args, _autoroute_enabled(), _load_seen(root), _replay_enabled())
     if d["intent"] is not None:
         try:
@@ -205,20 +401,43 @@ def main() -> None:
         except Exception:
             pass
-    if d["spawn"]:
+    # PHASE 1 (opt-in): route the whole mission to ONE coherent agentic epic run
+    # instead of the per-file side-channel. When it takes over, the single
+    # `uap deliver --epics` run owns the build, so we do NOT also fire per-file
+    # replay/spawn for this write (that is what produced non-integrating output).
+    coherent = ""
+    message = d["message"]
+    if _coherent_enabled() and d["route"] == "deliver" and d["file_path"]:
+        mission = _recover_mission(root)
+        coherent = coherent_route(True, d["route"], True, mission, _coherent_inflight(root))
+        if coherent == "spawn":
+            _spawn_coherent_epic(root, mission)
+            message = d["message"] + " [routed to a single coherent `uap deliver --epics` run — building the whole mission in-band]"
+        elif coherent == "wait":
+            message = d["message"] + " [a coherent `uap deliver --epics` run is already building this mission — intent recorded, not re-routed]"
+    if not coherent and (d["replay"] or d["spawn"]):
         try:
             # Dedup on the SAME key `decide` gated on (file when present, else the
             # hint) — writing file_path here would record "" for a bash-routed
-            # intent and never dedup it.
+            # intent and never dedup it. Both paths (deterministic replay and the
+            # model-spawn autoroute) mark the change seen so a retry does not
+            # double-run.
             key = d.get("dedup_key") or d["file_path"] or d["hint"]
             with _seen_path(root).open("a") as f:
                 f.write(key.replace("\n", " ").replace("\r", " ") + "\n")
         except Exception:
             pass
-        _spawn_deliver(root, d["hint"])
+        if d["replay"]:
+            # Deterministic path: the blocked write's content is recorded, so
+            # replay it to disk exactly (no model). This is what makes the block
+            # productive instead of an infinite record-and-re-block loop.
+            _spawn_pending_replay(root, d["file_path"])
+        else:
+            _spawn_deliver(root, d["hint"])
     prefix = ("[UAP policy blocked: " + ns.policy + "] ") if ns.policy else ""
-    sys.stdout.write(prefix + d["message"])
+    sys.stdout.write(prefix + message)
 if __name__ == "__main__":

package/tools/agents/scripts/__pycache__/toolcall_path_normalizer.cpython-312.pyc CHANGED Viewed

Binary file

package/tools/agents/tests/test_deliver_autoroute.py CHANGED Viewed

@@ -30,9 +30,13 @@ class DecideTest(unittest.TestCase):
     def test_deliver_route_logs_intent_no_spawn_when_off(self):
         d = mod.decide(BLOCK_OUT, "Write", ARGS, False, set())
         self.assertFalse(d["spawn"])
+        self.assertFalse(d["replay"])  # no recorded content -> not replayable
         self.assertIsNotNone(d["intent"])
         self.assertEqual(d["intent"]["file_path"], "/repo/src/foo.ts")
-        self.assertEqual(d["message"], BLOCK_OUT["reason"])  # unchanged
+        # autoroute off + no recorded content: message is annotated to tell the
+        # agent to run deliver itself; the block reason is preserved as prefix.
+        self.assertTrue(d["message"].startswith(BLOCK_OUT["reason"]))
+        self.assertIn("apply it yourself", d["message"])
     def test_deliver_route_spawns_when_on_and_unseen(self):
         d = mod.decide(BLOCK_OUT, "Write", ARGS, True, set())
@@ -117,5 +121,116 @@ class BashRoutedIntentTest(unittest.TestCase):
         self.assertFalse(d["spawn"])
+class BashHeredocReplayTest(unittest.TestCase):
+    """A model whose Write tool is gated reaches for `cat > FILE << EOF ... EOF`.
+    That heredoc carries the path AND body in the command, so autoroute recovers
+    both and the write becomes REPLAYABLE — else the model's `cat >` rewrites are
+    blocked forever (octopus_invaders_v3, 2026-07-16: 35 min, 0 landed)."""
+    HEREDOC = 'cat > src/app.js <<EOF\nconsole.log(1)\nEOF'
+    def test_parse_bash_write_extracts_path_and_body(self):
+        p, b = mod._parse_bash_write(self.HEREDOC)
+        self.assertEqual(p, 'src/app.js')
+        self.assertEqual(b, 'console.log(1)')
+    def test_parse_handles_wrapper_and_quoted_delim(self):
+        cmd = "UAP_DELIVER_BYPASS=1 bash -c 'cat > /a/game.js << \"GAMEJS\"\nX=1\nGAMEJS'"
+        p, b = mod._parse_bash_write(cmd)
+        self.assertEqual(p, '/a/game.js')
+        self.assertEqual(b, 'X=1')
+    def test_parse_returns_none_for_non_heredoc(self):
+        self.assertEqual(mod._parse_bash_write('cat > a.js'), (None, None))
+        self.assertEqual(mod._parse_bash_write('echo hi > a.js'), (None, None))
+    def test_bash_heredoc_is_replayable(self):
+        d = mod.decide(BLOCK_OUT, "Bash", {"command": self.HEREDOC}, True, set())
+        self.assertTrue(d["replay"])          # recovered content -> deterministic replay
+        self.assertFalse(d["spawn"])
+        self.assertEqual(d["file_path"], 'src/app.js')  # path recovered from the command
+        self.assertEqual(d["intent"]["edit"]["content"], 'console.log(1)')
+    def test_bash_without_body_still_model_spawns(self):
+        # No heredoc body to recover -> not replayable -> model-spawn on the hint.
+        d = mod.decide(BLOCK_OUT, "Bash", {"command": "cat > a.js <<EOF"}, True, set())
+        self.assertFalse(d["replay"])
+        self.assertTrue(d["spawn"])
+        self.assertEqual(d["file_path"], "")
+class ReplayIntentTest(unittest.TestCase):
+    """A REPLAYABLE intent (the blocked edit's exact content was recorded) must
+    be applied DETERMINISTICALLY via `uap deliver --pending` — not re-routed
+    through a fresh model deliver that just re-blocks. Without this the blocked
+    write is recorded but never lands: the model re-emits it forever and 0 files
+    change (octopus_invaders_v3, 2026-07-16 — every run frozen at phase 0)."""
+    REPLAY_ARGS = {"file_path": "/repo/src/foo.ts", "content": "const X = 1;\n"}
+    def test_content_intent_is_replayable_not_model_spawn(self):
+        d = mod.decide(BLOCK_OUT, "Write", self.REPLAY_ARGS, True, set())
+        self.assertTrue(d["replay"])
+        self.assertFalse(d["spawn"])  # deterministic replay, not a model run
+        self.assertIn("--pending", d["message"])
+        self.assertEqual(d["intent"]["edit"]["content"], "const X = 1;\n")
+    def test_replay_not_gated_on_autoroute(self):
+        d = mod.decide(BLOCK_OUT, "Write", self.REPLAY_ARGS, False, set())
+        self.assertTrue(d["replay"])  # safe deterministic path runs even when autoroute is off
+        self.assertFalse(d["spawn"])
+    def test_enforcer_editIntent_old_new_is_replayable(self):
+        out = dict(BLOCK_OUT); out["editIntent"] = {"old_string": "a", "new_string": "b"}
+        d = mod.decide(out, "Edit", {"file_path": "/repo/src/foo.ts"}, True, set())
+        self.assertTrue(d["replay"])
+        self.assertFalse(d["spawn"])
+    def test_non_replayable_still_model_spawns(self):
+        d = mod.decide(BLOCK_OUT, "Write", ARGS, True, set())  # no content recorded
+        self.assertFalse(d["replay"])
+        self.assertTrue(d["spawn"])
+class CoherentMissionRouteTest(unittest.TestCase):
+    """Phase 1: route the whole mission to ONE agentic `uap deliver --epics` run
+    instead of landing files one at a time via the per-file replay/model-spawn
+    side-channel — which produced syntactically-valid but NON-integrating output
+    (octopus_invaders_v3, 2026-07-16). Opt-in: UAP_DELIVER_COHERENT_MISSION."""
+    def test_off_by_default(self):
+        self.assertEqual(mod.coherent_route(False, "deliver", True, "build X", False), "")
+    def test_spawn_when_on_mission_and_free(self):
+        self.assertEqual(mod.coherent_route(True, "deliver", True, "build X", False), "spawn")
+    def test_wait_when_run_already_inflight(self):
+        self.assertEqual(mod.coherent_route(True, "deliver", True, "build X", True), "wait")
+    def test_no_route_without_mission(self):
+        self.assertEqual(mod.coherent_route(True, "deliver", True, "", False), "")
+    def test_no_route_without_write_intent(self):
+        self.assertEqual(mod.coherent_route(True, "deliver", False, "build X", False), "")
+    def test_no_route_for_non_deliver(self):
+        self.assertEqual(mod.coherent_route(True, "worktree", True, "build X", False), "")
+    def test_recover_mission_from_ledger(self):
+        import tempfile, os, json as _j
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            os.makedirs(os.path.join(td, ".uap"))
+            _j.dump({"mission": "Build the thing"},
+                    open(os.path.join(td, ".uap", "completion-ledger.json"), "w"))
+            self.assertEqual(mod._recover_mission(Path(td)), "Build the thing")
+    def test_recover_mission_empty_when_absent(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            self.assertEqual(mod._recover_mission(Path(td)), "")
 if __name__ == "__main__":
     unittest.main()