use khive_pack_brain::BrainPack;
use khive_pack_kg::KgPack;
use khive_pack_knowledge::KnowledgePack;
use khive_runtime::{KhiveRuntime, Namespace, RuntimeConfig, VerbRegistryBuilder};
use serde_json::json;
fn make_rt(brain_profile: Option<String>, with_brain: bool) -> KhiveRuntime {
let packs: Vec<String> = if with_brain {
vec!["kg".into(), "knowledge".into(), "brain".into()]
} else {
vec!["kg".into(), "knowledge".into()]
};
KhiveRuntime::new(RuntimeConfig {
git_write: Default::default(),
display_timezone: khive_runtime::config::resolve_default_display_timezone(),
events_split: None,
db_path: None,
blob_hydration_bytes: khive_runtime::DEFAULT_BLOB_HYDRATION_BYTES,
embedding_model: None,
additional_embedding_models: vec![],
packs,
brain_profile,
actor_id: Some("knowledge-feedback-test".into()),
..RuntimeConfig::default()
})
.expect("runtime")
}
fn make_rt_with_actor(actor: &str) -> KhiveRuntime {
KhiveRuntime::new(RuntimeConfig {
wal_ceiling_bytes: 0,
wal_ceiling_configured_bytes: 0,
wal_ceiling_source: Default::default(),
wal_ceiling_env_raw: None,
web: Default::default(),
telemetry: Default::default(),
mounts: Vec::new(),
brain: Default::default(),
git_write: Default::default(),
display_timezone: khive_runtime::config::resolve_default_display_timezone(),
events_split: None,
db_path: None,
blob_hydration_bytes: khive_runtime::DEFAULT_BLOB_HYDRATION_BYTES,
default_namespace: Namespace::local(),
embedding_model: None,
additional_embedding_models: vec![],
gate: std::sync::Arc::new(khive_runtime::AllowAllGate),
packs: vec!["kg".into(), "knowledge".into(), "brain".into()],
backend_id: khive_runtime::BackendId::main(),
brain_profile: None,
visible_namespaces: vec![],
allowed_outbound_namespaces: vec![],
actor_id: Some(actor.to_string()),
exec: Default::default(),
..khive_runtime::RuntimeConfig::no_embeddings()
})
.expect("runtime with actor")
}
async fn make_atom(registry: &khive_runtime::VerbRegistry, ns: &str) -> String {
registry.dispatch("knowledge.upsert_atoms", json!({
"namespace": ns,
"atoms": [{"slug":"feedback-target-atom", "name":"Feedback Target Atom",
"content":"dense sparse retrieval corpus benchmark search latency gradient descent transformer attention vector index nearest neighbor ranking fusion pipeline embedding rerank cosine similarity"}]
})).await.expect("upsert atom");
let result = registry
.dispatch(
"knowledge.get",
json!({"namespace":ns,"id":"feedback-target-atom"}),
)
.await
.expect("get atom");
assert_eq!(result["kind"], "atom");
result["id"].as_str().unwrap().to_owned()
}
#[tokio::test]
async fn feedback_tier1_explicit_profile_routes_to_brain() {
let rt = make_rt(Some("balanced-recall-v1".into()), false);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("registry");
let atom_id = make_atom(®istry, ns.as_str()).await;
let result = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await;
assert!(
result.is_err(),
"tier-1 with no brain pack must error (verb not found), got: {result:?}"
);
}
#[tokio::test]
async fn feedback_tier1_explicit_wins_over_bound_profile() {
let rt = make_rt(Some("balanced-recall-v1".into()), true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
registry
.dispatch(
"brain.create_profile",
json!({"namespace": ns.as_str(), "name": "alt-profile", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("create alt profile");
registry
.dispatch(
"brain.activate",
json!({"namespace": ns.as_str(), "profile_id": "alt-profile"}),
)
.await
.expect("activate alt profile");
registry
.dispatch(
"brain.bind",
json!({"namespace": ns.as_str(), "profile_id": "alt-profile", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("bind alt profile");
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("feedback ok");
assert_eq!(
r["emitted"], true,
"tier-1 explicit profile must route to brain pack: {r:?}"
);
assert_eq!(
r.get("brain_profile").and_then(|v| v.as_str()),
Some("balanced-recall-v1"),
"knowledge.feedback tier-1 must include the explicit brain_profile in response: {r:?}"
);
let alt = registry
.dispatch(
"brain.profile",
json!({"namespace": ns.as_str(), "profile_id": "alt-profile"}),
)
.await
.expect("brain.profile alt");
assert_eq!(
alt["total_events"].as_u64().unwrap_or(0),
0,
"alt-profile must NOT receive events when tier-1 is active"
);
}
#[tokio::test]
async fn feedback_tier2_namespace_bound_profile_credited() {
let rt = make_rt(None, true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
registry
.dispatch(
"brain.create_profile",
json!({"namespace": ns.as_str(), "name": "ns-bound-compose", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("create ns-bound profile");
registry
.dispatch(
"brain.activate",
json!({"namespace": ns.as_str(), "profile_id": "ns-bound-compose"}),
)
.await
.expect("activate ns-bound profile");
registry
.dispatch(
"brain.bind",
json!({"namespace": ns.as_str(), "profile_id": "ns-bound-compose", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("bind ns-bound profile");
let resolve = registry
.dispatch(
"brain.resolve",
json!({"namespace": ns.as_str(), "consumer_kind": "knowledge_compose"}),
)
.await
.expect("brain.resolve");
assert_eq!(
resolve["resolved_profile_id"], "ns-bound-compose",
"brain.resolve must return the bound profile"
);
assert_eq!(
resolve["matched_binding"], true,
"must be matched_binding=true for an explicit binding"
);
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("feedback ok");
assert_eq!(
r["emitted"], true,
"tier-2 feedback must route to brain pack: {r:?}"
);
let prof = registry
.dispatch(
"brain.profile",
json!({"namespace": ns.as_str(), "profile_id": "ns-bound-compose"}),
)
.await
.expect("brain.profile");
assert_eq!(
prof["section_posteriors"]["overview"]["alpha"]
.as_f64()
.unwrap(),
3.0,
"ns-bound-compose must receive the feedback event"
);
}
#[tokio::test]
async fn feedback_tier2_actor_bound_profile_credited() {
let rt = make_rt_with_actor("leo");
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
builder.with_actor_id(Some("leo".to_string()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
registry
.dispatch(
"brain.create_profile",
json!({"namespace": ns.as_str(), "name": "actor-bound-compose", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("create actor-bound profile");
registry
.dispatch(
"brain.activate",
json!({"namespace": ns.as_str(), "profile_id": "actor-bound-compose"}),
)
.await
.expect("activate actor-bound profile");
registry
.dispatch(
"brain.bind",
json!({"actor": "leo", "profile_id": "actor-bound-compose", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("bind actor-bound profile to actor=leo");
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("feedback ok");
assert_eq!(
r["emitted"], true,
"tier-2 actor-bound feedback must route to brain pack: {r:?}"
);
assert_eq!(
r.get("brain_profile").and_then(|v| v.as_str()),
Some("actor-bound-compose"),
"knowledge.feedback must credit the actor-bound profile: {r:?}"
);
let prof = registry
.dispatch(
"brain.profile",
json!({"namespace": ns.as_str(), "profile_id": "actor-bound-compose"}),
)
.await
.expect("brain.profile");
assert_eq!(
prof["section_posteriors"]["overview"]["alpha"]
.as_f64()
.unwrap(),
3.0,
"actor-bound-compose must receive the feedback event"
);
}
#[tokio::test]
async fn feedback_tier3_namespace_fallback_no_explicit_binding() {
let rt = make_rt(None, true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
if let Ok(resolve) = registry
.dispatch(
"brain.resolve",
json!({"namespace": ns.as_str(), "consumer_kind": "knowledge_compose"}),
)
.await
{
assert_eq!(
resolve["matched_binding"], false,
"no explicit binding: matched_binding must be false (system default)"
);
}
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("tier-3 feedback must not error");
assert_eq!(r["ok"], true, "tier-3 must return ok=true: {r:?}");
assert!(
r.get("total_events").is_some(),
"tier-3 must include total_events from section_posteriors: {r:?}"
);
assert_eq!(r["emitted"], true, "tier-3 persists a knowledge event");
assert!(r["profile_event_id"].is_null());
}
#[tokio::test]
async fn feedback_tier3_no_brain_pack() {
let rt = make_rt(None, false);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "not_useful"},
}),
)
.await
.expect("tier-3 feedback must not error");
assert_eq!(r["ok"], true, "tier-3 must return ok=true: {r:?}");
assert!(
r.get("total_events").is_some(),
"tier-3 must include total_events: {r:?}"
);
}
#[tokio::test]
async fn feedback_tier3_no_target_id() {
let rt = make_rt(None, false);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("registry");
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"section_signals": {"overview": "wrong"},
}),
)
.await
.expect("feedback without target_id must not error");
assert_eq!(r["ok"], true, "ok=true even without target_id: {r:?}");
assert!(
r.get("total_events").is_some(),
"total_events must be present: {r:?}"
);
}
const ID_NAMING_NOTHING: &str = "00000000-0000-4000-8000-000000000000";
#[tokio::test]
async fn feedback_tier1_response_names_its_tier() {
let rt = make_rt(Some("balanced-recall-v1".into()), true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("feedback ok");
assert_eq!(
r.get("tier").and_then(|v| v.as_str()),
Some("explicit_profile"),
"tier-1 must name its tier: {r:?}"
);
assert_eq!(
r["target_id_used"], true,
"tier-1 records target_id in its knowledge event: {r:?}"
);
}
#[tokio::test]
async fn feedback_tier2_response_names_its_tier() {
let rt = make_rt(None, true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
registry
.dispatch(
"brain.create_profile",
json!({"namespace": ns.as_str(), "name": "tier-name-compose", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("create bound profile");
registry
.dispatch(
"brain.activate",
json!({"namespace": ns.as_str(), "profile_id": "tier-name-compose"}),
)
.await
.expect("activate bound profile");
registry
.dispatch(
"brain.bind",
json!({"namespace": ns.as_str(), "profile_id": "tier-name-compose", "consumer_kind": "knowledge_compose"}),
)
.await
.expect("bind bound profile");
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("feedback ok");
assert_eq!(
r.get("tier").and_then(|v| v.as_str()),
Some("bound_profile"),
"tier-2 must name its tier: {r:?}"
);
assert_eq!(
r.get("brain_profile").and_then(|v| v.as_str()),
Some("tier-name-compose"),
"tier-2 must credit the bound profile: {r:?}"
);
assert_eq!(
r["target_id_used"], true,
"tier-2 records target_id in its knowledge event: {r:?}"
);
}
#[tokio::test]
async fn feedback_tier3_response_names_its_tier_and_records_the_resolved_id() {
let rt = make_rt(None, false);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("tier-3 feedback must not error");
assert_eq!(
r.get("tier").and_then(|v| v.as_str()),
Some("namespace_local"),
"tier-3 must name its tier: {r:?}"
);
assert_eq!(
r["target_id_used"], true,
"tier-3 records the resolved knowledge target: {r:?}"
);
}
#[tokio::test]
async fn feedback_tier3_rejects_a_missing_target() {
let rt = make_rt(None, false);
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt));
let registry = builder.build().unwrap();
let error = registry
.dispatch(
"knowledge.feedback",
json!({
"target_id": ID_NAMING_NOTHING, "section_signals":{"overview":"useful"}
}),
)
.await
.unwrap_err();
assert!(error.to_string().contains("knowledge target"), "{error}");
}
#[tokio::test]
async fn feedback_tier1_rejects_a_target_id_naming_nothing() {
let rt = make_rt(Some("balanced-recall-v1".into()), true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let atom_id = make_atom(®istry, ns.as_str()).await;
let ok = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": atom_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("a real id is accepted under tier-1");
assert_eq!(ok["emitted"], true, "control must reach brain: {ok:?}");
let result = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": ID_NAMING_NOTHING,
"section_signals": {"overview": "useful"},
}),
)
.await;
assert!(
result.is_err(),
"tier-1 must refuse an id that resolves to nothing, got: {result:?}"
);
}
async fn make_domain(registry: &khive_runtime::VerbRegistry, ns: &str) -> String {
registry
.dispatch(
"knowledge.upsert_domains",
json!({
"namespace": ns,
"domains": [{
"slug": "feedback-target-domain",
"name": "Feedback Target Domain",
"description": "dense sparse retrieval corpus benchmark search latency gradient descent transformer attention vector index nearest neighbor ranking fusion pipeline embedding rerank cosine similarity",
}],
}),
)
.await
.expect("upsert_domains");
let got = registry
.dispatch(
"knowledge.get",
json!({"namespace": ns, "id": "feedback-target-domain"}),
)
.await
.expect("get domain");
assert_eq!(got["kind"], "domain", "fixture must be a domain: {got:?}");
got["id"]
.as_str()
.expect("domain id from knowledge.get")
.to_string()
}
#[tokio::test]
async fn feedback_tier3_records_a_domain_id() {
let rt = make_rt(None, false);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("registry");
let domain_id = make_domain(®istry, ns.as_str()).await;
let r = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": domain_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("tier-3 accepts a domain id");
assert_eq!(
r.get("tier").and_then(|v| v.as_str()),
Some("namespace_local"),
"tier-3 must name its tier: {r:?}"
);
assert_eq!(
r["target_id_used"], true,
"the domain is recorded while the namespace prior learns: {r:?}"
);
}
#[tokio::test]
async fn feedback_tier1_accepts_a_domain_id() {
let rt = make_rt(Some("balanced-recall-v1".into()), true);
let ns = Namespace::parse("local").expect("ns");
let mut builder = VerbRegistryBuilder::new();
builder.with_actor_id(Some("knowledge-feedback-test".into()));
builder.register(KgPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
let registry = builder.build().expect("registry");
rt.install_edge_rules(registry.all_edge_rules());
let entity_id = make_atom(®istry, ns.as_str()).await;
let ok = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": entity_id,
"section_signals": {"overview": "useful"},
}),
)
.await
.expect("an entity id is accepted under tier-1");
assert_eq!(ok["emitted"], true, "control must reach brain: {ok:?}");
let domain_id = make_domain(®istry, ns.as_str()).await;
let result = registry
.dispatch(
"knowledge.feedback",
json!({
"namespace": ns.as_str(),
"target_id": domain_id,
"section_signals": {"overview": "useful"},
}),
)
.await;
let result = result.expect("domain feedback reaches section hook");
assert_eq!(result["target_kind"], "domain");
assert!(result["profile_event_id"].is_string());
}
#[path = "feedback_targets/mod.rs"]
mod feedback_targets;