@miller-tech/uap 1.128.1 → 1.128.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.128.1",
+  "version": "1.128.2",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
     "start": "node dist/bin/cli.js",
     "test": "vitest",
     "test:ci": "vitest run",
-    "test:enforcers": "python3 -m unittest tools.agents.tests.test_enforcement_self_protect tools.agents.tests.test_workdir_scope_enforcer tools.agents.tests.test_path_containment tools.agents.tests.test_path_normalizer_hardened tools.agents.tests.test_sandbox_tool_strip tools.agents.tests.test_proxy_env_loader tools.agents.tests.test_stream_required_tool tools.agents.tests.test_tool_call_wrapper_profiles tools.agents.tests.test_tool_convert_cache",
+    "test:enforcers": "python3 -m unittest tools.agents.tests.test_enforcement_self_protect tools.agents.tests.test_schema_diff_gate tools.agents.tests.test_workdir_scope_enforcer tools.agents.tests.test_path_containment tools.agents.tests.test_path_normalizer_hardened tools.agents.tests.test_sandbox_tool_strip tools.agents.tests.test_proxy_env_loader tools.agents.tests.test_stream_required_tool tools.agents.tests.test_tool_call_wrapper_profiles tools.agents.tests.test_tool_convert_cache",
     "test:coverage": "vitest --coverage",
     "bench": "vitest --config vitest.bench.config.ts",
     "lint": "eslint src --ext .ts",

package/src/policies/enforcers/delivery_enforcement.py

@@ -86,32 +86,40 @@ def main() -> None:
     op, args = parse_cli()
     if op not in EDIT_OPS:
         emit(True, "not a file-edit operation")
+        return
 
     target = args.get("file_path") or args.get("path") or args.get("target") or ""
     if not target:
         emit(True, "no file path in args")
+        return
 
     root = repo_root()
     try:
         rel = str(Path(target).resolve().relative_to(root))
     except ValueError:
         emit(True, "target outside repo")
+        return
 
     rel_posix = rel.replace(os.sep, "/")
     low = rel_posix.lower()
 
     if not low.endswith(SOURCE_EXTS):
         emit(True, "not source code")
+        return
     if any(rel_posix.startswith(p) for p in EXEMPT_PREFIXES):
         emit(True, f"exempt path: {rel_posix}")
+        return
     if any(m in "/" + low for m in TEST_MARKERS):
         emit(True, "test file (protected by deliver itself)")
+        return
 
     # Escape hatches.
     if os.environ.get("UAP_DELIVER_ACTIVE") == "1":
         emit(True, "inside a deliver-driven run")
+        return
     if os.environ.get("UAP_DELIVER_BYPASS") == "1":
         emit(True, "UAP_DELIVER_BYPASS override set")
+        return
 
     # #3-F: terse, imperative, model-parseable. Weak local models otherwise
     # retry the blocked edit or hallucinate completion ("the files exist") when
@@ -143,6 +151,7 @@ def main() -> None:
             route="deliver",
             deliverHint=f'implement the intended change to {rel_posix}',
         )
+        return
 
     # Advisory (opt-out): never blocks. Surface the nudge, then allow.
     print(f"[delivery-enforcement advisory] {msg}", file=sys.stderr)
@@ -150,4 +159,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/src/policies/enforcers/schema_diff_gate.py

@@ -16,7 +16,10 @@ WATCHED_RE = re.compile(
     r"infra/helm_charts/[^/]*envoy|infra/helm_charts/[^/]*sentinel)",
     re.I,
 )
-COMMIT_OPS = {"git-commit", "git commit", "Bash"}
+# NOTE: bare "Bash" used to be in this set, which made EVERY shell command a
+# gate point — including the `uap schema-diff` remedy itself (self-deadlock).
+# Gate only actual commit/push commands (main() also inspects cmd content).
+COMMIT_OPS = {"git-commit", "git commit"}
 RECENT_SEC = 3600
 
 
@@ -35,17 +38,31 @@ def schema_diff_ok(root: Path) -> bool:
         return False
     try:
         con = sqlite3.connect(f"file:{db}?mode=ro", uri=True, timeout=1.0)
-        cur = con.execute(
-            "SELECT timestamp FROM session_memories "
-            "WHERE content LIKE '%schema-diff%pass%' "
-            "ORDER BY id DESC LIMIT 1"
-        )
-        row = cur.fetchone()
+        # `uap memory store` writes to `memories` (type 'action'), while older
+        # UAP wrote session rows to `session_memories` — accept the marker from
+        # either table so the documented remedy actually clears the gate.
+        row = None
+        for table in ("memories", "session_memories"):
+            try:
+                cur = con.execute(
+                    f"SELECT timestamp FROM {table} "
+                    "WHERE content LIKE '%schema-diff%pass%' "
+                    "ORDER BY id DESC LIMIT 1"
+                )
+                r = cur.fetchone()
+                if r and (row is None or r[0] > row[0]):
+                    row = r
+            except sqlite3.Error:
+                continue
         con.close()
         if not row:
             return False
         try:
