Step 544: extend constrained routing ruleset

editor/CMakeLists.txt

@@ -3775,4 +3775,13 @@ target_link_libraries(step543_test PRIVATE
     tree_sitter_javascript tree_sitter_typescript
     tree_sitter_java tree_sitter_rust tree_sitter_go)
 
+add_executable(step544_test tests/step544_test.cpp)
+target_include_directories(step544_test PRIVATE src)
+target_link_libraries(step544_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)

editor/src/ConstrainedRoutingRulesetExtension.h

@@ -0,0 +1,60 @@
+#pragma once
+// Step 544: Constrained Routing Ruleset Extension
+
+#include <string>
+#include <vector>
+
+struct ConstrainedRoutingInput {
+    std::string taskClass;
+    double legalChoiceConfidence = 0.0;
+    bool deterministicTemplateAvailable = false;
+    bool constrainedMode = true;
+    bool hasRecentPostApplyFailures = false;
+};
+
+struct ConstrainedRoutingDecision {
+    std::string route; // deterministic_template/constrained_worker/general_worker/escalate
+    double confidence = 0.0;
+    std::vector<std::string> reasons;
+};
+
+class ConstrainedRoutingRulesetExtension {
+public:
+    static ConstrainedRoutingDecision decide(const ConstrainedRoutingInput& input) {
+        ConstrainedRoutingDecision out;
+
+        if (!input.constrainedMode) {
+            out.route = "general_worker";
+            out.confidence = 0.70;
+            out.reasons.push_back("constrained_mode_disabled");
+            return out;
+        }
+
+        if (input.hasRecentPostApplyFailures) {
+            out.route = "escalate";
+            out.confidence = 0.55;
+            out.reasons.push_back("recent_post_apply_failures");
+            return out;
+        }
+
+        if (input.deterministicTemplateAvailable && input.legalChoiceConfidence >= 0.85) {
+            out.route = "deterministic_template";
+            out.confidence = input.legalChoiceConfidence;
+            out.reasons.push_back("high_legal_choice_confidence");
+            out.reasons.push_back("template_available");
+            return out;
+        }
+
+        if (input.legalChoiceConfidence >= 0.60) {
+            out.route = "constrained_worker";
+            out.confidence = input.legalChoiceConfidence;
+            out.reasons.push_back("moderate_legal_choice_confidence");
+            return out;
+        }
+
+        out.route = "general_worker";
+        out.confidence = input.legalChoiceConfidence;
+        out.reasons.push_back("low_legal_choice_confidence");
+        return out;
+    }
+};

editor/tests/step544_test.cpp

@@ -0,0 +1,126 @@
+// Step 544: Constrained Routing Ruleset Extension (12 tests)
+
+#include "ConstrainedRoutingRulesetExtension.h"
+
+#include <iostream>
+
+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 ConstrainedRoutingDecision& d, const std::string& reason) {
+    for (const auto& r : d.reasons) if (r == reason) return true;
+    return false;
+}
+
+void test_non_constrained_mode_routes_general_worker() {
+    TEST(non_constrained_mode_routes_general_worker);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"rename", 0.9, true, false, false});
+    CHECK(d.route == "general_worker", "should route general when constrained off");
+    CHECK(hasReason(d, "constrained_mode_disabled"), "reason expected");
+    PASS();
+}
+
+void test_recent_failures_force_escalation() {
+    TEST(recent_failures_force_escalation);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"rename", 0.95, true, true, true});
+    CHECK(d.route == "escalate", "recent failures should escalate");
+    CHECK(hasReason(d, "recent_post_apply_failures"), "reason expected");
+    PASS();
+}
+
+void test_high_confidence_with_template_promotes_deterministic_route() {
+    TEST(high_confidence_with_template_promotes_deterministic_route);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"rename", 0.92, true, true, false});
+    CHECK(d.route == "deterministic_template", "high confidence + template should promote deterministic route");
+    PASS();
+}
+
+void test_high_confidence_without_template_routes_constrained_worker() {
+    TEST(high_confidence_without_template_routes_constrained_worker);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"rename", 0.92, false, true, false});
+    CHECK(d.route == "constrained_worker", "without template should route constrained worker");
+    PASS();
+}
+
+void test_moderate_confidence_routes_constrained_worker() {
+    TEST(moderate_confidence_routes_constrained_worker);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.70, true, true, false});
+    CHECK(d.route == "constrained_worker", "moderate confidence should route constrained worker");
+    PASS();
+}
+
+void test_low_confidence_routes_general_worker() {
+    TEST(low_confidence_routes_general_worker);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.40, true, true, false});
+    CHECK(d.route == "general_worker", "low confidence should route general worker");
+    CHECK(hasReason(d, "low_legal_choice_confidence"), "reason expected");
+    PASS();
+}
+
+void test_template_threshold_is_inclusive_at_085() {
+    TEST(template_threshold_is_inclusive_at_085);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.85, true, true, false});
+    CHECK(d.route == "deterministic_template", "0.85 should qualify for template route");
+    PASS();
+}
+
+void test_constrained_worker_threshold_is_inclusive_at_060() {
+    TEST(constrained_worker_threshold_is_inclusive_at_060);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.60, false, true, false});
+    CHECK(d.route == "constrained_worker", "0.60 should qualify for constrained worker");
+    PASS();
+}
+
+void test_escalation_precedence_over_template_promotion() {
+    TEST(escalation_precedence_over_template_promotion);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.99, true, true, true});
+    CHECK(d.route == "escalate", "escalation should take precedence over template promotion");
+    PASS();
+}
+
+void test_confidence_propagates_for_constrained_worker_route() {
+    TEST(confidence_propagates_for_constrained_worker_route);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.73, false, true, false});
+    CHECK(d.route == "constrained_worker", "route mismatch");
+    CHECK(d.confidence > 0.72 && d.confidence < 0.74, "confidence should match input for constrained route");
+    PASS();
+}
+
+void test_confidence_propagates_for_template_route() {
+    TEST(confidence_propagates_for_template_route);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.89, true, true, false});
+    CHECK(d.route == "deterministic_template", "route mismatch");
+    CHECK(d.confidence > 0.88 && d.confidence < 0.90, "confidence should match input for template route");
+    PASS();
+}
+
+void test_reasons_include_template_and_confidence_tags() {
+    TEST(reasons_include_template_and_confidence_tags);
+    auto d = ConstrainedRoutingRulesetExtension::decide({"update", 0.89, true, true, false});
+    CHECK(hasReason(d, "high_legal_choice_confidence"), "high confidence reason expected");
+    CHECK(hasReason(d, "template_available"), "template reason expected");
+    PASS();
+}
+
+int main() {
+    std::cout << "Step 544: Constrained Routing Ruleset Extension\n";
+
+    test_non_constrained_mode_routes_general_worker();             // 1
+    test_recent_failures_force_escalation();                       // 2
+    test_high_confidence_with_template_promotes_deterministic_route(); // 3
+    test_high_confidence_without_template_routes_constrained_worker(); // 4
+    test_moderate_confidence_routes_constrained_worker();          // 5
+    test_low_confidence_routes_general_worker();                   // 6
+    test_template_threshold_is_inclusive_at_085();                 // 7
+    test_constrained_worker_threshold_is_inclusive_at_060();       // 8
+    test_escalation_precedence_over_template_promotion();          // 9
+    test_confidence_propagates_for_constrained_worker_route();     // 10
+    test_confidence_propagates_for_template_route();               // 11
+    test_reasons_include_template_and_confidence_tags();           // 12
+
+    std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n";
+    return failed == 0 ? 0 : 1;
+}