@miller-tech/uap 1.210.7 → 1.210.8

package/src/policies/enforcers/schema_diff_gate.py

@@ -23,6 +23,19 @@ COMMIT_OPS = {"git-commit", "git commit"}
 RECENT_SEC = 3600
 
 
+def merge_in_progress(root: Path) -> bool:
+    """Whether a merge is underway — invocation-constant, so resolved ONCE.
+
+    This used to be re-derived per watched file, spawning a `git rev-parse`
+    for each one on the hot path of every commit and push, purely to learn
+    "not a merge". A merge touching 30 migrations paid 30 spawns.
+    """
+    rc, git_dir_out, _ = run(["git", "rev-parse", "--absolute-git-dir"], cwd=root)
+    if rc != 0:
+        return False
+    return (Path(git_dir_out.strip()) / "MERGE_HEAD").exists()
+
+
 def merge_verbatim(root: Path, path: str) -> bool:
     """During a merge, a staged watched file that is byte-identical to the
     incoming MERGE_HEAD version was not authored on this branch — it was
@@ -30,20 +43,26 @@ def merge_verbatim(root: Path, path: str) -> bool:
     forced a schema-diff re-pass for content the merge cannot change (hit on
     the 2026-08-16 pay2u #3153 conflict-resolution merge, where migrations
     from already-merged main blocked the merge commit)."""
-    git_dir = root / ".git"
-    # Worktrees use a .git FILE pointing at the real gitdir.
-    if git_dir.is_file():
-        try:
-            ref = git_dir.read_text().strip()
-            if ref.startswith("gitdir:"):
-                git_dir = Path(ref.split(":", 1)[1].strip())
-        except OSError:
-            return False
-    if not (git_dir / "MERGE_HEAD").exists():
-        return False
     rc, staged_sha, _ = run(["git", "rev-parse", f":{path}"], cwd=root)
     rc2, theirs_sha, _ = run(["git", "rev-parse", f"MERGE_HEAD:{path}"], cwd=root)
-    return rc == 0 and rc2 == 0 and staged_sha.strip() == theirs_sha.strip()
+    if rc != 0 or rc2 != 0 or staged_sha.strip() != theirs_sha.strip():
+        return False
+
+    # The INDEX matching theirs is not enough: `git commit -a` and
+    # `git commit -- <path>` commit the WORKING TREE. Exempting on the index
+    # alone let an unstaged edit ride along ungated -- reproduced: an appended
+    # `DROP TABLE users;` yielded {"allowed": true, "reason": "no watched
+    # schema/pool paths in diff"} while `commit -am` would have committed the
+    # drop.
+    #
+    # `git diff --quiet` rather than hashing the file ourselves: it exits 0
+    # exactly when the worktree copy matches the index, using git's own
+    # comparison. Hashing followed symlinks (so a verbatim merged symlink never
+    # matched), failed outright on a dangling link or a sparse/skip-worktree
+    # path, and re-ran clean filters on large files against a 5s timeout --
+    # every one of those a FALSE BLOCK on a legitimate merge.
+    rc3, _, _ = run(["git", "diff", "--quiet", "--", path], cwd=root)
+    return rc3 == 0
 
 
 def touched_watched_paths(root: Path) -> list[str]:
@@ -52,10 +71,33 @@ def touched_watched_paths(root: Path) -> list[str]:
         return []
     rc2, staged, _ = run(["git", "diff", "--name-only", "--cached"], cwd=root)
     all_files = (out + "\n" + (staged if rc2 == 0 else "")).splitlines()
-    watched = [f for f in all_files if f and WATCHED_RE.search(f)]
+    # dict.fromkeys dedupes while preserving order: a file that is both
+    # unstaged and staged appeared twice, and the gate's reason line listed it
+    # twice ("covers: x, x"), which reads like two files were covered.
+    watched = list(dict.fromkeys(f for f in all_files if f and WATCHED_RE.search(f)))
+    # Nothing watched is the overwhelmingly common case; probing git there
+    # would make the hoist a net cost rather than a saving.
+    if not watched or not merge_in_progress(root):
+        return watched
     return [f for f in watched if not merge_verbatim(root, f)]
 
 
+def _parse_marker_ts(raw) -> float | None:
+    """Epoch seconds for a marker timestamp, or None when it cannot be read.
+
+    Stored as UTC ISO-8601 with a trailing Z; parsed as UTC because
+    time.mktime would read them as local time and expire the marker hours
+    early or late depending on the host timezone.
+    """
+    if not isinstance(raw, str):
+        return None
+    try:
+        import calendar
+        return calendar.timegm(time.strptime(raw[:19], "%Y-%m-%dT%H:%M:%S"))
+    except Exception:  # noqa: BLE001
+        return None
+
+
 def schema_diff_ok(root: Path) -> bool:
     db = root / "agents" / "data" / "memory" / "short_term.db"
     if not db.exists():
