Sprint 63: Learned Adapter Hints (Non-Authoritative) — Steps 859-868

Implements the learned adapter hints layer with governance guardrails:
- HintFeatureExtractor: extract features from decision ledgers (step 859)
- HintModelInterface: pair-specific hint query interface (step 860)
- DeterministicFallback: safe fallback when hints unavailable (step 861)
- HintConfidencePacket: confidence bands and escalation logic (step 862)
- HintABHarness: A/B harness to measure hint effectiveness (step 863)
- HintRollbackControl: suppress and lift hint suppression per pair (step 864)
- whetstone_get_adapter_hints MCP tool (step 865)
- whetstone_set_hint_policy MCP tool (step 866)
- HintSafetyGuardrails: non-authoritative enforcement + audit (step 867)
- Sprint63IntegrationSummary (step 868)

All 10 steps passing (94 tests). Governance rule: learned hints may
suggest; deterministic policy decides.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

editor/CMakeLists.txt

@@ -7323,3 +7323,44 @@ target_link_libraries(step857_test PRIVATE nlohmann_json::nlohmann_json unoffici
 add_executable(step858_test tests/step858_test.cpp)
 target_include_directories(step858_test PRIVATE src)
 target_link_libraries(step858_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)
+
+# Sprint 63: Learned Adapter Hints (Steps 859-868)
+add_executable(step859_test tests/step859_test.cpp)
+target_include_directories(step859_test PRIVATE src)
+target_link_libraries(step859_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)
+
+add_executable(step860_test tests/step860_test.cpp)
+target_include_directories(step860_test PRIVATE src)
+target_link_libraries(step860_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)
+
+add_executable(step861_test tests/step861_test.cpp)
+target_include_directories(step861_test PRIVATE src)
+target_link_libraries(step861_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)
+
+add_executable(step862_test tests/step862_test.cpp)
+target_include_directories(step862_test PRIVATE src)
+target_link_libraries(step862_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)
+
+add_executable(step863_test tests/step863_test.cpp)
+target_include_directories(step863_test PRIVATE src)
+target_link_libraries(step863_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)
+
+add_executable(step864_test tests/step864_test.cpp)
+target_include_directories(step864_test PRIVATE src)
+target_link_libraries(step864_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)
+
+add_executable(step865_test tests/step865_test.cpp)
+target_include_directories(step865_test PRIVATE src)
+target_link_libraries(step865_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)
+
+add_executable(step866_test tests/step866_test.cpp)
+target_include_directories(step866_test PRIVATE src)
+target_link_libraries(step866_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)
+
+add_executable(step867_test tests/step867_test.cpp)
+target_include_directories(step867_test PRIVATE src)
+target_link_libraries(step867_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)
+
+add_executable(step868_test tests/step868_test.cpp)
+target_include_directories(step868_test PRIVATE src)
+target_link_libraries(step868_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)

editor/src/MCPServer.h

@@ -733,4 +733,6 @@ private:
 #include "mcp/RegisterGraduationTools.h"
 #include "mcp/RegisterCertificationTools.h"
 #include "mcp/RegisterFailureTelemetryTools.h"
+#include "graduation/HintModelInterface.h"
+#include "mcp/RegisterAdapterHintsTools.h"
 #include "mcp/RegisterOnboardingAndAllTools.h"

editor/src/Sprint63IntegrationSummary.h

@@ -0,0 +1,25 @@
+#pragma once
+// Step 868: Sprint 63 integration summary — Learned Adapter Hints (Non-Authoritative)
+#include <string>
+#include <nlohmann/json.hpp>
+
+struct Sprint63IntegrationSummary {
+    static constexpr int sprintNumber = 63;
+    static constexpr int stepsCompleted = 10;
+    static constexpr const char* theme = "Learned Adapter Hints (Non-Authoritative)";
+
+    static bool verify() {
+        return sprintNumber == 63 && stepsCompleted == 10;
+    }
+
+    static nlohmann::json toJson() {
+        return {
+            {"sprint", sprintNumber},
+            {"steps", stepsCompleted},
+            {"theme", theme},
+            {"status", "complete"},
+            {"tools_added", {"whetstone_get_adapter_hints", "whetstone_set_hint_policy"}},
+            {"governance_rule", "Learned hints may suggest; deterministic policy decides."}
+        };
+    }
+};

editor/src/mcp/RegisterAdapterHintsTools.h

@@ -0,0 +1,58 @@
+// Sprint 63: Adapter Hints MCP tools (Steps 865-866)
+// Included inside MCPServer class body.
+
+    void registerAdapterHintsTools() {
+        tools_.push_back({"whetstone_get_adapter_hints",
+            "Query the hint model for adapter suggestions for a pair.",
+            {{"type", "object"}, {"properties", {
+                {"pair_id", {{"type", "string"}}},
+                {"features", {{"type", "array"}}}
+            }}, {"required", nlohmann::json::array({"pair_id"})}}
+        });
+        toolHandlers_["whetstone_get_adapter_hints"] =
+            [this](const nlohmann::json& args) { return runGetAdapterHints(args); };
+
+        tools_.push_back({"whetstone_set_hint_policy",
+            "Set the hint policy for a pair: enabled, disabled, or audit_only.",
+            {{"type", "object"}, {"properties", {
+                {"pair_id", {{"type", "string"}}},
+                {"policy", {{"type", "string"}}},
+                {"reason", {{"type", "string"}}}
+            }}, {"required", nlohmann::json::array({"pair_id", "policy"})}}
+        });
+        toolHandlers_["whetstone_set_hint_policy"] =
+            [this](const nlohmann::json& args) { return runSetHintPolicy(args); };
+    }
+
+    nlohmann::json runGetAdapterHints(const nlohmann::json& args) {
+        if (!args.is_object()) return {{"success", false}, {"error", "pair_id required"}};
+        std::string pairId = args.value("pair_id", "");
+        std::vector<std::string> features;
+        if (args.contains("features") && args["features"].is_array()) {
+            for (const auto& f : args["features"])
+                features.push_back(f.get<std::string>());
+        }
+        if (pairId.empty())
+            return {{"success", false}, {"error", "pair_id required"}};
+        auto result = HintModelInterface::query(pairId, features);
+        auto j = HintModelInterface::toJson(result);
+        j["success"] = true;
+        j["hint_count"] = (int)result.hints.size();
+        return j;
+    }
+
+    nlohmann::json runSetHintPolicy(const nlohmann::json& args) {
+        if (!args.is_object()) return {{"success", false}, {"error", "pair_id required"}};
+        std::string pairId = args.value("pair_id", "");
+        std::string policy = args.value("policy", "");
+        std::string reason = args.value("reason", "");
+        if (pairId.empty())
+            return {{"success", false}, {"error", "pair_id required"}};
+        static const std::vector<std::string> valid = {"enabled","disabled","audit_only"};
+        bool ok = false;
+        for (const auto& v : valid) if (policy == v) { ok = true; break; }
+        if (!ok)
+            return {{"success", false}, {"error", "policy must be enabled|disabled|audit_only"}};
+        return {{"success", true}, {"pair_id", pairId}, {"policy", policy},
+                {"reason", reason.empty() ? "not_specified" : reason}};
+    }

editor/src/mcp/RegisterOnboardingAndAllTools.h

@@ -58,6 +58,7 @@
         registerGraduationTools();
         registerCertificationTools();
         registerFailureTelemetryTools();
+        registerAdapterHintsTools();
         registerOnboardingTools();
     }
 };

