Step 530: add post-apply structural validation gate

2026-02-17 09:23:19 -07:00
parent aa76e9444c
commit d1c1660bc6
4 changed files with 324 additions and 0 deletions
--- a/editor/src/PostApplyStructuralGate.h
+++ b/editor/src/PostApplyStructuralGate.h
@@ -0,0 +1,123 @@
+#pragma once
+// Step 530: Post-Apply Structural Gate
+
+#include <algorithm>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "ConstraintViolationDiagnostics.h"
+
+struct PostApplyInput {
+    bool regionReparsed = false;
+    int parseErrorsAfter = 0;
+    std::vector<std::string> symbolsBefore;
+    std::vector<std::string> symbolsAfter;
+    std::vector<std::string> allowedSymbolDrift;
+};
+
+struct PostApplyResult {
+    bool valid = false;
+    std::vector<std::string> addedSymbols;
+    std::vector<std::string> removedSymbols;
+    ConstraintDiagnosticPacket diagnostics;
+};
+
+class PostApplyStructuralGate {
+public:
+    static PostApplyResult validate(const PostApplyInput& input) {
+        PostApplyResult result;
+
+        if (!input.regionReparsed) {
+            result.diagnostics.violations.push_back({
+                "region_not_reparsed",
+                "Touched region was not reparsed after apply",
+                "regionReparsed",
+                false
+            });
+        }
+
+        if (input.parseErrorsAfter > 0) {
+            result.diagnostics.violations.push_back({
+                "ast_integrity_failure",
+                "AST parse reported errors after apply",
+                "parseErrorsAfter",
+                false
+            });
+        }
+
+        computeSymbolDiff(input, result.addedSymbols, result.removedSymbols);
+        addUnexpectedDriftViolations(input.allowedSymbolDrift,
+                                     result.addedSymbols,
+                                     result.removedSymbols,
+                                     result.diagnostics.violations);
+
+        dedupe(result.diagnostics.violations);
+        result.valid = result.diagnostics.violations.empty();
+        result.diagnostics.ok = result.valid;
+        result.diagnostics.recommendedAction = result.valid ? "proceed" : "escalate";
+        return result;
+    }
+
+private:
+    static void computeSymbolDiff(const PostApplyInput& input,
+                                  std::vector<std::string>& added,
+                                  std::vector<std::string>& removed) {
+        auto before = asSet(input.symbolsBefore);
+        auto after = asSet(input.symbolsAfter);
+
+        for (const auto& s : after) {
+            if (before.count(s) == 0) added.push_back(s);
+        }
+        for (const auto& s : before) {
+            if (after.count(s) == 0) removed.push_back(s);
+        }
+    }
+
+    static void addUnexpectedDriftViolations(
+        const std::vector<std::string>& allowedDrift,
+        const std::vector<std::string>& added,
+        const std::vector<std::string>& removed,
+        std::vector<ConstraintViolation>& violations) {
+        auto allowed = asSet(allowedDrift);
+        for (const auto& symbol : added) {
+            if (allowed.count(symbol) == 0) {
+                violations.push_back({
+                    "unexpected_symbol_drift_add",
+                    "Unexpected symbol added after apply",
+                    symbol,
+                    false
+                });
+            }
+        }
+        for (const auto& symbol : removed) {
+            if (allowed.count(symbol) == 0) {
+                violations.push_back({
+                    "unexpected_symbol_drift_remove",
+                    "Unexpected symbol removed after apply",
+                    symbol,
+                    false
+                });
+            }
+        }
+    }
+
+    static std::set<std::string> asSet(const std::vector<std::string>& symbols) {
+        return std::set<std::string>(symbols.begin(), symbols.end());
+    }
+
+    static void dedupe(std::vector<ConstraintViolation>& violations) {
+        std::vector<ConstraintViolation> out;
+        for (const auto& v : violations) {
+            bool exists = false;
+            for (const auto& current : out) {
+                if (current.code == v.code && current.field == v.field) {
+                    exists = true;
+                    break;
+                }
+            }
+            if (!exists) out.push_back(v);
+        }
+        violations.swap(out);
+    }
+};