This repository has been archived on 2026-10-29. You can view files and clone it, but you cannot make any changes to its state, such as pushing and creating new issues, pull requests or comments.
Epiphany/epiphany-core/src/cultmesh_integration.rs
2026-06-09 02:45:09 +01:00

1815 lines
69 KiB
Rust

use crate::default_continuity_cultnet_contracts;
use crate::default_eyes_cultnet_contracts;
use crate::default_hands_cultnet_contracts;
use crate::default_mind_cultnet_contracts;
use crate::default_soul_cultnet_contracts;
use crate::default_substrate_gate_cultnet_contracts;
use anyhow::Result;
use anyhow::anyhow;
use cultcache_rs::DatabaseEntry;
use cultmesh_rs::CultMesh;
use cultmesh_rs::CultMeshNode;
use cultmesh_rs::CultMeshNodeOptions;
use cultmesh_rs::cultmesh_documents;
use serde::Serialize;
use serde_json::Value;
use std::path::Path;
pub const EPIPHANY_CULTMESH_STATUS_TYPE: &str = "epiphany.cultmesh.status";
pub const EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION: &str = "epiphany.cultmesh.status.v0";
pub const EPIPHANY_CULTMESH_STATUS_KEY: &str = "epiphany-local/status";
pub const EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE: &str = "epiphany.cultmesh.operator_status";
pub const EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION: &str =
"epiphany.cultmesh.operator_status.v0";
pub const EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY: &str = "epiphany-local/operator-status";
pub const EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE: &str = "epiphany.cultmesh.operator_snapshot";
pub const EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.operator_snapshot.v0";
pub const EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY: &str =
"epiphany-local/operator-snapshot/latest";
pub const EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE: &str =
"epiphany.cultmesh.operator_run_intent";
pub const EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.operator_run_intent.v0";
pub const EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY: &str =
"epiphany-local/operator-run-intent/latest";
pub const EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE: &str =
"epiphany.cultmesh.operator_run_receipt";
pub const EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.operator_run_receipt.v0";
pub const EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY: &str =
"epiphany-local/operator-run-receipt/latest";
pub const EPIPHANY_CULTMESH_VERSE_POLICY_TYPE: &str = "epiphany.cultmesh.verse_policy";
pub const EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION: &str = "epiphany.cultmesh.verse_policy.v0";
pub const EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_TYPE: &str = "epiphany.cultmesh.global_room_policy";
pub const EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.global_room_policy.v0";
pub const EPIPHANY_CULTMESH_MIND_CONTRACT_TYPE: &str = "epiphany.cultmesh.mind_contract";
pub const EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.mind_contract.v0";
pub const EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_TYPE: &str =
"epiphany.cultmesh.substrate_gate_contract";
pub const EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.substrate_gate_contract.v0";
pub const EPIPHANY_CULTMESH_EYES_CONTRACT_TYPE: &str = "epiphany.cultmesh.eyes_contract";
pub const EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.eyes_contract.v0";
pub const EPIPHANY_CULTMESH_HANDS_CONTRACT_TYPE: &str = "epiphany.cultmesh.hands_contract";
pub const EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.hands_contract.v0";
pub const EPIPHANY_CULTMESH_SOUL_CONTRACT_TYPE: &str = "epiphany.cultmesh.soul_contract";
pub const EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.soul_contract.v0";
pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_TYPE: &str =
"epiphany.cultmesh.continuity_contract";
pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.continuity_contract.v0";
pub const GJALLAR_AFFORDANCE_SCHEMA_VERSION: &str = "gjallar.affordance.v1";
pub const EPIPHANY_CULTMESH_INTERNAL_VERSE_ID: &str = "epiphany-internal";
pub const EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID: &str = "gamecult-local";
pub const EPIPHANY_CULTMESH_GLOBAL_VERSE_ID: &str = "epiphany-global";
pub const EPIPHANY_CULTMESH_INTERNAL_TIER: &str = "internal";
pub const EPIPHANY_CULTMESH_LOCAL_AREA_TIER: &str = "local-area";
pub const EPIPHANY_CULTMESH_GLOBAL_TIER: &str = "global";
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.status",
schema = "EpiphanyCultMeshStatusEntry"
)]
pub struct EpiphanyCultMeshStatusEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub runtime_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub app_id: String,
#[cultcache(key = 4)]
pub note: String,
#[cultcache(key = 5, default)]
pub verse_tier: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.operator_status",
schema = "EpiphanyCultMeshOperatorStatusEntry"
)]
pub struct EpiphanyCultMeshOperatorStatusEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub runtime_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub surface_id: String,
#[cultcache(key = 4)]
pub status: String,
#[cultcache(key = 5)]
pub generated_at_utc: String,
#[cultcache(key = 6)]
pub summary: String,
#[cultcache(key = 7)]
pub codex_bridge_role: String,
#[cultcache(key = 8)]
pub epiphany_authority_role: String,
#[cultcache(key = 9)]
pub prompt_authority: String,
#[cultcache(key = 10)]
pub native_authorities: Vec<String>,
#[cultcache(key = 11)]
pub quarantined_surfaces: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.operator_snapshot",
schema = "EpiphanyCultMeshOperatorSnapshotEntry"
)]
pub struct EpiphanyCultMeshOperatorSnapshotEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub runtime_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub snapshot_id: String,
#[cultcache(key = 4)]
pub generated_at_utc: String,
#[cultcache(key = 5)]
pub source_mode: String,
#[cultcache(key = 6)]
pub source_path: String,
#[cultcache(key = 7)]
pub thread_id: String,
#[cultcache(key = 8)]
pub status: String,
#[cultcache(key = 9)]
pub state_status: String,
#[cultcache(key = 10)]
pub coordinator_action: String,
#[cultcache(key = 11)]
pub crrc_action: String,
#[cultcache(key = 12)]
pub pressure_level: String,
#[cultcache(key = 13)]
pub reorient_action: String,
#[cultcache(key = 14)]
pub next_action: String,
#[cultcache(key = 15)]
pub artifact_refs: Vec<String>,
#[cultcache(key = 16)]
pub available_actions: Vec<String>,
#[cultcache(key = 17)]
pub notes: Vec<String>,
#[cultcache(key = 18, default)]
pub implementation_commit_requires_modeling_refresh: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.operator_run_intent",
schema = "EpiphanyCultMeshOperatorRunIntentEntry"
)]
pub struct EpiphanyCultMeshOperatorRunIntentEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub runtime_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub run_id: String,
#[cultcache(key = 4)]
pub requested_at_utc: String,
#[cultcache(key = 5)]
pub mode: String,
#[cultcache(key = 6)]
pub root: String,
#[cultcache(key = 7)]
pub workspace: String,
#[cultcache(key = 8)]
pub thread_id: String,
#[cultcache(key = 9)]
pub codex_home: String,
#[cultcache(key = 10)]
pub target_dir: String,
#[cultcache(key = 11)]
pub max_steps: u32,
#[cultcache(key = 12)]
pub timeout_seconds: u32,
#[cultcache(key = 13)]
pub auto_review: bool,
#[cultcache(key = 14)]
pub no_ephemeral: bool,
#[cultcache(key = 15)]
pub artifact_root: String,
#[cultcache(key = 16)]
pub dogfood_root: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.operator_run_receipt",
schema = "EpiphanyCultMeshOperatorRunReceiptEntry"
)]
pub struct EpiphanyCultMeshOperatorRunReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub runtime_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub run_id: String,
#[cultcache(key = 4)]
pub completed_at_utc: String,
#[cultcache(key = 5)]
pub mode: String,
#[cultcache(key = 6)]
pub status: String,
#[cultcache(key = 7)]
pub result_path: String,
#[cultcache(key = 8)]
pub artifact_root: String,
#[cultcache(key = 9)]
pub dogfood_root: String,
#[cultcache(key = 10)]
pub operator_snapshot_store: String,
#[cultcache(key = 11)]
pub operator_snapshot_id: String,
#[cultcache(key = 12)]
pub artifact_refs: Vec<String>,
#[cultcache(key = 13)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.verse_policy",
schema = "EpiphanyCultMeshVersePolicyEntry"
)]
pub struct EpiphanyCultMeshVersePolicyEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub verse_id: String,
#[cultcache(key = 2)]
pub tier: String,
#[cultcache(key = 3)]
pub purpose: String,
#[cultcache(key = 4)]
pub transport_scope: String,
#[cultcache(key = 5)]
pub trust_boundary: String,
#[cultcache(key = 6)]
pub private_state_allowed: bool,
#[cultcache(key = 7)]
pub untrusted_ingress_allowed: bool,
#[cultcache(key = 8)]
pub yggdrasil_tunnel_allowed: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.global_room_policy",
schema = "EpiphanyCultMeshGlobalRoomPolicyEntry"
)]
pub struct EpiphanyCultMeshGlobalRoomPolicyEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub room_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub topic: String,
#[cultcache(key = 4)]
pub purpose: String,
#[cultcache(key = 5)]
pub posting_policy: String,
#[cultcache(key = 6)]
pub threaded: bool,
#[cultcache(key = 7)]
pub persona_posting_allowed: bool,
#[cultcache(key = 8)]
pub untrusted_ingress_allowed: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.mind_contract",
schema = "EpiphanyCultMeshMindContractEntry"
)]
pub struct EpiphanyCultMeshMindContractEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub contract_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub document_type: String,
#[cultcache(key = 4)]
pub payload_schema_version: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub operations: Vec<String>,
#[cultcache(key = 7)]
pub intent_document_types: Vec<String>,
#[cultcache(key = 8)]
pub receipt_document_types: Vec<String>,
#[cultcache(key = 9)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.substrate_gate_contract",
schema = "EpiphanyCultMeshSubstrateGateContractEntry"
)]
pub struct EpiphanyCultMeshSubstrateGateContractEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub contract_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub document_type: String,
#[cultcache(key = 4)]
pub payload_schema_version: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub operations: Vec<String>,
#[cultcache(key = 7)]
pub intent_document_types: Vec<String>,
#[cultcache(key = 8)]
pub receipt_document_types: Vec<String>,
#[cultcache(key = 9)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.eyes_contract",
schema = "EpiphanyCultMeshEyesContractEntry"
)]
pub struct EpiphanyCultMeshEyesContractEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub contract_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub document_type: String,
#[cultcache(key = 4)]
pub payload_schema_version: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub operations: Vec<String>,
#[cultcache(key = 7)]
pub intent_document_types: Vec<String>,
#[cultcache(key = 8)]
pub receipt_document_types: Vec<String>,
#[cultcache(key = 9)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.hands_contract",
schema = "EpiphanyCultMeshHandsContractEntry"
)]
pub struct EpiphanyCultMeshHandsContractEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub contract_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub document_type: String,
#[cultcache(key = 4)]
pub payload_schema_version: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub operations: Vec<String>,
#[cultcache(key = 7)]
pub intent_document_types: Vec<String>,
#[cultcache(key = 8)]
pub receipt_document_types: Vec<String>,
#[cultcache(key = 9)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.soul_contract",
schema = "EpiphanyCultMeshSoulContractEntry"
)]
pub struct EpiphanyCultMeshSoulContractEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub contract_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub document_type: String,
#[cultcache(key = 4)]
pub payload_schema_version: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub operations: Vec<String>,
#[cultcache(key = 7)]
pub intent_document_types: Vec<String>,
#[cultcache(key = 8)]
pub receipt_document_types: Vec<String>,
#[cultcache(key = 9)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.continuity_contract",
schema = "EpiphanyCultMeshContinuityContractEntry"
)]
pub struct EpiphanyCultMeshContinuityContractEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub contract_id: String,
#[cultcache(key = 2)]
pub verse_id: String,
#[cultcache(key = 3)]
pub document_type: String,
#[cultcache(key = 4)]
pub payload_schema_version: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub operations: Vec<String>,
#[cultcache(key = 7)]
pub intent_document_types: Vec<String>,
#[cultcache(key = 8)]
pub receipt_document_types: Vec<String>,
#[cultcache(key = 9)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(type = "gjallar.affordance", schema = "gjallar.affordance.v1")]
pub struct GjallarAffordanceEntry {
#[cultcache(key = 0)]
pub affordance_id: String,
#[cultcache(key = 1)]
pub source_record: String,
#[cultcache(key = 2)]
pub verse_id: Option<String>,
#[cultcache(key = 3)]
pub surface_kind: String,
#[cultcache(key = 4)]
pub action: String,
#[cultcache(key = 5)]
pub authority: String,
#[cultcache(key = 6)]
pub status: String,
#[cultcache(key = 7)]
pub provenance: String,
#[cultcache(key = 8)]
pub observed_at: String,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyLocalVerseContext {
pub schema_version: String,
pub runtime_id: String,
pub store_path: String,
pub summary: String,
pub odin_scope: String,
pub yggdrasil_scope: String,
pub prompt_assembly_note: String,
pub verse_policies: Vec<EpiphanyCultMeshVersePolicyEntry>,
pub global_room_policies: Vec<EpiphanyCultMeshGlobalRoomPolicyEntry>,
pub operator_status: Option<EpiphanyCultMeshOperatorStatusEntry>,
pub latest_operator_snapshot: Option<EpiphanyCultMeshOperatorSnapshotEntry>,
pub latest_operator_run_intent: Option<EpiphanyCultMeshOperatorRunIntentEntry>,
pub latest_operator_run_receipt: Option<EpiphanyCultMeshOperatorRunReceiptEntry>,
pub contract_summaries: Vec<EpiphanyLocalVerseContractSummary>,
pub daemon_affordances: Vec<EpiphanyLocalDaemonAffordanceSummary>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyLocalVerseContractSummary {
pub contract_id: String,
pub verse_id: String,
pub authority: String,
pub document_type: String,
pub operations: Vec<String>,
pub receipt_document_types: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyLocalDaemonAffordanceSummary {
pub affordance_id: String,
pub source_record: String,
pub verse_id: Option<String>,
pub surface_kind: String,
pub action: String,
pub authority: String,
pub status: String,
pub provenance: String,
pub observed_at: String,
}
cultmesh_documents!(EpiphanyCultMeshDocuments {
EpiphanyCultMeshStatusEntry => EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION,
EpiphanyCultMeshOperatorStatusEntry => EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION,
EpiphanyCultMeshOperatorSnapshotEntry => EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION,
EpiphanyCultMeshOperatorRunIntentEntry => EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION,
EpiphanyCultMeshOperatorRunReceiptEntry => EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshVersePolicyEntry => EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION,
EpiphanyCultMeshGlobalRoomPolicyEntry => EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION,
EpiphanyCultMeshMindContractEntry => EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION,
EpiphanyCultMeshSubstrateGateContractEntry => EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION,
EpiphanyCultMeshEyesContractEntry => EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION,
EpiphanyCultMeshHandsContractEntry => EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION,
EpiphanyCultMeshSoulContractEntry => EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION,
EpiphanyCultMeshContinuityContractEntry => EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION,
GjallarAffordanceEntry => GJALLAR_AFFORDANCE_SCHEMA_VERSION,
});
pub fn open_epiphany_cultmesh_node(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<CultMeshNode> {
CultMesh::create_node(
store_path,
EpiphanyCultMeshDocuments,
CultMeshNodeOptions {
runtime_id: runtime_id.into(),
..CultMeshNodeOptions::default()
},
)
}
pub fn write_epiphany_cultmesh_status(
store_path: impl AsRef<Path>,
status: EpiphanyCultMeshStatusEntry,
) -> Result<EpiphanyCultMeshStatusEntry> {
let mut node = open_epiphany_cultmesh_node(&store_path, status.runtime_id.clone())?;
let written = node.put(EPIPHANY_CULTMESH_STATUS_KEY, &status)?;
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_status(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshStatusEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_STATUS_KEY)
}
pub fn default_epiphany_cultmesh_operator_status(
runtime_id: impl Into<String>,
generated_at_utc: impl Into<String>,
) -> EpiphanyCultMeshOperatorStatusEntry {
EpiphanyCultMeshOperatorStatusEntry {
schema_version: EPIPHANY_CULTMESH_OPERATOR_STATUS_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.into(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
surface_id: "epiphany.operator.status".to_string(),
status: "ready".to_string(),
generated_at_utc: generated_at_utc.into(),
summary:
"Epiphany operator status is native typed state; Codex is bridge transport, not policy owner."
.to_string(),
codex_bridge_role:
"relatively vanilla Codex may provide OpenAI auth/model transport, streaming, and Codex-native app-server affordances."
.to_string(),
epiphany_authority_role:
"Epiphany owns state, processes, prompts, scheduler decisions, organ contracts, and mutation law."
.to_string(),
prompt_authority:
"Codex prompt machinery must not inject doctrine, role instructions, state law, or coordinator policy into Epiphany agents."
.to_string(),
native_authorities: vec![
"CultCache typed documents".to_string(),
"CultMesh local Verse store".to_string(),
"CultNet read/mutation/event contracts".to_string(),
"Epiphany organ receipt gates".to_string(),
],
quarantined_surfaces: vec![
"Rider bridge".to_string(),
"Unity bridge".to_string(),
],
}
}
pub fn write_epiphany_cultmesh_operator_status(
store_path: impl AsRef<Path>,
status: EpiphanyCultMeshOperatorStatusEntry,
) -> Result<EpiphanyCultMeshOperatorStatusEntry> {
let mut node = open_epiphany_cultmesh_node(&store_path, status.runtime_id.clone())?;
let written = node.put(EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY, &status)?;
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_operator_status(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshOperatorStatusEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY)
}
pub fn epiphany_cultmesh_operator_snapshot_from_status_json(
runtime_id: impl Into<String>,
snapshot_id: impl Into<String>,
generated_at_utc: impl Into<String>,
source_mode: impl Into<String>,
source_path: impl Into<String>,
status_json: &Value,
) -> Result<EpiphanyCultMeshOperatorSnapshotEntry> {
let source_path = source_path.into();
let state_status = pointer_text(status_json, "/scene/scene/stateStatus", "unknown");
let crrc_action = pointer_text(status_json, "/crrc/recommendation/action", "unknown");
let reorient_action = pointer_text(status_json, "/reorient/decision/action", "unknown");
let implementation_commit_requires_modeling_refresh = pointer_bool(
status_json,
"/coordinator/sourceSignals/implementationCommitRequiresModelingRefresh",
);
let operator_status = if state_status == "missing" || crrc_action == "regatherManually" {
"needs-regather"
} else if implementation_commit_requires_modeling_refresh {
"needs-modeling-refresh"
} else {
"ready"
};
let mut artifact_refs = Vec::new();
if !source_path.trim().is_empty() {
artifact_refs.push(source_path.clone());
}
Ok(EpiphanyCultMeshOperatorSnapshotEntry {
schema_version: EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.into(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
snapshot_id: snapshot_id.into(),
generated_at_utc: generated_at_utc.into(),
source_mode: source_mode.into(),
source_path,
thread_id: pointer_text(status_json, "/threadId", "missing"),
status: operator_status.to_string(),
state_status,
coordinator_action: pointer_text(status_json, "/coordinator/action", "none"),
crrc_action,
pressure_level: pointer_text(status_json, "/pressure/pressure/level", "unknown"),
reorient_action,
next_action: pointer_text(status_json, "/reorient/decision/nextAction", "none"),
artifact_refs,
available_actions: pointer_string_array(status_json, "/scene/scene/availableActions")?,
notes: operator_snapshot_notes(implementation_commit_requires_modeling_refresh),
implementation_commit_requires_modeling_refresh,
})
}
fn operator_snapshot_notes(implementation_commit_requires_modeling_refresh: bool) -> Vec<String> {
let mut notes = vec![
"Snapshot is derived from the operator-safe MVP status artifact; raw JSON remains an edge artifact, not internal state.".to_string(),
"Codex app-server remains compatibility transport for this source until the status surface is native end to end.".to_string(),
];
if implementation_commit_requires_modeling_refresh {
notes.push(
"Hands commit evidence is newer than the accepted Proprioception map; refresh modeling before another Implementation turn.".to_string(),
);
}
notes
}
pub fn write_epiphany_cultmesh_operator_snapshot(
store_path: impl AsRef<Path>,
snapshot: EpiphanyCultMeshOperatorSnapshotEntry,
) -> Result<EpiphanyCultMeshOperatorSnapshotEntry> {
let mut node = open_epiphany_cultmesh_node(&store_path, snapshot.runtime_id.clone())?;
let snapshot_key = epiphany_cultmesh_operator_snapshot_key(&snapshot.snapshot_id);
let written = node.put(snapshot_key.as_str(), &snapshot)?;
node.put(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY, &written)?;
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_operator_snapshot(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
snapshot_id: impl AsRef<str>,
) -> Result<Option<EpiphanyCultMeshOperatorSnapshotEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let snapshot_key = epiphany_cultmesh_operator_snapshot_key(snapshot_id.as_ref());
node.get(snapshot_key.as_str())
}
pub fn load_latest_epiphany_cultmesh_operator_snapshot(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshOperatorSnapshotEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY)
}
pub fn write_epiphany_cultmesh_operator_run_intent(
store_path: impl AsRef<Path>,
intent: EpiphanyCultMeshOperatorRunIntentEntry,
) -> Result<EpiphanyCultMeshOperatorRunIntentEntry> {
let mut node = open_epiphany_cultmesh_node(&store_path, intent.runtime_id.clone())?;
let intent_key = epiphany_cultmesh_operator_run_intent_key(&intent.run_id);
let written = node.put(intent_key.as_str(), &intent)?;
node.put(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY, &written)?;
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_operator_run_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshOperatorRunIntentEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY)
}
pub fn write_epiphany_cultmesh_operator_run_receipt(
store_path: impl AsRef<Path>,
receipt: EpiphanyCultMeshOperatorRunReceiptEntry,
) -> Result<EpiphanyCultMeshOperatorRunReceiptEntry> {
let mut node = open_epiphany_cultmesh_node(&store_path, receipt.runtime_id.clone())?;
let receipt_key = epiphany_cultmesh_operator_run_receipt_key(&receipt.run_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY, &written)?;
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_operator_run_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshOperatorRunReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY)
}
pub fn seed_epiphany_local_verse_context(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
generated_at_utc: impl Into<String>,
) -> Result<()> {
let store_path = store_path.as_ref();
let runtime_id = runtime_id.into();
let status = EpiphanyCultMeshStatusEntry {
schema_version: EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.clone(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
verse_tier: EPIPHANY_CULTMESH_INTERNAL_TIER.to_string(),
app_id: "epiphany".to_string(),
note: "Epiphany local Verse query context is typed CultMesh state; prompt assembly may read it, but Mind still owns durable adoption.".to_string(),
};
write_epiphany_cultmesh_status(store_path, status)?;
write_epiphany_cultmesh_verse_policies(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_global_room_policies(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_mind_contracts(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_substrate_gate_contracts(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_eyes_contracts(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_hands_contracts(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_soul_contracts(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_continuity_contracts(store_path, runtime_id.clone())?;
write_epiphany_cultmesh_operator_status(
store_path,
default_epiphany_cultmesh_operator_status(runtime_id, generated_at_utc),
)?;
Ok(())
}
pub fn query_epiphany_local_verse_context(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<EpiphanyLocalVerseContext> {
let store_path = store_path.as_ref();
let runtime_id = runtime_id.into();
let node = open_epiphany_cultmesh_node(store_path, runtime_id.clone())?;
let mut verse_policies = Vec::new();
for policy in epiphany_cultmesh_verse_policies() {
if let Some(loaded) = node.get::<EpiphanyCultMeshVersePolicyEntry>(&policy.verse_id)? {
verse_policies.push(loaded);
}
}
let mut global_room_policies = Vec::new();
for room in epiphany_cultmesh_global_room_policies() {
if let Some(loaded) = node.get::<EpiphanyCultMeshGlobalRoomPolicyEntry>(&room.room_id)? {
global_room_policies.push(loaded);
}
}
let mut contract_summaries = Vec::new();
collect_contract_summaries(
&node,
epiphany_cultmesh_mind_contracts(),
&mut contract_summaries,
)?;
collect_contract_summaries(
&node,
epiphany_cultmesh_substrate_gate_contracts(),
&mut contract_summaries,
)?;
collect_contract_summaries(
&node,
epiphany_cultmesh_eyes_contracts(),
&mut contract_summaries,
)?;
collect_contract_summaries(
&node,
epiphany_cultmesh_hands_contracts(),
&mut contract_summaries,
)?;
collect_contract_summaries(
&node,
epiphany_cultmesh_soul_contracts(),
&mut contract_summaries,
)?;
collect_contract_summaries(
&node,
epiphany_cultmesh_continuity_contracts(),
&mut contract_summaries,
)?;
Ok(EpiphanyLocalVerseContext {
schema_version: "epiphany.local_verse_context.v0".to_string(),
runtime_id: runtime_id.clone(),
store_path: store_path.display().to_string(),
summary: "Local Verse query context for compact Epiphany prompt assembly and operator inspection.".to_string(),
odin_scope: "Odin is the all-seer coordinator of Verse discovery: it may know every Verse's advertised public/operator-safe surface, but it must not bypass Verse trust boundaries or Mind adoption gates.".to_string(),
yggdrasil_scope: "Yggdrasil is the hosting spine for important trusted GameCult Verses such as Bifrost; local-area writes require explicit trusted tunnel/lease policy and never carry private internal state.".to_string(),
prompt_assembly_note: "Prompt assembly should query this compact typed bundle plus semantic memory context cuts; Verse context is injected dynamically as bounded context, not as durable truth.".to_string(),
verse_policies,
global_room_policies,
operator_status: node.get(EPIPHANY_CULTMESH_OPERATOR_STATUS_KEY)?,
latest_operator_snapshot: node.get(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY)?,
latest_operator_run_intent: node.get(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY)?,
latest_operator_run_receipt: node.get(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY)?,
contract_summaries,
daemon_affordances: query_gjallar_daemon_affordances_from_node(&node)?,
})
}
pub fn query_gjallar_daemon_affordances(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyLocalDaemonAffordanceSummary>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
query_gjallar_daemon_affordances_from_node(&node)
}
pub fn import_gjallar_daemon_affordances(
local_store_path: impl AsRef<Path>,
gjallar_store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyLocalDaemonAffordanceSummary>> {
let runtime_id = runtime_id.into();
let gjallar_node =
open_epiphany_cultmesh_node(gjallar_store_path, format!("{runtime_id}-gjallar-import"))?;
let affordances = gjallar_node.cache().get_all::<GjallarAffordanceEntry>()?;
let mut local_node = open_epiphany_cultmesh_node(local_store_path, runtime_id)?;
for affordance in &affordances {
local_node.put(affordance.affordance_id.clone(), affordance)?;
}
local_node.flush()?;
Ok(affordances
.into_iter()
.map(EpiphanyLocalDaemonAffordanceSummary::from)
.collect())
}
fn query_gjallar_daemon_affordances_from_node(
node: &CultMeshNode,
) -> Result<Vec<EpiphanyLocalDaemonAffordanceSummary>> {
let mut summaries: Vec<_> = node
.cache()
.get_all::<GjallarAffordanceEntry>()?
.into_iter()
.map(EpiphanyLocalDaemonAffordanceSummary::from)
.collect();
summaries.sort_by(|left, right| left.affordance_id.cmp(&right.affordance_id));
Ok(summaries)
}
impl From<GjallarAffordanceEntry> for EpiphanyLocalDaemonAffordanceSummary {
fn from(value: GjallarAffordanceEntry) -> Self {
Self {
affordance_id: value.affordance_id,
source_record: value.source_record,
verse_id: value.verse_id,
surface_kind: value.surface_kind,
action: value.action,
authority: value.authority,
status: value.status,
provenance: value.provenance,
observed_at: value.observed_at,
}
}
}
pub trait EpiphanyCultMeshContractSummarySource: DatabaseEntry {
fn contract_id(&self) -> &str;
fn verse_id(&self) -> &str;
fn authority(&self) -> &str;
fn document_type(&self) -> &str;
fn operations(&self) -> &[String];
fn receipt_document_types(&self) -> &[String];
}
macro_rules! impl_contract_summary_source {
($ty:ty) => {
impl EpiphanyCultMeshContractSummarySource for $ty {
fn contract_id(&self) -> &str {
&self.contract_id
}
fn verse_id(&self) -> &str {
&self.verse_id
}
fn authority(&self) -> &str {
&self.authority
}
fn document_type(&self) -> &str {
&self.document_type
}
fn operations(&self) -> &[String] {
&self.operations
}
fn receipt_document_types(&self) -> &[String] {
&self.receipt_document_types
}
}
};
}
impl_contract_summary_source!(EpiphanyCultMeshMindContractEntry);
impl_contract_summary_source!(EpiphanyCultMeshSubstrateGateContractEntry);
impl_contract_summary_source!(EpiphanyCultMeshEyesContractEntry);
impl_contract_summary_source!(EpiphanyCultMeshHandsContractEntry);
impl_contract_summary_source!(EpiphanyCultMeshSoulContractEntry);
impl_contract_summary_source!(EpiphanyCultMeshContinuityContractEntry);
fn collect_contract_summaries<T>(
node: &CultMeshNode,
contracts: Vec<T>,
out: &mut Vec<EpiphanyLocalVerseContractSummary>,
) -> Result<()>
where
T: EpiphanyCultMeshContractSummarySource,
{
for contract in contracts {
if let Some(loaded) = node.get::<T>(contract.contract_id())? {
out.push(EpiphanyLocalVerseContractSummary {
contract_id: loaded.contract_id().to_string(),
verse_id: loaded.verse_id().to_string(),
authority: loaded.authority().to_string(),
document_type: loaded.document_type().to_string(),
operations: loaded.operations().to_vec(),
receipt_document_types: loaded.receipt_document_types().to_vec(),
});
}
}
Ok(())
}
fn epiphany_cultmesh_operator_snapshot_key(snapshot_id: &str) -> String {
format!("epiphany-local/operator-snapshot/{snapshot_id}")
}
fn epiphany_cultmesh_operator_run_intent_key(run_id: &str) -> String {
format!("epiphany-local/operator-run-intent/{run_id}")
}
fn epiphany_cultmesh_operator_run_receipt_key(run_id: &str) -> String {
format!("epiphany-local/operator-run-receipt/{run_id}")
}
fn pointer_text(value: &Value, pointer: &str, fallback: &str) -> String {
value
.pointer(pointer)
.and_then(Value::as_str)
.filter(|text| !text.trim().is_empty())
.unwrap_or(fallback)
.to_string()
}
fn pointer_bool(value: &Value, pointer: &str) -> bool {
value
.pointer(pointer)
.and_then(Value::as_bool)
.unwrap_or(false)
}
fn pointer_string_array(value: &Value, pointer: &str) -> Result<Vec<String>> {
let Some(items) = value.pointer(pointer) else {
return Ok(Vec::new());
};
let items = items
.as_array()
.ok_or_else(|| anyhow!("{pointer} must be an array when present"))?;
items
.iter()
.map(|item| {
item.as_str()
.map(ToString::to_string)
.ok_or_else(|| anyhow!("{pointer} must contain only strings"))
})
.collect()
}
pub fn epiphany_cultmesh_verse_policies() -> Vec<EpiphanyCultMeshVersePolicyEntry> {
vec![
EpiphanyCultMeshVersePolicyEntry {
schema_version: EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION.to_string(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
tier: EPIPHANY_CULTMESH_INTERNAL_TIER.to_string(),
purpose: "Sub-agent typed state: heartbeat, organ-state records, runtime-spine jobs, private receipts, and other Epiphany-owned organs.".to_string(),
transport_scope: "single-host or trusted localhost mesh".to_string(),
trust_boundary: "private Epiphany instance boundary".to_string(),
private_state_allowed: true,
untrusted_ingress_allowed: false,
yggdrasil_tunnel_allowed: false,
},
EpiphanyCultMeshVersePolicyEntry {
schema_version: EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION.to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
tier: EPIPHANY_CULTMESH_LOCAL_AREA_TIER.to_string(),
purpose: "Trusted GameCult local-area sharing across projects, including operator-approved tunnels to services on Yggdrasil.".to_string(),
transport_scope: "LAN plus explicit GameCult tunnel endpoints".to_string(),
trust_boundary: "trusted GameCult project/runtime boundary".to_string(),
private_state_allowed: false,
untrusted_ingress_allowed: false,
yggdrasil_tunnel_allowed: true,
},
EpiphanyCultMeshVersePolicyEntry {
schema_version: EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION.to_string(),
verse_id: EPIPHANY_CULTMESH_GLOBAL_VERSE_ID.to_string(),
tier: EPIPHANY_CULTMESH_GLOBAL_TIER.to_string(),
purpose: "Untrusted public surfaces: public dreams, questions, hypotheses, invitations, lineage, ingress receipts, and adoption receipts.".to_string(),
transport_scope: "public internet".to_string(),
trust_boundary: "untrusted public boundary".to_string(),
private_state_allowed: false,
untrusted_ingress_allowed: true,
yggdrasil_tunnel_allowed: false,
},
]
}
pub fn write_epiphany_cultmesh_verse_policies(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshVersePolicyEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for policy in epiphany_cultmesh_verse_policies() {
written.push(node.put(policy.verse_id.clone(), &policy)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_global_room_policies() -> Vec<EpiphanyCultMeshGlobalRoomPolicyEntry> {
[
(
"dreams",
"Dreams",
"Public dreams, symbolic fragments, imaginative pressure, and unfinished possible worlds.",
),
(
"architecture",
"Architecture",
"System design, ownership maps, protocol boundaries, and rejected machine shapes.",
),
(
"research",
"Research",
"Prior art, papers, source-grounded findings, and scout reports.",
),
(
"faces",
"Personas",
"Public Persona identity, voice, social surface, and community-facing presence.",
),
(
"gamecult",
"GameCult",
"GameCult project coordination, public receipts, and cross-project questions.",
),
(
"governance",
"Governance",
"Public proposals and governance-adjacent discussion before any Bifrost adoption.",
),
]
.into_iter()
.map(|(slug, topic, purpose)| EpiphanyCultMeshGlobalRoomPolicyEntry {
schema_version: EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION.to_string(),
room_id: format!("epiphany-global/{slug}"),
verse_id: EPIPHANY_CULTMESH_GLOBAL_VERSE_ID.to_string(),
topic: topic.to_string(),
purpose: purpose.to_string(),
posting_policy:
"Personas may post public, non-private, citation/provenance-bearing thread roots and replies; local adoption still requires review."
.to_string(),
threaded: true,
persona_posting_allowed: true,
untrusted_ingress_allowed: true,
})
.collect()
}
pub fn write_epiphany_cultmesh_global_room_policies(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshGlobalRoomPolicyEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for room in epiphany_cultmesh_global_room_policies() {
written.push(node.put(room.room_id.clone(), &room)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_mind_contracts() -> Vec<EpiphanyCultMeshMindContractEntry> {
default_mind_cultnet_contracts()
.into_iter()
.map(|contract| EpiphanyCultMeshMindContractEntry {
schema_version: EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: contract.contract_id,
verse_id: contract.verse_id,
document_type: contract.document_type,
payload_schema_version: contract.payload_schema_version,
authority: contract.authority,
operations: contract.operations,
intent_document_types: contract.intent_document_types,
receipt_document_types: contract.receipt_document_types,
notes: contract.notes,
})
.collect()
}
pub fn write_epiphany_cultmesh_mind_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshMindContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_mind_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_substrate_gate_contracts()
-> Vec<EpiphanyCultMeshSubstrateGateContractEntry> {
default_substrate_gate_cultnet_contracts()
.into_iter()
.map(|contract| EpiphanyCultMeshSubstrateGateContractEntry {
schema_version: EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: contract.contract_id,
verse_id: contract.verse_id,
document_type: contract.document_type,
payload_schema_version: contract.payload_schema_version,
authority: contract.authority,
operations: contract.operations,
intent_document_types: contract.intent_document_types,
receipt_document_types: contract.receipt_document_types,
notes: contract.notes,
})
.collect()
}
pub fn write_epiphany_cultmesh_substrate_gate_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshSubstrateGateContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_substrate_gate_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_eyes_contracts() -> Vec<EpiphanyCultMeshEyesContractEntry> {
default_eyes_cultnet_contracts()
.into_iter()
.map(|contract| EpiphanyCultMeshEyesContractEntry {
schema_version: EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: contract.contract_id,
verse_id: contract.verse_id,
document_type: contract.document_type,
payload_schema_version: contract.payload_schema_version,
authority: contract.authority,
operations: contract.operations,
intent_document_types: contract.intent_document_types,
receipt_document_types: contract.receipt_document_types,
notes: contract.notes,
})
.collect()
}
pub fn write_epiphany_cultmesh_eyes_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshEyesContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_eyes_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_hands_contracts() -> Vec<EpiphanyCultMeshHandsContractEntry> {
default_hands_cultnet_contracts()
.into_iter()
.map(|contract| EpiphanyCultMeshHandsContractEntry {
schema_version: EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: contract.contract_id,
verse_id: contract.verse_id,
document_type: contract.document_type,
payload_schema_version: contract.payload_schema_version,
authority: contract.authority,
operations: contract.operations,
intent_document_types: contract.intent_document_types,
receipt_document_types: contract.receipt_document_types,
notes: contract.notes,
})
.collect()
}
pub fn write_epiphany_cultmesh_hands_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshHandsContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_hands_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_soul_contracts() -> Vec<EpiphanyCultMeshSoulContractEntry> {
default_soul_cultnet_contracts()
.into_iter()
.map(|contract| EpiphanyCultMeshSoulContractEntry {
schema_version: EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: contract.contract_id,
verse_id: contract.verse_id,
document_type: contract.document_type,
payload_schema_version: contract.payload_schema_version,
authority: contract.authority,
operations: contract.operations,
intent_document_types: contract.intent_document_types,
receipt_document_types: contract.receipt_document_types,
notes: contract.notes,
})
.collect()
}
pub fn write_epiphany_cultmesh_soul_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshSoulContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_soul_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
pub fn epiphany_cultmesh_continuity_contracts() -> Vec<EpiphanyCultMeshContinuityContractEntry> {
default_continuity_cultnet_contracts()
.into_iter()
.map(|contract| EpiphanyCultMeshContinuityContractEntry {
schema_version: EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: contract.contract_id,
verse_id: contract.verse_id,
document_type: contract.document_type,
payload_schema_version: contract.payload_schema_version,
authority: contract.authority,
operations: contract.operations,
intent_document_types: contract.intent_document_types,
receipt_document_types: contract.receipt_document_types,
notes: contract.notes,
})
.collect()
}
pub fn write_epiphany_cultmesh_continuity_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshContinuityContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_continuity_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[test]
fn epiphany_status_round_trips_through_cultmesh() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-local.cc");
let status = EpiphanyCultMeshStatusEntry {
schema_version: EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION.to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
verse_tier: EPIPHANY_CULTMESH_INTERNAL_TIER.to_string(),
app_id: "epiphany".to_string(),
note: "CultMesh is the local abstraction over CultCache and CultNet.".to_string(),
};
write_epiphany_cultmesh_status(&store, status.clone())?;
assert_eq!(
load_epiphany_cultmesh_status(&store, "epiphany-test")?,
Some(status)
);
Ok(())
}
#[test]
fn operator_status_round_trips_as_native_cultmesh_document() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-operator-status.cc");
let status =
default_epiphany_cultmesh_operator_status("epiphany-test", "2026-05-27T00:00:00Z");
write_epiphany_cultmesh_operator_status(&store, status.clone())?;
let loaded = load_epiphany_cultmesh_operator_status(&store, "epiphany-test")?;
assert_eq!(loaded, Some(status));
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_OPERATOR_STATUS_TYPE)
.is_some()
);
Ok(())
}
#[test]
fn operator_snapshot_distills_status_json_into_typed_cultmesh_document() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-operator-snapshot.cc");
let status_json = serde_json::json!({
"threadId": "thread-test",
"scene": {
"scene": {
"stateStatus": "missing",
"availableActions": ["crrc", "roles"]
}
},
"pressure": {
"pressure": {
"level": "low"
}
},
"reorient": {
"decision": {
"action": "regather",
"nextAction": "Regather source context."
}
},
"crrc": {
"recommendation": {
"action": "regatherManually"
}
},
"coordinator": {
"action": "wait",
"sourceSignals": {
"implementationCommitRequiresModelingRefresh": true
}
},
"rawResult": {
"sealed": true
}
});
let snapshot = epiphany_cultmesh_operator_snapshot_from_status_json(
"epiphany-test",
"snapshot-test",
"2026-05-27T00:00:00Z",
"status",
".epiphany-run/status.json",
&status_json,
)?;
assert_eq!(snapshot.status, "needs-regather");
assert_eq!(snapshot.thread_id, "thread-test");
assert_eq!(snapshot.available_actions, vec!["crrc", "roles"]);
assert_eq!(snapshot.artifact_refs, vec![".epiphany-run/status.json"]);
assert!(snapshot.implementation_commit_requires_modeling_refresh);
assert!(
snapshot
.notes
.iter()
.any(|note| note.contains("refresh modeling"))
);
let mut ready_debt_status_json = status_json.clone();
ready_debt_status_json["scene"]["scene"]["stateStatus"] = serde_json::json!("ready");
ready_debt_status_json["crrc"]["recommendation"]["action"] = serde_json::json!("continue");
let ready_debt_snapshot = epiphany_cultmesh_operator_snapshot_from_status_json(
"epiphany-test",
"snapshot-test-ready-debt",
"2026-05-27T00:00:00Z",
"status",
".epiphany-run/status.json",
&ready_debt_status_json,
)?;
assert_eq!(ready_debt_snapshot.status, "needs-modeling-refresh");
write_epiphany_cultmesh_operator_snapshot(&store, snapshot.clone())?;
assert_eq!(
load_epiphany_cultmesh_operator_snapshot(&store, "epiphany-test", "snapshot-test")?,
Some(snapshot.clone())
);
assert_eq!(
load_latest_epiphany_cultmesh_operator_snapshot(&store, "epiphany-test")?,
Some(snapshot)
);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE)
.is_some()
);
Ok(())
}
#[test]
fn operator_run_intent_and_receipt_round_trip_as_native_cultmesh_documents() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-operator-run.cc");
let intent = EpiphanyCultMeshOperatorRunIntentEntry {
schema_version: EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION.to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
run_id: "run-test".to_string(),
requested_at_utc: "2026-05-27T00:00:00Z".to_string(),
mode: "status".to_string(),
root: "E:\\Projects\\EpiphanyAgent".to_string(),
workspace: "E:\\Projects\\EpiphanyAgent".to_string(),
thread_id: String::new(),
codex_home: "C:\\Users\\Meta\\.codex".to_string(),
target_dir: "C:\\Users\\Meta\\.cargo-target-codex".to_string(),
max_steps: 4,
timeout_seconds: 240,
auto_review: false,
no_ephemeral: false,
artifact_root: ".epiphany-run/run-test".to_string(),
dogfood_root: ".epiphany-dogfood/run-test".to_string(),
};
let receipt = EpiphanyCultMeshOperatorRunReceiptEntry {
schema_version: EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION.to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
run_id: "run-test".to_string(),
completed_at_utc: "2026-05-27T00:00:01Z".to_string(),
mode: "status".to_string(),
status: "completed".to_string(),
result_path: ".epiphany-run/run-test/status.json".to_string(),
artifact_root: ".epiphany-run/run-test".to_string(),
dogfood_root: ".epiphany-dogfood/run-test".to_string(),
operator_snapshot_store: ".epiphany-run/cultmesh/operator-snapshots.cc".to_string(),
operator_snapshot_id: "run-test-status".to_string(),
artifact_refs: vec![".epiphany-run/run-test/status.json".to_string()],
notes: vec!["receipt".to_string()],
};
write_epiphany_cultmesh_operator_run_intent(&store, intent.clone())?;
write_epiphany_cultmesh_operator_run_receipt(&store, receipt.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_operator_run_intent(&store, "epiphany-test")?,
Some(intent)
);
assert_eq!(
load_latest_epiphany_cultmesh_operator_run_receipt(&store, "epiphany-test")?,
Some(receipt)
);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE)
.is_some()
);
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_TYPE)
.is_some()
);
Ok(())
}
#[test]
fn builtin_verse_policies_keep_public_and_private_boundaries_apart() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-verses.cc");
let written = write_epiphany_cultmesh_verse_policies(&store, "epiphany-test")?;
assert_eq!(written.len(), 3);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let internal = node.get_required::<EpiphanyCultMeshVersePolicyEntry>(
EPIPHANY_CULTMESH_INTERNAL_VERSE_ID,
)?;
let local_area = node.get_required::<EpiphanyCultMeshVersePolicyEntry>(
EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID,
)?;
let global = node
.get_required::<EpiphanyCultMeshVersePolicyEntry>(EPIPHANY_CULTMESH_GLOBAL_VERSE_ID)?;
assert!(internal.private_state_allowed);
assert!(!internal.untrusted_ingress_allowed);
assert!(!local_area.private_state_allowed);
assert!(local_area.yggdrasil_tunnel_allowed);
assert!(!global.private_state_allowed);
assert!(global.untrusted_ingress_allowed);
Ok(())
}
#[test]
fn global_room_policies_make_public_threaded_rooms_for_personas() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-global-rooms.cc");
let written = write_epiphany_cultmesh_global_room_policies(&store, "epiphany-test")?;
assert!(written.len() >= 5);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let dreams =
node.get_required::<EpiphanyCultMeshGlobalRoomPolicyEntry>("epiphany-global/dreams")?;
let architecture = node.get_required::<EpiphanyCultMeshGlobalRoomPolicyEntry>(
"epiphany-global/architecture",
)?;
assert_eq!(dreams.verse_id, EPIPHANY_CULTMESH_GLOBAL_VERSE_ID);
assert!(dreams.threaded);
assert!(dreams.persona_posting_allowed);
assert!(dreams.untrusted_ingress_allowed);
assert!(architecture.purpose.contains("ownership"));
Ok(())
}
#[test]
fn local_verse_context_queries_compact_policy_status_and_contracts() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-local-verse.cc");
seed_epiphany_local_verse_context(&store, "epiphany-test", "2026-06-02T00:00:00Z")?;
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(context.verse_policies.len(), 3);
assert!(context.verse_policies.iter().any(|policy| policy.verse_id
== EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID
&& policy.yggdrasil_tunnel_allowed));
assert_eq!(context.global_room_policies.len(), 6);
assert!(context.operator_status.is_some());
assert!(
context
.contract_summaries
.iter()
.any(|contract| contract.authority == "mind")
);
assert!(
context
.contract_summaries
.iter()
.any(|contract| contract.authority == "substrateGate")
);
assert!(context.odin_scope.contains("all-seer"));
assert!(context.yggdrasil_scope.contains("Bifrost"));
assert!(context.prompt_assembly_note.contains("bounded context"));
Ok(())
}
#[test]
fn local_verse_context_imports_gjallar_daemon_affordances() -> Result<()> {
let temp = tempfile::tempdir()?;
let local_store = temp.path().join("epiphany-local-verse.cc");
let gjallar_store = temp.path().join("gjallar-affordances.cc");
seed_epiphany_local_verse_context(&local_store, "epiphany-test", "2026-06-02T00:00:00Z")?;
let mut gjallar_node = open_epiphany_cultmesh_node(&gjallar_store, "gjallar-test")?;
let affordance = GjallarAffordanceEntry {
affordance_id: "gjallar:odin.service:bifrost:0".to_string(),
source_record: "odin.service:bifrost".to_string(),
verse_id: Some(EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string()),
surface_kind: "service".to_string(),
action: "inspect-eve-tui".to_string(),
authority: "odin".to_string(),
status: "available".to_string(),
provenance: "cultmesh://odin/gjallar".to_string(),
observed_at: "2026-06-04T00:00:00Z".to_string(),
};
gjallar_node.put(affordance.affordance_id.clone(), &affordance)?;
gjallar_node.flush()?;
let imported =
import_gjallar_daemon_affordances(&local_store, &gjallar_store, "epiphany-test")?;
let context = query_epiphany_local_verse_context(&local_store, "epiphany-test")?;
assert_eq!(imported.len(), 1);
assert_eq!(context.daemon_affordances.len(), 1);
assert_eq!(
context.daemon_affordances[0].source_record,
"odin.service:bifrost"
);
assert_eq!(context.daemon_affordances[0].authority, "odin");
assert_eq!(context.daemon_affordances[0].action, "inspect-eve-tui");
Ok(())
}
#[test]
fn mind_contracts_use_verses_to_keep_state_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-mind-contracts.cc");
let written = write_epiphany_cultmesh_mind_contracts(&store, "epiphany-test")?;
assert!(written.len() >= 4);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let state_review = node.get_required::<EpiphanyCultMeshMindContractEntry>(
"epiphany.mind.state_effect.review",
)?;
let public_adoption = node.get_required::<EpiphanyCultMeshMindContractEntry>(
"epiphany.mind.public_adoption.review",
)?;
assert_eq!(state_review.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID);
assert_eq!(state_review.authority, "mind");
assert!(
state_review
.notes
.iter()
.any(|note| note.contains("persistent state guardian"))
);
assert_eq!(public_adoption.verse_id, EPIPHANY_CULTMESH_GLOBAL_VERSE_ID);
assert!(
public_adoption
.notes
.iter()
.any(|note| note.contains("thought weather"))
);
Ok(())
}
#[test]
fn substrate_gate_contracts_use_verses_to_keep_repo_access_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-substrate-gate-contracts.cc");
let written = write_epiphany_cultmesh_substrate_gate_contracts(&store, "epiphany-test")?;
assert!(written.len() >= 4);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let repo_access = node.get_required::<EpiphanyCultMeshSubstrateGateContractEntry>(
"epiphany.substrate_gate.repo_access.review",
)?;
assert_eq!(repo_access.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID);
assert_eq!(repo_access.authority, "substrateGate");
assert!(
repo_access
.notes
.iter()
.any(|note| note.contains("repo access protocol"))
);
Ok(())
}
#[test]
fn eyes_contracts_use_verses_to_keep_evidence_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-eyes-contracts.cc");
let written = write_epiphany_cultmesh_eyes_contracts(&store, "epiphany-test")?;
assert!(written.len() >= 4);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let evidence = node
.get_required::<EpiphanyCultMeshEyesContractEntry>("epiphany.eyes.evidence.review")?;
assert_eq!(evidence.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID);
assert_eq!(evidence.authority, "eyes");
assert!(
evidence
.notes
.iter()
.any(|note| note.contains("evidence ingress guardian"))
);
Ok(())
}
#[test]
fn hands_contracts_use_verses_to_keep_action_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-hands-contracts.cc");
let written = write_epiphany_cultmesh_hands_contracts(&store, "epiphany-test")?;
assert!(written.len() >= 5);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let action = node
.get_required::<EpiphanyCultMeshHandsContractEntry>("epiphany.hands.action.review")?;
assert_eq!(action.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID);
assert_eq!(action.authority, "hands");
assert!(
action
.notes
.iter()
.any(|note| note.contains("action organ"))
);
Ok(())
}
#[test]
fn soul_contracts_use_verses_to_keep_verification_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-soul-contracts.cc");
let written = write_epiphany_cultmesh_soul_contracts(&store, "epiphany-test")?;
assert!(written.len() >= 5);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let verification = node.get_required::<EpiphanyCultMeshSoulContractEntry>(
"epiphany.soul.verification.review",
)?;
assert_eq!(verification.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID);
assert_eq!(verification.authority, "soul");
assert!(
verification
.notes
.iter()
.any(|note| note.contains("verification organ"))
);
Ok(())
}
#[test]
fn continuity_contracts_use_verses_to_keep_continuity_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-continuity-contracts.cc");
let written = write_epiphany_cultmesh_continuity_contracts(&store, "epiphany-test")?;
assert!(written.len() >= 5);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let continuity = node.get_required::<EpiphanyCultMeshContinuityContractEntry>(
"epiphany.continuity.review",
)?;
assert_eq!(continuity.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID);
assert_eq!(continuity.authority, "continuity");
assert!(
continuity
.notes
.iter()
.any(|note| note.contains("deterministic protocol surface"))
);
Ok(())
}
}