use std::collections::HashMap;
use uuid::Uuid;
use khive_brain_core::{FeedbackSignal, SectionPosteriorState, SectionType};
use khive_runtime::{KhiveRuntime, Namespace, PackRuntime, VerbRegistryBuilder};
use serde_json::json;
use crate::knowledge::section_feedback::on_section_feedback;
use crate::KnowledgePack;
fn secondary_backend_runtime() -> KhiveRuntime {
use std::sync::Arc;
let make_backend = || {
let backend = khive_db::StorageBackend::memory().expect("in-memory backend");
{
let mut writer = backend.pool().try_writer().expect("writer");
khive_db::run_migrations(writer.conn_mut()).expect("migrations");
}
Arc::new(backend)
};
let main_backend = make_backend();
let knowledge_backend = make_backend();
let mut config = khive_runtime::RuntimeConfig::no_embeddings();
config.packs = vec!["kg".to_string()];
config.backend_id = khive_runtime::BackendId::parse("knowledge").expect("valid backend id");
KhiveRuntime::from_backend(knowledge_backend, config).with_core_backend(main_backend)
}
#[tokio::test]
async fn concept_tier_routes_through_core_on_secondary_backend() {
let rt = secondary_backend_runtime();
let pack = KnowledgePack::new(rt.clone());
let registry = VerbRegistryBuilder::new()
.build()
.expect("empty registry builds");
let token = rt.authorize(Namespace::local()).expect("authorize local");
let learned = pack
.dispatch(
"knowledge.learn",
json!({ "name": "core-routing probe", "content": "concept body", "domain": "retrieval" }),
®istry,
&token,
)
.await
.expect("learn succeeds");
let concept_id: Uuid = learned["full_id"]
.as_str()
.expect("full_id")
.parse()
.expect("uuid");
let on_core = rt
.core()
.get_entities_by_ids(&token, &[concept_id])
.await
.expect("core read succeeds");
assert_eq!(
on_core.len(),
1,
"learn must write the concept entity to the core (main) backend"
);
let on_secondary = rt
.get_entities_by_ids(&token, &[concept_id])
.await
.expect("secondary read succeeds");
assert!(
on_secondary.is_empty(),
"concept entity must not land on the knowledge backend"
);
let source = rt
.core()
.create_entity_with_embedding_report(
&token,
"document",
None,
"source paper",
Some("source body"),
None,
vec![],
)
.await
.map(|(entity, _report)| entity)
.expect("source document entity");
let source_id = source.id.to_string();
pack.dispatch(
"knowledge.cite",
json!({ "concept_id": concept_id.to_string(), "source_id": source_id }),
®istry,
&token,
)
.await
.expect("cite must resolve both core-side entities and write the edge");
let topics = pack
.dispatch(
"knowledge.topic",
json!({ "domain": "retrieval" }),
®istry,
&token,
)
.await
.expect("topic succeeds");
assert_eq!(
topics["total"].as_u64(),
Some(1),
"topic must list the core-side concept: {topics}"
);
}
#[test]
fn filter_map_drops_missing_entities_without_panic() {
let present_id = Uuid::new_v4();
let absent_id = Uuid::new_v4();
let mut entity_map: HashMap<Uuid, &str> = HashMap::new();
entity_map.insert(present_id, "present");
let hits = vec![present_id, absent_id];
let results: Vec<&str> = hits
.into_iter()
.filter_map(|id| entity_map.get(&id).copied())
.collect();
assert_eq!(
results,
vec!["present"],
"absent entity must be dropped silently"
);
}
#[tokio::test]
async fn invalid_section_type_error_lists_valid_values() {
let rt = KhiveRuntime::memory().expect("in-memory runtime");
let pack = KnowledgePack::new(rt.clone());
let registry = VerbRegistryBuilder::new()
.build()
.expect("empty registry builds");
let token = rt.authorize(Namespace::local()).expect("authorize local");
let err = pack
.dispatch(
"knowledge.feedback",
json!({ "section_signals": { "not_a_real_section": "useful" } }),
®istry,
&token,
)
.await
.unwrap_err();
let khive_runtime::RuntimeError::InvalidInput(msg) = err else {
panic!("expected InvalidInput, got {err:?}");
};
assert!(
msg.contains("overview"),
"error must list valid section types; got: {msg}",
);
}
#[tokio::test]
async fn resolve_compose_type_weights_reads_tuned_section_posteriors_at_tier3() {
let rt = KhiveRuntime::memory().expect("in-memory runtime");
let pack = KnowledgePack::new(rt.clone());
let registry = VerbRegistryBuilder::new()
.build()
.expect("empty registry builds");
let token = rt.authorize(Namespace::local()).expect("authorize local");
{
let mut states = pack.section_posteriors.lock().unwrap();
let state = states.entry("local".to_string()).or_default();
for _ in 0..80 {
on_section_feedback(
state,
&[
(SectionType::Formalism, FeedbackSignal::Useful),
(SectionType::OperationalGuidance, FeedbackSignal::Wrong),
],
);
}
state.exploration_epoch = 0;
}
let weights = pack.resolve_compose_type_weights(®istry, &token).await;
let formalism_tuned = *weights
.get("formalism")
.expect("formalism weight must be present");
let og_tuned = *weights
.get("operational_guidance")
.expect("operational_guidance weight must be present");
let default_state = SectionPosteriorState::default();
let default_w: HashMap<String, f32> = default_state
.deterministic_weights()
.into_iter()
.map(|(st, w)| (st.as_str().to_string(), w as f32))
.collect();
let formalism_default = *default_w.get("formalism").unwrap();
let og_default = *default_w.get("operational_guidance").unwrap();
assert!(
formalism_tuned > formalism_default,
"tuned formalism weight {formalism_tuned:.4} must exceed default {formalism_default:.4} \
after skewing feedback"
);
assert!(
og_tuned < og_default,
"tuned og weight {og_tuned:.4} must be below default {og_default:.4} \
after wrong feedback"
);
assert!(
formalism_tuned > og_tuned,
"after skewing, formalism {formalism_tuned:.4} must outweigh og {og_tuned:.4}"
);
}
#[tokio::test]
async fn tier3_section_posteriors_do_not_cross_namespaces() {
let rt = KhiveRuntime::new(khive_runtime::RuntimeConfig {
db_path: None,
packs: vec!["kg".to_string()],
brain_profile: None,
actor_id: Some("section-isolation-test".into()),
..khive_runtime::RuntimeConfig::no_embeddings()
})
.expect("in-memory runtime");
let pack = KnowledgePack::new(rt.clone());
let registry = VerbRegistryBuilder::new()
.build()
.expect("empty registry builds");
let local_token = rt.authorize(Namespace::local()).expect("local token");
let arm_token = rt
.authorize(Namespace::parse("bench-arm-a").expect("arm namespace"))
.expect("arm token");
for _ in 0..80 {
pack.dispatch(
"knowledge.feedback",
json!({
"section_signals": {
"formalism": "useful",
"operational_guidance": "wrong"
}
}),
®istry,
&local_token,
)
.await
.expect("local Tier-3 feedback");
}
let local = pack
.resolve_compose_type_weights(®istry, &local_token)
.await;
let arm = pack
.resolve_compose_type_weights(®istry, &arm_token)
.await;
let defaults: HashMap<String, f32> = SectionPosteriorState::default()
.deterministic_weights()
.into_iter()
.map(|(st, w)| (st.as_str().to_string(), w as f32))
.collect();
assert!(
local["formalism"] > local["operational_guidance"],
"local feedback must tune the local fallback"
);
assert_eq!(
arm, defaults,
"an untouched measurement arm must retain fresh Tier-3 defaults"
);
}
#[tokio::test]
async fn resolve_compose_type_weights_reads_bound_profile_weights_at_tier2() {
use khive_pack_brain::BrainPack;
use khive_pack_kg::KgPack;
let rt = KhiveRuntime::memory().expect("in-memory runtime");
let mut builder = VerbRegistryBuilder::new();
builder.register(KgPack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("kg+brain+knowledge registry builds");
let token = rt.authorize(Namespace::local()).expect("authorize local");
registry
.dispatch(
"brain.create_profile",
json!({
"name": "compose-tuned-v1",
"consumer_kind": "knowledge_compose",
"seed_priors": {
"section_posteriors": {
"formalism": {"alpha": 8.0, "beta": 1.0},
"operational_guidance": {"alpha": 1.0, "beta": 8.0}
}
}
}),
)
.await
.expect("create_profile with skewed seed_priors");
registry
.dispatch("brain.activate", json!({"profile_id": "compose-tuned-v1"}))
.await
.expect("activate compose-tuned-v1");
registry
.dispatch(
"brain.bind",
json!({
"profile_id": "compose-tuned-v1",
"namespace": "local",
"consumer_kind": "knowledge_compose"
}),
)
.await
.expect("bind compose-tuned-v1 for namespace=local");
let pack = KnowledgePack::new(rt.clone());
let weights = pack.resolve_compose_type_weights(®istry, &token).await;
let formalism_w = *weights
.get("formalism")
.expect("formalism weight must be present");
let og_w = *weights
.get("operational_guidance")
.expect("operational_guidance weight must be present");
assert!(
formalism_w > og_w,
"Tier-2 bound-profile: formalism {formalism_w:.4} must exceed og {og_w:.4}; \
ordering reflects seed_priors (formalism β(8,1) >> og β(1,8)), \
not default priors where og α=6,β=1.5 dominates"
);
}
#[tokio::test]
async fn resolve_compose_type_weights_keeps_nonlocal_namespace_for_profile_read() {
use khive_pack_brain::BrainPack;
use khive_pack_kg::KgPack;
let rt = KhiveRuntime::memory().expect("in-memory runtime");
let mut builder = VerbRegistryBuilder::new();
builder.register(KgPack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("kg+brain+knowledge registry builds");
let arm_ns = "bench-arm-a";
registry
.dispatch(
"brain.create_profile",
json!({
"namespace": arm_ns,
"name": "compose-bench-arm-v1",
"consumer_kind": "knowledge_compose",
"seed_priors": {
"section_posteriors": {
"formalism": {"alpha": 8.0, "beta": 1.0},
"operational_guidance": {"alpha": 1.0, "beta": 8.0}
}
}
}),
)
.await
.expect("create arm profile");
registry
.dispatch(
"brain.activate",
json!({
"namespace": arm_ns,
"profile_id": "compose-bench-arm-v1",
}),
)
.await
.expect("activate arm profile");
registry
.dispatch(
"brain.bind",
json!({
"namespace": arm_ns,
"profile_id": "compose-bench-arm-v1",
"consumer_kind": "knowledge_compose",
}),
)
.await
.expect("bind arm profile");
let pack = KnowledgePack::new(rt.clone());
let token = rt
.authorize(Namespace::parse(arm_ns).expect("arm namespace"))
.expect("arm token");
let weights = pack.resolve_compose_type_weights(®istry, &token).await;
let formalism = weights["formalism"];
let operational = weights["operational_guidance"];
assert!(
formalism > operational,
"nonlocal Tier-2 profile must supply its inverted weights; got \
formalism={formalism:.4}, operational_guidance={operational:.4}"
);
}
#[tokio::test]
async fn resolve_compose_type_weights_reads_bound_profile_weights_via_actor_binding_at_tier2() {
use khive_pack_brain::BrainPack;
use khive_pack_kg::KgPack;
let rt = KhiveRuntime::new(khive_runtime::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".to_string()],
backend_id: khive_runtime::BackendId::main(),
brain_profile: None,
visible_namespaces: vec![],
allowed_outbound_namespaces: vec![],
actor_id: Some("leo".to_string()),
exec: Default::default(),
..khive_runtime::RuntimeConfig::no_embeddings()
})
.expect("in-memory runtime with actor");
let mut builder = VerbRegistryBuilder::new();
builder.register(KgPack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("kg+brain+knowledge registry builds");
let token = rt.authorize(Namespace::local()).expect("authorize local");
assert_eq!(
token.actor().id,
"leo",
"test setup: token must carry the configured actor"
);
registry
.dispatch(
"brain.create_profile",
json!({
"name": "compose-tuned-actor-v1",
"consumer_kind": "knowledge_compose",
"seed_priors": {
"section_posteriors": {
"formalism": {"alpha": 8.0, "beta": 1.0},
"operational_guidance": {"alpha": 1.0, "beta": 8.0}
}
}
}),
)
.await
.expect("create_profile with skewed seed_priors");
registry
.dispatch(
"brain.activate",
json!({"profile_id": "compose-tuned-actor-v1"}),
)
.await
.expect("activate compose-tuned-actor-v1");
registry
.dispatch(
"brain.bind",
json!({
"actor": "leo",
"profile_id": "compose-tuned-actor-v1",
"consumer_kind": "knowledge_compose"
}),
)
.await
.expect("bind compose-tuned-actor-v1 for actor=leo");
let pack = KnowledgePack::new(rt.clone());
let weights = pack.resolve_compose_type_weights(®istry, &token).await;
let formalism_w = *weights
.get("formalism")
.expect("formalism weight must be present");
let og_w = *weights
.get("operational_guidance")
.expect("operational_guidance weight must be present");
assert!(
formalism_w > og_w,
"Tier-2 actor-bound profile: formalism {formalism_w:.4} must exceed \
og {og_w:.4}; ordering reflects seed_priors (formalism β(8,1) >> \
og β(1,8)) resolved via the actor-scoped binding, not the default \
priors where og α=6,β=1.5 dominates"
);
}
#[tokio::test]
async fn resolve_compose_type_weights_anonymous_caller_does_not_match_explicit_actor_local_binding()
{
use khive_pack_brain::BrainPack;
use khive_pack_kg::KgPack;
let rt = KhiveRuntime::memory().expect("in-memory runtime");
let mut builder = VerbRegistryBuilder::new();
builder.register(KgPack::new(rt.clone()));
builder.register(BrainPack::new(rt.clone()));
builder.register(KnowledgePack::new(rt.clone()));
let registry = builder.build().expect("kg+brain+knowledge registry builds");
let token = rt.authorize(Namespace::local()).expect("authorize local");
assert!(
token.actor().is_anonymous(),
"test setup: token must carry the anonymous actor"
);
assert_eq!(
token.actor().id,
"local",
"test setup: anonymous actor id must be \"local\" to exercise the collision"
);
registry
.dispatch(
"brain.create_profile",
json!({
"name": "compose-tuned-anon-v1",
"consumer_kind": "knowledge_compose",
"seed_priors": {
"section_posteriors": {
"formalism": {"alpha": 8.0, "beta": 1.0},
"operational_guidance": {"alpha": 1.0, "beta": 8.0}
}
}
}),
)
.await
.expect("create_profile with skewed seed_priors");
registry
.dispatch(
"brain.activate",
json!({"profile_id": "compose-tuned-anon-v1"}),
)
.await
.expect("activate compose-tuned-anon-v1");
registry
.dispatch(
"brain.bind",
json!({
"actor": "local",
"profile_id": "compose-tuned-anon-v1",
"consumer_kind": "knowledge_compose"
}),
)
.await
.expect("bind compose-tuned-anon-v1 for actor=local");
let pack = KnowledgePack::new(rt.clone());
let weights = pack.resolve_compose_type_weights(®istry, &token).await;
let formalism_w = *weights
.get("formalism")
.expect("formalism weight must be present");
let og_w = *weights
.get("operational_guidance")
.expect("operational_guidance weight must be present");
assert!(
og_w > formalism_w,
"anonymous caller must NOT match the actor=\"local\" binding: og {og_w:.4} \
must exceed formalism {formalism_w:.4} (default-prior ordering, Tier 3), \
not the bound profile's inverted seed_priors (formalism β(8,1) >> og β(1,8))"
);
}