From e8c90df8711d134eb288041aab43e5b3a533a5d5 Mon Sep 17 00:00:00 2001 From: Bill Date: Tue, 17 Feb 2026 10:21:04 -0700 Subject: [PATCH] Step 551: refine review-gate escalation policy --- editor/CMakeLists.txt | 9 ++ editor/src/ReviewGatePolicyRefinement.h | 70 +++++++++++++ editor/tests/step551_test.cpp | 132 ++++++++++++++++++++++++ progress.md | 36 +++++++ 4 files changed, 247 insertions(+) create mode 100644 editor/src/ReviewGatePolicyRefinement.h create mode 100644 editor/tests/step551_test.cpp diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index a811724..318595c 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -3838,4 +3838,13 @@ target_link_libraries(step550_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step551_test tests/step551_test.cpp) +target_include_directories(step551_test PRIVATE src) +target_link_libraries(step551_test PRIVATE + nlohmann_json::nlohmann_json + unofficial::tree-sitter::tree-sitter + tree_sitter_python tree_sitter_cpp tree_sitter_elisp + tree_sitter_javascript tree_sitter_typescript + tree_sitter_java tree_sitter_rust tree_sitter_go) + # Step 12: Dear ImGui shell scaffolding created (main.cpp exists but not built due to dependencies) diff --git a/editor/src/ReviewGatePolicyRefinement.h b/editor/src/ReviewGatePolicyRefinement.h new file mode 100644 index 0000000..a77ad49 --- /dev/null +++ b/editor/src/ReviewGatePolicyRefinement.h @@ -0,0 +1,70 @@ +#pragma once +// Step 551: Review-Gate Policy Refinement + +#include +#include + +struct ReviewGateInput { + bool safetyCritical = false; + bool securitySensitive = false; + bool policyViolationDetected = false; + int confidenceScore = 0; // 0..100 + int postApplyFailureStreak = 0; + bool deterministicTemplatePath = false; + bool highCostOverage = false; +}; + +struct ReviewGateResult { + bool requiresHumanReview = false; + std::string decision; // auto_approve/auto_approve_with_audit/escalate_review/block + std::vector reasons; +}; + +class ReviewGatePolicyRefinement { +public: + static ReviewGateResult evaluate(const ReviewGateInput& input) { + ReviewGateResult out; + + if (input.policyViolationDetected) { + out.requiresHumanReview = true; + out.decision = "block"; + out.reasons.push_back("policy_violation_detected"); + return out; + } + + if (input.safetyCritical || input.securitySensitive) { + out.requiresHumanReview = true; + out.decision = "escalate_review"; + if (input.safetyCritical) out.reasons.push_back("safety_critical_change"); + if (input.securitySensitive) out.reasons.push_back("security_sensitive_change"); + return out; + } + + if (input.postApplyFailureStreak >= 3) { + out.requiresHumanReview = true; + out.decision = "escalate_review"; + out.reasons.push_back("repeated_post_apply_failures"); + return out; + } + + if (input.confidenceScore >= 85 && input.deterministicTemplatePath && !input.highCostOverage) { + out.requiresHumanReview = false; + out.decision = "auto_approve"; + out.reasons.push_back("high_confidence_deterministic_path"); + return out; + } + + if (input.confidenceScore >= 70 && !input.highCostOverage) { + out.requiresHumanReview = false; + out.decision = "auto_approve_with_audit"; + out.reasons.push_back("moderate_confidence_low_risk"); + return out; + } + + out.requiresHumanReview = true; + out.decision = "escalate_review"; + if (input.highCostOverage) out.reasons.push_back("high_cost_overage"); + if (input.confidenceScore < 70) out.reasons.push_back("low_confidence"); + return out; + } +}; diff --git a/editor/tests/step551_test.cpp b/editor/tests/step551_test.cpp new file mode 100644 index 0000000..f78cb85 --- /dev/null +++ b/editor/tests/step551_test.cpp @@ -0,0 +1,132 @@ +// Step 551: Review-Gate Policy Refinement (12 tests) + +#include "ReviewGatePolicyRefinement.h" + +#include + +static int passed = 0, failed = 0; +#define TEST(name) { std::cout << " " << #name << "... "; } +#define PASS() { std::cout << "PASS\n"; ++passed; } +#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; } +#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {} + +static bool hasReason(const ReviewGateResult& r, const std::string& reason) { + for (const auto& x : r.reasons) if (x == reason) return true; + return false; +} + +void test_policy_violation_blocks_immediately() { + TEST(policy_violation_blocks_immediately); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, true, 95, 0, true, false}); + CHECK(r.requiresHumanReview, "block should still require human review state"); + CHECK(r.decision == "block", "policy violation should block"); + CHECK(hasReason(r, "policy_violation_detected"), "reason expected"); + PASS(); +} + +void test_safety_critical_requires_review() { + TEST(safety_critical_requires_review); + auto r = ReviewGatePolicyRefinement::evaluate({true, false, false, 95, 0, true, false}); + CHECK(r.decision == "escalate_review", "safety-critical should escalate"); + CHECK(hasReason(r, "safety_critical_change"), "safety reason expected"); + PASS(); +} + +void test_security_sensitive_requires_review() { + TEST(security_sensitive_requires_review); + auto r = ReviewGatePolicyRefinement::evaluate({false, true, false, 95, 0, true, false}); + CHECK(r.decision == "escalate_review", "security-sensitive should escalate"); + CHECK(hasReason(r, "security_sensitive_change"), "security reason expected"); + PASS(); +} + +void test_repeated_failures_require_review() { + TEST(repeated_failures_require_review); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 95, 3, true, false}); + CHECK(r.decision == "escalate_review", "failure streak should escalate"); + CHECK(hasReason(r, "repeated_post_apply_failures"), "failure streak reason expected"); + PASS(); +} + +void test_high_confidence_deterministic_auto_approves() { + TEST(high_confidence_deterministic_auto_approves); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 90, 0, true, false}); + CHECK(!r.requiresHumanReview, "should auto approve"); + CHECK(r.decision == "auto_approve", "decision mismatch"); + PASS(); +} + +void test_moderate_confidence_auto_approve_with_audit() { + TEST(moderate_confidence_auto_approve_with_audit); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 75, 0, false, false}); + CHECK(!r.requiresHumanReview, "should not require human review"); + CHECK(r.decision == "auto_approve_with_audit", "decision mismatch"); + PASS(); +} + +void test_low_confidence_escalates_review() { + TEST(low_confidence_escalates_review); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 60, 0, false, false}); + CHECK(r.requiresHumanReview, "low confidence should require review"); + CHECK(r.decision == "escalate_review", "decision mismatch"); + CHECK(hasReason(r, "low_confidence"), "low confidence reason expected"); + PASS(); +} + +void test_high_cost_overage_escalates_review() { + TEST(high_cost_overage_escalates_review); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 90, 0, true, true}); + CHECK(r.requiresHumanReview, "high overage should escalate"); + CHECK(r.decision == "escalate_review", "decision mismatch"); + CHECK(hasReason(r, "high_cost_overage"), "overage reason expected"); + PASS(); +} + +void test_safety_overrides_high_confidence_auto_approve() { + TEST(safety_overrides_high_confidence_auto_approve); + auto r = ReviewGatePolicyRefinement::evaluate({true, false, false, 95, 0, true, false}); + CHECK(r.decision == "escalate_review", "safety should override auto approval"); + PASS(); +} + +void test_policy_violation_overrides_all_other_conditions() { + TEST(policy_violation_overrides_all_other_conditions); + auto r = ReviewGatePolicyRefinement::evaluate({true, true, true, 99, 10, true, true}); + CHECK(r.decision == "block", "policy violation should dominate"); + CHECK(hasReason(r, "policy_violation_detected"), "policy reason expected"); + PASS(); +} + +void test_failure_streak_threshold_is_inclusive() { + TEST(failure_streak_threshold_is_inclusive); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 90, 3, true, false}); + CHECK(r.decision == "escalate_review", "streak==3 should escalate"); + PASS(); +} + +void test_deterministic_path_without_high_confidence_uses_audit_path() { + TEST(deterministic_path_without_high_confidence_uses_audit_path); + auto r = ReviewGatePolicyRefinement::evaluate({false, false, false, 80, 0, true, false}); + CHECK(r.decision == "auto_approve_with_audit", "80 confidence should use audit path"); + PASS(); +} + +int main() { + std::cout << "Step 551: Review-Gate Policy Refinement\n"; + + test_policy_violation_blocks_immediately(); // 1 + test_safety_critical_requires_review(); // 2 + test_security_sensitive_requires_review(); // 3 + test_repeated_failures_require_review(); // 4 + test_high_confidence_deterministic_auto_approves(); // 5 + test_moderate_confidence_auto_approve_with_audit(); // 6 + test_low_confidence_escalates_review(); // 7 + test_high_cost_overage_escalates_review(); // 8 + test_safety_overrides_high_confidence_auto_approve(); // 9 + test_policy_violation_overrides_all_other_conditions(); // 10 + test_failure_streak_threshold_is_inclusive(); // 11 + test_deterministic_path_without_high_confidence_uses_audit_path(); // 12 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index 33f5176..630fcd4 100644 --- a/progress.md +++ b/progress.md @@ -9621,3 +9621,39 @@ cost, rejection, and latency metrics by worker and task class. - `editor/src/WorkerEfficiencyDashboardModel.h` within header-size limit (`71` <= `600`) - `editor/tests/step550_test.cpp` within test-file size guidance (`170` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 551: Review-Gate Policy Refinement +**Status:** PASS (12/12 tests) + +Implements refined review-gate policy logic to reduce unnecessary human +escalations while preserving hard safety/security/policy protections. + +**Files added:** +- `editor/src/ReviewGatePolicyRefinement.h` - review-gate policy module: + - policy-violation hard block precedence + - safety/security escalation precedence + - repeated post-apply failure escalation trigger + - high-confidence deterministic auto-approval path + - moderate-confidence auto-approve-with-audit path + - low-confidence/high-cost escalation behavior +- `editor/tests/step551_test.cpp` - 12 tests covering: + - policy/safety/security precedence behavior + - failure-streak escalation behavior + - auto-approve and audit-path behavior + - low-confidence/high-cost escalation behavior + - precedence override behavior across mixed conditions + - threshold boundary behavior + +**Files modified:** +- `editor/CMakeLists.txt` - `step551_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step551_test step550_test` - PASS +- `./editor/build-native/step551_test` - PASS (12/12) +- `./editor/build-native/step550_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/ReviewGatePolicyRefinement.h` within header-size limit (`70` <= `600`) +- `editor/tests/step551_test.cpp` within test-file size guidance (`132` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md`