@@ -65,31 +107,44 @@ def schema_diff_ok(root: Path) -> bool:
         # `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
+        newest = None
         for table in ("memories", "session_memories"):
             try:
+                # ANCHORED to the recorder's fixed prefix. The old
+                # '%schema-diff%pass%' matched those substrings anywhere in any
+                # memory -- including this gate's OWN refusal text ("...require
+                # `uap schema-diff` to pass"), so an agent storing the blocker
+                # as a lesson unblocked itself, and a note saying the diff
+                # FAILED cleared it just as well. Verified both.
                 cur = con.execute(
                     f"SELECT timestamp FROM {table} "
-                    "WHERE content LIKE '%schema-diff%pass%' "
+                    "WHERE content LIKE 'schema-diff pass: base %' "
                     "ORDER BY id DESC LIMIT 1"
                 )
                 r = cur.fetchone()
-                if r and (row is None or r[0] > row[0]):
-                    row = r
+                # Compare PARSED epochs, not raw strings. The two tables need
+                # not share a timestamp format, and a lexicographic winner that
+                # then fails to parse returned False without ever considering
+                # the runner-up: one legacy row sorting above ISO-8601 (say
+                # "2026/08/17", '/' > '-') would out-rank every correct marker
+                # forever, and re-running the remedy could not help because it
+                # writes to the other table. Gate shut permanently, no waiver.
+                # A malformed row is ignored, never authoritative.
+                ts_val = _parse_marker_ts(r[0]) if r else None
+                if ts_val is not None and (newest is None or ts_val > newest):
+                    newest = ts_val
             except sqlite3.Error:
                 continue
         con.close()
-        if not row:
-            return False
-        try:
-            # 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
+        if newest is None:
             return False
-        return (time.time() - ts) < RECENT_SEC
+        ts = newest
+        # Two-sided. The upper bound alone let a FUTURE timestamp clear the
+        # gate until wall-clock caught up -- reachable via an importing writer
+        # that supplies its own timestamp, or plain clock skew. A small
+        # tolerance absorbs sub-second skew between writer and reader.
+        age = time.time() - ts
+        return -5 <= age < RECENT_SEC
     except sqlite3.Error:
         return False
 
@@ -107,7 +162,10 @@ def main() -> None:
         emit(True, "no watched schema/pool paths in diff")
 
     if schema_diff_ok(repo_root()):