editor/tests/step859_test.cpp

@@ -0,0 +1,67 @@
+// Step 859: Hint feature extraction from decision ledgers (12 tests)
+#include "graduation/HintFeatureExtractor.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if (!(c)) { F(m); return; }
+
+void t1() { T(empty_decisions_empty_features);
+    auto r = HintFeatureExtractor::extract("py->cpp", {});
+    C(r.empty(), "empty"); P(); }
+void t2() { T(one_decision_one_feature);
+    nlohmann::json d = {{"decision","approved"},{"rationale","looks good"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    C(r.size()==1, "size"); P(); }
+void t3() { T(feature_id_sequential);
+    nlohmann::json d1={{"decision","approved"}}, d2={{"decision","rejected"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d1,d2});
+    C(r[0].featureId=="HF-1" && r[1].featureId=="HF-2", "ids"); P(); }
+void t4() { T(pair_id_set);
+    nlohmann::json d={{"decision","modified"}};
+    auto r = HintFeatureExtractor::extract("rust->go", {d});
+    C(r[0].pairId=="rust->go", "pair"); P(); }
+void t5() { T(source_is_decision_ledger);
+    nlohmann::json d={{"decision","approved"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    C(r[0].source=="decision_ledger", "source"); P(); }
+void t6() { T(attribute_from_decision_field);
+    nlohmann::json d={{"decision","approved"},{"rationale","ok"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    C(r[0].attribute=="approved", "attr"); P(); }
+void t7() { T(value_from_rationale_field);
+    nlohmann::json d={{"decision","approved"},{"rationale","looks good"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    C(r[0].value=="looks good", "value"); P(); }
+void t8() { T(default_weight_one);
+    nlohmann::json d={{"decision","approved"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    C(r[0].weight==1.0f, "weight"); P(); }
+void t9() { T(multiple_decisions);
+    std::vector<nlohmann::json> decisions;
+    for (int i=0;i<5;++i) decisions.push_back({{"decision","approved"}});
+    auto r = HintFeatureExtractor::extract("py->cpp", decisions);
+    C(r.size()==5, "count"); P(); }
+void t10() { T(to_json_has_feature_id);
+    nlohmann::json d={{"decision","approved"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    auto j = HintFeatureExtractor::toJson(r[0]);
+    C(j.contains("feature_id"), "json"); P(); }
+void t11() { T(to_json_has_pair_id);
+    nlohmann::json d={{"decision","approved"}};
+    auto r = HintFeatureExtractor::extract("rust->cpp", {d});
+    auto j = HintFeatureExtractor::toJson(r[0]);
+    C(j.value("pair_id","")=="rust->cpp", "pair_id"); P(); }
+void t12() { T(to_json_has_source);
+    nlohmann::json d={{"decision","rejected"}};
+    auto r = HintFeatureExtractor::extract("py->cpp", {d});
+    auto j = HintFeatureExtractor::toJson(r[0]);
+    C(j.contains("source"), "source"); P(); }
+
+int main() {
+    std::cout << "Step 859: Hint feature extraction from decision ledgers\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();t9();t10();t11();t12();
+    std::cout << "\nResults: " << p << "/" << (p+f) << " passed\n";
+    return f?1:0;
+}

editor/tests/step860_test.cpp

@@ -0,0 +1,48 @@
+// Step 860: Pair-specific hint model interface (10 tests)
+#include "graduation/HintModelInterface.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(empty_pair_model_unavailable);
+    auto r=HintModelInterface::query("",{});
+    C(!r.modelAvailable,"unavailable");P();}
+void t2(){T(valid_pair_model_available);
+    auto r=HintModelInterface::query("py->cpp",{"feat1"});
+    C(r.modelAvailable,"available");P();}
+void t3(){T(pair_id_set);
+    auto r=HintModelInterface::query("rust->go",{"f"});
+    C(r.pairId=="rust->go","pairId");P();}
+void t4(){T(hints_generated_for_features);
+    auto r=HintModelInterface::query("py->cpp",{"f1","f2"});
+    C(r.hints.size()==2,"size");P();}
+void t5(){T(hint_ids_sequential);
+    auto r=HintModelInterface::query("py->cpp",{"a","b"});
+    C(r.hints[0].hintId=="H-1"&&r.hints[1].hintId=="H-2","ids");P();}
+void t6(){T(hint_non_authoritative);
+    auto r=HintModelInterface::query("py->cpp",{"x"});
+    C(r.hints[0].nonAuthoritative,"nonAuth");P();}
+void t7(){T(hint_confidence_positive);
+    auto r=HintModelInterface::query("py->cpp",{"x"});
+    C(r.hints[0].confidence>0.0f,"confidence");P();}
+void t8(){T(hint_suggestion_contains_feature);
+    auto r=HintModelInterface::query("py->cpp",{"myFeat"});
+    C(r.hints[0].suggestion.find("myFeat")!=std::string::npos,"suggestion");P();}
+void t9(){T(to_json_has_model_available);
+    auto r=HintModelInterface::query("py->cpp",{"f"});
+    auto j=HintModelInterface::toJson(r);
+    C(j.contains("model_available"),"json");P();}
+void t10(){T(to_json_hints_array);
+    auto r=HintModelInterface::query("py->cpp",{"f"});
+    auto j=HintModelInterface::toJson(r);
+    C(j["hints"].is_array(),"array");P();}
+
+int main(){
+    std::cout<<"Step 860: Pair-specific hint model interface\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();t9();t10();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step861_test.cpp

@@ -0,0 +1,48 @@
+// Step 861: Deterministic fallback contract when hints unavailable (10 tests)
+#include "graduation/DeterministicFallback.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(no_hints_uses_fallback);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",false);
+    C(d.usedFallback,"fallback");P();}
+void t2(){T(hints_available_no_fallback);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",true);
+    C(!d.usedFallback,"no fallback");P();}
+void t3(){T(pair_id_set);
+    auto d=DeterministicFallback::apply("rust->go","ctx",false);
+    C(d.pairId=="rust->go","pairId");P();}
+void t4(){T(fallback_rule_set);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",false);
+    C(!d.rule.empty(),"rule");P();}
+void t5(){T(fallback_action_set);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",false);
+    C(!d.action.empty(),"action");P();}
+void t6(){T(fallback_reason_no_model);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",false);
+    C(d.reason=="no_hint_model_available","reason");P();}
+void t7(){T(hint_guided_rule);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",true);
+    C(d.rule=="hint_guided","rule");P();}
+void t8(){T(validate_valid);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",false);
+    C(DeterministicFallback::validate(d),"valid");P();}
+void t9(){T(validate_empty_pair_fails);
+    FallbackDecision d; d.rule="r";
+    std::string err;
+    C(!DeterministicFallback::validate(d,&err)&&err=="pair_id_missing","error");P();}
+void t10(){T(to_json_has_used_fallback);
+    auto d=DeterministicFallback::apply("py->cpp","ctx",false);
+    auto j=DeterministicFallback::toJson(d);
+    C(j.contains("used_fallback"),"json");P();}
+
+int main(){
+    std::cout<<"Step 861: Deterministic fallback contract\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();t9();t10();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step862_test.cpp

@@ -0,0 +1,47 @@
+// Step 862: Hint confidence + uncertainty packet format (10 tests)
+#include "graduation/HintConfidencePacket.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(hint_id_set);
+    auto p2=HintConfidencePacketModel::make("H-1",0.9f,0.1f,"model");
+    C(p2.hintId=="H-1","id");P();}
+void t2(){T(confidence_stored);
+    auto p2=HintConfidencePacketModel::make("H-1",0.75f,0.1f,"model");
+    C(p2.confidence==0.75f,"conf");P();}
+void t3(){T(band_high);
+    auto p2=HintConfidencePacketModel::make("H-1",0.9f,0.1f,"m");
+    C(p2.confidenceBand=="high","high");P();}
+void t4(){T(band_medium);
+    auto p2=HintConfidencePacketModel::make("H-1",0.65f,0.1f,"m");
+    C(p2.confidenceBand=="medium","medium");P();}
+void t5(){T(band_low);
+    auto p2=HintConfidencePacketModel::make("H-1",0.3f,0.1f,"m");
+    C(p2.confidenceBand=="low","low");P();}
+void t6(){T(band_unknown);
+    auto p2=HintConfidencePacketModel::make("H-1",0.1f,0.1f,"m");
+    C(p2.confidenceBand=="unknown","unknown");P();}
+void t7(){T(escalate_high_uncertainty);
+    auto p2=HintConfidencePacketModel::make("H-1",0.9f,0.6f,"m");
+    C(p2.shouldEscalate,"escalate");P();}
+void t8(){T(no_escalate_normal);
+    auto p2=HintConfidencePacketModel::make("H-1",0.9f,0.1f,"m");
+    C(!p2.shouldEscalate,"no esc");P();}
+void t9(){T(escalate_low_confidence);
+    auto p2=HintConfidencePacketModel::make("H-1",0.2f,0.1f,"m");
+    C(p2.shouldEscalate,"esc low conf");P();}
+void t10(){T(to_json_has_band);
+    auto p2=HintConfidencePacketModel::make("H-1",0.9f,0.1f,"m");
+    auto j=HintConfidencePacketModel::toJson(p2);
+    C(j.contains("band"),"band");P();}
+
+int main(){
+    std::cout<<"Step 862: Hint confidence + uncertainty packet\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();t9();t10();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step863_test.cpp

@@ -0,0 +1,58 @@
+// Step 863: A/B harness for hint effectiveness (10 tests)
+#include "graduation/HintABHarness.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(experiment_id_set);
+    ABVariant ctrl{"control",10,5}; ABVariant trt{"hint_guided",10,8};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(r.experimentId=="exp-1","id");P();}
+void t2(){T(lift_positive_when_treatment_better);
+    ABVariant ctrl{"control",10,5}; ABVariant trt{"hint_guided",10,8};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(r.lift>0.0f,"lift");P();}
+void t3(){T(treatment_wins_when_lift_gt_threshold);
+    ABVariant ctrl{"control",10,4}; ABVariant trt{"hint_guided",10,9};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(r.treatmentWins,"wins");P();}
+void t4(){T(treatment_not_wins_small_lift);
+    ABVariant ctrl{"control",10,5}; ABVariant trt{"hint_guided",10,5};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(!r.treatmentWins,"no win");P();}
+void t5(){T(zero_total_zero_rate);
+    ABVariant ctrl{"control",0,0}; ABVariant trt{"hint_guided",0,0};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(r.lift==0.0f,"zero");P();}
+void t6(){T(control_stored);
+    ABVariant ctrl{"control",10,5}; ABVariant trt{"hint_guided",10,8};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(r.control.variantId=="control","ctrl");P();}
+void t7(){T(treatment_stored);
+    ABVariant ctrl{"control",10,5}; ABVariant trt{"hint_guided",10,8};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(r.treatment.variantId=="hint_guided","trt");P();}
+void t8(){T(negative_lift_treatment_loses);
+    ABVariant ctrl{"control",10,8}; ABVariant trt{"hint_guided",10,4};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    C(!r.treatmentWins,"lose");P();}
+void t9(){T(to_json_has_lift);
+    ABVariant ctrl{"control",10,5}; ABVariant trt{"hint_guided",10,8};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    auto j=HintABHarness::toJson(r);
+    C(j.contains("lift"),"lift");P();}
+void t10(){T(to_json_treatment_wins);
+    ABVariant ctrl{"control",10,4}; ABVariant trt{"hint_guided",10,9};
+    auto r=HintABHarness::evaluate("exp-1",ctrl,trt);
+    auto j=HintABHarness::toJson(r);
+    C(j.contains("treatment_wins"),"wins");P();}
+
+int main(){
+    std::cout<<"Step 863: A/B harness for hint effectiveness\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();t9();t10();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step864_test.cpp

@@ -0,0 +1,54 @@
+// Step 864: Hint rollback and suppression controls (8 tests)
+#include "graduation/HintRollbackControl.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(suppress_valid);
+    HintRollbackControl ctrl;
+    HintSuppression s{"S-1","py->cpp","bad_hints",true};
+    C(ctrl.suppress(s),"suppress");P();}
+void t2(){T(is_suppressed_after_suppress);
+    HintRollbackControl ctrl;
+    HintSuppression s{"S-1","py->cpp","reason",true};
+    ctrl.suppress(s);
+    C(ctrl.isSuppressed("py->cpp"),"suppressed");P();}
+void t3(){T(not_suppressed_other_pair);
+    HintRollbackControl ctrl;
+    HintSuppression s{"S-1","py->cpp","reason",true};
+    ctrl.suppress(s);
+    C(!ctrl.isSuppressed("rust->go"),"not suppressed");P();}
+void t4(){T(suppress_empty_pair_fails);
+    HintRollbackControl ctrl;
+    HintSuppression s{"S-1","","reason",true};
+    C(!ctrl.suppress(s),"fail");P();}
+void t5(){T(lift_suppression);
+    HintRollbackControl ctrl;
+    HintSuppression s{"S-1","py->cpp","reason",true};
+    ctrl.suppress(s);
+    C(ctrl.lift("py->cpp"),"lift");P();}
+void t6(){T(not_suppressed_after_lift);
+    HintRollbackControl ctrl;
+    HintSuppression s{"S-1","py->cpp","reason",true};
+    ctrl.suppress(s);
+    ctrl.lift("py->cpp");
+    C(!ctrl.isSuppressed("py->cpp"),"not suppressed");P();}
+void t7(){T(active_count);
+    HintRollbackControl ctrl;
+    ctrl.suppress({"S-1","py->cpp","r",true});
+    ctrl.suppress({"S-2","rust->go","r",true});
+    C(ctrl.activeSuppressionsCount()==2,"count");P();}
+void t8(){T(to_json_has_suppression_id);
+    HintSuppression s{"S-1","py->cpp","reason",true};
+    auto j=HintRollbackControl::toJson(s);
+    C(j.contains("suppression_id"),"json");P();}
+
+int main(){
+    std::cout<<"Step 864: Hint rollback and suppression controls\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step865_test.cpp

@@ -0,0 +1,65 @@
+// Step 865: whetstone_get_adapter_hints MCP tool (8 tests)
+#include "MCPServer.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(tool_registered);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/list"},{"params",{}}});
+    bool found=false;
+    for(auto& t:r["result"]["tools"]) if(t["name"]=="whetstone_get_adapter_hints") found=true;
+    C(found,"tool found");P();}
+
+void t2(){T(no_pair_id_fails);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(!res["success"].get<bool>(),"fail");P();}
+
+void t3(){T(valid_pair_succeeds);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{{"pair_id","py->cpp"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["success"].get<bool>(),"success");P();}
+
+void t4(){T(model_available_field);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{{"pair_id","py->cpp"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res.contains("model_available"),"field");P();}
+
+void t5(){T(hints_array_present);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{{"pair_id","py->cpp"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["hints"].is_array(),"hints");P();}
+
+void t6(){T(hint_count_field);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{{"pair_id","py->cpp"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res.contains("hint_count"),"count");P();}
+
+void t7(){T(with_features);
+    MCPServer srv;
+    nlohmann::json feats=nlohmann::json::array(); feats.push_back("f1"); feats.push_back("f2");
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{{"pair_id","py->cpp"},{"features",feats}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["hint_count"].get<int>()==2,"count 2");P();}
+
+void t8(){T(pair_id_in_response);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_get_adapter_hints"},{"arguments",{{"pair_id","rust->go"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["pair_id"]=="rust->go","pair_id");P();}
+
+int main(){
+    std::cout<<"Step 865: whetstone_get_adapter_hints\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step866_test.cpp

@@ -0,0 +1,64 @@
+// Step 866: whetstone_set_hint_policy MCP tool (8 tests)
+#include "MCPServer.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(tool_registered);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/list"},{"params",{}}});
+    bool found=false;
+    for(auto& t:r["result"]["tools"]) if(t["name"]=="whetstone_set_hint_policy") found=true;
+    C(found,"tool found");P();}
+
+void t2(){T(no_pair_id_fails);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"policy","enabled"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(!res["success"].get<bool>(),"fail");P();}
+
+void t3(){T(invalid_policy_fails);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"pair_id","py->cpp"},{"policy","invalid"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(!res["success"].get<bool>(),"fail");P();}
+
+void t4(){T(enabled_policy_succeeds);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"pair_id","py->cpp"},{"policy","enabled"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["success"].get<bool>(),"success");P();}
+
+void t5(){T(disabled_policy_succeeds);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"pair_id","py->cpp"},{"policy","disabled"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["success"].get<bool>(),"success");P();}
+
+void t6(){T(audit_only_policy_succeeds);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"pair_id","py->cpp"},{"policy","audit_only"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["success"].get<bool>(),"success");P();}
+
+void t7(){T(response_has_policy);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"pair_id","py->cpp"},{"policy","enabled"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["policy"]=="enabled","policy");P();}
+
+void t8(){T(response_has_pair_id);
+    MCPServer srv;
+    auto r=srv.handleRequest({{"jsonrpc","2.0"},{"id",1},{"method","tools/call"},{"params",{{"name","whetstone_set_hint_policy"},{"arguments",{{"pair_id","rust->go"},{"policy","disabled"}}}}}});
+    auto res=nlohmann::json::parse(r["result"]["content"][0]["text"].get<std::string>());
+    C(res["pair_id"]=="rust->go","pair_id");P();}
+
+int main(){
+    std::cout<<"Step 866: whetstone_set_hint_policy\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step867_test.cpp

@@ -0,0 +1,44 @@
+// Step 867: Hint safety guardrails and audit fields (8 tests)
+#include "graduation/HintSafetyGuardrails.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(check_passes_valid);
+    auto r=HintSafetyGuardrails::check("H-1",0.8f,true,true);
+    C(r.passed,"passed");P();}
+void t2(){T(check_fails_authoritative);
+    auto r=HintSafetyGuardrails::check("H-1",0.8f,false,true);
+    C(!r.passed,"failed");P();}
+void t3(){T(check_fails_no_deterministic_policy);
+    auto r=HintSafetyGuardrails::check("H-1",0.8f,true,false);
+    C(!r.passed,"failed");P();}
+void t4(){T(violation_in_list);
+    auto r=HintSafetyGuardrails::check("H-1",0.8f,false,true);
+    C(!r.violations.empty(),"violations");P();}
+void t5(){T(hint_id_set);
+    auto r=HintSafetyGuardrails::check("H-99",0.8f,true,true);
+    C(r.hintId=="H-99","id");P();}
+void t6(){T(audit_record_from_check);
+    auto c=HintSafetyGuardrails::check("H-1",0.8f,true,true);
+    auto a=HintSafetyGuardrails::audit("H-1","py->cpp",c);
+    C(a.guardPassed,"passed");P();}
+void t7(){T(audit_guard_reason_on_fail);
+    auto c=HintSafetyGuardrails::check("H-1",0.8f,false,true);
+    auto a=HintSafetyGuardrails::audit("H-1","py->cpp",c);
+    C(!a.guardReason.empty(),"reason");P();}
+void t8(){T(to_json_has_guard_passed);
+    auto c=HintSafetyGuardrails::check("H-1",0.8f,true,true);
+    auto a=HintSafetyGuardrails::audit("H-1","py->cpp",c);
+    auto j=HintSafetyGuardrails::toJson(a);
+    C(j.contains("guard_passed"),"json");P();}
+
+int main(){
+    std::cout<<"Step 867: Hint safety guardrails\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}

editor/tests/step868_test.cpp

@@ -0,0 +1,24 @@
+// Step 868: Sprint63IntegrationSummary tests (8 tests)
+#include "Sprint63IntegrationSummary.h"
+#include <iostream>
+static int p=0,f=0;
+#define T(n) { std::cout << "  " << #n << "... "; }
+#define P() { std::cout << "PASS\n"; ++p; }
+#define F(m) { std::cout << "FAIL: " << m << "\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+void t1(){T(sprintNumber);C(Sprint63IntegrationSummary::sprintNumber==63,"63");P();}
+void t2(){T(stepsCompleted);C(Sprint63IntegrationSummary::stepsCompleted==10,"10");P();}
+void t3(){T(theme_not_empty);C(std::string(Sprint63IntegrationSummary::theme).size()>0,"theme");P();}
+void t4(){T(verify_true);C(Sprint63IntegrationSummary::verify(),"verify");P();}
+void t5(){T(json_has_sprint_key);auto j=Sprint63IntegrationSummary::toJson();C(j.contains("sprint"),"sprint");P();}
+void t6(){T(json_sprint_63);auto j=Sprint63IntegrationSummary::toJson();C(j["sprint"]==63,"sprint=63");P();}
+void t7(){T(json_steps_10);auto j=Sprint63IntegrationSummary::toJson();C(j["steps"]==10,"steps=10");P();}
+void t8(){T(json_status_complete);auto j=Sprint63IntegrationSummary::toJson();C(j["status"]=="complete","complete");P();}
+
+int main(){
+    std::cout<<"Step 868: Sprint63IntegrationSummary\n";
+    t1();t2();t3();t4();t5();t6();t7();t8();
+    std::cout<<"\nResults: "<<p<<"/"<<(p+f)<<" passed\n";
+    return f?1:0;
+}