-            ts = time.mktime(time.strptime(row[0][:19], "%Y-%m-%dT%H:%M:%S"))
+            # Timestamps are stored as UTC ISO-8601 (trailing 'Z'); parse them
+            # as UTC — time.mktime would misread them as local time and expire
+            # the marker hours early (or late) depending on the host TZ.
+            import calendar
+            ts = calendar.timegm(time.strptime(row[0][:19], "%Y-%m-%dT%H:%M:%S"))
         except Exception:  # noqa: BLE001
             return False
         return (time.time() - ts) < RECENT_SEC

package/tools/agents/tests/test_schema_diff_gate.py

@@ -0,0 +1,115 @@
+"""Tests for the schema-diff-gate enforcer fixes (self-deadlock + marker read).
+
+Covers the 2026-07-08 mid-session incident: bare "Bash" in COMMIT_OPS gated
+EVERY shell command (including the `uap schema-diff` remedy — self-deadlock),
+and the pass-marker check read only the legacy session_memories table and
+parsed UTC timestamps with time.mktime (host-timezone skew).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import subprocess
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[3]
+ENFORCER = REPO / "src" / "policies" / "enforcers" / "schema_diff_gate.py"
+
+
+def run_gate(op: str, args: dict, root: Path, tz: str | None = None):
+    env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
+    env["UAP_REPO_ROOT"] = str(root)
+    env["UAP_WORKTREE_ROOT"] = str(root)
+    if tz:
+        env["TZ"] = tz
+    r = subprocess.run(
+        ["python3", str(ENFORCER), "--operation", op, "--args", json.dumps(args)],
+        cwd=root,
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    try:
+        payload = json.loads(r.stdout or "{}")
+    except json.JSONDecodeError:
+        payload = {}
+    return r.returncode, payload.get("allowed", False), payload.get("reason", "")
+
+
+class SchemaDiffGateTest(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory(prefix="schema-gate-")
+        self.root = Path(self._tmp.name)
+        subprocess.run(["git", "init", "-q"], cwd=self.root, check=True)
+        subprocess.run(
+            ["git", "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", "--allow-empty", "-m", "init"],
+            cwd=self.root,
+            check=True,
+        )
+        (self.root / "migrations").mkdir()
+        (self.root / "migrations" / "001_add_table.sql").write_text("CREATE TABLE t (id int);")
+        subprocess.run(["git", "add", "migrations"], cwd=self.root, check=True)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def write_marker(self, iso_timestamp: str, table: str = "memories"):
+        mem = self.root / "agents" / "data" / "memory"
+        mem.mkdir(parents=True)
+        con = sqlite3.connect(mem / "short_term.db")
+        con.execute(f"CREATE TABLE {table} (id INTEGER PRIMARY KEY, content TEXT, timestamp TEXT)")
+        con.execute(
+            f"INSERT INTO {table} (content, timestamp) VALUES (?, ?)",
+            ("schema-diff pass: verified", iso_timestamp),
+        )
+        con.commit()
+        con.close()
+
+    def test_ordinary_bash_is_not_a_gate_point(self):
+        """Regression: bare Bash op must not gate — that deadlocked the remedy itself."""
+        code, allowed, reason = run_gate("Bash", {"command": "uap schema-diff"}, self.root)
+        self.assertEqual(code, 0)
+        self.assertTrue(allowed)
+        self.assertIn("not a commit/push gate point", reason)
+
+    def test_commit_command_still_gated(self):
+        code, allowed, reason = run_gate("Bash", {"command": 'git commit -m "add migration"'}, self.root)
+        self.assertEqual(code, 2)
+        self.assertFalse(allowed)
+        self.assertIn("uap schema-diff", reason)
+
+    def test_fresh_marker_in_memories_table_clears_gate(self):
+        """`uap memory store` writes to `memories`; the gate must accept it."""
+        self.write_marker(datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"))
+        code, allowed, reason = run_gate("git-commit", {}, self.root)
+        self.assertEqual(code, 0)
+        self.assertTrue(allowed)
+        self.assertIn("recent schema-diff pass", reason)
+
+    def test_legacy_session_memories_table_still_accepted(self):
+        self.write_marker(
+            datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), table="session_memories"
+        )
+        code, allowed, _ = run_gate("git-commit", {}, self.root)
+        self.assertEqual(code, 0)
+        self.assertTrue(allowed)
+
+    def test_stale_marker_blocks_regardless_of_host_timezone(self):
+        """Pre-fix, time.mktime read UTC timestamps as local: east-of-UTC hosts
+        saw stale markers shifted into the future and the gate cleared on a
+        2h-old pass."""
+        stale = (datetime.now(timezone.utc) - timedelta(hours=2)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        self.write_marker(stale)
+        code, allowed, _ = run_gate("git-commit", {}, self.root, tz="Australia/Sydney")
+        self.assertEqual(code, 2)
+        self.assertFalse(allowed)
+
+
+if __name__ == "__main__":
+    unittest.main()