-        emit(True, f"recent schema-diff pass covers: {', '.join(watched[:5])}")
+        # Says what was checked, not what it "covers". The marker is not scoped
+        # to files, so claiming coverage of these specific paths asserted
+        # something the gate never computed.
+        emit(True, f"recent schema-diff pass on record; watched paths: {', '.join(watched[:5])}")
 
     emit(
         False,

package/tools/agents/tests/test_schema_diff_gate.py

@@ -59,14 +59,21 @@ class SchemaDiffGateTest(unittest.TestCase):
     def tearDown(self):
         self._tmp.cleanup()
 
-    def write_marker(self, iso_timestamp: str, table: str = "memories"):
+    # The literal the CLI records (src/cli/schema-diff.ts). The gate matches it
+    # ANCHORED, so this string is now a contract between the two.
+    MARKER = "schema-diff pass: base HEAD~1 | files: migrations/001_add_table.sql"
+
+    def write_marker(self, iso_timestamp: str, table: str = "memories", content: str | None = None):
         mem = self.root / "agents" / "data" / "memory"
-        mem.mkdir(parents=True)
+        mem.mkdir(parents=True, exist_ok=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"CREATE TABLE IF NOT EXISTS {table} "
+            "(id INTEGER PRIMARY KEY, content TEXT, timestamp TEXT)"
+        )
         con.execute(
             f"INSERT INTO {table} (content, timestamp) VALUES (?, ?)",
-            ("schema-diff pass: verified", iso_timestamp),
+            (self.MARKER if content is None else content, iso_timestamp),
         )
         con.commit()
         con.close()
@@ -110,9 +117,64 @@ class SchemaDiffGateTest(unittest.TestCase):
         self.assertEqual(code, 2)
         self.assertFalse(allowed)
 
+    def test_the_gates_own_refusal_message_does_not_clear_it(self):
+        """A block message that is itself a valid unblock token is self-defeating.
 
-if __name__ == "__main__":
-    unittest.main()
+        The old matcher was LIKE '%schema-diff%pass%', which the gate's own
+        refusal text satisfies ("...require `uap schema-diff` to pass"). Agents
+        here are instructed to store lessons, and blockers are exactly what they
+        store — so recording the refusal unblocked the next commit.
+        """
+        self.write_marker(
+            datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            content=(
+                "Lesson: schema-diff-gate: changes to migrations/001_add_table.sql "
+                "require `uap schema-diff` to pass (within 1h). Run it and re-commit."
+            ),
+        )
+        code, allowed, _ = run_gate("git-commit", {}, self.root)
+        self.assertFalse(allowed, "the gate's own refusal text must not clear the gate")
+        self.assertEqual(code, 2)
+
+    def test_a_marker_from_the_PREVIOUS_cli_release_still_clears_it(self):
+        """Anchoring must not deadlock operators running an older global `uap`.
+
+        The previously-released recorder wrote
+        "schema-diff pass: base <b>, N schema file(s) checked, no breaking
+        changes" — same prefix — so it still matches. If a future format change
+        drops that prefix, the gate must be updated in the same commit or every
+        operator on the old CLI is blocked with no reachable remedy.
+        """
+        self.write_marker(
+            datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            content="schema-diff pass: base HEAD~1, 3 schema file(s) checked, no breaking changes",
+        )
+        _, allowed, _ = run_gate("git-commit", {}, self.root)
+        self.assertTrue(allowed, "a marker from the previous CLI release must still clear the gate")
+
+    def test_a_note_saying_the_diff_FAILED_does_not_clear_it(self):
+        self.write_marker(
+            datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            content="schema-diff FAILED - breaking change, do not pass this to review",
+        )
+        _, allowed, _ = run_gate("git-commit", {}, self.root)
+        self.assertFalse(allowed, "a failure note must not read as a pass")
+
+    def test_a_future_dated_marker_does_not_clear_it(self):
+        """The window was upper-bounded only, so a future timestamp cleared the
+        gate until wall-clock caught up — reachable via an importing writer that
+        supplies its own timestamp, or plain clock skew."""
+        ahead = (datetime.now(timezone.utc) + timedelta(hours=6)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        self.write_marker(ahead)
+        _, allowed, _ = run_gate("git-commit", {}, self.root)
+        self.assertFalse(allowed, "a future-dated marker must not clear the gate")
+
+    def test_watched_path_is_listed_once(self):
+        """A file both unstaged and staged appeared twice in the reason line,
+        which reads as two covered files."""
+        (self.root / "migrations" / "001_add_table.sql").write_text("CREATE TABLE t (id bigint);")
+        _, _, reason = run_gate("git-commit", {"command": "git commit"}, self.root)
+        self.assertEqual(reason.count("001_add_table.sql"), 1, reason)
 
 
 class MergeVerbatimTest(unittest.TestCase):
@@ -161,9 +223,40 @@ class MergeVerbatimTest(unittest.TestCase):
 
     def test_merge_edited_migration_still_gates(self):
         # Editing the migration during the merge makes it THIS branch's change.
+        # NB this stages the edit; the UNSTAGED variant below is the one that
+        # was actually exploitable.
         (self.root / "migrations" / "001_add_table.sql").write_text("CREATE TABLE t (id bigint);")
         subprocess.run(["git", "add", "migrations/001_add_table.sql"], cwd=self.root, check=True)
         _, allowed, reason = run_gate("git-commit", {"command": "git commit"}, self.root)
         self.assertFalse(allowed, "a migration edited during the merge must still gate")
         self.assertIn("schema-diff", reason)
 
+    def test_UNSTAGED_merge_edit_still_gates(self):
+        """The exemption compared the INDEX blob, but `git commit -a` commits the
+        WORKING TREE.
+
+        Reproduced against the shipped gate: with the index still matching
+        MERGE_HEAD and an unstaged `DROP TABLE users;` appended, it answered
+        {"allowed": true, "reason": "no watched schema/pool paths in diff"} —
+        not even naming the exemption — while `git commit -am` would have
+        committed the drop. This is also the likely ACCIDENTAL path: a human
+        resolving a conflict, tweaking a migration, running `git commit -am`.
+        """
+        p = self.root / "migrations" / "001_add_table.sql"
+        p.write_text(p.read_text() + "\nDROP TABLE t;\n")  # deliberately NOT staged
+        _, allowed, reason = run_gate("git-commit", {"command": "git commit -am merge"}, self.root)
+        self.assertFalse(
+            allowed,
+            "an unstaged edit during a merge is committed by `commit -a` and must gate: " + reason,
+        )
+
+    def test_a_genuinely_verbatim_merge_is_still_exempt_after_the_fix(self):
+        """The deadlock fix must survive the hardening: with no local edit at
+        all, the incoming migration stays exempt."""
+        _, allowed, reason = run_gate("git-commit", {"command": "git commit -am merge"}, self.root)
+        self.assertTrue(allowed, f"verbatim merge must remain exempt: {reason}")
+
+
+if __name__ == "__main__":
+    unittest.main()
+