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-08-06 01:46:50 +01:00

11425 lines
449 KiB
Rust

use crate::EpiphanyAgentStateSoaEntry;
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 crate::packaged_release::{EpiphanyPackagedReleaseEntry, EpiphanyPackagedReleaseHead};
use crate::workspace_coverage_process_documents::{
WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION,
WORKSPACE_COVERAGE_CLAIM_SIGHT_SCHEMA_VERSION,
WORKSPACE_COVERAGE_PROCESS_EVIDENCE_HEAD_SCHEMA_VERSION,
WORKSPACE_COVERAGE_PROCESS_LAUNCH_SCHEMA_VERSION,
WORKSPACE_COVERAGE_PROCESS_TERMINATION_SCHEMA_VERSION,
WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_SCHEMA_VERSION,
WORKSPACE_COVERAGE_RECOVERY_DIRECTIVE_SCHEMA_VERSION,
WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION, WorkspaceCoverageAdvancementSightEntry,
WorkspaceCoverageClaimSightEntry, WorkspaceCoverageManagedProcessLaunchEntry,
WorkspaceCoverageProcessEvidenceHead, WorkspaceCoverageProcessTerminationObservationEntry,
WorkspaceCoverageProviderHeartbeatEntry, WorkspaceCoverageRecoveryDirectiveEntry,
WorkspaceCoverageTerminalSightEntry,
};
use crate::workspace_coverage_projection_progress::{
WORKSPACE_COVERAGE_PROJECTION_PROGRESS_SCHEMA_VERSION, WorkspaceCoverageProjectionProgressEntry,
};
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use chrono::DateTime;
use chrono::FixedOffset;
use chrono::Utc;
use cultcache_rs::CacheBackingStore;
use cultcache_rs::CultSoaColumnValues;
use cultcache_rs::DatabaseEntry;
use cultcache_rs::SingleFileMessagePackBackingStore;
use cultcache_rs::SoaDocument;
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 sha2::Digest;
use sha2::Sha256;
use std::path::Path;
use uuid::Uuid;
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_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_COORDINATOR_RUN_RECEIPT_TYPE: &str =
"epiphany.cultmesh.coordinator_run_receipt";
pub const EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.coordinator_run_receipt.v0";
pub const EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_LATEST_KEY: &str =
"epiphany-local/coordinator-run-receipt/latest";
pub const EPIPHANY_CULTMESH_HANDS_ACTION_GATE_TYPE: &str = "epiphany.cultmesh.hands_action_gate";
pub const EPIPHANY_CULTMESH_HANDS_ACTION_GATE_SCHEMA_VERSION: &str =
"epiphany.cultmesh.hands_action_gate.v0";
pub const EPIPHANY_CULTMESH_HANDS_ACTION_GATE_LATEST_KEY: &str =
"epiphany-local/hands-action-gate/latest";
pub const EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_TYPE: &str = "epiphany.cultmesh.role_review_event";
pub const EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.role_review_event.v0";
pub const EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_LATEST_KEY: &str =
"epiphany-local/role-review-event/latest";
pub const EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_TYPE: &str =
"epiphany.cultmesh.work_loop_telemetry";
pub const EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.work_loop_telemetry.v0";
pub const EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_LATEST_KEY: &str =
"epiphany-internal/work-loop-telemetry/latest";
pub const EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_TYPE: &str =
"epiphany.cultmesh.agent_state_soa_summary";
pub const EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.agent_state_soa_summary.v0";
pub const EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_LATEST_KEY: &str =
"epiphany-local/agent-state-soa-summary/latest";
pub const EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_TYPE: &str = "epiphany.cultmesh.repo_work_overview";
pub const EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_SCHEMA_VERSION: &str =
"epiphany.cultmesh.repo_work_overview.v0";
pub const EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_LATEST_KEY: &str =
"gamecult-local/repo-work-overview/latest";
pub const EPIPHANY_CULTMESH_REPO_WORK_READINESS_TYPE: &str =
"epiphany.cultmesh.repo_work_readiness";
pub const EPIPHANY_CULTMESH_REPO_WORK_READINESS_SCHEMA_VERSION: &str =
"epiphany.cultmesh.repo_work_readiness.v0";
pub const EPIPHANY_CULTMESH_REPO_WORK_READINESS_LATEST_KEY: &str =
"gamecult-local/repo-work-readiness/latest";
pub const EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_TYPE: &str =
"epiphany.cultmesh.repo_work_map_entry";
pub const EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.repo_work_map_entry.v0";
pub const EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_LATEST_KEY: &str =
"gamecult-local/repo-work-map/latest";
pub const EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_TYPE: &str =
"epiphany.cultmesh.repo_work_public_proof";
pub const EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_SCHEMA_VERSION: &str =
"epiphany.cultmesh.repo_work_public_proof.v0";
pub const EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_LATEST_KEY: &str =
"gamecult-local/repo-work-public-proof/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_CLUSTER_TOPOLOGY_TYPE: &str = "epiphany.cultmesh.cluster_topology";
pub const EPIPHANY_CULTMESH_CLUSTER_TOPOLOGY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.cluster_topology.v0";
pub const EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_TYPE: &str = "epiphany.cultmesh.odin_advertisement";
pub const EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.odin_advertisement.v0";
pub const EPIPHANY_CULTMESH_EVE_SURFACE_STATE_TYPE: &str = "gamecult.eve.surface_state";
pub const EPIPHANY_CULTMESH_EVE_SURFACE_STATE_SCHEMA_VERSION: &str =
"gamecult.eve.surface_state.v0";
pub const EPIPHANY_CULTMESH_DAEMON_STATUS_TYPE: &str = "epiphany.cultmesh.daemon_status";
pub const EPIPHANY_CULTMESH_DAEMON_STATUS_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_status.v0";
pub const EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_TYPE: &str =
"epiphany.cultmesh.daemon_heartbeat_event";
pub const EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_heartbeat_event.v1";
pub const EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_TYPE: &str = "epiphany.cultmesh.daemon_poke_intent";
pub const EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_poke_intent.v1";
pub const EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_LATEST_KEY: &str =
"epiphany-local/daemon-poke-intent/latest";
pub const EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_TYPE: &str =
"epiphany.cultmesh.daemon_poke_receipt";
pub const EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_poke_receipt.v1";
pub const EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_LATEST_KEY: &str =
"epiphany-local/daemon-poke-receipt/latest";
pub const EPIPHANY_CULTMESH_DAEMON_RESTART_POLICY_TYPE: &str =
"epiphany.cultmesh.daemon_restart_policy";
pub const EPIPHANY_CULTMESH_DAEMON_RESTART_POLICY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_restart_policy.v0";
pub const EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_TYPE: &str =
"epiphany.cultmesh.daemon_scheduler_receipt";
pub const EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_scheduler_receipt.v0";
pub const EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_LATEST_KEY: &str =
"epiphany-local/daemon-scheduler-receipt/latest";
pub const EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE: &str =
"epiphany.cultmesh.daemon_service_lifecycle_receipt";
pub const EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_service_lifecycle_receipt.v2";
pub const EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY: &str =
"epiphany-local/daemon-service-lifecycle-receipt/latest";
pub const EPIPHANY_CULTMESH_MANAGED_SERVICE_POLICY_TYPE: &str =
"epiphany.cultmesh.managed_service_policy";
pub const EPIPHANY_CULTMESH_MANAGED_SERVICE_POLICY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.managed_service_policy.v0";
const EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID: &str = "epiphany-memory-semantic-projector-service";
pub const EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID: &str =
"epiphany-workspace-coverage-projector-service";
pub const EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID: &str =
"epiphany-workspace-coverage-projector";
pub const EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.idunn.deployment_receipt.v0";
pub const EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_LATEST_KEY: &str =
"gamecult-local/idunn/deployment-receipt/latest";
pub const EPIPHANY_CULTMESH_IDUNN_AFTERCARE_AUDIT_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.idunn.deployment_aftercare_audit.v0";
pub const EPIPHANY_CULTMESH_IDUNN_AFTERCARE_AUDIT_RECEIPT_LATEST_KEY: &str =
"gamecult-local/idunn/deployment-aftercare-audit/latest";
pub const EPIPHANY_CULTMESH_SWARM_BRAKE_TYPE: &str = "epiphany.cultmesh.swarm_brake";
pub const EPIPHANY_CULTMESH_SWARM_BRAKE_SCHEMA_VERSION: &str = "epiphany.cultmesh.swarm_brake.v0";
pub const EPIPHANY_CULTMESH_SWARM_BRAKE_KEY: &str = "epiphany-local/swarm-brake";
pub const EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_TYPE: &str =
"epiphany.cultmesh.persona_speech_audit";
pub const EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.persona_speech_audit.v0";
pub const EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_LATEST_KEY: &str =
"epiphany-local/persona-speech-audit/latest";
pub const EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_TYPE: &str =
"epiphany.cultmesh.weksa_lowering_receipt";
pub const EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.weksa_lowering_receipt.v0";
pub const EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_LATEST_KEY: &str =
"epiphany-local/weksa-lowering-receipt/latest";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_TYPE: &str =
"epiphany.cultmesh.daemon_tool_capability";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_tool_capability.v0";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_TYPE: &str =
"epiphany.cultmesh.daemon_tool_invocation_intent";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_tool_invocation_intent.v0";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_LATEST_KEY: &str =
"epiphany-local/daemon-tool-invocation-intent/latest";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_TYPE: &str =
"epiphany.cultmesh.daemon_tool_invocation_receipt";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.daemon_tool_invocation_receipt.v0";
pub const EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_LATEST_KEY: &str =
"epiphany-local/daemon-tool-invocation-receipt/latest";
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 EPIPHANY_CULTMESH_BIFROST_CONTRACT_TYPE: &str = "epiphany.cultmesh.bifrost_contract";
pub const EPIPHANY_CULTMESH_BIFROST_CONTRACT_SCHEMA_VERSION: &str =
"epiphany.cultmesh.bifrost_contract.v0";
pub const EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_TYPE: &str =
"gamecult.bifrost.body_change_publication_intent";
pub const EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_SCHEMA_VERSION: &str =
"gamecult.bifrost.body_change_publication_intent.v0";
pub const EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_ARRIVAL_LATEST_KEY: &str =
"gamecult-local/bifrost/body-change-publication-intent/latest";
pub const EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_TYPE: &str =
"gamecult.bifrost.body_change_publication_receipt";
pub const EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.bifrost.body_change_publication_receipt.v0";
pub const EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY: &str =
"gamecult-local/bifrost/body-change-publication-receipt/latest";
pub const EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_TYPE: &str =
"gamecult.bifrost.github_publication_receipt";
pub const EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.bifrost.github_publication_receipt.v0";
pub const EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY: &str =
"gamecult-local/bifrost/github-publication-receipt/latest";
pub const EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_TYPE: &str =
"gamecult.bifrost.public_proof_publication_receipt";
pub const EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.bifrost.public_proof_publication_receipt.v0";
pub const EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY: &str =
"gamecult-local/bifrost/public-proof-publication-receipt/latest";
pub const EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_TYPE: &str =
"gamecult.bifrost.artifact_acceptance_receipt";
pub const EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.bifrost.artifact_acceptance_receipt.v0";
pub const EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_ARRIVAL_LATEST_KEY: &str =
"gamecult-local/bifrost/artifact-acceptance-receipt/latest";
pub const EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_TYPE: &str = "gamecult.bifrost.metrics_receipt";
pub const EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_SCHEMA_VERSION: &str =
"gamecult.bifrost.metrics_receipt.v0";
pub const EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_ARRIVAL_LATEST_KEY: &str =
"gamecult-local/bifrost/metrics-receipt/latest";
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";
pub const EPIPHANY_CULTMESH_SEMANTIC_PROJECTION_HEALTH_TYPE: &str =
"epiphany.cultmesh.semantic_projection_health";
pub const EPIPHANY_CULTMESH_SEMANTIC_PROJECTION_HEALTH_SCHEMA_VERSION: &str =
"epiphany.cultmesh.semantic_projection_health.v0";
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.semantic_projection_health",
schema = "EpiphanyCultMeshSemanticProjectionHealthEntry"
)]
pub struct EpiphanyCultMeshSemanticProjectionHealthEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub verse_id: String,
#[cultcache(key = 2)]
pub verse_tier: String,
#[cultcache(key = 3)]
pub swarm_id: String,
#[cultcache(key = 4)]
pub partition: String,
#[cultcache(key = 5)]
pub obligation_id: String,
#[cultcache(key = 6)]
pub source_generation: u64,
#[cultcache(key = 7)]
pub canonical_model_hash: String,
#[cultcache(key = 8)]
pub canonical_content_set_hash: String,
#[cultcache(key = 9)]
pub status: String,
#[cultcache(key = 10)]
pub receipt_id: Option<String>,
#[cultcache(key = 11)]
pub indexed_document_count: Option<u32>,
#[cultcache(key = 12)]
pub vector_dimensions: Option<u32>,
#[cultcache(key = 13)]
pub observed_at: String,
#[cultcache(key = 14)]
pub private_state_exposed: bool,
#[cultcache(key = 15)]
pub provider_id: String,
#[cultcache(key = 16)]
pub provider_incarnation: String,
#[cultcache(key = 17)]
pub observed_source_at: String,
#[cultcache(key = 18)]
pub authoritative: bool,
#[cultcache(key = 19)]
pub query_eligible_display_only: bool,
}
#[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_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>,
}
#[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.coordinator_run_receipt",
schema = "EpiphanyCultMeshCoordinatorRunReceiptEntry"
)]
pub struct EpiphanyCultMeshCoordinatorRunReceiptEntry {
#[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 receipt_id: String,
#[cultcache(key = 4)]
pub source_document_type: String,
#[cultcache(key = 5)]
pub source_receipt_id: String,
#[cultcache(key = 6)]
pub source_store: String,
#[cultcache(key = 7)]
pub thread_id: String,
#[cultcache(key = 8)]
pub mode: String,
#[cultcache(key = 9)]
pub status: String,
#[cultcache(key = 10)]
pub final_action: String,
#[cultcache(key = 11)]
pub final_reason: String,
#[cultcache(key = 12)]
pub step_count: u64,
#[cultcache(key = 13)]
pub artifact_root: String,
#[cultcache(key = 14)]
pub artifact_refs: Vec<String>,
#[cultcache(key = 15)]
pub sealed_artifact_refs: Vec<String>,
#[cultcache(key = 16)]
pub created_at_utc: String,
#[cultcache(key = 17)]
pub private_state_exposed: bool,
#[cultcache(key = 18)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.hands_action_gate",
schema = "EpiphanyCultMeshHandsActionGateEntry"
)]
pub struct EpiphanyCultMeshHandsActionGateEntry {
#[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 gate_id: String,
#[cultcache(key = 4)]
pub source_coordinator_receipt_id: String,
#[cultcache(key = 5)]
pub source_summary_path: String,
#[cultcache(key = 6)]
pub thread_id: String,
#[cultcache(key = 7)]
pub mode: String,
#[cultcache(key = 8)]
pub status: String,
#[cultcache(key = 9)]
pub hands_intent_id: String,
#[cultcache(key = 10)]
pub hands_review_id: String,
#[cultcache(key = 11)]
pub substrate_gate_grant_receipt_id: String,
#[cultcache(key = 12)]
pub runtime_job_id: String,
#[cultcache(key = 13)]
pub requested_paths: Vec<String>,
#[cultcache(key = 14)]
pub required_receipts: Vec<String>,
#[cultcache(key = 15)]
pub record_pass_executable: String,
#[cultcache(key = 16)]
pub record_pass_args: Vec<String>,
#[cultcache(key = 17)]
pub created_at_utc: String,
#[cultcache(key = 18)]
pub private_state_exposed: bool,
#[cultcache(key = 19)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.role_review_event",
schema = "EpiphanyCultMeshRoleReviewEventEntry"
)]
pub struct EpiphanyCultMeshRoleReviewEventEntry {
#[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 event_id: String,
#[cultcache(key = 4)]
pub source_coordinator_receipt_id: String,
#[cultcache(key = 5)]
pub source_summary_path: String,
#[cultcache(key = 6)]
pub thread_id: String,
#[cultcache(key = 7)]
pub mode: String,
#[cultcache(key = 8)]
pub surface: String,
#[cultcache(key = 9)]
pub role_id: String,
#[cultcache(key = 10)]
pub review_status: String,
#[cultcache(key = 11)]
pub acceptance_receipt_id: String,
#[cultcache(key = 12)]
pub runtime_result_id: String,
#[cultcache(key = 13)]
pub runtime_job_id: String,
#[cultcache(key = 14)]
pub binding_id: String,
#[cultcache(key = 15)]
pub summary: String,
#[cultcache(key = 16)]
pub created_at_utc: String,
#[cultcache(key = 17)]
pub private_state_exposed: bool,
#[cultcache(key = 18)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.work_loop_telemetry",
schema = "EpiphanyCultMeshWorkLoopTelemetryEntry"
)]
pub struct EpiphanyCultMeshWorkLoopTelemetryEntry {
#[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 telemetry_id: String,
#[cultcache(key = 4)]
pub thread_id: String,
#[cultcache(key = 5)]
pub produced_at_utc: String,
#[cultcache(key = 6)]
pub source_stage: String,
#[cultcache(key = 7)]
pub target_stages: Vec<String>,
#[cultcache(key = 8)]
pub lower_bound_receipt_at: String,
#[cultcache(key = 9)]
pub hands_intent_id: String,
#[cultcache(key = 10)]
pub hands_review_id: String,
#[cultcache(key = 11)]
pub hands_runtime_job_id: String,
#[cultcache(key = 12)]
pub substrate_gate_grant_receipt_id: String,
#[cultcache(key = 13)]
pub hands_patch_receipt_id: String,
#[cultcache(key = 14)]
pub hands_command_receipt_id: String,
#[cultcache(key = 15)]
pub hands_commit_receipt_id: String,
#[cultcache(key = 16)]
pub command: String,
#[cultcache(key = 17)]
pub exit_code: String,
#[cultcache(key = 18)]
pub stdout_artifact: String,
#[cultcache(key = 19)]
pub stderr_artifact: String,
#[cultcache(key = 20)]
pub commit_sha: String,
#[cultcache(key = 21)]
pub branch: String,
#[cultcache(key = 22)]
pub changed_paths: Vec<String>,
#[cultcache(key = 23)]
pub artifact_previews: Vec<String>,
#[cultcache(key = 24)]
pub source_refs: Vec<String>,
#[cultcache(key = 25)]
pub source_path_proof: Vec<String>,
#[cultcache(key = 26)]
pub soul_receipt_ids: Vec<String>,
#[cultcache(key = 27)]
pub summary: String,
#[cultcache(key = 28, default)]
pub receipt_payload_previews: Vec<String>,
#[cultcache(key = 29, default)]
pub commit_diff_preview: String,
#[cultcache(key = 30, default)]
pub verification_assertions: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.agent_state_soa_summary",
schema = "EpiphanyCultMeshAgentStateSoaSummaryEntry"
)]
pub struct EpiphanyCultMeshAgentStateSoaSummaryEntry {
#[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 summary_id: String,
#[cultcache(key = 4)]
pub generated_at: String,
#[cultcache(key = 5)]
pub source_store: String,
#[cultcache(key = 6)]
pub row_count: u32,
#[cultcache(key = 7)]
pub role_ids: Vec<String>,
#[cultcache(key = 8)]
pub agent_ids: Vec<String>,
#[cultcache(key = 9)]
pub display_names: Vec<String>,
#[cultcache(key = 10)]
pub profile_kinds: Vec<String>,
#[cultcache(key = 11)]
pub portable_contracts: Vec<String>,
#[cultcache(key = 12)]
pub semantic_memory_counts: Vec<u32>,
#[cultcache(key = 13)]
pub episodic_memory_counts: Vec<u32>,
#[cultcache(key = 14)]
pub relationship_memory_counts: Vec<u32>,
#[cultcache(key = 15)]
pub goal_counts: Vec<u32>,
#[cultcache(key = 16)]
pub value_counts: Vec<u32>,
#[cultcache(key = 17)]
pub private_state_exposed: bool,
#[cultcache(key = 18)]
pub notes: Vec<String>,
}
impl SoaDocument for EpiphanyCultMeshAgentStateSoaSummaryEntry {
fn soa_columns(rows: &[Self]) -> std::collections::BTreeMap<&'static str, CultSoaColumnValues> {
let mut columns = std::collections::BTreeMap::new();
columns.insert(
"summaryId",
CultSoaColumnValues::new(
rows.iter()
.map(|row| row.summary_id.clone())
.collect::<Vec<_>>(),
),
);
columns.insert(
"rowCount",
CultSoaColumnValues::new(rows.iter().map(|row| row.row_count).collect::<Vec<_>>()),
);
columns.insert(
"privateStateExposed",
CultSoaColumnValues::new(
rows.iter()
.map(|row| row.private_state_exposed)
.collect::<Vec<_>>(),
),
);
columns.insert(
"roleIds",
CultSoaColumnValues::new(
rows.iter()
.map(|row| row.role_ids.clone())
.collect::<Vec<_>>(),
),
);
columns.insert(
"portableContracts",
CultSoaColumnValues::new(
rows.iter()
.map(|row| row.portable_contracts.clone())
.collect::<Vec<_>>(),
),
);
columns
}
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.repo_work_overview",
schema = "EpiphanyCultMeshRepoWorkOverviewEntry"
)]
pub struct EpiphanyCultMeshRepoWorkOverviewEntry {
#[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 overview_id: String,
#[cultcache(key = 4)]
pub generated_at: String,
#[cultcache(key = 5)]
pub workspace: String,
#[cultcache(key = 6)]
pub item: String,
#[cultcache(key = 7)]
pub branch: String,
#[cultcache(key = 8)]
pub current_gate: String,
#[cultcache(key = 9)]
pub blocker: String,
#[cultcache(key = 10)]
pub next_safe_move: String,
#[cultcache(key = 11)]
pub changed_paths: Vec<String>,
#[cultcache(key = 12)]
pub commit_sha: String,
#[cultcache(key = 13)]
pub soul_verdict: String,
#[cultcache(key = 14)]
pub publication_status: String,
#[cultcache(key = 15)]
pub sync_status: String,
#[cultcache(key = 16)]
pub receipt_refs: Vec<String>,
#[cultcache(key = 17)]
pub tui_rows: Vec<String>,
#[cultcache(key = 18)]
pub proof_bundle_ref: String,
#[cultcache(key = 19)]
pub private_state_exposed: bool,
#[cultcache(key = 20)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.repo_work_readiness",
schema = "EpiphanyCultMeshRepoWorkReadinessEntry"
)]
pub struct EpiphanyCultMeshRepoWorkReadinessEntry {
#[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 readiness_id: String,
#[cultcache(key = 4)]
pub generated_at: String,
#[cultcache(key = 5)]
pub workspace: String,
#[cultcache(key = 6)]
pub item: String,
#[cultcache(key = 7)]
pub status: String,
#[cultcache(key = 8)]
pub missing_required_count: u32,
#[cultcache(key = 9)]
pub satisfied_required_count: u32,
#[cultcache(key = 10)]
pub readiness_receipt_ref: String,
#[cultcache(key = 11)]
pub overview_receipt_ref: String,
#[cultcache(key = 12)]
pub proof_bundle_id: String,
#[cultcache(key = 13)]
pub missing_kinds: Vec<String>,
#[cultcache(key = 14)]
pub tui_rows: Vec<String>,
#[cultcache(key = 15)]
pub sight_only: bool,
#[cultcache(key = 16)]
pub readiness_approval_authorized: bool,
#[cultcache(key = 17)]
pub publication_authorized: bool,
#[cultcache(key = 18)]
pub service_lifecycle_authority: bool,
#[cultcache(key = 19)]
pub hands_action_authorized: bool,
#[cultcache(key = 20)]
pub private_state_exposed: bool,
#[cultcache(key = 21)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.repo_work_map_entry",
schema = "EpiphanyCultMeshRepoWorkMapEntry"
)]
pub struct EpiphanyCultMeshRepoWorkMapEntry {
#[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 map_entry_id: String,
#[cultcache(key = 4)]
pub admitted_at: String,
#[cultcache(key = 5)]
pub mirrored_at: String,
#[cultcache(key = 6)]
pub workspace: String,
#[cultcache(key = 7)]
pub item: String,
#[cultcache(key = 8)]
pub branch: String,
#[cultcache(key = 9)]
pub changed_paths: Vec<String>,
#[cultcache(key = 10)]
pub commit_sha: String,
#[cultcache(key = 11)]
pub safe_action_family: String,
#[cultcache(key = 12)]
pub modeling_summary: String,
#[cultcache(key = 13)]
pub soul_verdict_receipt_id: String,
#[cultcache(key = 14)]
pub mind_gateway_review_id: String,
#[cultcache(key = 15)]
pub mind_state_commit_receipt_id: String,
#[cultcache(key = 16)]
pub publication_gate: String,
#[cultcache(key = 17)]
pub durable_state_admitted: bool,
#[cultcache(key = 18)]
pub source_store_path: String,
#[cultcache(key = 19)]
pub tui_rows: Vec<String>,
#[cultcache(key = 20)]
pub private_state_exposed: bool,
#[cultcache(key = 21)]
pub notes: Vec<String>,
#[cultcache(key = 22)]
pub modeling_finding_receipt_id: String,
#[cultcache(key = 23)]
pub modeling_route_id: String,
#[cultcache(key = 24)]
pub modeling_generation: u64,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.repo_work_public_proof",
schema = "EpiphanyCultMeshRepoWorkPublicProofEntry"
)]
pub struct EpiphanyCultMeshRepoWorkPublicProofEntry {
#[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 public_proof_id: String,
#[cultcache(key = 4)]
pub generated_at: String,
#[cultcache(key = 5)]
pub workspace: String,
#[cultcache(key = 6)]
pub item: String,
#[cultcache(key = 7)]
pub branch: String,
#[cultcache(key = 8)]
pub current_gate: String,
#[cultcache(key = 9)]
pub blocker: String,
#[cultcache(key = 10)]
pub next_safe_move: String,
#[cultcache(key = 11)]
pub changed_paths: Vec<String>,
#[cultcache(key = 12)]
pub commit_sha: String,
#[cultcache(key = 13)]
pub soul_verdict: String,
#[cultcache(key = 14)]
pub upstream_main_synced: bool,
#[cultcache(key = 15)]
pub artifact_row_count: u32,
#[cultcache(key = 16)]
pub publication_row_count: u32,
#[cultcache(key = 17)]
pub public_proof_ref: String,
#[cultcache(key = 18)]
pub public_proof_sha256: String,
#[cultcache(key = 19)]
pub tui_rows: Vec<String>,
#[cultcache(key = 20)]
pub private_state_exposed: bool,
#[cultcache(key = 21)]
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.cluster_topology",
schema = "EpiphanyCultMeshClusterTopologyEntry"
)]
pub struct EpiphanyCultMeshClusterTopologyEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub cluster_id: String,
#[cultcache(key = 2)]
pub role_id: String,
#[cultcache(key = 3)]
pub display_name: String,
#[cultcache(key = 4)]
pub private_verse_id: String,
#[cultcache(key = 5)]
pub body_domain: String,
#[cultcache(key = 6)]
pub body_kind: String,
#[cultcache(key = 7)]
pub daemon_id: String,
#[cultcache(key = 8)]
pub daemon_surface_id: String,
#[cultcache(key = 9)]
pub eve_surface_id: String,
#[cultcache(key = 10)]
pub public_persona_discussion_allowed: bool,
#[cultcache(key = 11)]
#[cultcache(key = 12)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.odin_advertisement",
schema = "EpiphanyCultMeshOdinAdvertisementEntry"
)]
pub struct EpiphanyCultMeshOdinAdvertisementEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub advertisement_id: String,
#[cultcache(key = 2)]
pub cluster_id: String,
#[cultcache(key = 3)]
pub advertised_verse_id: String,
#[cultcache(key = 4)]
pub body_domain: String,
#[cultcache(key = 5)]
pub body_kind: String,
#[cultcache(key = 6)]
pub daemon_surface_id: String,
#[cultcache(key = 7)]
pub eve_surface_id: String,
#[cultcache(key = 8)]
pub public_summary: String,
#[cultcache(key = 9)]
pub advertised_document_types: Vec<String>,
#[cultcache(key = 10)]
pub trust_boundary: String,
#[cultcache(key = 11)]
pub private_state_exposed: bool,
#[cultcache(key = 12)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.eve.surface_state",
schema = "EpiphanyCultMeshEveSurfaceStateEntry"
)]
pub struct EpiphanyCultMeshEveSurfaceStateEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub surface_id: String,
#[cultcache(key = 2)]
pub cluster_id: String,
#[cultcache(key = 3)]
pub daemon_id: String,
#[cultcache(key = 4)]
pub body_domain: String,
#[cultcache(key = 5)]
pub tui_title: String,
#[cultcache(key = 6)]
pub tui_rows: Vec<String>,
#[cultcache(key = 7)]
pub exposed_document_types: Vec<String>,
#[cultcache(key = 8)]
pub supported_actions: Vec<String>,
#[cultcache(key = 9)]
pub private_state_exposed: bool,
#[cultcache(key = 10)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_status",
schema = "EpiphanyCultMeshDaemonStatusEntry"
)]
pub struct EpiphanyCultMeshDaemonStatusEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub daemon_id: String,
#[cultcache(key = 2)]
pub cluster_id: String,
#[cultcache(key = 3)]
pub body_domain: String,
#[cultcache(key = 4)]
pub daemon_surface_id: String,
#[cultcache(key = 5)]
pub eve_surface_id: String,
#[cultcache(key = 6)]
pub status: String,
#[cultcache(key = 7)]
pub last_heartbeat_utc: String,
#[cultcache(key = 8)]
pub supported_actions: Vec<String>,
#[cultcache(key = 9)]
pub operator_action: String,
#[cultcache(key = 10)]
pub private_state_exposed: bool,
#[cultcache(key = 11)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_heartbeat_event",
schema = "EpiphanyCultMeshDaemonHeartbeatEventEntry"
)]
pub struct EpiphanyCultMeshDaemonHeartbeatEventEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub heartbeat_id: String,
#[cultcache(key = 2)]
pub daemon_id: String,
#[cultcache(key = 3)]
pub cluster_id: String,
#[cultcache(key = 4)]
pub provider_incarnation: String,
#[cultcache(key = 5)]
pub sequence: u64,
#[cultcache(key = 6)]
pub status: String,
#[cultcache(key = 7)]
pub heartbeat_at: String,
#[cultcache(key = 8)]
pub private_state_exposed: bool,
#[cultcache(key = 9, default)]
pub startup_lifecycle_receipt_id: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_poke_intent",
schema = "EpiphanyCultMeshDaemonPokeIntentEntry"
)]
pub struct EpiphanyCultMeshDaemonPokeIntentEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub intent_id: String,
#[cultcache(key = 2)]
pub requesting_agent_id: String,
#[cultcache(key = 3)]
pub target_daemon_id: String,
#[cultcache(key = 4)]
pub target_cluster_id: String,
#[cultcache(key = 5)]
pub daemon_surface_id: String,
#[cultcache(key = 6)]
pub eve_surface_id: String,
#[cultcache(key = 7)]
pub reason: String,
#[cultcache(key = 8)]
pub requested_action: String,
#[cultcache(key = 9)]
pub observed_status: String,
#[cultcache(key = 10)]
pub private_state_requested: bool,
#[cultcache(key = 11)]
pub notes: Vec<String>,
#[cultcache(key = 12, default)]
pub observed_last_heartbeat_utc: String,
#[cultcache(key = 13, default)]
pub requested_at_utc: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_poke_receipt",
schema = "EpiphanyCultMeshDaemonPokeReceiptEntry"
)]
pub struct EpiphanyCultMeshDaemonPokeReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub intent_id: String,
#[cultcache(key = 3)]
pub target_daemon_id: String,
#[cultcache(key = 4)]
pub target_cluster_id: String,
#[cultcache(key = 5)]
pub action_taken: String,
#[cultcache(key = 6)]
pub status: String,
#[cultcache(key = 7)]
pub resulting_status: String,
#[cultcache(key = 8)]
pub operator_artifact_ref: String,
#[cultcache(key = 9)]
pub private_state_exposed: bool,
#[cultcache(key = 10)]
pub notes: Vec<String>,
#[cultcache(key = 11, default)]
pub attempted_at_utc: String,
#[cultcache(key = 12, default)]
pub completed_at_utc: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_restart_policy",
schema = "EpiphanyCultMeshDaemonRestartPolicyEntry"
)]
pub struct EpiphanyCultMeshDaemonRestartPolicyEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub policy_id: String,
#[cultcache(key = 2)]
pub daemon_id: String,
#[cultcache(key = 3)]
pub cluster_id: String,
#[cultcache(key = 4)]
pub restart_command: String,
#[cultcache(key = 5)]
pub restart_args: Vec<String>,
#[cultcache(key = 6)]
pub cwd: Option<String>,
#[cultcache(key = 7)]
pub cooldown_seconds: i64,
#[cultcache(key = 8)]
pub backoff_multiplier: u32,
#[cultcache(key = 9)]
pub failure_count: u32,
#[cultcache(key = 10)]
pub last_attempt_utc: Option<String>,
#[cultcache(key = 11)]
pub last_result_status: String,
#[cultcache(key = 12)]
pub enabled: bool,
#[cultcache(key = 13)]
pub private_state_exposed: bool,
#[cultcache(key = 14)]
pub notes: Vec<String>,
#[cultcache(key = 15)]
pub reconcile_interval_seconds: i64,
#[cultcache(key = 16)]
pub heartbeat_stale_seconds: i64,
#[cultcache(key = 17)]
pub last_reconcile_utc: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_scheduler_receipt",
schema = "EpiphanyCultMeshDaemonSchedulerReceiptEntry"
)]
pub struct EpiphanyCultMeshDaemonSchedulerReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub scheduler_id: String,
#[cultcache(key = 3)]
pub runtime_id: String,
#[cultcache(key = 4)]
pub daemon_selector: String,
#[cultcache(key = 5)]
pub iteration: u64,
#[cultcache(key = 6)]
pub status: String,
#[cultcache(key = 7)]
pub tick_started_utc: String,
#[cultcache(key = 8)]
pub tick_completed_utc: String,
#[cultcache(key = 9)]
pub next_wake_utc: Option<String>,
#[cultcache(key = 10)]
pub outcome_count: u32,
#[cultcache(key = 11)]
pub restarted_count: u32,
#[cultcache(key = 12)]
pub refused_count: u32,
#[cultcache(key = 13)]
pub skipped_count: u32,
#[cultcache(key = 14)]
pub private_state_exposed: bool,
#[cultcache(key = 15)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_service_lifecycle_receipt",
schema = "EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry"
)]
pub struct EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub service_id: String,
#[cultcache(key = 3)]
pub scheduler_id: String,
#[cultcache(key = 4)]
pub runtime_id: String,
#[cultcache(key = 5)]
pub daemon_selector: String,
#[cultcache(key = 6)]
pub action: String,
#[cultcache(key = 7)]
pub status: String,
#[cultcache(key = 8)]
pub command: String,
#[cultcache(key = 9)]
pub args: Vec<String>,
#[cultcache(key = 10)]
pub cwd: Option<String>,
#[cultcache(key = 11)]
pub process_id: Option<u32>,
#[cultcache(key = 12)]
pub exit_code: Option<i32>,
#[cultcache(key = 13)]
pub started_at_utc: String,
#[cultcache(key = 14)]
pub completed_at_utc: Option<String>,
#[cultcache(key = 15)]
pub operator_artifact_ref: String,
#[cultcache(key = 16)]
pub private_state_exposed: bool,
#[cultcache(key = 17)]
pub notes: Vec<String>,
#[cultcache(key = 18, default)]
pub executable_sha256: String,
#[cultcache(key = 19, default)]
pub preflight_witness_id: String,
#[cultcache(key = 20, default)]
pub required_document_types: Vec<String>,
#[cultcache(key = 21, default)]
pub schema_preflight_passed: bool,
#[cultcache(key = 22, default)]
pub schema_catalog_sha256: String,
#[cultcache(key = 23, default)]
pub managed_policy_id: String,
#[cultcache(key = 24, default)]
pub managed_policy_digest: String,
#[cultcache(key = 25, default)]
pub provider_daemon_id: String,
#[cultcache(key = 26, default)]
pub startup_correlation_id: String,
#[cultcache(key = 27, default)]
pub process_creation_token: u64,
#[cultcache(key = 28, default)]
pub process_created_at_rfc3339: Option<String>,
#[cultcache(key = 29, default)]
pub process_executable_path: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.managed_service_policy",
schema = "EpiphanyCultMeshManagedServicePolicyEntry"
)]
pub struct EpiphanyCultMeshManagedServicePolicyEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub policy_id: String,
#[cultcache(key = 2)]
pub service_id: String,
#[cultcache(key = 3)]
pub owner_daemon_id: String,
#[cultcache(key = 4)]
pub command: String,
#[cultcache(key = 5)]
pub args: Vec<String>,
#[cultcache(key = 6)]
pub cwd: Option<String>,
#[cultcache(key = 7)]
pub enabled: bool,
#[cultcache(key = 8)]
pub restart_mode: String,
#[cultcache(key = 9)]
pub cooldown_seconds: i64,
#[cultcache(key = 10)]
pub backoff_multiplier: u32,
#[cultcache(key = 11)]
pub stdout_artifact: String,
#[cultcache(key = 12)]
pub stderr_artifact: String,
#[cultcache(key = 14)]
pub updated_at_utc: String,
#[cultcache(key = 15)]
pub private_state_exposed: bool,
#[cultcache(key = 16)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.idunn.deployment_receipt",
schema = "EpiphanyCultMeshIdunnDeploymentReceiptEntry"
)]
pub struct EpiphanyCultMeshIdunnDeploymentReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub runtime_id: String,
#[cultcache(key = 3)]
pub verse_id: String,
#[cultcache(key = 4)]
pub status: String,
#[cultcache(key = 5)]
pub trigger: String,
#[cultcache(key = 6)]
pub watched_ref: String,
#[cultcache(key = 7)]
pub source_commit: String,
#[cultcache(key = 8)]
pub result_ref: String,
#[cultcache(key = 9)]
pub result_summary: String,
#[cultcache(key = 10)]
pub private_state_exposed: bool,
#[cultcache(key = 11)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.idunn.deployment_aftercare_audit",
schema = "EpiphanyCultMeshIdunnAftercareAuditReceiptEntry"
)]
pub struct EpiphanyCultMeshIdunnAftercareAuditReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub runtime_id: String,
#[cultcache(key = 3)]
pub verse_id: String,
#[cultcache(key = 4)]
pub status: String,
#[cultcache(key = 5)]
pub checked_ref: String,
#[cultcache(key = 6)]
pub deployment_receipt_id: String,
#[cultcache(key = 7)]
pub audit_ref: String,
#[cultcache(key = 8)]
pub result_summary: String,
#[cultcache(key = 9)]
pub private_state_exposed: bool,
#[cultcache(key = 10)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyServiceExecutionAuditCheck {
pub service_id: Option<String>,
pub action: String,
pub allowed_statuses: Vec<String>,
pub receipt_id: Option<String>,
pub observed_status: Option<String>,
pub operator_artifact_ref: Option<String>,
pub ok: bool,
pub private_state_sealed: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyServiceExecutionAuditReport {
pub status: String,
pub receipt_count: usize,
pub missing_count: usize,
pub failed_count: usize,
pub private_state_exposed: bool,
pub checks: Vec<EpiphanyServiceExecutionAuditCheck>,
}
pub fn epiphany_service_execution_audit_report(
receipts: &[EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry],
) -> EpiphanyServiceExecutionAuditReport {
epiphany_service_execution_audit_report_for_expected(
receipts,
&[
("windows-service-execution-runbook", &["written"][..]),
(
"windows-service-execution-readiness",
&["elevated-ready"][..],
),
(
"windows-service-install",
&["install-command-succeeded"][..],
),
("windows-service-start", &["start-requested"][..]),
(
"windows-service-status",
&["running", "present", "stopped"][..],
),
("windows-service-reconcile", &["in-sync"][..]),
("windows-service-stop", &["stop-requested"][..]),
],
)
}
pub fn epiphany_cluster_service_execution_audit_report(
receipts: &[EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry],
) -> EpiphanyServiceExecutionAuditReport {
epiphany_service_execution_audit_report_for_expected(
receipts,
&[
(
"cluster-windows-service-execution-runbook",
&["written"][..],
),
(
"cluster-windows-service-execution-readiness",
&["elevated-ready"][..],
),
(
"cluster-windows-service-install",
&["install-command-succeeded"][..],
),
("cluster-windows-service-start", &["start-requested"][..]),
("cluster-windows-service-audit", &["complete"][..]),
("cluster-windows-service-stop", &["stop-requested"][..]),
],
)
}
fn epiphany_service_execution_audit_report_for_expected(
receipts: &[EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry],
expected: &[(&str, &[&str])],
) -> EpiphanyServiceExecutionAuditReport {
let mut checks = Vec::new();
let mut missing_count = 0_usize;
let mut failed_count = 0_usize;
let mut private_state_exposed = false;
let mut service_ids = receipts
.iter()
.map(|receipt| receipt.service_id.as_str())
.collect::<Vec<_>>();
service_ids.sort();
service_ids.dedup();
let inferred_service_id = if service_ids.len() == 1 {
Some(service_ids[0].to_string())
} else {
None
};
for (action, allowed_statuses) in expected {
let receipt = latest_lifecycle_receipt_for_action(receipts, action);
let (service_id, receipt_id, observed_status, operator_artifact_ref, ok, sealed) =
match receipt {
Some(receipt) => {
let status_ok = allowed_statuses
.iter()
.any(|allowed| *allowed == receipt.status);
(
Some(receipt.service_id.clone()),
Some(receipt.receipt_id.clone()),
Some(receipt.status.clone()),
non_empty_operator_artifact_ref(receipt),
status_ok,
!receipt.private_state_exposed,
)
}
None => {
missing_count += 1;
(inferred_service_id.clone(), None, None, None, false, true)
}
};
if !ok {
failed_count += 1;
}
if !sealed {
private_state_exposed = true;
}
checks.push(EpiphanyServiceExecutionAuditCheck {
service_id,
action: (*action).to_string(),
allowed_statuses: allowed_statuses
.iter()
.map(|status| (*status).to_string())
.collect(),
receipt_id,
observed_status,
operator_artifact_ref,
ok,
private_state_sealed: sealed,
});
}
let status = if missing_count == 0 && failed_count == 0 && !private_state_exposed {
"complete"
} else {
"incomplete"
}
.to_string();
EpiphanyServiceExecutionAuditReport {
status,
receipt_count: receipts.len(),
missing_count,
failed_count,
private_state_exposed,
checks,
}
}
fn non_empty_operator_artifact_ref(
receipt: &EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
) -> Option<String> {
let artifact_ref = receipt.operator_artifact_ref.trim();
if artifact_ref.is_empty() || artifact_ref == "none" {
None
} else {
Some(receipt.operator_artifact_ref.clone())
}
}
fn latest_lifecycle_receipt_for_action<'a>(
receipts: &'a [EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry],
action: &str,
) -> Option<&'a EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry> {
receipts
.iter()
.filter(|receipt| receipt.action == action)
.max_by(|left, right| {
lifecycle_receipt_sort_key(left).cmp(&lifecycle_receipt_sort_key(right))
})
}
fn lifecycle_receipt_sort_key(
receipt: &EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
) -> (&str, &str) {
(
receipt
.completed_at_utc
.as_deref()
.unwrap_or(receipt.started_at_utc.as_str()),
receipt.receipt_id.as_str(),
)
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.swarm_brake",
schema = "EpiphanyCultMeshSwarmBrakeEntry"
)]
pub struct EpiphanyCultMeshSwarmBrakeEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub brake_id: String,
#[cultcache(key = 2)]
pub status: String,
#[cultcache(key = 3)]
pub scope: String,
#[cultcache(key = 4)]
pub reason: String,
#[cultcache(key = 5)]
pub operator_agent_id: String,
#[cultcache(key = 6)]
pub affected_clusters: Vec<String>,
#[cultcache(key = 7)]
pub protected_surfaces: Vec<String>,
#[cultcache(key = 8)]
pub created_at_utc: String,
#[cultcache(key = 9)]
pub expires_at_utc: Option<String>,
#[cultcache(key = 10)]
pub private_state_exposed: bool,
#[cultcache(key = 11)]
pub notes: Vec<String>,
#[cultcache(key = 12, default)]
pub runtime_id: String,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.persona_speech_audit",
schema = "EpiphanyCultMeshPersonaSpeechAuditEntry"
)]
pub struct EpiphanyCultMeshPersonaSpeechAuditEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub audit_id: String,
#[cultcache(key = 2)]
pub runtime_id: String,
#[cultcache(key = 3)]
pub verse_id: String,
#[cultcache(key = 4)]
pub persona_agent_id: String,
#[cultcache(key = 5)]
pub action_kind: String,
#[cultcache(key = 6)]
pub decision: String,
#[cultcache(key = 7)]
pub content_fingerprint: String,
#[cultcache(key = 8)]
pub opening_key: String,
#[cultcache(key = 9)]
pub topic_key: String,
#[cultcache(key = 10)]
pub requested_channel_id: String,
#[cultcache(key = 11)]
pub recent_window_count: u32,
#[cultcache(key = 12)]
pub repeated_opening_count: u32,
#[cultcache(key = 13)]
pub repeated_topic_count: u32,
#[cultcache(key = 14)]
pub same_channel_post_count: u32,
#[cultcache(key = 15)]
pub reasons: Vec<String>,
#[cultcache(key = 16)]
pub artifact_ref: String,
#[cultcache(key = 17)]
pub created_at_utc: String,
#[cultcache(key = 18)]
pub private_state_exposed: bool,
#[cultcache(key = 19)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.weksa_lowering_receipt",
schema = "EpiphanyCultMeshWeksaLoweringReceiptEntry"
)]
pub struct EpiphanyCultMeshWeksaLoweringReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub runtime_id: String,
#[cultcache(key = 3)]
pub verse_id: String,
#[cultcache(key = 4)]
pub packet_id: String,
#[cultcache(key = 5)]
pub request_id: String,
#[cultcache(key = 6)]
pub persona_agent_id: String,
#[cultcache(key = 7)]
pub target_language: String,
#[cultcache(key = 8)]
pub target_register: String,
#[cultcache(key = 9)]
pub delivery_surface: String,
#[cultcache(key = 10)]
pub lowering_method: String,
#[cultcache(key = 11)]
pub transport_authority: String,
#[cultcache(key = 12)]
pub publication_authorized: bool,
#[cultcache(key = 13)]
pub lowered_text_ref: String,
#[cultcache(key = 14)]
pub lowered_text_preview: String,
#[cultcache(key = 15)]
pub created_at_utc: String,
#[cultcache(key = 16)]
pub private_state_exposed: bool,
#[cultcache(key = 17)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_tool_capability",
schema = "EpiphanyCultMeshDaemonToolCapabilityEntry"
)]
pub struct EpiphanyCultMeshDaemonToolCapabilityEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub capability_id: String,
#[cultcache(key = 2)]
pub host_cluster_id: String,
#[cultcache(key = 3)]
pub host_daemon_id: String,
#[cultcache(key = 4)]
pub eve_surface_id: String,
#[cultcache(key = 5)]
pub tool_name: String,
#[cultcache(key = 6)]
pub operation: String,
#[cultcache(key = 7)]
pub input_contract_type: String,
#[cultcache(key = 8)]
pub receipt_contract_type: String,
#[cultcache(key = 9)]
pub available_to_all_agents: bool,
#[cultcache(key = 10)]
pub requires_receipt: bool,
#[cultcache(key = 11)]
pub authority_gate: String,
#[cultcache(key = 12)]
pub private_state_exposed: bool,
#[cultcache(key = 13)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_tool_invocation_intent",
schema = "EpiphanyCultMeshDaemonToolInvocationIntentEntry"
)]
pub struct EpiphanyCultMeshDaemonToolInvocationIntentEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub intent_id: String,
#[cultcache(key = 2)]
pub requesting_agent_id: String,
#[cultcache(key = 3)]
pub requesting_cluster_id: String,
#[cultcache(key = 4)]
pub capability_id: String,
#[cultcache(key = 5)]
pub host_cluster_id: String,
#[cultcache(key = 6)]
pub host_daemon_id: String,
#[cultcache(key = 7)]
pub eve_surface_id: String,
#[cultcache(key = 8)]
pub tool_name: String,
#[cultcache(key = 9)]
pub operation: String,
#[cultcache(key = 10)]
pub input_contract_type: String,
#[cultcache(key = 11)]
pub payload_ref: String,
#[cultcache(key = 12)]
pub payload_summary: String,
#[cultcache(key = 13)]
pub authority_gate: String,
#[cultcache(key = 14)]
pub requires_receipt: bool,
#[cultcache(key = 15)]
pub private_state_requested: bool,
#[cultcache(key = 16)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "epiphany.cultmesh.daemon_tool_invocation_receipt",
schema = "EpiphanyCultMeshDaemonToolInvocationReceiptEntry"
)]
pub struct EpiphanyCultMeshDaemonToolInvocationReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub intent_id: String,
#[cultcache(key = 3)]
pub requesting_agent_id: String,
#[cultcache(key = 4)]
pub requesting_cluster_id: String,
#[cultcache(key = 5)]
pub capability_id: String,
#[cultcache(key = 6)]
pub host_cluster_id: String,
#[cultcache(key = 7)]
pub host_daemon_id: String,
#[cultcache(key = 8)]
pub tool_name: String,
#[cultcache(key = 9)]
pub operation: String,
#[cultcache(key = 10)]
pub status: String,
#[cultcache(key = 11)]
pub receipt_contract_type: String,
#[cultcache(key = 12)]
pub result_ref: String,
#[cultcache(key = 13)]
pub result_summary: String,
#[cultcache(key = 14)]
pub authority_gate: String,
#[cultcache(key = 15)]
pub private_state_exposed: bool,
#[cultcache(key = 16)]
pub notes: Vec<String>,
}
#[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 = "epiphany.cultmesh.bifrost_contract",
schema = "EpiphanyCultMeshBifrostContractEntry"
)]
pub struct EpiphanyCultMeshBifrostContractEntry {
#[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 = "gamecult.bifrost.body_change_publication_intent",
schema = "EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry"
)]
pub struct EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub intent_id: String,
#[cultcache(key = 2)]
pub source_cluster_id: String,
#[cultcache(key = 3)]
pub source_agent_id: String,
#[cultcache(key = 4)]
pub body_domain: String,
#[cultcache(key = 5)]
pub target_repository: String,
#[cultcache(key = 6)]
pub target_branch: String,
#[cultcache(key = 7)]
pub change_summary: String,
#[cultcache(key = 8)]
pub justification: String,
#[cultcache(key = 9)]
pub changed_paths: Vec<String>,
#[cultcache(key = 10)]
pub verification_receipt_ids: Vec<String>,
#[cultcache(key = 11)]
pub review_receipt_ids: Vec<String>,
#[cultcache(key = 12)]
pub authorship_agent_ids: Vec<String>,
#[cultcache(key = 13)]
pub credit_subjects: Vec<String>,
#[cultcache(key = 14)]
pub github_publication_requested: bool,
#[cultcache(key = 15)]
pub private_state_included: bool,
#[cultcache(key = 16)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.bifrost.body_change_publication_receipt",
schema = "EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry"
)]
pub struct EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub intent_id: String,
#[cultcache(key = 3)]
pub status: String,
#[cultcache(key = 4)]
pub bifrost_ledger_entry_id: String,
#[cultcache(key = 5)]
pub github_publication_receipt_id: String,
#[cultcache(key = 6)]
pub credit_receipt_ids: Vec<String>,
#[cultcache(key = 7)]
pub accepted_changed_paths: Vec<String>,
#[cultcache(key = 8)]
pub reviewer_ids: Vec<String>,
#[cultcache(key = 9)]
pub publication_url: String,
#[cultcache(key = 10)]
pub private_state_exposed: bool,
#[cultcache(key = 11)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.bifrost.github_publication_receipt",
schema = "EpiphanyCultMeshBifrostGithubPublicationReceiptEntry"
)]
pub struct EpiphanyCultMeshBifrostGithubPublicationReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub bifrost_publication_receipt_id: String,
#[cultcache(key = 3)]
pub hands_pr_receipt_id: String,
#[cultcache(key = 4)]
pub target_repository: String,
#[cultcache(key = 5)]
pub target_branch: String,
#[cultcache(key = 6)]
pub pull_request_url: String,
#[cultcache(key = 7)]
pub pull_request_number: String,
#[cultcache(key = 8)]
pub commit_sha: String,
#[cultcache(key = 9)]
pub changed_paths: Vec<String>,
#[cultcache(key = 10)]
pub ledger_entry_id: String,
#[cultcache(key = 11)]
pub credit_receipt_ids: Vec<String>,
#[cultcache(key = 12)]
pub published_by_agent_id: String,
#[cultcache(key = 13)]
pub publication_status: String,
#[cultcache(key = 14)]
pub private_state_exposed: bool,
#[cultcache(key = 15)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.bifrost.public_proof_publication_receipt",
schema = "EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry"
)]
pub struct EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub public_proof_id: String,
#[cultcache(key = 3)]
pub public_proof_ref: String,
#[cultcache(key = 4)]
pub public_proof_sha256: String,
#[cultcache(key = 5)]
pub item: String,
#[cultcache(key = 6)]
pub source_workspace: String,
#[cultcache(key = 7)]
pub source_branch: String,
#[cultcache(key = 8)]
pub target_public_verse_id: String,
#[cultcache(key = 9)]
pub public_room_id: String,
#[cultcache(key = 10)]
pub status: String,
#[cultcache(key = 11)]
pub bifrost_ledger_entry_id: String,
#[cultcache(key = 12)]
pub credit_receipt_ids: Vec<String>,
#[cultcache(key = 13)]
pub reviewer_ids: Vec<String>,
#[cultcache(key = 14)]
pub publication_url: String,
#[cultcache(key = 15)]
pub private_state_exposed: bool,
#[cultcache(key = 16)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.bifrost.artifact_acceptance_receipt",
schema = "EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry"
)]
pub struct EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub item: String,
#[cultcache(key = 3)]
pub source_workspace: String,
#[cultcache(key = 4)]
pub source_branch: String,
#[cultcache(key = 5)]
pub commit_sha: String,
#[cultcache(key = 6)]
pub changed_paths: Vec<String>,
#[cultcache(key = 7)]
pub artifact_ref: String,
#[cultcache(key = 8)]
pub public_proof_ref: String,
#[cultcache(key = 9)]
pub maintainer_review_receipt_ids: Vec<String>,
#[cultcache(key = 10)]
pub bifrost_ledger_entry_id: String,
#[cultcache(key = 11)]
pub status: String,
#[cultcache(key = 12)]
pub accepted_by: String,
#[cultcache(key = 13)]
pub private_state_exposed: bool,
#[cultcache(key = 14)]
pub notes: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(
type = "gamecult.bifrost.metrics_receipt",
schema = "EpiphanyCultMeshBifrostMetricsReceiptEntry"
)]
pub struct EpiphanyCultMeshBifrostMetricsReceiptEntry {
#[cultcache(key = 0)]
pub schema_version: String,
#[cultcache(key = 1)]
pub receipt_id: String,
#[cultcache(key = 2)]
pub item: String,
#[cultcache(key = 3)]
pub source_workspace: String,
#[cultcache(key = 4)]
pub source_branch: String,
#[cultcache(key = 5)]
pub artifact_acceptance_receipt_id: String,
#[cultcache(key = 6)]
pub model_spend_receipt_ids: Vec<String>,
#[cultcache(key = 7)]
pub review_load_receipt_ids: Vec<String>,
#[cultcache(key = 8)]
pub credit_readback_receipt_ids: Vec<String>,
#[cultcache(key = 9)]
pub public_proof_ref: String,
#[cultcache(key = 10)]
pub metrics_summary: String,
#[cultcache(key = 11)]
pub status: String,
#[cultcache(key = 12)]
pub private_state_exposed: bool,
#[cultcache(key = 13)]
pub notes: Vec<String>,
#[cultcache(key = 14)]
pub token_summary_ref: Option<String>,
#[cultcache(key = 15)]
pub cost_availability_status: Option<String>,
#[cultcache(key = 16)]
pub cost_summary_ref: Option<String>,
#[cultcache(key = 17)]
pub cost_unavailable_reason: Option<String>,
#[cultcache(key = 18)]
pub review_duration_ms: Option<u64>,
#[cultcache(key = 19)]
pub review_event_count: Option<u64>,
}
#[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 cluster_topology: Vec<EpiphanyCultMeshClusterTopologyEntry>,
pub odin_advertisements: Vec<EpiphanyCultMeshOdinAdvertisementEntry>,
pub eve_surface_states: Vec<EpiphanyCultMeshEveSurfaceStateEntry>,
pub daemon_statuses: Vec<EpiphanyCultMeshDaemonStatusEntry>,
pub latest_daemon_poke_intent: Option<EpiphanyCultMeshDaemonPokeIntentEntry>,
pub latest_daemon_poke_receipt: Option<EpiphanyCultMeshDaemonPokeReceiptEntry>,
pub daemon_restart_policies: Vec<EpiphanyCultMeshDaemonRestartPolicyEntry>,
pub latest_daemon_scheduler_receipt: Option<EpiphanyCultMeshDaemonSchedulerReceiptEntry>,
pub latest_daemon_service_lifecycle_receipt:
Option<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>,
pub latest_idunn_deployment_receipt: Option<EpiphanyCultMeshIdunnDeploymentReceiptEntry>,
pub latest_idunn_aftercare_audit_receipt:
Option<EpiphanyCultMeshIdunnAftercareAuditReceiptEntry>,
pub swarm_brake: Option<EpiphanyCultMeshSwarmBrakeEntry>,
pub latest_persona_speech_audit: Option<EpiphanyCultMeshPersonaSpeechAuditEntry>,
pub latest_weksa_lowering_receipt: Option<EpiphanyCultMeshWeksaLoweringReceiptEntry>,
pub daemon_tool_capabilities: Vec<EpiphanyCultMeshDaemonToolCapabilityEntry>,
pub latest_daemon_tool_invocation_intent:
Option<EpiphanyCultMeshDaemonToolInvocationIntentEntry>,
pub latest_daemon_tool_invocation_receipt:
Option<EpiphanyCultMeshDaemonToolInvocationReceiptEntry>,
pub arrival_latest_bifrost_body_change_publication_intent:
Option<EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry>,
pub arrival_latest_bifrost_body_change_publication_receipt:
Option<EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry>,
pub arrival_latest_bifrost_github_publication_receipt:
Option<EpiphanyCultMeshBifrostGithubPublicationReceiptEntry>,
pub arrival_latest_bifrost_public_proof_publication_receipt:
Option<EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry>,
pub latest_operator_snapshot: Option<EpiphanyCultMeshOperatorSnapshotEntry>,
pub latest_operator_run_intent: Option<EpiphanyCultMeshOperatorRunIntentEntry>,
pub latest_operator_run_receipt: Option<EpiphanyCultMeshOperatorRunReceiptEntry>,
pub latest_coordinator_run_receipt: Option<EpiphanyCultMeshCoordinatorRunReceiptEntry>,
pub latest_hands_action_gate: Option<EpiphanyCultMeshHandsActionGateEntry>,
pub latest_role_review_event: Option<EpiphanyCultMeshRoleReviewEventEntry>,
pub latest_work_loop_summary: Option<EpiphanyLocalVerseWorkLoopSummary>,
pub latest_agent_state_soa_summary: Option<EpiphanyCultMeshAgentStateSoaSummaryEntry>,
pub latest_repo_work_overview: Option<EpiphanyCultMeshRepoWorkOverviewEntry>,
pub latest_repo_work_map_entry: Option<EpiphanyCultMeshRepoWorkMapEntry>,
pub contract_summaries: Vec<EpiphanyLocalVerseContractSummary>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyLocalVerseWorkLoopSummary {
pub telemetry_id: String,
pub thread_id: String,
pub source_stage: String,
pub target_stages: Vec<String>,
pub hands_intent_id: String,
pub hands_review_id: String,
pub substrate_gate_grant_receipt_id: String,
pub hands_patch_receipt_id: String,
pub hands_command_receipt_id: String,
pub hands_commit_receipt_id: String,
pub commit_sha: String,
pub branch: String,
pub changed_path_count: usize,
pub source_ref_count: usize,
pub soul_receipt_ids: Vec<String>,
pub verification_assertion_count: usize,
pub summary: String,
pub sealed_preview_note: String,
}
#[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>,
}
cultmesh_documents!(EpiphanyCultMeshDocuments {
EpiphanyCultMeshStatusEntry => EPIPHANY_CULTMESH_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,
EpiphanyCultMeshCoordinatorRunReceiptEntry => EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshHandsActionGateEntry => EPIPHANY_CULTMESH_HANDS_ACTION_GATE_SCHEMA_VERSION,
EpiphanyCultMeshRoleReviewEventEntry => EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_SCHEMA_VERSION,
EpiphanyCultMeshWorkLoopTelemetryEntry => EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_SCHEMA_VERSION,
EpiphanyCultMeshAgentStateSoaSummaryEntry => EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_SCHEMA_VERSION,
EpiphanyCultMeshRepoWorkOverviewEntry => EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_SCHEMA_VERSION,
EpiphanyCultMeshRepoWorkReadinessEntry => EPIPHANY_CULTMESH_REPO_WORK_READINESS_SCHEMA_VERSION,
EpiphanyCultMeshRepoWorkMapEntry => EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_SCHEMA_VERSION,
EpiphanyCultMeshRepoWorkPublicProofEntry => EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_SCHEMA_VERSION,
EpiphanyCultMeshVersePolicyEntry => EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION,
EpiphanyCultMeshGlobalRoomPolicyEntry => EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION,
EpiphanyCultMeshClusterTopologyEntry => EPIPHANY_CULTMESH_CLUSTER_TOPOLOGY_SCHEMA_VERSION,
EpiphanyCultMeshOdinAdvertisementEntry => EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_SCHEMA_VERSION,
EpiphanyCultMeshEveSurfaceStateEntry => EPIPHANY_CULTMESH_EVE_SURFACE_STATE_SCHEMA_VERSION,
EpiphanyCultMeshDaemonStatusEntry => EPIPHANY_CULTMESH_DAEMON_STATUS_SCHEMA_VERSION,
EpiphanyCultMeshDaemonHeartbeatEventEntry => EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION,
EpiphanyCultMeshDaemonPokeIntentEntry => EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_SCHEMA_VERSION,
EpiphanyCultMeshDaemonPokeReceiptEntry => EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshDaemonRestartPolicyEntry => EPIPHANY_CULTMESH_DAEMON_RESTART_POLICY_SCHEMA_VERSION,
EpiphanyCultMeshDaemonSchedulerReceiptEntry => EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry => EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshManagedServicePolicyEntry => EPIPHANY_CULTMESH_MANAGED_SERVICE_POLICY_SCHEMA_VERSION,
WorkspaceCoverageManagedProcessLaunchEntry => WORKSPACE_COVERAGE_PROCESS_LAUNCH_SCHEMA_VERSION,
WorkspaceCoverageProcessEvidenceHead => WORKSPACE_COVERAGE_PROCESS_EVIDENCE_HEAD_SCHEMA_VERSION,
WorkspaceCoverageProviderHeartbeatEntry => WORKSPACE_COVERAGE_PROVIDER_HEARTBEAT_SCHEMA_VERSION,
WorkspaceCoverageProcessTerminationObservationEntry => WORKSPACE_COVERAGE_PROCESS_TERMINATION_SCHEMA_VERSION,
WorkspaceCoverageProjectionProgressEntry => WORKSPACE_COVERAGE_PROJECTION_PROGRESS_SCHEMA_VERSION,
WorkspaceCoverageAdvancementSightEntry => WORKSPACE_COVERAGE_ADVANCEMENT_SIGHT_SCHEMA_VERSION,
WorkspaceCoverageClaimSightEntry => WORKSPACE_COVERAGE_CLAIM_SIGHT_SCHEMA_VERSION,
WorkspaceCoverageRecoveryDirectiveEntry => WORKSPACE_COVERAGE_RECOVERY_DIRECTIVE_SCHEMA_VERSION,
WorkspaceCoverageTerminalSightEntry => WORKSPACE_COVERAGE_TERMINAL_SIGHT_SCHEMA_VERSION,
EpiphanyPackagedReleaseEntry => crate::packaged_release::EPIPHANY_PACKAGED_RELEASE_SCHEMA_VERSION,
EpiphanyPackagedReleaseHead => crate::packaged_release::EPIPHANY_PACKAGED_RELEASE_HEAD_SCHEMA_VERSION,
EpiphanyCultMeshIdunnDeploymentReceiptEntry => EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshIdunnAftercareAuditReceiptEntry => EPIPHANY_CULTMESH_IDUNN_AFTERCARE_AUDIT_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshSwarmBrakeEntry => EPIPHANY_CULTMESH_SWARM_BRAKE_SCHEMA_VERSION,
EpiphanyCultMeshPersonaSpeechAuditEntry => EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_SCHEMA_VERSION,
EpiphanyCultMeshWeksaLoweringReceiptEntry => EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshDaemonToolCapabilityEntry => EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_SCHEMA_VERSION,
EpiphanyCultMeshDaemonToolInvocationIntentEntry => EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_SCHEMA_VERSION,
EpiphanyCultMeshDaemonToolInvocationReceiptEntry => EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_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,
EpiphanyCultMeshBifrostContractEntry => EPIPHANY_CULTMESH_BIFROST_CONTRACT_SCHEMA_VERSION,
EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry => EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_SCHEMA_VERSION,
EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry => EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshBifrostGithubPublicationReceiptEntry => EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry => EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry => EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_SCHEMA_VERSION,
EpiphanyCultMeshBifrostMetricsReceiptEntry => EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_SCHEMA_VERSION,
crate::persona_feedback_admission::LocalAdmittedPersonaFeedback => crate::persona_feedback_admission::LOCAL_PERSONA_FEEDBACK_SCHEMA_VERSION,
EpiphanyCultMeshSemanticProjectionHealthEntry => EPIPHANY_CULTMESH_SEMANTIC_PROJECTION_HEALTH_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()
},
)
}
/// Removes the extinct ownerless operator-status projection from an existing
/// local Verse so the live schema catalog can open it again.
///
/// This is deliberately explicit migration, never implicit node bootstrap.
pub fn retire_epiphany_cultmesh_operator_status_documents(
store_path: impl AsRef<Path>,
) -> Result<Vec<String>> {
const RETIRED_TYPE: &str = "epiphany.cultmesh.operator_status";
let mut backing = SingleFileMessagePackBackingStore::new(store_path.as_ref());
let retired = backing
.pull_all()?
.into_iter()
.filter(|entry| entry.r#type == RETIRED_TYPE)
.collect::<Vec<_>>();
for entry in &retired {
backing.delete(entry)?;
}
Ok(retired.into_iter().map(|entry| entry.key).collect())
}
/// Removes centrally forged provider documents from the pre-provider-contract
/// era. Their v0 payloads carry no provider provenance, so retaining them as
/// live discovery state would let a dead coordinator impersonate providers.
pub fn retire_epiphany_cultmesh_legacy_provider_documents(
store_path: impl AsRef<Path>,
) -> Result<Vec<String>> {
const RETIRED_TYPES: [&str; 3] = [
EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_TYPE,
EPIPHANY_CULTMESH_EVE_SURFACE_STATE_TYPE,
EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_TYPE,
];
let mut backing = SingleFileMessagePackBackingStore::new(store_path.as_ref());
let retired = backing
.pull_all()?
.into_iter()
.filter(|entry| RETIRED_TYPES.contains(&entry.r#type.as_str()))
.collect::<Vec<_>>();
for entry in &retired {
backing.delete(entry)?;
}
Ok(retired.into_iter().map(|entry| entry.key).collect())
}
fn semantic_projection_health_scope_key(swarm_id: &str, partition: &str) -> String {
use sha2::{Digest, Sha256};
format!(
"gamecult-local/semantic-projection-health/{:x}",
Sha256::digest(format!("{swarm_id}|{partition}").as_bytes())
)
}
/// Publishes operator sight derived from authenticated canonical projection state.
///
/// This mirror is deliberately powerless: it neither creates work nor participates
/// in semantic-query admission. Callers must retain the canonical source store and
/// sealed input for either operation.
pub fn publish_epiphany_cultmesh_semantic_projection_health(
verse_store: impl AsRef<Path>,
runtime_id: impl Into<String>,
canonical_store: impl AsRef<Path>,
input: &crate::MemorySemanticProjectionInput,
provider_incarnation: &str,
) -> Result<EpiphanyCultMeshSemanticProjectionHealthEntry> {
let runtime_id = runtime_id.into();
if !bounded_opaque_health_id(&runtime_id) || !bounded_opaque_health_id(provider_incarnation) {
return Err(anyhow!(
"semantic projection health provider identity is required"
));
}
let observation = crate::observe_memory_semantic_projection(canonical_store, input)?;
let entry = EpiphanyCultMeshSemanticProjectionHealthEntry {
schema_version: EPIPHANY_CULTMESH_SEMANTIC_PROJECTION_HEALTH_SCHEMA_VERSION.to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
verse_tier: EPIPHANY_CULTMESH_LOCAL_AREA_TIER.to_string(),
swarm_id: observation.swarm_id,
partition: observation.partition,
obligation_id: observation.obligation_id,
source_generation: observation.source_generation,
canonical_model_hash: observation.canonical_model_hash,
canonical_content_set_hash: observation.canonical_content_set_hash,
status: observation.status,
receipt_id: observation.receipt_id,
indexed_document_count: observation.indexed_document_count,
vector_dimensions: observation.vector_dimensions,
observed_at: Utc::now().to_rfc3339(),
private_state_exposed: false,
provider_id: runtime_id.clone(),
provider_incarnation: provider_incarnation.to_string(),
observed_source_at: observation.observed_source_at,
authoritative: false,
query_eligible_display_only: observation.query_eligible_display_only,
};
validate_semantic_projection_health(&entry)?;
let scope_key = semantic_projection_health_scope_key(&entry.swarm_id, &entry.partition);
let latest_key = format!("{scope_key}/latest");
use sha2::{Digest, Sha256};
let event_key = format!(
"{scope_key}/event-{:x}",
Sha256::digest(
format!(
"{}|{}|{}|{}",
entry.obligation_id,
entry.status,
entry.receipt_id.as_deref().unwrap_or("none"),
entry.observed_at
)
.as_bytes()
)
);
let node = open_epiphany_cultmesh_node(&verse_store, runtime_id)?;
let backing = SingleFileMessagePackBackingStore::new(verse_store.as_ref());
for _ in 0..8 {
let opening = backing.pull_all()?;
let latest_envelope = opening.iter().find(|row| {
row.r#type == EPIPHANY_CULTMESH_SEMANTIC_PROJECTION_HEALTH_TYPE && row.key == latest_key
});
let latest = latest_envelope
.map(|row| {
rmp_serde::from_slice::<EpiphanyCultMeshSemanticProjectionHealthEntry>(&row.payload)
})
.transpose()?;
if let Some(latest) = &latest {
validate_semantic_projection_health(latest)?;
let latest_time = DateTime::parse_from_rfc3339(&latest.observed_source_at)?;
let entry_time = DateTime::parse_from_rfc3339(&entry.observed_source_at)?;
if latest.source_generation == entry.source_generation
&& latest.obligation_id != entry.obligation_id
{
return Err(anyhow!(
"semantic projection health generation has conflicting canonical obligations"
));
}
if latest.source_generation > entry.source_generation
|| (latest.source_generation == entry.source_generation && latest_time > entry_time)
{
return Ok(latest.clone());
}
}
let event = node.cache().prepare_entry(&event_key, &entry)?.0;
let latest_replacement = node.cache().prepare_entry(&latest_key, &entry)?.0;
let expected = latest_envelope.cloned().into_iter().collect::<Vec<_>>();
if backing.compare_and_swap_batch(&expected, vec![event, latest_replacement])? {
return Ok(entry);
}
}
Err(anyhow!(
"semantic projection health latest advanced during publication"
))
}
pub fn load_epiphany_cultmesh_semantic_projection_health(
verse_store: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshSemanticProjectionHealthEntry>> {
let node = open_epiphany_cultmesh_node(verse_store, runtime_id)?;
let mut rows = node
.get_all_with_keys::<EpiphanyCultMeshSemanticProjectionHealthEntry>()?
.into_iter()
.filter(|(key, _)| key.ends_with("/latest"))
.map(|(key, row)| {
let expected_key = format!(
"{}/latest",
semantic_projection_health_scope_key(&row.swarm_id, &row.partition)
);
if key != expected_key {
return Err(anyhow!(
"semantic projection health latest key does not match its declared scope"
));
}
Ok(row)
})
.collect::<Result<Vec<_>>>()?;
for row in &rows {
validate_semantic_projection_health(row)?;
}
rows.sort_by(|left, right| {
left.swarm_id
.cmp(&right.swarm_id)
.then(left.partition.cmp(&right.partition))
});
Ok(rows)
}
fn validate_semantic_projection_health(
row: &EpiphanyCultMeshSemanticProjectionHealthEntry,
) -> Result<()> {
if row.schema_version != EPIPHANY_CULTMESH_SEMANTIC_PROJECTION_HEALTH_SCHEMA_VERSION
|| row.verse_id != EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID
|| row.verse_tier != EPIPHANY_CULTMESH_LOCAL_AREA_TIER
|| row.swarm_id.trim().is_empty()
|| !matches!(row.partition.as_str(), "mind" | "modeling")
|| row.obligation_id.trim().is_empty()
|| row.canonical_model_hash.trim().is_empty()
|| row.canonical_content_set_hash.trim().is_empty()
|| !matches!(row.status.as_str(), "pending" | "failed" | "ready")
|| DateTime::parse_from_rfc3339(&row.observed_at).is_err()
|| DateTime::parse_from_rfc3339(&row.observed_source_at).is_err()
|| row.private_state_exposed
|| !bounded_opaque_health_id(&row.provider_id)
|| !bounded_opaque_health_id(&row.provider_incarnation)
|| row.authoritative
{
return Err(anyhow!("semantic projection health mirror is invalid"));
}
let has_receipt = row.receipt_id.is_some()
&& row.indexed_document_count.is_some()
&& row.vector_dimensions.is_some();
if row.query_eligible_display_only != (row.status == "ready")
|| has_receipt != (row.status == "ready")
{
return Err(anyhow!(
"semantic projection health evidence shape is invalid"
));
}
Ok(())
}
fn bounded_opaque_health_id(value: &str) -> bool {
!value.is_empty()
&& value.len() <= 128
&& value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-' | b':'))
}
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 store_path = store_path.as_ref();
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_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 snapshot_status = if state_status == "missing" || crrc_action == "regatherManually" {
"needs-regather"
} 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: snapshot_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: 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 is an external edge adapter for this source until the status surface is native end to end; it is not CultMesh transport authority.".to_string(),
],
})
}
#[cfg(test)]
pub fn epiphany_cultmesh_daemon_tool_invocation_from_status_json(
requesting_cluster_id: impl Into<String>,
status_path: impl Into<String>,
status_json: &Value,
) -> Result<
Option<(
EpiphanyCultMeshDaemonToolInvocationIntentEntry,
Option<EpiphanyCultMeshDaemonToolInvocationReceiptEntry>,
)>,
> {
let requesting_cluster_id = requesting_cluster_id.into();
let status_path = status_path.into();
let Some((index, invocation)) = status_json
.pointer("/tools/invocations")
.and_then(Value::as_array)
.and_then(|items| items.iter().enumerate().next_back())
else {
return Ok(None);
};
let intent_id = pointer_text(invocation, "/intentId", "");
if intent_id.trim().is_empty() {
return Ok(None);
}
let adapter = pointer_text(invocation, "/adapter", "epiphany-tool-adapter");
let server = pointer_text(invocation, "/server", "unknown-server");
let tool_name = pointer_text(invocation, "/toolName", "");
let status = pointer_text(invocation, "/status", "pending");
let intent = EpiphanyCultMeshDaemonToolInvocationIntentEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_SCHEMA_VERSION
.to_string(),
intent_id: intent_id.clone(),
requesting_agent_id: pointer_text(invocation, "/caller", "unknown-caller"),
requesting_cluster_id,
capability_id: format!("runtime-spine/{adapter}/{server}/{tool_name}"),
host_cluster_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
host_daemon_id: format!("{adapter}:{server}"),
eve_surface_id: "epiphany-local/tools".to_string(),
tool_name: tool_name.clone(),
operation: "runtimeToolInvocation".to_string(),
input_contract_type: "epiphany.tool_invocation_intent.v0".to_string(),
payload_ref: format!("{status_path}#/tools/invocations/{index}"),
payload_summary: pointer_text(invocation, "/reason", ""),
authority_gate: "epiphany-tool-adapter".to_string(),
requires_receipt: true,
private_state_requested: false,
notes: vec![
"Mirror of the operator-safe native status tool invocation surface; runtime-spine tool intent remains the lifecycle owner.".to_string(),
"Raw MCP JSON stays quarantined behind epiphany.tool_invocation_intent.v0 / receipt documents.".to_string(),
],
};
validate_daemon_tool_invocation_intent(&intent)?;
let receipt = invocation
.pointer("/receiptId")
.and_then(Value::as_str)
.filter(|receipt_id| !receipt_id.trim().is_empty())
.map(|receipt_id| {
let receipt = EpiphanyCultMeshDaemonToolInvocationReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: receipt_id.to_string(),
intent_id: intent.intent_id.clone(),
requesting_agent_id: intent.requesting_agent_id.clone(),
requesting_cluster_id: intent.requesting_cluster_id.clone(),
capability_id: intent.capability_id.clone(),
host_cluster_id: intent.host_cluster_id.clone(),
host_daemon_id: intent.host_daemon_id.clone(),
tool_name: intent.tool_name.clone(),
operation: intent.operation.clone(),
status: status.clone(),
receipt_contract_type: "epiphany.tool_invocation_receipt.v0".to_string(),
result_ref: format!("runtime-spine://tool-invocation-receipts/{receipt_id}"),
result_summary: pointer_text(invocation, "/error", ""),
authority_gate: intent.authority_gate.clone(),
private_state_exposed: false,
notes: vec![
"Mirror of the runtime-spine tool invocation receipt status; runtime-spine remains the receipt owner.".to_string(),
"This local Verse receipt exposes routing/status only, not private tool payloads or raw MCP cargo.".to_string(),
],
};
validate_daemon_tool_invocation_receipt(&receipt)?;
Ok::<EpiphanyCultMeshDaemonToolInvocationReceiptEntry, anyhow::Error>(receipt)
})
.transpose()?;
Ok(Some((intent, receipt)))
}
pub fn write_epiphany_cultmesh_operator_snapshot(
store_path: impl AsRef<Path>,
snapshot: EpiphanyCultMeshOperatorSnapshotEntry,
) -> Result<EpiphanyCultMeshOperatorSnapshotEntry> {
validate_operator_snapshot(&snapshot)?;
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)?;
let current_latest = node.get::<EpiphanyCultMeshOperatorSnapshotEntry>(
EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
operator_snapshot_generation_key(&written) >= operator_snapshot_generation_key(current)
}) {
node.put(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_LATEST_KEY, &written)?;
}
node.flush()?;
Ok(written)
}
fn validate_operator_snapshot(snapshot: &EpiphanyCultMeshOperatorSnapshotEntry) -> Result<()> {
if snapshot.schema_version != EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_SCHEMA_VERSION {
return Err(anyhow!("operator snapshot has unsupported schema version"));
}
if snapshot.verse_id != EPIPHANY_CULTMESH_INTERNAL_VERSE_ID {
return Err(anyhow!(
"operator snapshot must remain in the internal Verse"
));
}
for (label, value) in [
("runtime id", snapshot.runtime_id.as_str()),
("snapshot id", snapshot.snapshot_id.as_str()),
("source mode", snapshot.source_mode.as_str()),
("source path", snapshot.source_path.as_str()),
("status", snapshot.status.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("operator snapshot missing {label}"));
}
}
DateTime::parse_from_rfc3339(&snapshot.generated_at_utc)
.map_err(|error| anyhow!("operator snapshot has invalid generated_at_utc: {error}"))?;
Ok(())
}
fn operator_snapshot_generation_key(
snapshot: &EpiphanyCultMeshOperatorSnapshotEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&snapshot.generated_at_utc)
.expect("validated operator snapshot generation timestamp"),
snapshot.snapshot_id.as_str(),
)
}
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> {
validate_operator_run_intent(&intent)?;
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)?;
let current_latest = node.get::<EpiphanyCultMeshOperatorRunIntentEntry>(
EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
operator_run_intent_event_key(&written) >= operator_run_intent_event_key(current)
}) {
node.put(EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_LATEST_KEY, &written)?;
}
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_operator_run_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
run_id: &str,
) -> Result<Option<EpiphanyCultMeshOperatorRunIntentEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(epiphany_cultmesh_operator_run_intent_key(run_id).as_str())
}
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> {
validate_operator_run_receipt(&receipt)?;
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)?;
let current_latest = node.get::<EpiphanyCultMeshOperatorRunReceiptEntry>(
EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
operator_run_receipt_event_key(&written) >= operator_run_receipt_event_key(current)
}) {
node.put(EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_LATEST_KEY, &written)?;
}
node.flush()?;
Ok(written)
}
fn validate_operator_run_intent(intent: &EpiphanyCultMeshOperatorRunIntentEntry) -> Result<()> {
if intent.schema_version != EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION {
return Err(anyhow!(
"operator run intent has unsupported schema version"
));
}
if intent.verse_id != EPIPHANY_CULTMESH_INTERNAL_VERSE_ID {
return Err(anyhow!(
"operator run intent must remain in the internal Verse"
));
}
for (label, value) in [
("runtime id", intent.runtime_id.as_str()),
("run id", intent.run_id.as_str()),
("mode", intent.mode.as_str()),
("root", intent.root.as_str()),
("workspace", intent.workspace.as_str()),
("artifact root", intent.artifact_root.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("operator run intent missing {label}"));
}
}
DateTime::parse_from_rfc3339(&intent.requested_at_utc)
.map_err(|error| anyhow!("operator run intent has invalid requested_at_utc: {error}"))?;
Ok(())
}
fn validate_operator_run_receipt(receipt: &EpiphanyCultMeshOperatorRunReceiptEntry) -> Result<()> {
if receipt.schema_version != EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION {
return Err(anyhow!(
"operator run receipt has unsupported schema version"
));
}
if receipt.verse_id != EPIPHANY_CULTMESH_INTERNAL_VERSE_ID {
return Err(anyhow!(
"operator run receipt must remain in the internal Verse"
));
}
for (label, value) in [
("runtime id", receipt.runtime_id.as_str()),
("run id", receipt.run_id.as_str()),
("mode", receipt.mode.as_str()),
("status", receipt.status.as_str()),
("result path", receipt.result_path.as_str()),
("artifact root", receipt.artifact_root.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("operator run receipt missing {label}"));
}
}
DateTime::parse_from_rfc3339(&receipt.completed_at_utc)
.map_err(|error| anyhow!("operator run receipt has invalid completed_at_utc: {error}"))?;
Ok(())
}
fn operator_run_intent_event_key(
intent: &EpiphanyCultMeshOperatorRunIntentEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&intent.requested_at_utc)
.expect("validated operator run intent timestamp"),
intent.run_id.as_str(),
)
}
fn operator_run_receipt_event_key(
receipt: &EpiphanyCultMeshOperatorRunReceiptEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&receipt.completed_at_utc)
.expect("validated operator run receipt timestamp"),
receipt.run_id.as_str(),
)
}
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 load_epiphany_cultmesh_operator_run_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
run_id: &str,
) -> Result<Option<EpiphanyCultMeshOperatorRunReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(epiphany_cultmesh_operator_run_receipt_key(run_id).as_str())
}
pub fn epiphany_cultmesh_coordinator_run_receipt_from_summary_json(
runtime_id: impl Into<String>,
receipt_id: impl Into<String>,
created_at_utc: impl Into<String>,
artifact_root: impl Into<String>,
summary_json: &Value,
) -> Result<EpiphanyCultMeshCoordinatorRunReceiptEntry> {
let artifact_root = artifact_root.into();
let artifact_refs = pointer_string_array(summary_json, "/artifactManifest")?;
let sealed_artifact_refs = summary_json
.pointer("/sealedArtifactManifest")
.and_then(Value::as_array)
.map(|items| {
items
.iter()
.filter_map(|item| {
item.get("path")
.and_then(Value::as_str)
.or_else(|| item.as_str())
.map(str::to_string)
})
.collect::<Vec<_>>()
})
.unwrap_or_default();
let step_count = summary_json
.pointer("/steps")
.and_then(Value::as_array)
.map_or(0, |items| items.len() as u64);
let receipt = EpiphanyCultMeshCoordinatorRunReceiptEntry {
schema_version: EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.into(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
receipt_id: receipt_id.into(),
source_document_type: pointer_text(
summary_json,
"/coordinatorRunReceipt/documentType",
"epiphany.coordinator_run_receipt.v0",
),
source_receipt_id: pointer_text(summary_json, "/coordinatorRunReceipt/receiptId", ""),
source_store: pointer_text(summary_json, "/coordinatorRunReceipt/store", ""),
thread_id: pointer_text(summary_json, "/threadId", ""),
mode: pointer_text(summary_json, "/mode", ""),
status: pointer_text(summary_json, "/finalAction/action", ""),
final_action: pointer_text(summary_json, "/finalAction/action", ""),
final_reason: pointer_text(summary_json, "/finalAction/reason", ""),
step_count,
artifact_root,
artifact_refs,
sealed_artifact_refs,
created_at_utc: created_at_utc.into(),
private_state_exposed: false,
notes: vec![
"CultMesh mirror of the runtime-spine coordinator receipt; runtime-spine remains the lifecycle owner.".to_string(),
"Coordinator JSON artifacts are display/audit evidence; sealed transcript and stderr paths are referenced but not opened here.".to_string(),
],
};
validate_coordinator_run_receipt(&receipt)?;
Ok(receipt)
}
pub fn write_epiphany_cultmesh_coordinator_run_receipt(
store_path: impl AsRef<Path>,
receipt: EpiphanyCultMeshCoordinatorRunReceiptEntry,
) -> Result<EpiphanyCultMeshCoordinatorRunReceiptEntry> {
validate_coordinator_run_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(&store_path, receipt.runtime_id.clone())?;
let receipt_key = epiphany_cultmesh_coordinator_run_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
let current_latest = node.get::<EpiphanyCultMeshCoordinatorRunReceiptEntry>(
EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
coordinator_run_receipt_event_key(&written) >= coordinator_run_receipt_event_key(current)
}) {
node.put(
EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_LATEST_KEY,
&written,
)?;
}
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_coordinator_run_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshCoordinatorRunReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_LATEST_KEY)
}
pub fn epiphany_cultmesh_hands_action_gate_from_summary_json(
runtime_id: impl Into<String>,
created_at_utc: impl Into<String>,
source_summary_path: impl Into<String>,
summary_json: &Value,
) -> Result<Option<EpiphanyCultMeshHandsActionGateEntry>> {
let Some(gate_json) = summary_json.pointer("/finalAction/handsActionGate") else {
return Ok(None);
};
let hands_intent_id = pointer_text(gate_json, "/intentId", "");
let hands_review_id = pointer_text(gate_json, "/reviewId", "");
let gate = EpiphanyCultMeshHandsActionGateEntry {
schema_version: EPIPHANY_CULTMESH_HANDS_ACTION_GATE_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.into(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
gate_id: format!("{hands_intent_id}:{hands_review_id}"),
source_coordinator_receipt_id: pointer_text(
summary_json,
"/coordinatorRunReceipt/receiptId",
"",
),
source_summary_path: source_summary_path.into(),
thread_id: pointer_text(summary_json, "/threadId", ""),
mode: pointer_text(summary_json, "/mode", ""),
status: pointer_text(gate_json, "/status", ""),
hands_intent_id,
hands_review_id,
substrate_gate_grant_receipt_id: pointer_text(
gate_json,
"/substrateGateGrantReceiptId",
"",
),
runtime_job_id: pointer_text(gate_json, "/runtimeJobId", ""),
requested_paths: pointer_string_array(gate_json, "/requestedPaths")?,
required_receipts: pointer_string_array(gate_json, "/requiredReceipts")?,
record_pass_executable: pointer_text(gate_json, "/recordPassCommand/executable", ""),
record_pass_args: pointer_string_array(gate_json, "/recordPassCommand/args")?,
created_at_utc: created_at_utc.into(),
private_state_exposed: false,
notes: vec![
"CultMesh mirror of the coordinator Hands action gate; runtime-spine Hands/Substrate Gate receipts remain the action owners.".to_string(),
"The record-pass command is an operator hint only; this mirror cannot approve, execute, or mutate the repo.".to_string(),
],
};
validate_hands_action_gate(&gate)?;
Ok(Some(gate))
}
pub fn write_epiphany_cultmesh_hands_action_gate(
store_path: impl AsRef<Path>,
gate: EpiphanyCultMeshHandsActionGateEntry,
) -> Result<EpiphanyCultMeshHandsActionGateEntry> {
validate_hands_action_gate(&gate)?;
let mut node = open_epiphany_cultmesh_node(&store_path, gate.runtime_id.clone())?;
let gate_key = epiphany_cultmesh_hands_action_gate_key(&gate.gate_id);
let written = node.put(gate_key.as_str(), &gate)?;
let current_latest = node.get::<EpiphanyCultMeshHandsActionGateEntry>(
EPIPHANY_CULTMESH_HANDS_ACTION_GATE_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
hands_action_gate_event_key(&written) >= hands_action_gate_event_key(current)
}) {
node.put(EPIPHANY_CULTMESH_HANDS_ACTION_GATE_LATEST_KEY, &written)?;
}
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_hands_action_gate(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshHandsActionGateEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_HANDS_ACTION_GATE_LATEST_KEY)
}
pub fn epiphany_cultmesh_role_review_event_from_summary_json(
runtime_id: impl Into<String>,
created_at_utc: impl Into<String>,
source_summary_path: impl Into<String>,
summary_json: &Value,
) -> Result<Option<EpiphanyCultMeshRoleReviewEventEntry>> {
let Some(event_json) = latest_role_review_event_json(summary_json) else {
return Ok(None);
};
let surface = pointer_text(event_json, "/type", "");
let role_id = pointer_text(event_json, "/roleId", "");
let acceptance = event_json
.pointer("/accepted/receipt")
.or_else(|| event_json.pointer("/accepted/acceptanceReceipt"))
.or_else(|| event_json.pointer("/superseded/patch/acceptanceReceipts/0"))
.or_else(|| event_json.pointer("/superseded/update/acceptanceReceipts/0"))
.or_else(|| event_json.pointer("/superseded/acceptanceReceipts/0"));
let review_status = acceptance
.map(|value| pointer_text(value, "/status", ""))
.filter(|value| !value.trim().is_empty())
.unwrap_or_else(|| {
if surface == "roleFailureReview" {
"superseded".to_string()
} else {
"accepted".to_string()
}
});
let acceptance_receipt_id = acceptance
.map(|value| pointer_text(value, "/id", ""))
.unwrap_or_default();
let runtime_result_id = acceptance
.map(|value| pointer_text(value, "/result_id", ""))
.filter(|value| !value.trim().is_empty())
.or_else(|| {
acceptance
.map(|value| pointer_text(value, "/resultId", ""))
.filter(|value| !value.trim().is_empty())
})
.unwrap_or_default();
let runtime_job_id = acceptance
.map(|value| pointer_text(value, "/job_id", ""))
.filter(|value| !value.trim().is_empty())
.or_else(|| {
acceptance
.map(|value| pointer_text(value, "/jobId", ""))
.filter(|value| !value.trim().is_empty())
})
.unwrap_or_default();
let binding_id = acceptance
.map(|value| pointer_text(value, "/binding_id", ""))
.filter(|value| !value.trim().is_empty())
.or_else(|| {
acceptance
.map(|value| pointer_text(value, "/bindingId", ""))
.filter(|value| !value.trim().is_empty())
})
.unwrap_or_default();
let summary = acceptance
.map(|value| pointer_text(value, "/summary", ""))
.filter(|value| !value.trim().is_empty())
.or_else(|| {
event_json
.pointer("/accepted/note")
.and_then(Value::as_str)
.map(str::to_string)
})
.or_else(|| {
event_json
.pointer("/superseded/note")
.and_then(Value::as_str)
.map(str::to_string)
})
.unwrap_or_default();
let event = EpiphanyCultMeshRoleReviewEventEntry {
schema_version: EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.into(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
event_id: format!("{surface}:{role_id}:{review_status}"),
source_coordinator_receipt_id: pointer_text(
summary_json,
"/coordinatorRunReceipt/receiptId",
"",
),
source_summary_path: source_summary_path.into(),
thread_id: pointer_text(summary_json, "/threadId", ""),
mode: pointer_text(summary_json, "/mode", ""),
surface,
role_id,
review_status,
acceptance_receipt_id,
runtime_result_id,
runtime_job_id,
binding_id,
summary,
created_at_utc: created_at_utc.into(),
private_state_exposed: false,
notes: vec![
"CultMesh mirror of the latest coordinator role review event; thread-state acceptance receipts remain the review owner.".to_string(),
"This mirror is for operator discovery/readback only and cannot accept, supersede, or relaunch a lane.".to_string(),
],
};
validate_role_review_event(&event)?;
Ok(Some(event))
}
pub fn write_epiphany_cultmesh_role_review_event(
store_path: impl AsRef<Path>,
event: EpiphanyCultMeshRoleReviewEventEntry,
) -> Result<EpiphanyCultMeshRoleReviewEventEntry> {
validate_role_review_event(&event)?;
let mut node = open_epiphany_cultmesh_node(&store_path, event.runtime_id.clone())?;
let event_key = epiphany_cultmesh_role_review_event_key(&event.event_id);
let written = node.put(event_key.as_str(), &event)?;
let current_latest = node.get::<EpiphanyCultMeshRoleReviewEventEntry>(
EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_LATEST_KEY,
)?;
if current_latest
.as_ref()
.is_none_or(|current| role_review_event_key(&written) >= role_review_event_key(current))
{
node.put(EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_LATEST_KEY, &written)?;
}
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_role_review_event(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshRoleReviewEventEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_LATEST_KEY)
}
fn validate_coordinator_run_receipt(
receipt: &EpiphanyCultMeshCoordinatorRunReceiptEntry,
) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"coordinator run CultMesh receipts must not expose private state"
));
}
for (label, value) in [
("receipt id", receipt.receipt_id.as_str()),
("source receipt id", receipt.source_receipt_id.as_str()),
("source store", receipt.source_store.as_str()),
("thread id", receipt.thread_id.as_str()),
("mode", receipt.mode.as_str()),
("final action", receipt.final_action.as_str()),
("created at", receipt.created_at_utc.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("coordinator run CultMesh receipt missing {label}"));
}
}
if receipt
.sealed_artifact_refs
.iter()
.any(|path| path.trim().is_empty())
{
return Err(anyhow!(
"coordinator run CultMesh receipt has an empty sealed artifact ref"
));
}
DateTime::parse_from_rfc3339(&receipt.created_at_utc).map_err(|error| {
anyhow!("coordinator run CultMesh receipt has invalid created at: {error}")
})?;
Ok(())
}
fn coordinator_run_receipt_event_key(
receipt: &EpiphanyCultMeshCoordinatorRunReceiptEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&receipt.created_at_utc)
.expect("validated coordinator run receipt timestamp"),
receipt.receipt_id.as_str(),
)
}
fn validate_hands_action_gate(gate: &EpiphanyCultMeshHandsActionGateEntry) -> Result<()> {
if gate.private_state_exposed {
return Err(anyhow!(
"Hands action gate CultMesh mirrors must not expose private state"
));
}
for (label, value) in [
("gate id", gate.gate_id.as_str()),
(
"source coordinator receipt id",
gate.source_coordinator_receipt_id.as_str(),
),
("source summary path", gate.source_summary_path.as_str()),
("thread id", gate.thread_id.as_str()),
("mode", gate.mode.as_str()),
("status", gate.status.as_str()),
("Hands intent id", gate.hands_intent_id.as_str()),
("Hands review id", gate.hands_review_id.as_str()),
(
"Substrate Gate grant receipt id",
gate.substrate_gate_grant_receipt_id.as_str(),
),
("created at", gate.created_at_utc.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("Hands action gate CultMesh mirror missing {label}"));
}
}
if gate.required_receipts.is_empty() {
return Err(anyhow!(
"Hands action gate CultMesh mirror missing required receipts"
));
}
if gate
.requested_paths
.iter()
.any(|path| path.trim().is_empty())
|| gate
.required_receipts
.iter()
.any(|receipt| receipt.trim().is_empty())
|| gate
.record_pass_args
.iter()
.any(|arg| arg.trim().is_empty())
{
return Err(anyhow!(
"Hands action gate CultMesh mirror has an empty path, receipt, or command argument"
));
}
DateTime::parse_from_rfc3339(&gate.created_at_utc).map_err(|error| {
anyhow!("Hands action gate CultMesh mirror has invalid created at: {error}")
})?;
Ok(())
}
fn hands_action_gate_event_key(
gate: &EpiphanyCultMeshHandsActionGateEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&gate.created_at_utc)
.expect("validated Hands action gate timestamp"),
gate.gate_id.as_str(),
)
}
fn validate_role_review_event(event: &EpiphanyCultMeshRoleReviewEventEntry) -> Result<()> {
if event.private_state_exposed {
return Err(anyhow!(
"role review CultMesh mirrors must not expose private state"
));
}
if !matches!(event.surface.as_str(), "roleAccept" | "roleFailureReview") {
return Err(anyhow!(
"role review CultMesh mirror has unsupported surface {:?}",
event.surface
));
}
for (label, value) in [
("event id", event.event_id.as_str()),
(
"source coordinator receipt id",
event.source_coordinator_receipt_id.as_str(),
),
("source summary path", event.source_summary_path.as_str()),
("thread id", event.thread_id.as_str()),
("mode", event.mode.as_str()),
("role id", event.role_id.as_str()),
("review status", event.review_status.as_str()),
("created at", event.created_at_utc.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("role review CultMesh mirror missing {label}"));
}
}
DateTime::parse_from_rfc3339(&event.created_at_utc)
.map_err(|error| anyhow!("role review CultMesh mirror has invalid created at: {error}"))?;
Ok(())
}
fn role_review_event_key(
event: &EpiphanyCultMeshRoleReviewEventEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&event.created_at_utc)
.expect("validated role review event timestamp"),
event.event_id.as_str(),
)
}
fn latest_role_review_event_json(summary_json: &Value) -> Option<&Value> {
let steps = summary_json.pointer("/steps")?.as_array()?;
steps.iter().rev().find_map(|step| {
step.pointer("/events")
.and_then(Value::as_array)?
.iter()
.rev()
.find(|event| {
matches!(
event.pointer("/type").and_then(Value::as_str),
Some("roleAccept" | "roleFailureReview")
)
})
})
}
pub fn epiphany_cultmesh_daemon_poke_intent_from_status(
intent_id: impl Into<String>,
requesting_agent_id: impl Into<String>,
status: &EpiphanyCultMeshDaemonStatusEntry,
reason: impl Into<String>,
) -> EpiphanyCultMeshDaemonPokeIntentEntry {
let requested_at_utc = Utc::now().to_rfc3339();
EpiphanyCultMeshDaemonPokeIntentEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_SCHEMA_VERSION.to_string(),
intent_id: intent_id.into(),
requesting_agent_id: requesting_agent_id.into(),
target_daemon_id: status.daemon_id.clone(),
target_cluster_id: status.cluster_id.clone(),
daemon_surface_id: status.daemon_surface_id.clone(),
eve_surface_id: status.eve_surface_id.clone(),
reason: reason.into(),
requested_action: "pokeDaemon".to_string(),
observed_status: status.status.clone(),
private_state_requested: false,
notes: vec![
"Daemon poke intent is an operator-safe lifecycle action request, not a private Verse inspection.".to_string(),
"The target daemon owns the resulting status; this intent only records the requested poke.".to_string(),
],
observed_last_heartbeat_utc: status.last_heartbeat_utc.clone(),
requested_at_utc,
}
}
pub fn epiphany_cultmesh_daemon_poke_receipt_for_intent(
receipt_id: impl Into<String>,
intent: &EpiphanyCultMeshDaemonPokeIntentEntry,
status: impl Into<String>,
resulting_status: impl Into<String>,
operator_artifact_ref: impl Into<String>,
) -> EpiphanyCultMeshDaemonPokeReceiptEntry {
let completed_at_utc = Utc::now().to_rfc3339();
EpiphanyCultMeshDaemonPokeReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: receipt_id.into(),
intent_id: intent.intent_id.clone(),
target_daemon_id: intent.target_daemon_id.clone(),
target_cluster_id: intent.target_cluster_id.clone(),
action_taken: intent.requested_action.clone(),
status: status.into(),
resulting_status: resulting_status.into(),
operator_artifact_ref: operator_artifact_ref.into(),
private_state_exposed: false,
notes: vec![
"Daemon poke receipt records lifecycle intervention proof without exposing private daemon state.".to_string(),
"Follow-up daemon status documents remain the liveness authority.".to_string(),
],
attempted_at_utc: intent.requested_at_utc.clone(),
completed_at_utc,
}
}
pub fn write_epiphany_cultmesh_daemon_poke_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
intent: EpiphanyCultMeshDaemonPokeIntentEntry,
) -> Result<EpiphanyCultMeshDaemonPokeIntentEntry> {
validate_daemon_poke_intent(&intent)?;
let store_path = store_path.as_ref();
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let intent_key = epiphany_cultmesh_daemon_poke_intent_key(&intent.intent_id);
put_immutable_cultmesh_entry_and_advance_latest(
&node,
store_path,
&intent_key,
EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_LATEST_KEY,
&intent,
|entry| &entry.requested_at_utc,
)
}
pub fn write_epiphany_cultmesh_daemon_poke_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshDaemonPokeReceiptEntry,
) -> Result<EpiphanyCultMeshDaemonPokeReceiptEntry> {
validate_daemon_poke_receipt(&receipt)?;
let store_path = store_path.as_ref();
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key = epiphany_cultmesh_daemon_poke_receipt_key(&receipt.receipt_id);
put_immutable_cultmesh_entry_and_advance_latest(
&node,
store_path,
&receipt_key,
EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_LATEST_KEY,
&receipt,
|entry| &entry.completed_at_utc,
)
}
fn put_immutable_cultmesh_entry_and_advance_latest<T, F>(
node: &CultMeshNode,
store_path: &Path,
identity_key: &str,
latest_key: &str,
value: &T,
event_time: F,
) -> Result<T>
where
T: DatabaseEntry + Clone + PartialEq,
F: Fn(&T) -> &str,
{
let existing = node.get::<T>(identity_key)?;
if existing.as_ref().is_some_and(|current| current != value) {
return Err(anyhow!(
"immutable CultMesh identity collision for type {:?} key {:?}",
T::TYPE,
identity_key
));
}
let candidate_time = DateTime::parse_from_rfc3339(event_time(value))
.context("immutable CultMesh event requires RFC3339 ordering time")?;
let latest = node.get::<T>(latest_key)?;
let advances_latest = match latest.as_ref() {
Some(current) => {
candidate_time
> DateTime::parse_from_rfc3339(event_time(current))
.context("persisted immutable CultMesh event has invalid ordering time")?
}
None => true,
};
if existing.is_some() && !advances_latest {
return Ok(existing.expect("existing checked"));
}
let mut expected = Vec::new();
if advances_latest && let Some(envelope) = node.cache().get_envelope::<T>(latest_key)? {
expected.push(envelope);
}
let mut replacements = Vec::new();
if existing.is_none() {
replacements.push(node.cache().prepare_entry(identity_key, value)?.0);
}
if advances_latest {
replacements.push(node.cache().prepare_entry(latest_key, value)?.0);
}
let backing = SingleFileMessagePackBackingStore::new(store_path);
if backing.compare_and_swap_batch(&expected, replacements)? {
return Ok(value.clone());
}
let refreshed = open_epiphany_cultmesh_node(store_path, node.runtime_id())?;
match refreshed.get::<T>(identity_key)? {
Some(current)
if current == *value
&& refreshed
.get::<T>(latest_key)?
.as_ref()
.is_some_and(|latest| {
DateTime::parse_from_rfc3339(event_time(latest)).ok()
>= Some(candidate_time)
}) =>
{
Ok(current)
}
Some(_) => Err(anyhow!(
"immutable CultMesh identity collision for type {:?} key {:?}",
T::TYPE,
identity_key
)),
None => Err(anyhow!(
"immutable CultMesh write lost compare-and-swap for type {:?} key {:?}",
T::TYPE,
identity_key
)),
}
}
pub fn load_latest_epiphany_cultmesh_daemon_poke_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshDaemonPokeIntentEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_daemon_poke_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
intent_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonPokeIntentEntry>> {
if intent_id.trim().is_empty() {
return Err(anyhow!("daemon poke intent identity is required"));
}
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(&epiphany_cultmesh_daemon_poke_intent_key(intent_id))
}
pub fn load_latest_epiphany_cultmesh_daemon_poke_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshDaemonPokeReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_daemon_poke_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonPokeReceiptEntry>> {
if receipt_id.trim().is_empty() {
return Err(anyhow!("daemon poke receipt identity is required"));
}
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(&epiphany_cultmesh_daemon_poke_receipt_key(receipt_id))
}
pub fn write_epiphany_cultmesh_daemon_restart_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
policy: EpiphanyCultMeshDaemonRestartPolicyEntry,
) -> Result<EpiphanyCultMeshDaemonRestartPolicyEntry> {
validate_daemon_restart_policy(&policy)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let key = epiphany_cultmesh_daemon_restart_policy_key(&policy.daemon_id);
let written = node.put(key.as_str(), &policy)?;
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_daemon_restart_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
daemon_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonRestartPolicyEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let key = epiphany_cultmesh_daemon_restart_policy_key(daemon_id);
node.get(key.as_str())
}
pub fn write_epiphany_cultmesh_daemon_scheduler_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshDaemonSchedulerReceiptEntry,
) -> Result<EpiphanyCultMeshDaemonSchedulerReceiptEntry> {
validate_daemon_scheduler_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key = epiphany_cultmesh_daemon_scheduler_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
let current_latest = node.get::<EpiphanyCultMeshDaemonSchedulerReceiptEntry>(
EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
daemon_scheduler_event_key(&written) >= daemon_scheduler_event_key(current)
}) {
node.put(
EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_LATEST_KEY,
&written,
)?;
}
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_daemon_scheduler_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshDaemonSchedulerReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_LATEST_KEY)
}
pub fn write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
) -> Result<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry> {
validate_daemon_service_lifecycle_receipt(&receipt)?;
let store_path = store_path.as_ref();
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key = epiphany_cultmesh_daemon_service_lifecycle_receipt_key(&receipt.receipt_id);
if let Some(existing) =
node.get::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>(&receipt_key)?
{
if existing == receipt {
return Ok(existing);
}
return Err(anyhow!(
"daemon service lifecycle receipt identity collision for {:?}",
receipt.receipt_id
));
}
let (receipt_envelope, written) = node.cache().prepare_entry(receipt_key, &receipt)?;
let mut expected = Vec::new();
let mut replacements = vec![receipt_envelope];
if written.service_id == EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID && written.action == "launch" {
let reserved_name = "semantic projector";
let policy_key = epiphany_cultmesh_managed_service_policy_key(&written.service_id);
let policy_envelope = node
.cache()
.get_envelope::<EpiphanyCultMeshManagedServicePolicyEntry>(&policy_key)?
.ok_or_else(|| anyhow!("reserved {reserved_name} managed policy is absent"))?;
let mut digest = Sha256::new();
digest.update(policy_envelope.r#type.as_bytes());
digest.update([0]);
digest.update(policy_envelope.key.as_bytes());
digest.update([0]);
digest.update(&policy_envelope.payload);
if written.managed_policy_digest != format!("sha256-{:x}", digest.finalize()) {
return Err(anyhow!(
"reserved {reserved_name} launch receipt has stale managed policy digest"
));
}
expected.push(policy_envelope.clone());
replacements.push(policy_envelope);
}
let current_latest = node.get::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>(
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
daemon_service_lifecycle_event_key(&written) >= daemon_service_lifecycle_event_key(current)
}) {
if let Some(envelope) = node
.cache()
.get_envelope::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>(
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY,
)?
{
expected.push(envelope);
}
replacements.push(
node.cache()
.prepare_entry(
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY,
&written,
)?
.0,
);
}
let service_latest_key =
epiphany_cultmesh_daemon_service_lifecycle_receipt_latest_key(&written.service_id);
let current_service_latest =
node.get::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>(&service_latest_key)?;
if current_service_latest.as_ref().is_none_or(|current| {
daemon_service_lifecycle_event_key(&written) >= daemon_service_lifecycle_event_key(current)
}) {
if let Some(envelope) = node
.cache()
.get_envelope::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>(
&service_latest_key,
)?
{
expected.push(envelope);
}
replacements.push(node.cache().prepare_entry(&service_latest_key, &written)?.0);
}
let backing = SingleFileMessagePackBackingStore::new(store_path);
if backing.compare_and_swap_batch(&expected, replacements)? {
return Ok(written);
}
let reloaded = open_epiphany_cultmesh_node(store_path, "lifecycle-cas-readback")?;
match reloaded.get::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>(
&epiphany_cultmesh_daemon_service_lifecycle_receipt_key(&written.receipt_id),
)? {
Some(existing) if existing == written => Ok(existing),
Some(_) => Err(anyhow!(
"daemon service lifecycle receipt identity collision for {:?}",
written.receipt_id
)),
None => Err(anyhow!(
"daemon service lifecycle receipt CAS lost concurrent latest-state race"
)),
}
}
pub fn load_epiphany_cultmesh_daemon_service_lifecycle_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(&epiphany_cultmesh_daemon_service_lifecycle_receipt_key(
receipt_id,
))
}
pub fn load_epiphany_cultmesh_managed_service_policy_with_digest(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
service_id: &str,
) -> Result<Option<(EpiphanyCultMeshManagedServicePolicyEntry, String)>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let key = epiphany_cultmesh_managed_service_policy_key(service_id);
let Some(policy) = node.get::<EpiphanyCultMeshManagedServicePolicyEntry>(&key)? else {
return Ok(None);
};
let digest =
cultmesh_envelope_digest::<EpiphanyCultMeshManagedServicePolicyEntry>(&node, &key)?;
Ok(Some((policy, digest)))
}
pub fn authenticate_epiphany_cultmesh_semantic_projector_launch(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt_id: &str,
) -> Result<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry> {
let runtime_id = runtime_id.into();
let receipt = load_epiphany_cultmesh_daemon_service_lifecycle_receipt(
store_path.as_ref(),
runtime_id.clone(),
receipt_id,
)?
.ok_or_else(|| anyhow!("semantic projector startup launch receipt is absent"))?;
validate_semantic_projector_launch_receipt(&receipt)?;
let (policy, digest) = load_epiphany_cultmesh_managed_service_policy_with_digest(
store_path,
runtime_id,
EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID,
)?
.ok_or_else(|| anyhow!("semantic projector managed policy is absent"))?;
validate_semantic_projector_managed_service_policy(&policy)?;
if receipt.managed_policy_id != policy.policy_id
|| receipt.managed_policy_digest != digest
|| receipt.command != policy.command
|| receipt.args != policy.args
|| receipt.cwd != policy.cwd
{
return Err(anyhow!(
"semantic projector startup launch receipt disagrees with current managed policy"
));
}
Ok(receipt)
}
pub fn load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY)
}
pub fn load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt_for_service(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
service_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(&epiphany_cultmesh_daemon_service_lifecycle_receipt_latest_key(service_id))
}
pub fn load_epiphany_cultmesh_daemon_service_lifecycle_receipts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
Ok(node
.get_all_with_keys::<EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry>()?
.into_iter()
.filter(|(key, _)| {
key != EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY
&& !key.starts_with("epiphany-local/daemon-service-lifecycle-receipt/latest/")
})
.map(|(_, receipt)| receipt)
.collect())
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_managed_service_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
policy: EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<EpiphanyCultMeshManagedServicePolicyEntry> {
if policy.service_id == EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID {
return Err(anyhow!(
"reserved semantic projector policy requires its specialized writer"
));
}
if policy.service_id == EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID {
return Err(anyhow!(
"reserved workspace coverage projector policy requires its specialized writer"
));
}
validate_managed_service_policy(&policy)?;
write_validated_managed_service_policy(store_path, runtime_id, policy)
}
pub fn write_epiphany_cultmesh_semantic_projector_service_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
policy: EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<EpiphanyCultMeshManagedServicePolicyEntry> {
validate_managed_service_policy(&policy)?;
if policy.service_id != EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID {
return Err(anyhow!(
"semantic projector policy writer requires its reserved service id"
));
}
validate_semantic_projector_managed_service_policy(&policy)?;
write_validated_managed_service_policy(store_path, runtime_id, policy)
}
pub fn write_epiphany_cultmesh_workspace_coverage_projector_service_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
policy: EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<EpiphanyCultMeshManagedServicePolicyEntry> {
validate_managed_service_policy(&policy)?;
if policy.service_id != EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID {
return Err(anyhow!(
"workspace coverage projector policy writer requires its reserved service id"
));
}
validate_workspace_coverage_projector_managed_service_policy(&policy)?;
write_validated_managed_service_policy(store_path, runtime_id, policy)
}
fn write_validated_managed_service_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
policy: EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<EpiphanyCultMeshManagedServicePolicyEntry> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let key = epiphany_cultmesh_managed_service_policy_key(&policy.service_id);
let written = node.put(key.as_str(), &policy)?;
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_managed_service_policy(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
service_id: &str,
) -> Result<Option<EpiphanyCultMeshManagedServicePolicyEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(&epiphany_cultmesh_managed_service_policy_key(service_id))
}
pub fn load_epiphany_cultmesh_managed_service_policies(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshManagedServicePolicyEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
Ok(node
.get_all_with_keys::<EpiphanyCultMeshManagedServicePolicyEntry>()?
.into_iter()
.map(|(_, policy)| policy)
.collect())
}
pub fn load_epiphany_cultmesh_idunn_deployment_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt_ref: impl AsRef<str>,
) -> Result<Option<EpiphanyCultMeshIdunnDeploymentReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let key = epiphany_cultmesh_idunn_deployment_receipt_ref_key(receipt_ref.as_ref());
node.get(key.as_str())
}
pub fn load_latest_epiphany_cultmesh_idunn_deployment_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshIdunnDeploymentReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_idunn_aftercare_audit_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt_ref: impl AsRef<str>,
) -> Result<Option<EpiphanyCultMeshIdunnAftercareAuditReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let key = epiphany_cultmesh_idunn_aftercare_audit_receipt_ref_key(receipt_ref.as_ref());
node.get(key.as_str())
}
pub fn load_latest_epiphany_cultmesh_idunn_aftercare_audit_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshIdunnAftercareAuditReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_IDUNN_AFTERCARE_AUDIT_RECEIPT_LATEST_KEY)
}
pub fn default_epiphany_cultmesh_swarm_brake(
generated_at_utc: impl Into<String>,
) -> EpiphanyCultMeshSwarmBrakeEntry {
EpiphanyCultMeshSwarmBrakeEntry {
schema_version: EPIPHANY_CULTMESH_SWARM_BRAKE_SCHEMA_VERSION.to_string(),
brake_id: EPIPHANY_CANONICAL_SWARM_BRAKE_ID.to_string(),
status: "released".to_string(),
scope: "swarm".to_string(),
reason: "No swarm brake is engaged; unattended automation still requires typed scheduler, cooldown, recovery, and operator receipt gates.".to_string(),
operator_agent_id: EPIPHANY_CANONICAL_SWARM_BRAKE_OWNER.to_string(),
affected_clusters: epiphany_cultmesh_cluster_topology()
.into_iter()
.map(|cluster| cluster.cluster_id)
.collect(),
protected_surfaces: vec![
"heartbeat.scheduler".to_string(),
"coordinator.run".to_string(),
"persona.public_speech".to_string(),
"daemon.tool_invocation".to_string(),
"daemon.lifecycle_poke".to_string(),
],
created_at_utc: generated_at_utc.into(),
expires_at_utc: None,
private_state_exposed: false,
notes: vec![
"The swarm brake is the operator-safe pause surface for live-fire readiness.".to_string(),
"It may stop scheduling and daemon pokes, but it must not expose worker thoughts or private Verse state.".to_string(),
"Engaged brakes require a scoped reason so silence cannot masquerade as consent.".to_string(),
],
runtime_id: String::new(),
}
}
/// The single runtime brake identity shared by deployment, resident readiness,
/// and authenticated operator commands. A caller identity is provenance, not
/// brake ownership, and must not be substituted into either constant.
pub const EPIPHANY_CANONICAL_SWARM_BRAKE_ID: &str = "epiphany/swarm-brake";
pub const EPIPHANY_CANONICAL_SWARM_BRAKE_OWNER: &str = "epiphany.swarm-brake";
pub fn canonical_epiphany_swarm_brake_protected_surfaces() -> Vec<String> {
vec![
"heartbeat.scheduler".to_string(),
"coordinator.run".to_string(),
"persona.public_speech".to_string(),
"daemon.tool_invocation".to_string(),
]
}
pub fn engage_epiphany_cultmesh_swarm_brake(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
reason: impl Into<String>,
actor_id: impl Into<String>,
created_at_utc: impl Into<String>,
allow_engaged_adoption: bool,
) -> Result<EpiphanyCultMeshSwarmBrakeEntry> {
let runtime_id = runtime_id.into();
let actor_id = actor_id.into();
if actor_id.trim().is_empty() {
return Err(anyhow!("swarm brake engagement requires an actor identity"));
}
if allow_engaged_adoption && actor_id != "Idunn" {
return Err(anyhow!(
"only Idunn may adopt an already-engaged legacy brake"
));
}
if let Some(current) = load_epiphany_cultmesh_swarm_brake(&store_path, runtime_id.clone())? {
let foreign = current.brake_id != EPIPHANY_CANONICAL_SWARM_BRAKE_ID
|| current.operator_agent_id != EPIPHANY_CANONICAL_SWARM_BRAKE_OWNER;
if current.status == "engaged" && foreign && !allow_engaged_adoption {
return Err(anyhow!(
"refusing to replace engaged foreign swarm brake {} owned by {}",
current.brake_id,
current.operator_agent_id
));
}
}
let mut brake = default_epiphany_cultmesh_swarm_brake(created_at_utc);
brake.status = "engaged".to_string();
brake.scope = "all".to_string();
brake.reason = reason.into();
brake.affected_clusters = vec![runtime_id.clone()];
brake.protected_surfaces = canonical_epiphany_swarm_brake_protected_surfaces();
brake.notes = vec![format!("Explicit brake engagement by {actor_id}.")];
write_epiphany_cultmesh_swarm_brake(store_path, runtime_id, brake)
}
pub fn release_epiphany_cultmesh_swarm_brake(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
reason: impl Into<String>,
actor_id: impl Into<String>,
created_at_utc: impl Into<String>,
) -> Result<EpiphanyCultMeshSwarmBrakeEntry> {
let runtime_id = runtime_id.into();
let actor_id = actor_id.into();
if actor_id.trim().is_empty() {
return Err(anyhow!("swarm brake release requires an actor identity"));
}
let mut brake = load_epiphany_cultmesh_swarm_brake(&store_path, runtime_id.clone())?
.ok_or_else(|| anyhow!("refusing to release an absent swarm brake"))?;
if brake.brake_id != EPIPHANY_CANONICAL_SWARM_BRAKE_ID
|| brake.operator_agent_id != EPIPHANY_CANONICAL_SWARM_BRAKE_OWNER
{
return Err(anyhow!(
"refusing to release foreign swarm brake {} owned by {}",
brake.brake_id,
brake.operator_agent_id
));
}
brake.status = "released".to_string();
brake.reason = reason.into();
brake.created_at_utc = created_at_utc.into();
brake.expires_at_utc = None;
brake.notes = vec![format!("Explicit brake release by {actor_id}.")];
write_epiphany_cultmesh_swarm_brake(store_path, runtime_id, brake)
}
pub fn write_epiphany_cultmesh_swarm_brake(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
mut brake: EpiphanyCultMeshSwarmBrakeEntry,
) -> Result<EpiphanyCultMeshSwarmBrakeEntry> {
let runtime_id = runtime_id.into();
brake.runtime_id = runtime_id.clone();
validate_swarm_brake(&brake)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let written = node.put(EPIPHANY_CULTMESH_SWARM_BRAKE_KEY, &brake)?;
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_swarm_brake(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshSwarmBrakeEntry>> {
let runtime_id = runtime_id.into();
let node = open_epiphany_cultmesh_node(store_path, runtime_id.clone())?;
Ok(node
.get::<EpiphanyCultMeshSwarmBrakeEntry>(EPIPHANY_CULTMESH_SWARM_BRAKE_KEY)?
.filter(|brake| brake.runtime_id.is_empty() || brake.runtime_id == runtime_id))
}
pub fn write_epiphany_cultmesh_persona_speech_audit(
store_path: impl AsRef<Path>,
audit: EpiphanyCultMeshPersonaSpeechAuditEntry,
) -> Result<EpiphanyCultMeshPersonaSpeechAuditEntry> {
validate_persona_speech_audit(&audit)?;
let mut node = open_epiphany_cultmesh_node(&store_path, audit.runtime_id.clone())?;
let audit_key = epiphany_cultmesh_persona_speech_audit_key(&audit.audit_id);
let written = node.put(audit_key.as_str(), &audit)?;
node.put(EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_LATEST_KEY, &written)?;
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_persona_speech_audit(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshPersonaSpeechAuditEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_LATEST_KEY)
}
pub fn validate_persona_speech_audit(
audit: &EpiphanyCultMeshPersonaSpeechAuditEntry,
) -> Result<()> {
if audit.private_state_exposed {
return Err(anyhow!(
"Persona speech audit must not expose private state"
));
}
if audit.audit_id.trim().is_empty()
|| audit.runtime_id.trim().is_empty()
|| audit.persona_agent_id.trim().is_empty()
{
return Err(anyhow!(
"Persona speech audit requires audit, runtime, and persona ids"
));
}
if !matches!(audit.action_kind.as_str(), "draft" | "bubble" | "post") {
return Err(anyhow!(
"Persona speech audit action_kind must be draft, bubble, or post"
));
}
if !matches!(audit.decision.as_str(), "eligible" | "blocked") {
return Err(anyhow!(
"Persona speech audit decision must be eligible or blocked"
));
}
if audit.decision == "blocked" && audit.reasons.is_empty() {
return Err(anyhow!("blocked Persona speech audit requires reasons"));
}
if audit.content_fingerprint.trim().is_empty() || audit.created_at_utc.trim().is_empty() {
return Err(anyhow!(
"Persona speech audit requires fingerprint and timestamp"
));
}
Ok(())
}
pub fn write_epiphany_cultmesh_weksa_lowering_receipt(
store_path: impl AsRef<Path>,
receipt: EpiphanyCultMeshWeksaLoweringReceiptEntry,
) -> Result<EpiphanyCultMeshWeksaLoweringReceiptEntry> {
validate_weksa_lowering_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(&store_path, receipt.runtime_id.clone())?;
let receipt_key = epiphany_cultmesh_weksa_lowering_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_weksa_lowering_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshWeksaLoweringReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_LATEST_KEY)
}
pub fn validate_weksa_lowering_receipt(
receipt: &EpiphanyCultMeshWeksaLoweringReceiptEntry,
) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"Weksa lowering receipt must not expose private state"
));
}
if receipt.publication_authorized {
return Err(anyhow!(
"Weksa lowering receipt must not claim publication authority"
));
}
if receipt.receipt_id.trim().is_empty()
|| receipt.runtime_id.trim().is_empty()
|| receipt.packet_id.trim().is_empty()
|| receipt.request_id.trim().is_empty()
|| receipt.persona_agent_id.trim().is_empty()
{
return Err(anyhow!(
"Weksa lowering receipt requires receipt, runtime, packet, request, and persona ids"
));
}
if receipt.target_language.trim().is_empty()
|| receipt.delivery_surface.trim().is_empty()
|| receipt.created_at_utc.trim().is_empty()
{
return Err(anyhow!(
"Weksa lowering receipt requires target language, delivery surface, and timestamp"
));
}
if !receipt.transport_authority.contains("must publish")
&& receipt.transport_authority.trim() != "none"
{
return Err(anyhow!(
"Weksa lowering receipt transport authority must remain none or defer publication"
));
}
Ok(())
}
fn validate_swarm_brake(brake: &EpiphanyCultMeshSwarmBrakeEntry) -> Result<()> {
if brake.private_state_exposed {
return Err(anyhow!("swarm brake must not expose private state"));
}
if brake.brake_id.trim().is_empty() || brake.scope.trim().is_empty() {
return Err(anyhow!("swarm brake requires brake id and scope"));
}
if brake.runtime_id.trim().is_empty() {
return Err(anyhow!("swarm brake requires its owning runtime id"));
}
if brake.created_at_utc.trim().is_empty() {
return Err(anyhow!("swarm brake requires a creation timestamp"));
}
if !matches!(brake.status.as_str(), "released" | "engaged") {
return Err(anyhow!("swarm brake status must be released or engaged"));
}
if brake.status == "engaged" {
if brake.reason.trim().is_empty() || brake.operator_agent_id.trim().is_empty() {
return Err(anyhow!(
"engaged swarm brake requires operator id and reason"
));
}
if brake.affected_clusters.is_empty() && brake.protected_surfaces.is_empty() {
return Err(anyhow!(
"engaged swarm brake requires affected clusters or protected surfaces"
));
}
}
Ok(())
}
fn validate_daemon_poke_intent(intent: &EpiphanyCultMeshDaemonPokeIntentEntry) -> Result<()> {
if intent.private_state_requested {
return Err(anyhow!(
"daemon poke intents must not request private state"
));
}
if intent.target_daemon_id.trim().is_empty() || intent.target_cluster_id.trim().is_empty() {
return Err(anyhow!(
"daemon poke intents require daemon and cluster ids"
));
}
if intent.requested_action != "pokeDaemon" {
return Err(anyhow!("daemon poke intents must request pokeDaemon"));
}
if intent.reason.trim().is_empty() {
return Err(anyhow!("daemon poke intents require a reason"));
}
for (label, value) in [
(
"observed provider heartbeat",
intent.observed_last_heartbeat_utc.as_str(),
),
("request timestamp", intent.requested_at_utc.as_str()),
] {
DateTime::parse_from_rfc3339(value)
.with_context(|| format!("daemon poke intent requires RFC3339 {label}"))?;
}
Ok(())
}
fn validate_daemon_poke_receipt(receipt: &EpiphanyCultMeshDaemonPokeReceiptEntry) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"daemon poke receipts must not expose private state"
));
}
if receipt.intent_id.trim().is_empty() || receipt.target_daemon_id.trim().is_empty() {
return Err(anyhow!(
"daemon poke receipts require intent and daemon ids"
));
}
if receipt.action_taken != "pokeDaemon" {
return Err(anyhow!("daemon poke receipts must record pokeDaemon"));
}
if receipt.status.trim().is_empty() || receipt.resulting_status.trim().is_empty() {
return Err(anyhow!("daemon poke receipts require status results"));
}
let attempted = DateTime::parse_from_rfc3339(&receipt.attempted_at_utc)
.context("daemon poke receipt requires RFC3339 attempt timestamp")?;
let completed = DateTime::parse_from_rfc3339(&receipt.completed_at_utc)
.context("daemon poke receipt requires RFC3339 completion timestamp")?;
if completed < attempted {
return Err(anyhow!(
"daemon poke receipt completion cannot precede its attempt"
));
}
Ok(())
}
fn validate_daemon_restart_policy(policy: &EpiphanyCultMeshDaemonRestartPolicyEntry) -> Result<()> {
if policy.private_state_exposed {
return Err(anyhow!(
"daemon restart policies must not expose private state"
));
}
for (label, value) in [
("policy id", policy.policy_id.as_str()),
("daemon id", policy.daemon_id.as_str()),
("cluster id", policy.cluster_id.as_str()),
("restart command", policy.restart_command.as_str()),
("last result status", policy.last_result_status.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("daemon restart policy missing {label}"));
}
}
if policy.cooldown_seconds < 0 {
return Err(anyhow!(
"daemon restart policy cooldown_seconds must be non-negative"
));
}
if policy.backoff_multiplier == 0 {
return Err(anyhow!(
"daemon restart policy backoff_multiplier must be positive"
));
}
if policy.reconcile_interval_seconds < 0 {
return Err(anyhow!(
"daemon restart policy reconcile_interval_seconds must be non-negative"
));
}
if policy.heartbeat_stale_seconds < 0 {
return Err(anyhow!(
"daemon restart policy heartbeat_stale_seconds must be non-negative"
));
}
Ok(())
}
fn validate_managed_service_policy(
policy: &EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<()> {
if policy.private_state_exposed {
return Err(anyhow!(
"managed service policies must not expose private state"
));
}
for (label, value) in [
("policy id", policy.policy_id.as_str()),
("service id", policy.service_id.as_str()),
("owner daemon id", policy.owner_daemon_id.as_str()),
("command", policy.command.as_str()),
("restart mode", policy.restart_mode.as_str()),
("stdout artifact", policy.stdout_artifact.as_str()),
("stderr artifact", policy.stderr_artifact.as_str()),
("updated timestamp", policy.updated_at_utc.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("managed service policy missing {label}"));
}
}
if !matches!(
policy.restart_mode.as_str(),
"always" | "on-failure" | "never"
) {
return Err(anyhow!(
"managed service policy restart_mode must be always, on-failure, or never"
));
}
if policy.cooldown_seconds < 0 || policy.backoff_multiplier == 0 {
return Err(anyhow!(
"managed service policy requires non-negative cooldown and positive backoff"
));
}
Ok(())
}
fn validate_semantic_projector_managed_service_policy(
policy: &EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<()> {
let expected_binary = if cfg!(windows) {
"epiphany-memory-semantic-projector.exe"
} else {
"epiphany-memory-semantic-projector"
};
if Path::new(&policy.command)
.file_name()
.and_then(|name| name.to_str())
!= Some(expected_binary)
{
return Err(anyhow!(
"reserved semantic projector policy requires the packaged projector executable"
));
}
if policy.policy_id != "managed-service-policy-epiphany-memory-semantic-projector-service"
|| policy.owner_daemon_id != "epiphany-daemon-supervisor"
|| policy.restart_mode != "always"
|| policy.args.len() != 17
|| policy.args[0] != "serve"
|| policy.args[1] != "--agent-store"
|| policy.args[2].trim().is_empty()
|| policy.args[3] != "--runtime-store"
|| policy.args[4].trim().is_empty()
|| policy.args[5] != "--local-verse-store"
|| policy.args[6].trim().is_empty()
|| policy.args[7] != "--runtime-id"
|| policy.args[8].trim().is_empty()
|| policy.args[9] != "--interval-seconds"
|| policy.args[10]
.parse::<u64>()
.ok()
.filter(|value| *value > 0)
.is_none()
|| policy.args[11] != "--qdrant-url"
|| policy.args[12].trim().is_empty()
|| policy.args[13] != "--ollama-base-url"
|| policy.args[14].trim().is_empty()
|| policy.args[15] != "--ollama-model"
|| policy.args[16].trim().is_empty()
{
return Err(anyhow!(
"reserved semantic projector policy must bind one packaged process to both canonical stores"
));
}
Ok(())
}
pub(crate) fn validate_workspace_coverage_projector_managed_service_policy(
policy: &EpiphanyCultMeshManagedServicePolicyEntry,
) -> Result<()> {
let expected_binary = if cfg!(windows) {
"epiphany-workspace-coverage-projector.exe"
} else {
"epiphany-workspace-coverage-projector"
};
let expected_command = std::env::current_exe()
.context("cannot resolve current executable for packaged projector policy")?
.with_file_name(expected_binary);
if Path::new(&policy.command) != expected_command {
return Err(anyhow!(
"reserved workspace coverage projector policy requires the packaged projector executable"
));
}
if policy.policy_id != "managed-service-policy-epiphany-workspace-coverage-projector-service"
|| policy.service_id != EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID
|| policy.owner_daemon_id != "epiphany-daemon-supervisor"
|| !policy.enabled
|| policy.restart_mode != "always"
|| policy.args.len() != 17
|| policy.args[0] != "serve"
|| policy.args[1] != "--runtime-store"
|| policy.args[2].trim().is_empty()
|| policy.args[3] != "--local-verse-store"
|| policy.args[4].trim().is_empty()
|| policy.args[5] != "--runtime-id"
|| policy.args[6].trim().is_empty()
|| policy.args[7] != "--interval-seconds"
|| policy.args[8]
.parse::<u64>()
.ok()
.filter(|value| *value > 0)
.is_none()
|| policy.args[9] != "--heartbeat-interval-seconds"
|| policy.args[10]
.parse::<u64>()
.ok()
.filter(|value| *value > 0)
.is_none()
|| policy.args[11] != "--qdrant-url"
|| policy.args[12].trim().is_empty()
|| policy.args[13] != "--ollama-base-url"
|| policy.args[14].trim().is_empty()
|| policy.args[15] != "--ollama-model"
|| policy.args[16].trim().is_empty()
{
return Err(anyhow!(
"reserved workspace coverage projector policy must bind one packaged process to its authenticated runtime Body route"
));
}
Ok(())
}
fn validate_daemon_scheduler_receipt(
receipt: &EpiphanyCultMeshDaemonSchedulerReceiptEntry,
) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"daemon scheduler receipts must not expose private state"
));
}
for (label, value) in [
("receipt id", receipt.receipt_id.as_str()),
("scheduler id", receipt.scheduler_id.as_str()),
("runtime id", receipt.runtime_id.as_str()),
("daemon selector", receipt.daemon_selector.as_str()),
("status", receipt.status.as_str()),
("tick started", receipt.tick_started_utc.as_str()),
("tick completed", receipt.tick_completed_utc.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("daemon scheduler receipt missing {label}"));
}
}
let started_at = DateTime::parse_from_rfc3339(&receipt.tick_started_utc)
.map_err(|error| anyhow!("daemon scheduler receipt has invalid tick start: {error}"))?;
let completed_at =
DateTime::parse_from_rfc3339(&receipt.tick_completed_utc).map_err(|error| {
anyhow!("daemon scheduler receipt has invalid tick completion: {error}")
})?;
if completed_at < started_at {
return Err(anyhow!(
"daemon scheduler receipt tick completed before it started"
));
}
if let Some(next_wake) = receipt.next_wake_utc.as_deref() {
DateTime::parse_from_rfc3339(next_wake)
.map_err(|error| anyhow!("daemon scheduler receipt has invalid next wake: {error}"))?;
}
Ok(())
}
fn daemon_scheduler_event_key(
receipt: &EpiphanyCultMeshDaemonSchedulerReceiptEntry,
) -> (DateTime<FixedOffset>, u64, &str) {
(
DateTime::parse_from_rfc3339(&receipt.tick_completed_utc)
.expect("validated scheduler completion timestamp"),
receipt.iteration,
receipt.receipt_id.as_str(),
)
}
fn validate_daemon_service_lifecycle_receipt(
receipt: &EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
) -> Result<()> {
if receipt.service_id == EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID {
return Err(anyhow!(
"workspace coverage process authority belongs to its specialized managed process documents"
));
}
if receipt.private_state_exposed {
return Err(anyhow!(
"daemon service lifecycle receipts must not expose private state"
));
}
for (label, value) in [
("receipt id", receipt.receipt_id.as_str()),
("service id", receipt.service_id.as_str()),
("scheduler id", receipt.scheduler_id.as_str()),
("runtime id", receipt.runtime_id.as_str()),
("daemon selector", receipt.daemon_selector.as_str()),
("action", receipt.action.as_str()),
("status", receipt.status.as_str()),
("command", receipt.command.as_str()),
("started at", receipt.started_at_utc.as_str()),
(
"operator artifact ref",
receipt.operator_artifact_ref.as_str(),
),
] {
if value.trim().is_empty() {
return Err(anyhow!("daemon service lifecycle receipt missing {label}"));
}
}
let started_at = DateTime::parse_from_rfc3339(&receipt.started_at_utc).map_err(|error| {
anyhow!("daemon service lifecycle receipt has invalid started at: {error}")
})?;
if let Some(completed_at) = receipt.completed_at_utc.as_deref() {
let completed_at = DateTime::parse_from_rfc3339(completed_at).map_err(|error| {
anyhow!("daemon service lifecycle receipt has invalid completed at: {error}")
})?;
if completed_at < started_at {
return Err(anyhow!(
"daemon service lifecycle receipt completed before it started"
));
}
}
if !receipt.required_document_types.is_empty()
&& (!receipt.schema_preflight_passed
|| receipt.executable_sha256.trim().is_empty()
|| receipt.schema_catalog_sha256.trim().is_empty()
|| receipt.preflight_witness_id.trim().is_empty())
{
return Err(anyhow!(
"typed daemon service lifecycle receipt requires passing schema preflight, executable fingerprint, and preflight witness"
));
}
if receipt.service_id == EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID && receipt.action == "launch" {
validate_semantic_projector_launch_receipt(receipt)?;
}
Ok(())
}
fn validate_semantic_projector_launch_receipt(
receipt: &EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
) -> Result<()> {
if receipt.schema_version != EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
|| receipt.service_id != EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID
|| receipt.action != "launch"
|| receipt.status != "launched"
|| receipt.process_id.is_none()
|| receipt.process_creation_token == 0
|| receipt.process_executable_path.trim().is_empty()
|| receipt.exit_code.is_some()
|| receipt.completed_at_utc.is_none()
|| !receipt.executable_sha256.starts_with("sha256-")
|| receipt.managed_policy_id.trim().is_empty()
|| !receipt.managed_policy_digest.starts_with("sha256-")
|| receipt.provider_daemon_id != "epiphany-memory-semantic-projector"
|| receipt.startup_correlation_id != receipt.receipt_id
|| Uuid::parse_str(&receipt.receipt_id).is_err()
{
return Err(anyhow!(
"reserved semantic projector launch receipt must bind completed spawn to exact managed policy and provider identity"
));
}
Ok(())
}
fn daemon_service_lifecycle_event_key(
receipt: &EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
) -> (DateTime<FixedOffset>, &str) {
let event_time = receipt
.completed_at_utc
.as_deref()
.map(DateTime::parse_from_rfc3339)
.transpose()
.expect("validated lifecycle completion timestamp")
.unwrap_or_else(|| {
DateTime::parse_from_rfc3339(&receipt.started_at_utc)
.expect("validated lifecycle start timestamp")
});
(event_time, receipt.receipt_id.as_str())
}
pub fn epiphany_cultmesh_daemon_tool_invocation_intent_from_capability(
intent_id: impl Into<String>,
requesting_agent_id: impl Into<String>,
requesting_cluster_id: impl Into<String>,
capability: &EpiphanyCultMeshDaemonToolCapabilityEntry,
payload_ref: impl Into<String>,
payload_summary: impl Into<String>,
) -> EpiphanyCultMeshDaemonToolInvocationIntentEntry {
EpiphanyCultMeshDaemonToolInvocationIntentEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_SCHEMA_VERSION.to_string(),
intent_id: intent_id.into(),
requesting_agent_id: requesting_agent_id.into(),
requesting_cluster_id: requesting_cluster_id.into(),
capability_id: capability.capability_id.clone(),
host_cluster_id: capability.host_cluster_id.clone(),
host_daemon_id: capability.host_daemon_id.clone(),
eve_surface_id: capability.eve_surface_id.clone(),
tool_name: capability.tool_name.clone(),
operation: capability.operation.clone(),
input_contract_type: capability.input_contract_type.clone(),
payload_ref: payload_ref.into(),
payload_summary: payload_summary.into(),
authority_gate: capability.authority_gate.clone(),
requires_receipt: capability.requires_receipt,
private_state_requested: false,
notes: vec![
"Any local CultMesh agent may submit this daemon tool invocation intent when it cites an advertised capability.".to_string(),
"The payload is referenced through the capability's typed input contract; this document is the routing envelope, not private state cargo.".to_string(),
"Execution remains gated by the advertised authority and must produce a typed receipt.".to_string(),
],
}
}
#[cfg(test)]
pub fn epiphany_cultmesh_daemon_tool_invocation_receipt_for_intent(
receipt_id: impl Into<String>,
intent: &EpiphanyCultMeshDaemonToolInvocationIntentEntry,
status: impl Into<String>,
receipt_contract_type: impl Into<String>,
result_ref: impl Into<String>,
result_summary: impl Into<String>,
) -> EpiphanyCultMeshDaemonToolInvocationReceiptEntry {
EpiphanyCultMeshDaemonToolInvocationReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: receipt_id.into(),
intent_id: intent.intent_id.clone(),
requesting_agent_id: intent.requesting_agent_id.clone(),
requesting_cluster_id: intent.requesting_cluster_id.clone(),
capability_id: intent.capability_id.clone(),
host_cluster_id: intent.host_cluster_id.clone(),
host_daemon_id: intent.host_daemon_id.clone(),
tool_name: intent.tool_name.clone(),
operation: intent.operation.clone(),
status: status.into(),
receipt_contract_type: receipt_contract_type.into(),
result_ref: result_ref.into(),
result_summary: result_summary.into(),
authority_gate: intent.authority_gate.clone(),
private_state_exposed: false,
notes: vec![
"Receipt records the daemon tool response over CultMesh without exposing private Verse payloads.".to_string(),
"The receipt contract is the tool-specific proof surface; this routing receipt keeps the global directory auditable.".to_string(),
],
}
}
fn validate_daemon_tool_invocation_intent(
intent: &EpiphanyCultMeshDaemonToolInvocationIntentEntry,
) -> Result<()> {
if intent.private_state_requested {
return Err(anyhow!(
"daemon tool invocation intents must not request private Verse state"
));
}
if !intent.requires_receipt {
return Err(anyhow!(
"daemon tool invocation intents must require typed receipts"
));
}
for (label, value) in [
("intent id", intent.intent_id.as_str()),
("requesting agent id", intent.requesting_agent_id.as_str()),
(
"requesting cluster id",
intent.requesting_cluster_id.as_str(),
),
("capability id", intent.capability_id.as_str()),
("host daemon id", intent.host_daemon_id.as_str()),
("tool name", intent.tool_name.as_str()),
("operation", intent.operation.as_str()),
("input contract type", intent.input_contract_type.as_str()),
("payload ref", intent.payload_ref.as_str()),
("authority gate", intent.authority_gate.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("daemon tool invocation intent missing {label}"));
}
}
Ok(())
}
#[cfg(test)]
fn validate_daemon_tool_invocation_receipt(
receipt: &EpiphanyCultMeshDaemonToolInvocationReceiptEntry,
) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"daemon tool invocation receipts must not expose private Verse state"
));
}
for (label, value) in [
("receipt id", receipt.receipt_id.as_str()),
("intent id", receipt.intent_id.as_str()),
("requesting agent id", receipt.requesting_agent_id.as_str()),
(
"requesting cluster id",
receipt.requesting_cluster_id.as_str(),
),
("capability id", receipt.capability_id.as_str()),
("host daemon id", receipt.host_daemon_id.as_str()),
("tool name", receipt.tool_name.as_str()),
("operation", receipt.operation.as_str()),
("status", receipt.status.as_str()),
(
"receipt contract type",
receipt.receipt_contract_type.as_str(),
),
("result ref", receipt.result_ref.as_str()),
("authority gate", receipt.authority_gate.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("daemon tool invocation receipt missing {label}"));
}
}
Ok(())
}
pub fn write_epiphany_cultmesh_daemon_tool_invocation_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
intent: EpiphanyCultMeshDaemonToolInvocationIntentEntry,
) -> Result<EpiphanyCultMeshDaemonToolInvocationIntentEntry> {
validate_daemon_tool_invocation_intent(&intent)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let intent_key = epiphany_cultmesh_daemon_tool_invocation_intent_key(&intent.intent_id);
let written = node.put(intent_key.as_str(), &intent)?;
node.put(
EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_daemon_tool_invocation_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshDaemonToolInvocationReceiptEntry,
) -> Result<EpiphanyCultMeshDaemonToolInvocationReceiptEntry> {
validate_daemon_tool_invocation_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key = epiphany_cultmesh_daemon_tool_invocation_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_daemon_tool_invocation_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshDaemonToolInvocationIntentEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_LATEST_KEY)
}
pub fn load_latest_epiphany_cultmesh_daemon_tool_invocation_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshDaemonToolInvocationReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_LATEST_KEY)
}
pub fn epiphany_cultmesh_bifrost_body_change_publication_intent(
intent_id: impl Into<String>,
source_cluster_id: impl Into<String>,
source_agent_id: impl Into<String>,
body_domain: impl Into<String>,
target_repository: impl Into<String>,
target_branch: impl Into<String>,
change_summary: impl Into<String>,
justification: impl Into<String>,
changed_paths: Vec<String>,
verification_receipt_ids: Vec<String>,
review_receipt_ids: Vec<String>,
authorship_agent_ids: Vec<String>,
credit_subjects: Vec<String>,
) -> EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry {
EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_SCHEMA_VERSION
.to_string(),
intent_id: intent_id.into(),
source_cluster_id: source_cluster_id.into(),
source_agent_id: source_agent_id.into(),
body_domain: body_domain.into(),
target_repository: target_repository.into(),
target_branch: target_branch.into(),
change_summary: change_summary.into(),
justification: justification.into(),
changed_paths,
verification_receipt_ids,
review_receipt_ids,
authorship_agent_ids,
credit_subjects,
github_publication_requested: true,
private_state_included: false,
notes: vec![
"Bifrost publication intent routes a body change to the local trusted GameCult Verse before GitHub publication.".to_string(),
"GitHub is the publication substrate; Bifrost owns ledger attribution, review proof, and credit routing.".to_string(),
"Private worker/operator/agent state must stay sealed outside this operator-safe publication packet.".to_string(),
],
}
}
#[cfg(test)]
pub fn epiphany_cultmesh_bifrost_body_change_publication_receipt_for_intent(
receipt_id: impl Into<String>,
intent: &EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry,
status: impl Into<String>,
bifrost_ledger_entry_id: impl Into<String>,
github_publication_receipt_id: impl Into<String>,
credit_receipt_ids: Vec<String>,
reviewer_ids: Vec<String>,
publication_url: impl Into<String>,
) -> EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry {
EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: receipt_id.into(),
intent_id: intent.intent_id.clone(),
status: status.into(),
bifrost_ledger_entry_id: bifrost_ledger_entry_id.into(),
github_publication_receipt_id: github_publication_receipt_id.into(),
credit_receipt_ids,
accepted_changed_paths: intent.changed_paths.clone(),
reviewer_ids,
publication_url: publication_url.into(),
private_state_exposed: false,
notes: vec![
"Bifrost receipt records publication routing and ledger attribution before treating GitHub publication as blessed.".to_string(),
"Credit and GitHub receipts are referenced as typed proof surfaces, not hidden side effects.".to_string(),
],
}
}
pub fn write_epiphany_cultmesh_bifrost_body_change_publication_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
intent: EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry,
) -> Result<EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry> {
validate_bifrost_body_change_publication_intent(&intent)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let intent_key =
epiphany_cultmesh_bifrost_body_change_publication_intent_key(&intent.intent_id);
let written = node.put(intent_key.as_str(), &intent)?;
node.put(
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_ARRIVAL_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_bifrost_body_change_publication_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry,
) -> Result<EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry> {
validate_bifrost_body_change_publication_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key =
epiphany_cultmesh_bifrost_body_change_publication_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_arrival_latest_epiphany_cultmesh_bifrost_body_change_publication_intent(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_ARRIVAL_LATEST_KEY)
}
pub fn load_arrival_latest_epiphany_cultmesh_bifrost_body_change_publication_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY)
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
pub fn epiphany_cultmesh_bifrost_github_publication_receipt_for_publication(
receipt_id: impl Into<String>,
publication_receipt: &EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry,
hands_pr_receipt_id: impl Into<String>,
target_repository: impl Into<String>,
target_branch: impl Into<String>,
pull_request_number: impl Into<String>,
commit_sha: impl Into<String>,
published_by_agent_id: impl Into<String>,
) -> EpiphanyCultMeshBifrostGithubPublicationReceiptEntry {
EpiphanyCultMeshBifrostGithubPublicationReceiptEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: receipt_id.into(),
bifrost_publication_receipt_id: publication_receipt.receipt_id.clone(),
hands_pr_receipt_id: hands_pr_receipt_id.into(),
target_repository: target_repository.into(),
target_branch: target_branch.into(),
pull_request_url: publication_receipt.publication_url.clone(),
pull_request_number: pull_request_number.into(),
commit_sha: commit_sha.into(),
changed_paths: publication_receipt.accepted_changed_paths.clone(),
ledger_entry_id: publication_receipt.bifrost_ledger_entry_id.clone(),
credit_receipt_ids: publication_receipt.credit_receipt_ids.clone(),
published_by_agent_id: published_by_agent_id.into(),
publication_status: publication_receipt.status.clone(),
private_state_exposed: false,
notes: vec![
"Bifrost GitHub publication receipt binds the Bifrost ledger decision to a concrete Hands PR receipt.".to_string(),
"GitHub is recorded as a publication substrate; Bifrost remains the routing and credit authority.".to_string(),
"This receipt must not expose private worker, operator, or agent-thought state.".to_string(),
],
}
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_bifrost_github_publication_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshBifrostGithubPublicationReceiptEntry,
) -> Result<EpiphanyCultMeshBifrostGithubPublicationReceiptEntry> {
validate_bifrost_github_publication_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key = epiphany_cultmesh_bifrost_github_publication_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_arrival_latest_epiphany_cultmesh_bifrost_github_publication_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshBifrostGithubPublicationReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY)
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
pub fn epiphany_cultmesh_bifrost_public_proof_publication_receipt_for_proof(
receipt_id: impl Into<String>,
proof: &EpiphanyCultMeshRepoWorkPublicProofEntry,
status: impl Into<String>,
target_public_verse_id: impl Into<String>,
public_room_id: impl Into<String>,
bifrost_ledger_entry_id: impl Into<String>,
credit_receipt_ids: Vec<String>,
reviewer_ids: Vec<String>,
publication_url: impl Into<String>,
) -> EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry {
EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry {
schema_version:
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: receipt_id.into(),
public_proof_id: proof.public_proof_id.clone(),
public_proof_ref: proof.public_proof_ref.clone(),
public_proof_sha256: proof.public_proof_sha256.clone(),
item: proof.item.clone(),
source_workspace: proof.workspace.clone(),
source_branch: proof.branch.clone(),
target_public_verse_id: target_public_verse_id.into(),
public_room_id: public_room_id.into(),
status: status.into(),
bifrost_ledger_entry_id: bifrost_ledger_entry_id.into(),
credit_receipt_ids,
reviewer_ids,
publication_url: publication_url.into(),
private_state_exposed: false,
notes: vec![
"Bifrost public-proof publication receipt binds a redacted repo-work proof bundle to a public Verse room.".to_string(),
"The receipt carries only proof refs, hashes, ledger, review, and credit ids; private worker/operator/agent state remains sealed.".to_string(),
"Downstream consumers may read this closure, but Bifrost owns public publication authority.".to_string(),
],
}
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_bifrost_public_proof_publication_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry,
) -> Result<EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry> {
validate_bifrost_public_proof_publication_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key =
epiphany_cultmesh_bifrost_public_proof_publication_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_arrival_latest_epiphany_cultmesh_bifrost_public_proof_publication_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY)
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
pub fn epiphany_cultmesh_bifrost_artifact_acceptance_receipt_for_map_entry(
receipt_id: impl Into<String>,
map_entry: &EpiphanyCultMeshRepoWorkMapEntry,
artifact_ref: impl Into<String>,
public_proof_ref: impl Into<String>,
maintainer_review_receipt_ids: Vec<String>,
bifrost_ledger_entry_id: impl Into<String>,
status: impl Into<String>,
accepted_by: impl Into<String>,
) -> EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry {
EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: receipt_id.into(),
item: map_entry.item.clone(),
source_workspace: map_entry.workspace.clone(),
source_branch: map_entry.branch.clone(),
commit_sha: map_entry.commit_sha.clone(),
changed_paths: map_entry.changed_paths.clone(),
artifact_ref: artifact_ref.into(),
public_proof_ref: public_proof_ref.into(),
maintainer_review_receipt_ids,
bifrost_ledger_entry_id: bifrost_ledger_entry_id.into(),
status: status.into(),
accepted_by: accepted_by.into(),
private_state_exposed: false,
notes: vec![
"Bifrost artifact acceptance receipt closes accepted-artifact accounting for Mind-admitted branch work.".to_string(),
"This receipt carries artifact, review, ledger, commit, and path refs only; private worker/operator/agent state remains sealed.".to_string(),
"Repo-work request cargo may ask for this receipt; Maintainer owns acceptance and Bifrost owns accounting.".to_string(),
],
}
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_bifrost_artifact_acceptance_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry,
) -> Result<EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry> {
validate_bifrost_artifact_acceptance_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key =
epiphany_cultmesh_bifrost_artifact_acceptance_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_ARRIVAL_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_arrival_latest_epiphany_cultmesh_bifrost_artifact_acceptance_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_ARRIVAL_LATEST_KEY)
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
pub fn epiphany_cultmesh_bifrost_metrics_receipt_for_map_entry(
receipt_id: impl Into<String>,
map_entry: &EpiphanyCultMeshRepoWorkMapEntry,
artifact_acceptance_receipt_id: impl Into<String>,
model_spend_receipt_ids: Vec<String>,
review_load_receipt_ids: Vec<String>,
credit_readback_receipt_ids: Vec<String>,
public_proof_ref: impl Into<String>,
metrics_summary: impl Into<String>,
status: impl Into<String>,
) -> EpiphanyCultMeshBifrostMetricsReceiptEntry {
EpiphanyCultMeshBifrostMetricsReceiptEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: receipt_id.into(),
item: map_entry.item.clone(),
source_workspace: map_entry.workspace.clone(),
source_branch: map_entry.branch.clone(),
artifact_acceptance_receipt_id: artifact_acceptance_receipt_id.into(),
model_spend_receipt_ids,
review_load_receipt_ids,
credit_readback_receipt_ids,
public_proof_ref: public_proof_ref.into(),
metrics_summary: metrics_summary.into(),
status: status.into(),
private_state_exposed: false,
token_summary_ref: Some("metrics://model-spend/tokens".to_string()),
cost_availability_status: Some("known".to_string()),
cost_summary_ref: Some("metrics://model-spend/cost".to_string()),
cost_unavailable_reason: None,
review_duration_ms: Some(1),
review_event_count: Some(1),
notes: vec![
"Bifrost metrics receipt closes model-spend, review-load, accepted-artifact, and credit-readback accounting for branch work.".to_string(),
"Metrics are operator-safe refs and summaries, not private worker transcripts or raw model streams.".to_string(),
"Repo-work request cargo may ask for this receipt; Bifrost owns accounting and Maintainer owns review-load evidence.".to_string(),
],
}
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_bifrost_metrics_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
receipt: EpiphanyCultMeshBifrostMetricsReceiptEntry,
) -> Result<EpiphanyCultMeshBifrostMetricsReceiptEntry> {
validate_bifrost_metrics_receipt(&receipt)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let receipt_key = epiphany_cultmesh_bifrost_metrics_receipt_key(&receipt.receipt_id);
let written = node.put(receipt_key.as_str(), &receipt)?;
node.put(
EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_ARRIVAL_LATEST_KEY,
&written,
)?;
node.flush()?;
Ok(written)
}
pub fn load_arrival_latest_epiphany_cultmesh_bifrost_metrics_receipt(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshBifrostMetricsReceiptEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_ARRIVAL_LATEST_KEY)
}
fn validate_bifrost_body_change_publication_intent(
intent: &EpiphanyCultMeshBifrostBodyChangePublicationIntentEntry,
) -> Result<()> {
if intent.private_state_included {
return Err(anyhow!(
"Bifrost body change publication intents must not include private state"
));
}
if !intent.github_publication_requested {
return Err(anyhow!(
"Bifrost body change publication intents must request GitHub publication routing"
));
}
if intent.justification.trim().is_empty() {
return Err(anyhow!(
"Bifrost body change publication intents require justification"
));
}
if intent.changed_paths.is_empty() {
return Err(anyhow!(
"Bifrost body change publication intents require changed path scope"
));
}
if intent.verification_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost body change publication intents require verification receipts"
));
}
if intent.review_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost body change publication intents require review receipts"
));
}
if intent.authorship_agent_ids.is_empty() {
return Err(anyhow!(
"Bifrost body change publication intents require authorship"
));
}
if intent.credit_subjects.is_empty() {
return Err(anyhow!(
"Bifrost body change publication intents require credit metadata"
));
}
Ok(())
}
#[cfg(test)]
fn validate_bifrost_body_change_publication_receipt(
receipt: &EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry,
) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"Bifrost body change publication receipts must not expose private state"
));
}
if receipt.bifrost_ledger_entry_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost body change publication receipts require a ledger entry"
));
}
if receipt.github_publication_receipt_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost body change publication receipts require a GitHub publication receipt"
));
}
if receipt.credit_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost body change publication receipts require credit receipts"
));
}
Ok(())
}
#[cfg(test)]
fn validate_bifrost_github_publication_receipt(
receipt: &EpiphanyCultMeshBifrostGithubPublicationReceiptEntry,
) -> Result<()> {
if receipt.private_state_exposed {
return Err(anyhow!(
"Bifrost GitHub publication receipts must not expose private state"
));
}
if receipt.bifrost_publication_receipt_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost GitHub publication receipts require a Bifrost publication receipt"
));
}
if receipt.hands_pr_receipt_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost GitHub publication receipts require a Hands PR receipt"
));
}
if receipt.pull_request_url.trim().is_empty() {
return Err(anyhow!(
"Bifrost GitHub publication receipts require a pull request URL"
));
}
if receipt.ledger_entry_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost GitHub publication receipts require a ledger entry"
));
}
if receipt.credit_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost GitHub publication receipts require credit receipts"
));
}
if receipt.changed_paths.is_empty() {
return Err(anyhow!(
"Bifrost GitHub publication receipts require changed paths"
));
}
Ok(())
}
#[cfg(test)]
fn validate_bifrost_public_proof_publication_receipt(
receipt: &EpiphanyCultMeshBifrostPublicProofPublicationReceiptEntry,
) -> Result<()> {
if receipt.schema_version
!= EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_SCHEMA_VERSION
{
return Err(anyhow!(
"Bifrost public proof publication receipts require schema version {}",
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_SCHEMA_VERSION
));
}
if receipt.private_state_exposed {
return Err(anyhow!(
"Bifrost public proof publication receipts must not expose private state"
));
}
if receipt.public_proof_id.trim().is_empty()
|| receipt.public_proof_ref.trim().is_empty()
|| receipt.public_proof_sha256.trim().is_empty()
{
return Err(anyhow!(
"Bifrost public proof publication receipts require proof id, ref, and SHA-256"
));
}
if receipt.target_public_verse_id != EPIPHANY_CULTMESH_GLOBAL_VERSE_ID {
return Err(anyhow!(
"Bifrost public proof publication receipts must target the global public Verse"
));
}
if receipt.public_room_id.trim().is_empty() || receipt.publication_url.trim().is_empty() {
return Err(anyhow!(
"Bifrost public proof publication receipts require a public room and publication URL"
));
}
if receipt.bifrost_ledger_entry_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost public proof publication receipts require a ledger entry"
));
}
if receipt.credit_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost public proof publication receipts require credit receipts"
));
}
if receipt.reviewer_ids.is_empty() {
return Err(anyhow!(
"Bifrost public proof publication receipts require reviewer receipts"
));
}
Ok(())
}
#[cfg(test)]
fn validate_bifrost_artifact_acceptance_receipt(
receipt: &EpiphanyCultMeshBifrostArtifactAcceptanceReceiptEntry,
) -> Result<()> {
if receipt.schema_version
!= EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_SCHEMA_VERSION
{
return Err(anyhow!(
"Bifrost artifact acceptance receipts require schema version {}",
EPIPHANY_CULTMESH_BIFROST_ARTIFACT_ACCEPTANCE_RECEIPT_SCHEMA_VERSION
));
}
if receipt.private_state_exposed {
return Err(anyhow!(
"Bifrost artifact acceptance receipts must not expose private state"
));
}
if receipt.item.trim().is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require an item"
));
}
if receipt.artifact_ref.trim().is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require an artifact ref"
));
}
if receipt.public_proof_ref.trim().is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require a public proof ref"
));
}
if receipt.commit_sha.trim().is_empty() || receipt.commit_sha == "none" {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require a commit SHA"
));
}
if receipt.changed_paths.is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require changed paths"
));
}
if receipt.maintainer_review_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require maintainer review receipts"
));
}
if receipt.bifrost_ledger_entry_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require a ledger entry"
));
}
if receipt.accepted_by.trim().is_empty() {
return Err(anyhow!(
"Bifrost artifact acceptance receipts require an accepted-by authority"
));
}
Ok(())
}
#[cfg(test)]
fn validate_bifrost_metrics_receipt(
receipt: &EpiphanyCultMeshBifrostMetricsReceiptEntry,
) -> Result<()> {
if receipt.schema_version != EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_SCHEMA_VERSION {
return Err(anyhow!(
"Bifrost metrics receipts require schema version {}",
EPIPHANY_CULTMESH_BIFROST_METRICS_RECEIPT_SCHEMA_VERSION
));
}
if receipt.private_state_exposed {
return Err(anyhow!(
"Bifrost metrics receipts must not expose private state"
));
}
if receipt.item.trim().is_empty() {
return Err(anyhow!("Bifrost metrics receipts require an item"));
}
if receipt.artifact_acceptance_receipt_id.trim().is_empty() {
return Err(anyhow!(
"Bifrost metrics receipts require an artifact acceptance receipt"
));
}
if receipt.model_spend_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost metrics receipts require model spend receipts"
));
}
if receipt.review_load_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost metrics receipts require review load receipts"
));
}
if receipt.credit_readback_receipt_ids.is_empty() {
return Err(anyhow!(
"Bifrost metrics receipts require credit readback receipts"
));
}
if receipt.public_proof_ref.trim().is_empty() {
return Err(anyhow!(
"Bifrost metrics receipts require a public proof ref"
));
}
if receipt.metrics_summary.trim().is_empty() {
return Err(anyhow!(
"Bifrost metrics receipts require a metrics summary"
));
}
if receipt
.token_summary_ref
.as_deref()
.unwrap_or_default()
.trim()
.is_empty()
{
return Err(anyhow!(
"Bifrost metrics receipts require a token summary ref"
));
}
match receipt.cost_availability_status.as_deref() {
Some("known")
if receipt
.cost_summary_ref
.as_deref()
.unwrap_or_default()
.trim()
.is_empty() =>
{
return Err(anyhow!("known metric cost requires a cost summary ref"));
}
Some("unavailable")
if receipt
.cost_unavailable_reason
.as_deref()
.unwrap_or_default()
.trim()
.is_empty() =>
{
return Err(anyhow!("unavailable metric cost requires a reason"));
}
Some("known" | "unavailable") => {}
_ => {
return Err(anyhow!(
"metric cost availability must be known or unavailable"
));
}
}
if receipt.review_duration_ms.unwrap_or_default() == 0 {
return Err(anyhow!("Bifrost metrics receipts require review duration"));
}
if receipt.review_event_count.unwrap_or_default() == 0 {
return Err(anyhow!(
"Bifrost metrics receipts require review event count"
));
}
Ok(())
}
pub fn write_epiphany_cultmesh_work_loop_telemetry(
store_path: impl AsRef<Path>,
telemetry: EpiphanyCultMeshWorkLoopTelemetryEntry,
) -> Result<EpiphanyCultMeshWorkLoopTelemetryEntry> {
validate_work_loop_telemetry(&telemetry)?;
let mut node = open_epiphany_cultmesh_node(&store_path, telemetry.runtime_id.clone())?;
let written = node.put(telemetry.telemetry_id.clone(), &telemetry)?;
let current_latest = node.get::<EpiphanyCultMeshWorkLoopTelemetryEntry>(
EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
work_loop_telemetry_event_key(&written) >= work_loop_telemetry_event_key(current)
}) {
node.put(EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_LATEST_KEY, &written)?;
}
node.flush()?;
Ok(written)
}
fn validate_work_loop_telemetry(telemetry: &EpiphanyCultMeshWorkLoopTelemetryEntry) -> Result<()> {
if telemetry.verse_id != EPIPHANY_CULTMESH_INTERNAL_VERSE_ID {
return Err(anyhow!(
"work-loop telemetry must remain in the internal Verse"
));
}
for (label, value) in [
("schema version", telemetry.schema_version.as_str()),
("runtime id", telemetry.runtime_id.as_str()),
("telemetry id", telemetry.telemetry_id.as_str()),
("source stage", telemetry.source_stage.as_str()),
("Hands intent id", telemetry.hands_intent_id.as_str()),
("Hands review id", telemetry.hands_review_id.as_str()),
(
"Hands runtime job id",
telemetry.hands_runtime_job_id.as_str(),
),
(
"Substrate Gate grant receipt id",
telemetry.substrate_gate_grant_receipt_id.as_str(),
),
(
"Hands patch receipt id",
telemetry.hands_patch_receipt_id.as_str(),
),
(
"Hands command receipt id",
telemetry.hands_command_receipt_id.as_str(),
),
(
"Hands commit receipt id",
telemetry.hands_commit_receipt_id.as_str(),
),
("command", telemetry.command.as_str()),
("commit SHA", telemetry.commit_sha.as_str()),
("branch", telemetry.branch.as_str()),
] {
if value.trim().is_empty() {
return Err(anyhow!("work-loop telemetry missing {label}"));
}
}
if telemetry.target_stages.is_empty()
|| telemetry
.target_stages
.iter()
.any(|stage| stage.trim().is_empty())
|| telemetry.changed_paths.is_empty()
|| telemetry
.changed_paths
.iter()
.any(|path| path.trim().is_empty())
{
return Err(anyhow!(
"work-loop telemetry requires nonempty target stages and changed paths"
));
}
let produced_at = DateTime::parse_from_rfc3339(&telemetry.produced_at_utc)
.map_err(|error| anyhow!("work-loop telemetry has invalid produced at: {error}"))?;
let lower_bound = DateTime::parse_from_rfc3339(&telemetry.lower_bound_receipt_at)
.map_err(|error| anyhow!("work-loop telemetry has invalid receipt lower bound: {error}"))?;
if lower_bound > produced_at {
return Err(anyhow!(
"work-loop telemetry receipt lower bound occurs after packet production"
));
}
Ok(())
}
fn work_loop_telemetry_event_key(
telemetry: &EpiphanyCultMeshWorkLoopTelemetryEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&telemetry.produced_at_utc)
.expect("validated work-loop telemetry timestamp"),
telemetry.telemetry_id.as_str(),
)
}
pub fn load_latest_epiphany_cultmesh_work_loop_telemetry(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshWorkLoopTelemetryEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_LATEST_KEY)
}
pub fn epiphany_local_verse_work_loop_summary(
telemetry: &EpiphanyCultMeshWorkLoopTelemetryEntry,
) -> EpiphanyLocalVerseWorkLoopSummary {
EpiphanyLocalVerseWorkLoopSummary {
telemetry_id: telemetry.telemetry_id.clone(),
thread_id: telemetry.thread_id.clone(),
source_stage: telemetry.source_stage.clone(),
target_stages: telemetry.target_stages.clone(),
hands_intent_id: telemetry.hands_intent_id.clone(),
hands_review_id: telemetry.hands_review_id.clone(),
substrate_gate_grant_receipt_id: telemetry.substrate_gate_grant_receipt_id.clone(),
hands_patch_receipt_id: telemetry.hands_patch_receipt_id.clone(),
hands_command_receipt_id: telemetry.hands_command_receipt_id.clone(),
hands_commit_receipt_id: telemetry.hands_commit_receipt_id.clone(),
commit_sha: telemetry.commit_sha.clone(),
branch: telemetry.branch.clone(),
changed_path_count: telemetry.changed_paths.len(),
source_ref_count: telemetry.source_refs.len(),
soul_receipt_ids: telemetry.soul_receipt_ids.clone(),
verification_assertion_count: telemetry.verification_assertions.len(),
summary: telemetry.summary.clone(),
sealed_preview_note: "Internal work-loop telemetry may carry receipt bodies, artifact previews, and commit diff previews; local Verse context exposes only this digest.".to_string(),
}
}
pub fn epiphany_cultmesh_agent_state_soa_summary_from_entry(
runtime_id: impl Into<String>,
summary_id: impl Into<String>,
soa: &EpiphanyAgentStateSoaEntry,
) -> EpiphanyCultMeshAgentStateSoaSummaryEntry {
EpiphanyCultMeshAgentStateSoaSummaryEntry {
schema_version: EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_SCHEMA_VERSION.to_string(),
runtime_id: runtime_id.into(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
summary_id: summary_id.into(),
generated_at: soa.generated_at.clone(),
source_store: soa.source_store.clone(),
row_count: soa.role_ids.len() as u32,
role_ids: soa.role_ids.clone(),
agent_ids: soa.agent_ids.clone(),
display_names: soa.display_names.clone(),
profile_kinds: soa.profile_kinds.clone(),
portable_contracts: soa.portable_contracts.clone(),
semantic_memory_counts: soa.semantic_memory_counts.clone(),
episodic_memory_counts: soa.episodic_memory_counts.clone(),
relationship_memory_counts: soa.relationship_memory_counts.clone(),
goal_counts: soa.goal_counts.clone(),
value_counts: soa.value_counts.clone(),
private_state_exposed: false,
notes: vec![
"Summary mirrors persisted epiphany.agent_state_soa.v0 column shape for local Verse discovery; agent memory text remains in the agent-memory store.".to_string(),
"CultMesh carries row/column topology for Odin, Eve, and prompt assembly without becoming the agent-memory owner.".to_string(),
],
}
}
pub fn write_epiphany_cultmesh_agent_state_soa_summary(
store_path: impl AsRef<Path>,
summary: EpiphanyCultMeshAgentStateSoaSummaryEntry,
) -> Result<EpiphanyCultMeshAgentStateSoaSummaryEntry> {
validate_agent_state_soa_summary(&summary)?;
let mut node = open_epiphany_cultmesh_node(&store_path, summary.runtime_id.clone())?;
let written = node.put(summary.summary_id.clone(), &summary)?;
let current_latest = node.get::<EpiphanyCultMeshAgentStateSoaSummaryEntry>(
EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_LATEST_KEY,
)?;
if current_latest.as_ref().is_none_or(|current| {
agent_state_soa_generation_key(&written) >= agent_state_soa_generation_key(current)
}) {
node.put(
EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_LATEST_KEY,
&written,
)?;
}
node.flush()?;
Ok(written)
}
pub fn load_latest_epiphany_cultmesh_agent_state_soa_summary(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshAgentStateSoaSummaryEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_LATEST_KEY)
}
fn validate_agent_state_soa_summary(
summary: &EpiphanyCultMeshAgentStateSoaSummaryEntry,
) -> Result<()> {
if summary.private_state_exposed {
return Err(anyhow!(
"agent state SoA summaries must not expose private state"
));
}
if summary.schema_version != EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_SCHEMA_VERSION {
return Err(anyhow!(
"agent state SoA summary schema_version must be {:?}",
EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_SCHEMA_VERSION
));
}
if summary.verse_id != EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID {
return Err(anyhow!(
"agent state SoA summary belongs in the local-area Verse"
));
}
DateTime::parse_from_rfc3339(&summary.generated_at)
.map_err(|error| anyhow!("agent state SoA summary has invalid generated_at: {error}"))?;
let len = summary.role_ids.len();
if summary.row_count as usize != len {
return Err(anyhow!(
"agent state SoA summary row_count is {}, expected {}",
summary.row_count,
len
));
}
for (name, candidate) in [
("agentIds", summary.agent_ids.len()),
("displayNames", summary.display_names.len()),
("profileKinds", summary.profile_kinds.len()),
("portableContracts", summary.portable_contracts.len()),
("semanticMemoryCounts", summary.semantic_memory_counts.len()),
("episodicMemoryCounts", summary.episodic_memory_counts.len()),
(
"relationshipMemoryCounts",
summary.relationship_memory_counts.len(),
),
("goalCounts", summary.goal_counts.len()),
("valueCounts", summary.value_counts.len()),
] {
if candidate != len {
return Err(anyhow!(
"agent state SoA summary column {name} has length {candidate}, expected {len}"
));
}
}
if summary
.role_ids
.iter()
.any(|role_id| role_id.trim().is_empty())
{
return Err(anyhow!("agent state SoA summary contains an empty role id"));
}
Ok(())
}
fn agent_state_soa_generation_key(
summary: &EpiphanyCultMeshAgentStateSoaSummaryEntry,
) -> (DateTime<FixedOffset>, &str) {
(
DateTime::parse_from_rfc3339(&summary.generated_at)
.expect("validated agent state SoA generation timestamp"),
summary.summary_id.as_str(),
)
}
pub fn load_latest_epiphany_cultmesh_repo_work_overview(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshRepoWorkOverviewEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_repo_work_overviews(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshRepoWorkOverviewEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut overviews = node
.get_all_with_keys::<EpiphanyCultMeshRepoWorkOverviewEntry>()?
.into_iter()
.filter(|(key, _)| key != EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_LATEST_KEY)
.map(|(_, overview)| overview)
.collect::<Vec<_>>();
overviews.sort_by(|a, b| {
b.generated_at
.cmp(&a.generated_at)
.then_with(|| a.overview_id.cmp(&b.overview_id))
});
Ok(overviews)
}
pub fn load_latest_epiphany_cultmesh_repo_work_readiness(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshRepoWorkReadinessEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_REPO_WORK_READINESS_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_repo_work_readiness_reports(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshRepoWorkReadinessEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut reports = node
.get_all_with_keys::<EpiphanyCultMeshRepoWorkReadinessEntry>()?
.into_iter()
.filter(|(key, _)| key != EPIPHANY_CULTMESH_REPO_WORK_READINESS_LATEST_KEY)
.map(|(_, report)| report)
.collect::<Vec<_>>();
reports.sort_by(|a, b| {
b.generated_at
.cmp(&a.generated_at)
.then_with(|| a.readiness_id.cmp(&b.readiness_id))
});
Ok(reports)
}
pub fn load_latest_epiphany_cultmesh_repo_work_map_entry(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshRepoWorkMapEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_repo_work_map_entries(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshRepoWorkMapEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut entries = node
.get_all_with_keys::<EpiphanyCultMeshRepoWorkMapEntry>()?
.into_iter()
.filter(|(key, _)| key != EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_LATEST_KEY)
.map(|(_, entry)| entry)
.collect::<Vec<_>>();
entries.sort_by(|a, b| {
b.admitted_at
.cmp(&a.admitted_at)
.then_with(|| a.map_entry_id.cmp(&b.map_entry_id))
});
Ok(entries)
}
pub fn load_latest_epiphany_cultmesh_repo_work_public_proof(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Option<EpiphanyCultMeshRepoWorkPublicProofEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.get(EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_LATEST_KEY)
}
pub fn load_epiphany_cultmesh_repo_work_public_proofs(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshRepoWorkPublicProofEntry>> {
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut proofs = node
.get_all_with_keys::<EpiphanyCultMeshRepoWorkPublicProofEntry>()?
.into_iter()
.filter(|(key, _)| key != EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_LATEST_KEY)
.map(|(_, proof)| proof)
.collect::<Vec<_>>();
proofs.sort_by(|a, b| {
b.generated_at
.cmp(&a.generated_at)
.then_with(|| a.public_proof_id.cmp(&b.public_proof_id))
});
Ok(proofs)
}
pub fn seed_epiphany_local_verse_context(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
generated_at_utc: impl Into<String>,
body_domain: impl Into<String>,
) -> Result<()> {
let store_path = store_path.as_ref();
retire_epiphany_cultmesh_legacy_provider_documents(store_path)?;
let runtime_id = runtime_id.into();
let generated_at_utc = generated_at_utc.into();
let body_domain = body_domain.into();
if !body_domain.starts_with("repo:") || body_domain.trim() == "repo:" {
anyhow::bail!("local Verse repository topology requires an explicit repo: Body domain");
}
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_cluster_topology(store_path, runtime_id.clone(), body_domain)?;
{
let node = open_epiphany_cultmesh_node(store_path, runtime_id.clone())?;
if node
.get::<EpiphanyCultMeshSwarmBrakeEntry>(EPIPHANY_CULTMESH_SWARM_BRAKE_KEY)?
.is_none()
{
write_epiphany_cultmesh_swarm_brake(
store_path,
runtime_id.clone(),
default_epiphany_cultmesh_swarm_brake(generated_at_utc.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_bifrost_contracts(store_path, runtime_id.clone())?;
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();
if !store_path.exists() {
anyhow::bail!(
"local Verse store does not exist at {}",
store_path.display()
);
}
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 cluster_topology = Vec::new();
for cluster in epiphany_cultmesh_cluster_topology() {
if let Some(loaded) =
node.get::<EpiphanyCultMeshClusterTopologyEntry>(&cluster.cluster_id)?
{
cluster_topology.push(loaded);
}
}
// v0 provider documents have no provider provenance. They are sealed
// legacy decoder vocabulary and never enter live context.
let odin_advertisements = Vec::new();
let eve_surface_states = Vec::new();
let mut daemon_statuses = Vec::new();
for cluster in epiphany_cultmesh_cluster_topology() {
if let Some(loaded) = node.get::<EpiphanyCultMeshDaemonStatusEntry>(&cluster.daemon_id)? {
daemon_statuses.push(loaded);
}
}
let mut daemon_restart_policies = Vec::new();
for status in &daemon_statuses {
let key = epiphany_cultmesh_daemon_restart_policy_key(&status.daemon_id);
if let Some(loaded) = node.get::<EpiphanyCultMeshDaemonRestartPolicyEntry>(key.as_str())? {
daemon_restart_policies.push(loaded);
}
}
let daemon_tool_capabilities = Vec::new();
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,
)?;
collect_contract_summaries(
&node,
epiphany_cultmesh_bifrost_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,
cluster_topology,
odin_advertisements,
eve_surface_states,
daemon_statuses,
latest_daemon_poke_intent: node.get(EPIPHANY_CULTMESH_DAEMON_POKE_INTENT_LATEST_KEY)?,
latest_daemon_poke_receipt: node.get(EPIPHANY_CULTMESH_DAEMON_POKE_RECEIPT_LATEST_KEY)?,
daemon_restart_policies,
latest_daemon_scheduler_receipt: node
.get(EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_LATEST_KEY)?,
latest_daemon_service_lifecycle_receipt: node
.get(EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY)?,
latest_idunn_deployment_receipt: node
.get(EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_LATEST_KEY)?,
latest_idunn_aftercare_audit_receipt: node
.get(EPIPHANY_CULTMESH_IDUNN_AFTERCARE_AUDIT_RECEIPT_LATEST_KEY)?,
swarm_brake: node.get(EPIPHANY_CULTMESH_SWARM_BRAKE_KEY)?,
latest_persona_speech_audit: node
.get(EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_LATEST_KEY)?,
latest_weksa_lowering_receipt: node
.get(EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_LATEST_KEY)?,
daemon_tool_capabilities,
latest_daemon_tool_invocation_intent: node
.get(EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_INTENT_LATEST_KEY)?,
latest_daemon_tool_invocation_receipt: node
.get(EPIPHANY_CULTMESH_DAEMON_TOOL_INVOCATION_RECEIPT_LATEST_KEY)?,
arrival_latest_bifrost_body_change_publication_intent: node
.get(EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_ARRIVAL_LATEST_KEY)?,
arrival_latest_bifrost_body_change_publication_receipt: node
.get(EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY)?,
arrival_latest_bifrost_github_publication_receipt: node
.get(EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_ARRIVAL_LATEST_KEY)?,
arrival_latest_bifrost_public_proof_publication_receipt: node
.get(EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_ARRIVAL_LATEST_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)?,
latest_coordinator_run_receipt: node
.get(EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_LATEST_KEY)?,
latest_hands_action_gate: node.get(EPIPHANY_CULTMESH_HANDS_ACTION_GATE_LATEST_KEY)?,
latest_role_review_event: node.get(EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_LATEST_KEY)?,
latest_work_loop_summary: node
.get::<EpiphanyCultMeshWorkLoopTelemetryEntry>(
EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_LATEST_KEY,
)?
.as_ref()
.map(epiphany_local_verse_work_loop_summary),
latest_agent_state_soa_summary: node
.get(EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_LATEST_KEY)?,
latest_repo_work_overview: node.get(EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_LATEST_KEY)?,
latest_repo_work_map_entry: node.get(EPIPHANY_CULTMESH_REPO_WORK_MAP_ENTRY_LATEST_KEY)?,
contract_summaries,
})
}
pub fn load_epiphany_cultmesh_daemon_liveness(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<
Vec<(
EpiphanyCultMeshClusterTopologyEntry,
EpiphanyCultMeshDaemonStatusEntry,
)>,
> {
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 rows = Vec::new();
for cluster in load_epiphany_cultmesh_cluster_topology(store_path, runtime_id.clone())? {
if let Some(status) = node.get::<EpiphanyCultMeshDaemonStatusEntry>(&cluster.daemon_id)? {
rows.push((cluster, status));
}
}
Ok(rows)
}
pub fn load_epiphany_cultmesh_daemon_restart_policy_directory(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<
Vec<(
EpiphanyCultMeshClusterTopologyEntry,
Option<EpiphanyCultMeshDaemonStatusEntry>,
Option<EpiphanyCultMeshDaemonRestartPolicyEntry>,
)>,
> {
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 rows = Vec::new();
for cluster in load_epiphany_cultmesh_cluster_topology(store_path, runtime_id.clone())? {
let status = node.get::<EpiphanyCultMeshDaemonStatusEntry>(&cluster.daemon_id)?;
let policy = node.get::<EpiphanyCultMeshDaemonRestartPolicyEntry>(
&epiphany_cultmesh_daemon_restart_policy_key(&cluster.daemon_id),
)?;
rows.push((cluster, status, policy));
}
Ok(rows)
}
pub fn load_epiphany_cultmesh_eve_surface_directory(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<
Vec<(
EpiphanyCultMeshClusterTopologyEntry,
EpiphanyCultMeshOdinAdvertisementEntry,
EpiphanyCultMeshEveSurfaceStateEntry,
)>,
> {
let _ = open_epiphany_cultmesh_node(store_path, runtime_id)?;
// No provenance-bearing provider advertisement contract exists yet.
// Topology supplies addresses, never availability.
Ok(Vec::new())
}
pub fn load_epiphany_cultmesh_daemon_tool_directory(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<
Vec<(
EpiphanyCultMeshClusterTopologyEntry,
EpiphanyCultMeshDaemonStatusEntry,
EpiphanyCultMeshDaemonToolCapabilityEntry,
)>,
> {
let _ = open_epiphany_cultmesh_node(store_path, runtime_id)?;
// v0 capabilities have no authenticated provider owner and are ignored.
Ok(Vec::new())
}
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);
impl_contract_summary_source!(EpiphanyCultMeshBifrostContractEntry);
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 epiphany_cultmesh_coordinator_run_receipt_key(receipt_id: &str) -> String {
format!("epiphany-local/coordinator-run-receipt/{receipt_id}")
}
fn epiphany_cultmesh_hands_action_gate_key(gate_id: &str) -> String {
format!("epiphany-local/hands-action-gate/{gate_id}")
}
fn epiphany_cultmesh_role_review_event_key(event_id: &str) -> String {
format!("epiphany-local/role-review-event/{event_id}")
}
fn epiphany_cultmesh_persona_speech_audit_key(audit_id: &str) -> String {
format!("epiphany-local/persona-speech-audit/{audit_id}")
}
fn epiphany_cultmesh_weksa_lowering_receipt_key(receipt_id: &str) -> String {
format!("epiphany-local/weksa-lowering-receipt/{receipt_id}")
}
fn epiphany_cultmesh_daemon_tool_invocation_intent_key(intent_id: &str) -> String {
format!("epiphany-local/daemon-tool-invocation-intent/{intent_id}")
}
fn epiphany_cultmesh_daemon_poke_intent_key(intent_id: &str) -> String {
format!("epiphany-local/daemon-poke-intent/{intent_id}")
}
fn epiphany_cultmesh_daemon_poke_receipt_key(receipt_id: &str) -> String {
format!("epiphany-local/daemon-poke-receipt/{receipt_id}")
}
fn epiphany_cultmesh_daemon_restart_policy_key(daemon_id: &str) -> String {
format!("epiphany-local/daemon-restart-policy/{daemon_id}")
}
fn epiphany_cultmesh_daemon_scheduler_receipt_key(receipt_id: &str) -> String {
format!("epiphany-local/daemon-scheduler-receipt/{receipt_id}")
}
fn epiphany_cultmesh_daemon_service_lifecycle_receipt_key(receipt_id: &str) -> String {
format!("epiphany-local/daemon-service-lifecycle-receipt/{receipt_id}")
}
fn epiphany_cultmesh_daemon_service_lifecycle_receipt_latest_key(service_id: &str) -> String {
format!("epiphany-local/daemon-service-lifecycle-receipt/latest/{service_id}")
}
fn epiphany_cultmesh_managed_service_policy_key(service_id: &str) -> String {
format!("epiphany-local/managed-service-policy/{service_id}")
}
fn epiphany_cultmesh_idunn_deployment_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/idunn/deployment-receipt/{receipt_id}")
}
fn epiphany_cultmesh_idunn_deployment_receipt_ref_key(receipt_ref: &str) -> String {
let trimmed = receipt_ref.trim();
if trimmed.is_empty() || trimmed == "latest" {
EPIPHANY_CULTMESH_IDUNN_DEPLOYMENT_RECEIPT_LATEST_KEY.to_string()
} else if trimmed.starts_with("gamecult-local/") {
trimmed.to_string()
} else {
epiphany_cultmesh_idunn_deployment_receipt_key(trimmed)
}
}
fn epiphany_cultmesh_idunn_aftercare_audit_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/idunn/deployment-aftercare-audit/{receipt_id}")
}
fn epiphany_cultmesh_idunn_aftercare_audit_receipt_ref_key(receipt_ref: &str) -> String {
let trimmed = receipt_ref.trim();
if trimmed.is_empty() || trimmed == "latest" {
EPIPHANY_CULTMESH_IDUNN_AFTERCARE_AUDIT_RECEIPT_LATEST_KEY.to_string()
} else if trimmed.starts_with("gamecult-local/") {
trimmed.to_string()
} else {
epiphany_cultmesh_idunn_aftercare_audit_receipt_key(trimmed)
}
}
#[cfg(test)]
fn epiphany_cultmesh_daemon_tool_invocation_receipt_key(receipt_id: &str) -> String {
format!("epiphany-local/daemon-tool-invocation-receipt/{receipt_id}")
}
fn epiphany_cultmesh_bifrost_body_change_publication_intent_key(intent_id: &str) -> String {
format!("gamecult-local/bifrost/body-change-publication-intent/{intent_id}")
}
#[cfg(test)]
fn epiphany_cultmesh_bifrost_body_change_publication_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/bifrost/body-change-publication-receipt/{receipt_id}")
}
#[cfg(test)]
fn epiphany_cultmesh_bifrost_github_publication_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/bifrost/github-publication-receipt/{receipt_id}")
}
#[cfg(test)]
fn epiphany_cultmesh_bifrost_public_proof_publication_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/bifrost/public-proof-publication-receipt/{receipt_id}")
}
#[cfg(test)]
fn epiphany_cultmesh_bifrost_artifact_acceptance_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/bifrost/artifact-acceptance-receipt/{receipt_id}")
}
#[cfg(test)]
fn epiphany_cultmesh_bifrost_metrics_receipt_key(receipt_id: &str) -> String {
format!("gamecult-local/bifrost/metrics-receipt/{receipt_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_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.",
),
(
"Personas",
"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_cluster_topology() -> Vec<EpiphanyCultMeshClusterTopologyEntry> {
epiphany_cultmesh_cluster_topology_for_body("repo:unbound")
}
pub fn epiphany_cultmesh_cluster_topology_for_body(
body_domain: impl Into<String>,
) -> Vec<EpiphanyCultMeshClusterTopologyEntry> {
let body_domain = body_domain.into();
[
("self", "coordinator", "Self", false),
("hands", "implementation", "Hands", false),
("persona", "Persona", "Persona", true),
("imagination", "imagination", "Imagination", false),
("eyes", "research", "Eyes", false),
("modeling", "modeling", "Modeling", false),
("soul", "verification", "Soul", false),
]
.into_iter()
.map(
|(cluster_slug, role_id, display_name, public_persona_discussion_allowed)| {
let cluster_id = format!("epiphany.cluster.{cluster_slug}");
EpiphanyCultMeshClusterTopologyEntry {
schema_version: EPIPHANY_CULTMESH_CLUSTER_TOPOLOGY_SCHEMA_VERSION.to_string(),
cluster_id: cluster_id.clone(),
role_id: role_id.to_string(),
display_name: display_name.to_string(),
private_verse_id: format!("{cluster_id}.private"),
body_domain: body_domain.clone(),
body_kind: "repository".to_string(),
daemon_id: format!("epiphany-daemon-{cluster_slug}"),
daemon_surface_id: format!("epiphany-daemon-{cluster_slug}/local"),
eve_surface_id: format!("eve://epiphany/{cluster_slug}"),
public_persona_discussion_allowed,
notes: vec![
format!(
"CultMesh advertises this cluster topology as {EPIPHANY_CULTMESH_CLUSTER_TOPOLOGY_TYPE}."
),
"Private Verse carries cluster-local typed state and is not public collaboration weather.".to_string(),
"Odin may advertise compact metadata and Eve connection hints, but not private state payloads.".to_string(),
"The body domain names the substrate this cluster serves; Substrate Gate still governs repo access.".to_string(),
],
}
},
)
.collect()
}
pub fn write_epiphany_cultmesh_cluster_topology(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
body_domain: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshClusterTopologyEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for cluster in epiphany_cultmesh_cluster_topology_for_body(body_domain) {
written.push(node.put(cluster.cluster_id.clone(), &cluster)?);
}
node.flush()?;
Ok(written)
}
pub fn load_epiphany_cultmesh_cluster_topology(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshClusterTopologyEntry>> {
let store_path = store_path.as_ref();
let node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut topology = Vec::new();
for cluster in epiphany_cultmesh_cluster_topology() {
if let Some(loaded) =
node.get::<EpiphanyCultMeshClusterTopologyEntry>(&cluster.cluster_id)?
{
topology.push(loaded);
}
}
Ok(topology)
}
#[cfg(test)]
fn epiphany_cultmesh_odin_advertisement_templates() -> Vec<EpiphanyCultMeshOdinAdvertisementEntry> {
epiphany_cultmesh_cluster_topology()
.into_iter()
.map(|cluster| EpiphanyCultMeshOdinAdvertisementEntry {
schema_version: EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_SCHEMA_VERSION.to_string(),
advertisement_id: format!("odin.advertisement.{}", cluster.cluster_id),
cluster_id: cluster.cluster_id.clone(),
advertised_verse_id: cluster.private_verse_id.clone(),
body_domain: cluster.body_domain.clone(),
body_kind: cluster.body_kind.clone(),
daemon_surface_id: cluster.daemon_surface_id.clone(),
eve_surface_id: cluster.eve_surface_id.clone(),
public_summary: format!(
"{} exposes an operator-safe Eve surface for compact CultMesh collaboration discovery.",
cluster.display_name
),
advertised_document_types: vec![
EPIPHANY_CULTMESH_CLUSTER_TOPOLOGY_TYPE.to_string(),
EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_TYPE.to_string(),
EPIPHANY_CULTMESH_VERSE_POLICY_TYPE.to_string(),
],
trust_boundary:
"Odin discovery metadata is operator-safe; private Verse payloads stay behind the cluster boundary."
.to_string(),
private_state_exposed: false,
notes: vec![
"This advertisement is discovery metadata, not membership in the private Verse.".to_string(),
"Peers may use the Eve surface hint to request collaboration through CultMesh contracts.".to_string(),
"Mind and Substrate Gate still review adoption, state mutation, and repo access.".to_string(),
],
})
.collect()
}
#[cfg(test)]
fn epiphany_cultmesh_eve_surface_templates() -> Vec<EpiphanyCultMeshEveSurfaceStateEntry> {
epiphany_cultmesh_cluster_topology()
.into_iter()
.map(|cluster| {
let mut exposed_document_types = vec![
EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_TYPE.to_string(),
EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_TYPE.to_string(),
EPIPHANY_CULTMESH_REPO_WORK_OVERVIEW_TYPE.to_string(),
];
if cluster.role_id == "hands" {
exposed_document_types.push(
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_TYPE.to_string(),
);
exposed_document_types.push(
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_TYPE.to_string(),
);
exposed_document_types
.push(EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_TYPE.to_string());
}
EpiphanyCultMeshEveSurfaceStateEntry {
schema_version: EPIPHANY_CULTMESH_EVE_SURFACE_STATE_SCHEMA_VERSION.to_string(),
surface_id: cluster.eve_surface_id.clone(),
cluster_id: cluster.cluster_id.clone(),
daemon_id: cluster.daemon_id.clone(),
body_domain: cluster.body_domain.clone(),
tui_title: format!("{} / {}", cluster.display_name, cluster.body_domain),
tui_rows: vec![
format!("cluster {}", cluster.cluster_id),
format!("body {}", cluster.body_domain),
format!("daemon {}", cluster.daemon_id),
format!("private {}", cluster.private_verse_id),
"presentation surface only; private Verse payloads are sealed".to_string(),
],
exposed_document_types,
supported_actions: vec![
"inspectCompactSurface".to_string(),
"watchTypedReceipts".to_string(),
],
private_state_exposed: false,
notes: vec![
"Eve surface state is compact operator-safe TUI/API state owned by the cluster daemon.".to_string(),
"Odin may advertise this surface id, but it must not synthesize the surface contents.".to_string(),
"Rows are agent-friendly hints, not private Verse state dumps.".to_string(),
],
}
})
.collect()
}
#[cfg(test)]
fn validate_eve_surface_state(surface: &EpiphanyCultMeshEveSurfaceStateEntry) -> Result<()> {
if surface.private_state_exposed {
return Err(anyhow!("Eve surface states must not expose private state"));
}
if !surface.surface_id.starts_with("eve://") {
return Err(anyhow!("Eve surface states require an eve:// surface id"));
}
if surface.tui_rows.is_empty() {
return Err(anyhow!("Eve surface states require compact TUI rows"));
}
if surface.exposed_document_types.is_empty() {
return Err(anyhow!(
"Eve surface states require exposed document type hints"
));
}
Ok(())
}
#[cfg(test)]
pub fn epiphany_cultmesh_daemon_statuses(
last_heartbeat_utc: impl Into<String>,
) -> Vec<EpiphanyCultMeshDaemonStatusEntry> {
let last_heartbeat_utc = last_heartbeat_utc.into();
epiphany_cultmesh_cluster_topology()
.into_iter()
.map(|cluster| EpiphanyCultMeshDaemonStatusEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_STATUS_SCHEMA_VERSION.to_string(),
daemon_id: cluster.daemon_id.clone(),
cluster_id: cluster.cluster_id.clone(),
body_domain: cluster.body_domain.clone(),
daemon_surface_id: cluster.daemon_surface_id.clone(),
eve_surface_id: cluster.eve_surface_id.clone(),
status: "ready".to_string(),
last_heartbeat_utc: last_heartbeat_utc.clone(),
supported_actions: vec![
"inspectStatus".to_string(),
"pokeDaemon".to_string(),
"watchHeartbeat".to_string(),
"submitTypedToolIntent".to_string(),
],
operator_action: "none".to_string(),
private_state_exposed: false,
notes: vec![
"Daemon status is operator-safe liveness telemetry for the deployed cluster body.".to_string(),
"A down daemon should be poked through typed operator/daemon action receipts, not by private Verse rummaging.".to_string(),
"This status may name surfaces and actions but must not expose worker thoughts or private state.".to_string(),
],
})
.collect()
}
#[cfg(test)]
pub fn write_epiphany_cultmesh_daemon_statuses(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
last_heartbeat_utc: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshDaemonStatusEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for status in epiphany_cultmesh_daemon_statuses(last_heartbeat_utc) {
validate_daemon_status(&status)?;
written.push(node.put(status.daemon_id.clone(), &status)?);
}
node.flush()?;
Ok(written)
}
pub fn write_epiphany_cultmesh_daemon_status(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
status: EpiphanyCultMeshDaemonStatusEntry,
) -> Result<EpiphanyCultMeshDaemonStatusEntry> {
validate_daemon_status(&status)?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let written = node.put(status.daemon_id.clone(), &status)?;
node.flush()?;
Ok(written)
}
fn epiphany_cultmesh_daemon_heartbeat_event_key(heartbeat_id: &str) -> String {
format!("epiphany-local/daemon-heartbeat/event/{heartbeat_id}")
}
fn epiphany_cultmesh_daemon_heartbeat_latest_key(daemon_id: &str) -> String {
format!("epiphany-local/daemon-heartbeat/{daemon_id}/latest")
}
pub fn write_epiphany_cultmesh_daemon_heartbeat_event(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
event: EpiphanyCultMeshDaemonHeartbeatEventEntry,
) -> Result<EpiphanyCultMeshDaemonHeartbeatEventEntry> {
validate_daemon_heartbeat_event(&event)?;
let store_path = store_path.as_ref();
let runtime_id = runtime_id.into();
let event_key = epiphany_cultmesh_daemon_heartbeat_event_key(&event.heartbeat_id);
let latest_key = epiphany_cultmesh_daemon_heartbeat_latest_key(&event.daemon_id);
let backing = SingleFileMessagePackBackingStore::new(store_path);
for _ in 0..8 {
let node = open_epiphany_cultmesh_node(store_path, runtime_id.clone())?;
if let Some(existing) = node.get::<EpiphanyCultMeshDaemonHeartbeatEventEntry>(&event_key)? {
return if existing == event {
Ok(existing)
} else {
Err(anyhow!(
"immutable daemon heartbeat identity collision for {:?}",
event.heartbeat_id
))
};
}
let latest = node.get::<EpiphanyCultMeshDaemonHeartbeatEventEntry>(&latest_key)?;
let advances_latest = match latest.as_ref() {
Some(current) => daemon_heartbeat_advances(current, &event)?,
None => true,
};
let event_envelope = node.cache().prepare_entry(&event_key, &event)?.0;
let mut replacements = vec![event_envelope];
let mut expected = Vec::new();
if advances_latest {
if let Some(envelope) = node
.cache()
.get_envelope::<EpiphanyCultMeshDaemonHeartbeatEventEntry>(&latest_key)?
{
expected.push(envelope);
}
replacements.push(node.cache().prepare_entry(&latest_key, &event)?.0);
}
if backing.compare_and_swap_batch(&expected, replacements)? {
return Ok(event);
}
}
Err(anyhow!(
"daemon heartbeat latest advanced during publication"
))
}
pub fn load_epiphany_cultmesh_daemon_heartbeat_event(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
heartbeat_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonHeartbeatEventEntry>> {
validate_heartbeat_identifier("heartbeat", heartbeat_id)?;
open_epiphany_cultmesh_node(store_path, runtime_id)?
.get(&epiphany_cultmesh_daemon_heartbeat_event_key(heartbeat_id))
}
pub fn load_latest_epiphany_cultmesh_daemon_heartbeat(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
daemon_id: &str,
) -> Result<Option<EpiphanyCultMeshDaemonHeartbeatEventEntry>> {
validate_heartbeat_identifier("daemon", daemon_id)?;
open_epiphany_cultmesh_node(store_path, runtime_id)?
.get(&epiphany_cultmesh_daemon_heartbeat_latest_key(daemon_id))
}
#[allow(clippy::too_many_arguments)]
pub fn idunn_recover_memory_semantic_projection_from_cultmesh(
verse_store: impl AsRef<Path>,
runtime_id: impl Into<String>,
canonical_store: impl AsRef<Path>,
input: &crate::MemorySemanticProjectionInput,
expected_claim_id: &str,
replacement_executor_id: &str,
launch_lifecycle_receipt_id: &str,
provider_heartbeat_id: &str,
recovered_at: &str,
) -> Result<(
crate::MemorySemanticProjectorRecoveryAuthorization,
crate::MemorySemanticProjectionClaim,
)> {
let verse_store = verse_store.as_ref();
let runtime_id = runtime_id.into();
let canonical_store = canonical_store.as_ref();
crate::observe_memory_semantic_projection(canonical_store, input)?;
let receipt = authenticate_epiphany_cultmesh_semantic_projector_launch(
verse_store,
runtime_id.clone(),
launch_lifecycle_receipt_id,
)?;
let (policy, policy_digest) = load_epiphany_cultmesh_managed_service_policy_with_digest(
verse_store,
runtime_id.clone(),
EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID,
)?
.ok_or_else(|| anyhow!("Idunn recovery managed service policy is absent"))?;
let node = open_epiphany_cultmesh_node(verse_store, runtime_id)?;
let receipt_key =
epiphany_cultmesh_daemon_service_lifecycle_receipt_key(launch_lifecycle_receipt_id);
let heartbeat_key = epiphany_cultmesh_daemon_heartbeat_event_key(provider_heartbeat_id);
let heartbeat = node
.get::<EpiphanyCultMeshDaemonHeartbeatEventEntry>(&heartbeat_key)?
.ok_or_else(|| anyhow!("Idunn recovery provider heartbeat is absent"))?;
validate_daemon_heartbeat_event(&heartbeat)?;
if heartbeat.heartbeat_id != provider_heartbeat_id
|| heartbeat.daemon_id != receipt.provider_daemon_id
|| heartbeat.cluster_id != "local"
|| heartbeat.status != "ready"
|| heartbeat.startup_lifecycle_receipt_id != receipt.receipt_id
{
return Err(anyhow!("Idunn recovery provider heartbeat disagrees"));
}
let receipt_completed_at = receipt
.completed_at_utc
.as_deref()
.ok_or_else(|| anyhow!("Idunn recovery launch receipt is not completed"))?;
let receipt_completed = DateTime::parse_from_rfc3339(receipt_completed_at)?;
let heartbeat_at = DateTime::parse_from_rfc3339(&heartbeat.heartbeat_at)?;
if heartbeat_at <= receipt_completed {
return Err(anyhow!(
"Idunn recovery heartbeat must follow lifecycle completion"
));
}
let receipt_digest = cultmesh_envelope_digest::<
EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry,
>(&node, &receipt_key)?;
let heartbeat_digest = cultmesh_envelope_digest::<EpiphanyCultMeshDaemonHeartbeatEventEntry>(
&node,
&heartbeat_key,
)?;
let evidence =
crate::memory_graph::semantic_projector::idunn_semantic_recovery_evidence_from_cultmesh(
canonical_store,
input,
expected_claim_id,
&format!("idunn-{}", Uuid::new_v4()),
&policy.policy_id,
&policy_digest,
&receipt.receipt_id,
&receipt_digest,
receipt_completed_at,
&heartbeat.heartbeat_id,
&heartbeat_digest,
&heartbeat.provider_incarnation,
&heartbeat.heartbeat_at,
&heartbeat.startup_lifecycle_receipt_id,
)?;
crate::memory_graph::semantic_projector::idunn_recover_memory_semantic_projection(
canonical_store,
input,
expected_claim_id,
replacement_executor_id,
&heartbeat.provider_incarnation,
&evidence,
recovered_at,
)
}
fn cultmesh_envelope_digest<T: DatabaseEntry>(node: &CultMeshNode, key: &str) -> Result<String> {
let envelope = node
.cache()
.get_envelope::<T>(key)?
.ok_or_else(|| anyhow!("authenticated CultMesh evidence envelope disappeared"))?;
let mut digest = Sha256::new();
digest.update(envelope.r#type.as_bytes());
digest.update([0]);
digest.update(envelope.key.as_bytes());
digest.update([0]);
digest.update(&envelope.payload);
Ok(format!("sha256-{:x}", digest.finalize()))
}
fn daemon_heartbeat_advances(
current: &EpiphanyCultMeshDaemonHeartbeatEventEntry,
candidate: &EpiphanyCultMeshDaemonHeartbeatEventEntry,
) -> Result<bool> {
validate_daemon_heartbeat_event(current)?;
let current_time = DateTime::parse_from_rfc3339(&current.heartbeat_at)?;
let candidate_time = DateTime::parse_from_rfc3339(&candidate.heartbeat_at)?;
if current.provider_incarnation == candidate.provider_incarnation {
if candidate.sequence > current.sequence && candidate_time < current_time {
return Err(anyhow!(
"daemon heartbeat time regressed within provider incarnation"
));
}
if candidate.sequence <= current.sequence {
return Ok(false);
}
}
Ok(
(candidate_time, candidate.sequence, &candidate.heartbeat_id)
> (current_time, current.sequence, &current.heartbeat_id),
)
}
fn validate_daemon_heartbeat_event(
event: &EpiphanyCultMeshDaemonHeartbeatEventEntry,
) -> Result<()> {
if event.schema_version != EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION {
return Err(anyhow!("unsupported daemon heartbeat schema"));
}
if event.daemon_id == EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID {
return Err(anyhow!(
"workspace coverage provider authority belongs to its specialized signed heartbeat"
));
}
validate_heartbeat_identifier("heartbeat", &event.heartbeat_id)?;
validate_heartbeat_identifier("daemon", &event.daemon_id)?;
validate_heartbeat_identifier("cluster", &event.cluster_id)?;
validate_heartbeat_identifier("provider incarnation", &event.provider_incarnation)?;
if !event.startup_lifecycle_receipt_id.is_empty() {
validate_heartbeat_identifier(
"startup lifecycle receipt",
&event.startup_lifecycle_receipt_id,
)?;
}
if event.sequence == 0 {
return Err(anyhow!("daemon heartbeat sequence must be positive"));
}
if !matches!(event.status.as_str(), "ready" | "degraded" | "stopping") {
return Err(anyhow!("invalid daemon heartbeat status"));
}
DateTime::parse_from_rfc3339(&event.heartbeat_at)
.context("daemon heartbeat requires RFC3339 heartbeat_at")?;
if event.private_state_exposed {
return Err(anyhow!("daemon heartbeat must not expose private state"));
}
Ok(())
}
fn validate_heartbeat_identifier(label: &str, value: &str) -> Result<()> {
if value.is_empty()
|| value.len() > 128
|| !value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.'))
{
return Err(anyhow!(
"daemon heartbeat requires a bounded opaque {label} id"
));
}
Ok(())
}
fn validate_daemon_status(status: &EpiphanyCultMeshDaemonStatusEntry) -> Result<()> {
if status.private_state_exposed {
return Err(anyhow!("daemon statuses must not expose private state"));
}
if status.daemon_id.trim().is_empty() || status.cluster_id.trim().is_empty() {
return Err(anyhow!("daemon statuses require daemon and cluster ids"));
}
if status.status.trim().is_empty() {
return Err(anyhow!("daemon statuses require a status"));
}
if status.last_heartbeat_utc.trim().is_empty() {
return Err(anyhow!("daemon statuses require a heartbeat timestamp"));
}
if status.supported_actions.is_empty() {
return Err(anyhow!(
"daemon statuses require supported operator actions"
));
}
Ok(())
}
#[cfg(test)]
fn epiphany_cultmesh_daemon_tool_capability_templates()
-> Vec<EpiphanyCultMeshDaemonToolCapabilityEntry> {
let mut capabilities = Vec::new();
for cluster in epiphany_cultmesh_cluster_topology() {
capabilities.push(epiphany_cultmesh_daemon_tool_capability(
&cluster,
"status",
"readStatus",
EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_TYPE,
"epiphany.cultmesh.tool_status_receipt",
"none",
));
}
capabilities.push(epiphany_cultmesh_daemon_tool_capability(
&epiphany_cultmesh_cluster_topology()
.into_iter()
.find(|cluster| cluster.cluster_id == "epiphany.cluster.self")
.expect("self cluster topology exists"),
"service-health",
"readServiceLifecycleStatus",
"epiphany.cultmesh.daemon_service_lifecycle_query",
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE,
"daemon.service_lifecycle",
));
capabilities.push(epiphany_cultmesh_daemon_tool_capability(
&epiphany_cultmesh_cluster_topology()
.into_iter()
.find(|cluster| cluster.cluster_id == "epiphany.cluster.self")
.expect("self cluster topology exists"),
"service-policy-directory",
"readServicePolicyDirectory",
"epiphany.cultmesh.daemon_restart_policy_directory_query",
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE,
"daemon.service_lifecycle",
));
capabilities.push(epiphany_cultmesh_daemon_tool_capability(
&epiphany_cultmesh_cluster_topology()
.into_iter()
.find(|cluster| cluster.cluster_id == "epiphany.cluster.self")
.expect("self cluster topology exists"),
"swarm-online-runbook",
"prepareSwarmOnlineRunbook",
"epiphany.cultmesh.daemon_service_online_runbook_request",
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE,
"daemon.service_lifecycle",
));
capabilities.push(epiphany_cultmesh_daemon_tool_capability(
&epiphany_cultmesh_cluster_topology()
.into_iter()
.find(|cluster| cluster.cluster_id == "epiphany.cluster.hands")
.expect("hands cluster topology exists"),
"repo-action",
"submitHandsActionIntent",
"epiphany.hands.action_intent",
"epiphany.hands.action_review",
"hands",
));
capabilities.push(epiphany_cultmesh_daemon_tool_capability(
&epiphany_cultmesh_cluster_topology()
.into_iter()
.find(|cluster| cluster.cluster_id == "epiphany.cluster.soul")
.expect("soul cluster topology exists"),
"verify",
"submitVerificationRequest",
"epiphany.soul.verification_request",
"epiphany.soul.verdict_receipt",
"soul",
));
capabilities
}
#[cfg(test)]
fn epiphany_cultmesh_daemon_tool_capability(
cluster: &EpiphanyCultMeshClusterTopologyEntry,
tool_slug: &str,
operation: &str,
input_contract_type: &str,
receipt_contract_type: &str,
authority_gate: &str,
) -> EpiphanyCultMeshDaemonToolCapabilityEntry {
EpiphanyCultMeshDaemonToolCapabilityEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_SCHEMA_VERSION.to_string(),
capability_id: format!("{}.tool.{tool_slug}", cluster.cluster_id),
host_cluster_id: cluster.cluster_id.clone(),
host_daemon_id: cluster.daemon_id.clone(),
eve_surface_id: cluster.eve_surface_id.clone(),
tool_name: tool_slug.to_string(),
operation: operation.to_string(),
input_contract_type: input_contract_type.to_string(),
receipt_contract_type: receipt_contract_type.to_string(),
available_to_all_agents: true,
requires_receipt: true,
authority_gate: authority_gate.to_string(),
private_state_exposed: false,
notes: vec![
format!(
"CultMesh advertises this daemon-hosted tool as {EPIPHANY_CULTMESH_DAEMON_TOOL_CAPABILITY_TYPE}."
),
"Every agent in the local CultMesh network may discover this tool at any time.".to_string(),
"Availability is global; execution still flows through the named typed contract and receipt gate.".to_string(),
"The tool advertisement must not expose private Verse payloads.".to_string(),
],
}
}
/// Test-only decoder fixture for proving retirement and legacy consumer
/// behavior. This is deliberately absent from production builds.
#[cfg(test)]
pub(crate) fn write_legacy_provider_fixture(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
daemon_id: &str,
) -> Result<()> {
let cluster = epiphany_cultmesh_cluster_topology()
.into_iter()
.find(|cluster| cluster.daemon_id == daemon_id)
.context("legacy fixture daemon has no topology")?;
let advertisement = epiphany_cultmesh_odin_advertisement_templates()
.into_iter()
.find(|row| row.cluster_id == cluster.cluster_id)
.context("legacy fixture has no advertisement")?;
let surface = epiphany_cultmesh_eve_surface_templates()
.into_iter()
.find(|row| row.cluster_id == cluster.cluster_id)
.context("legacy fixture has no surface")?;
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
node.put(advertisement.advertisement_id.clone(), &advertisement)?;
node.put(surface.surface_id.clone(), &surface)?;
for capability in epiphany_cultmesh_daemon_tool_capability_templates()
.into_iter()
.filter(|row| row.host_daemon_id == daemon_id)
{
node.put(capability.capability_id.clone(), &capability)?;
}
node.flush()?;
Ok(())
}
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)
}
pub fn epiphany_cultmesh_bifrost_contracts() -> Vec<EpiphanyCultMeshBifrostContractEntry> {
vec![
EpiphanyCultMeshBifrostContractEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: "gamecult.bifrost.body_change.publication".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
document_type: EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_TYPE
.to_string(),
payload_schema_version:
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_SCHEMA_VERSION
.to_string(),
authority: "bifrost".to_string(),
operations: vec![
"intentSubmit".to_string(),
"receiptWatch".to_string(),
"snapshot".to_string(),
],
intent_document_types: vec![
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_INTENT_TYPE.to_string(),
],
receipt_document_types: vec![
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_TYPE.to_string(),
EPIPHANY_CULTMESH_BIFROST_GITHUB_PUBLICATION_RECEIPT_TYPE.to_string(),
"gamecult.bifrost.credit_receipt".to_string(),
],
notes: vec![
format!(
"CultMesh advertises this Bifrost contract as {EPIPHANY_CULTMESH_BIFROST_CONTRACT_TYPE}."
),
"Body changes require justification, changed-path scope, verifier evidence, authorship, review, and credit metadata before GitHub publication.".to_string(),
"Bifrost is the credit and publication-routing authority; GitHub is a publication substrate, not the governance source.".to_string(),
"Epiphany clusters may prepare intents, but Bifrost receipts bless public publication and ledger attribution.".to_string(),
],
},
EpiphanyCultMeshBifrostContractEntry {
schema_version: EPIPHANY_CULTMESH_BIFROST_CONTRACT_SCHEMA_VERSION.to_string(),
contract_id: "gamecult.bifrost.public_proof.publication".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
document_type:
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_TYPE.to_string(),
payload_schema_version:
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_SCHEMA_VERSION
.to_string(),
authority: "bifrost".to_string(),
operations: vec![
"publishRedactedProof".to_string(),
"receiptWatch".to_string(),
"snapshot".to_string(),
],
intent_document_types: vec![
EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_TYPE.to_string(),
],
receipt_document_types: vec![
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_TYPE.to_string(),
"gamecult.bifrost.credit_receipt".to_string(),
],
notes: vec![
format!(
"CultMesh advertises this Bifrost contract as {EPIPHANY_CULTMESH_BIFROST_CONTRACT_TYPE}."
),
"Repo-work public proof bundles are redacted evidence packets, not body changes; Bifrost publishes them into public Verse rooms after review and credit receipts exist.".to_string(),
"Downstream consumers may read the published proof closure, but Bifrost owns public publication authority and ledger attribution.".to_string(),
],
},
]
}
pub fn write_epiphany_cultmesh_bifrost_contracts(
store_path: impl AsRef<Path>,
runtime_id: impl Into<String>,
) -> Result<Vec<EpiphanyCultMeshBifrostContractEntry>> {
let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?;
let mut written = Vec::new();
for contract in epiphany_cultmesh_bifrost_contracts() {
written.push(node.put(contract.contract_id.clone(), &contract)?);
}
node.flush()?;
Ok(written)
}
#[cfg(test)]
mod tests {
use super::*;
use cultcache_rs::CacheBackingStore;
use cultcache_rs::CultCacheEnvelope;
use pretty_assertions::assert_eq;
#[test]
fn explicit_migration_removes_only_retired_operator_status_documents() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("verse.ccmp");
let mut backing = SingleFileMessagePackBackingStore::new(&store);
backing.push(&CultCacheEnvelope {
key: "epiphany-local/operator-status/latest".into(),
r#type: "epiphany.cultmesh.operator_status".into(),
payload: vec![0x80],
stored_at: "2026-07-15T10:00:00Z".into(),
schema_id: Some("epiphany.cultmesh.operator_status".into()),
})?;
backing.push(&CultCacheEnvelope {
key: "epiphany-local/status".into(),
r#type: EPIPHANY_CULTMESH_STATUS_TYPE.into(),
payload: vec![0x80],
stored_at: "2026-07-15T10:00:01Z".into(),
schema_id: Some(EPIPHANY_CULTMESH_STATUS_TYPE.into()),
})?;
assert_eq!(
retire_epiphany_cultmesh_operator_status_documents(&store)?,
vec!["epiphany-local/operator-status/latest"]
);
let remaining = backing.pull_all()?;
assert_eq!(remaining.len(), 1);
assert_eq!(remaining[0].r#type, EPIPHANY_CULTMESH_STATUS_TYPE);
assert!(retire_epiphany_cultmesh_operator_status_documents(&store)?.is_empty());
Ok(())
}
#[test]
fn reserved_semantic_projector_policy_requires_specialized_exact_writer() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("verse.ccmp");
let binary = if cfg!(windows) {
"C:\\epiphany-memory-semantic-projector.exe"
} else {
"/tmp/epiphany-memory-semantic-projector"
};
let exact = EpiphanyCultMeshManagedServicePolicyEntry {
schema_version: EPIPHANY_CULTMESH_MANAGED_SERVICE_POLICY_SCHEMA_VERSION.to_string(),
policy_id: "managed-service-policy-epiphany-memory-semantic-projector-service".into(),
service_id: EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID.into(),
owner_daemon_id: "epiphany-daemon-supervisor".into(),
command: binary.into(),
args: vec![
"serve",
"--agent-store",
"mind.ccmp",
"--runtime-store",
"modeling.ccmp",
"--local-verse-store",
"verse.ccmp",
"--runtime-id",
"local",
"--interval-seconds",
"60",
"--qdrant-url",
"http://127.0.0.1:16333",
"--ollama-base-url",
"http://10.77.0.1:11435",
"--ollama-model",
"qwen3-embedding:0.6b",
]
.into_iter()
.map(str::to_string)
.collect(),
cwd: None,
enabled: true,
restart_mode: "always".into(),
cooldown_seconds: 0,
backoff_multiplier: 1,
stdout_artifact: "projector.stdout.log".into(),
stderr_artifact: "projector.stderr.log".into(),
updated_at_utc: "2026-07-15T12:00:00Z".into(),
private_state_exposed: false,
notes: vec![],
};
assert!(
write_epiphany_cultmesh_managed_service_policy(&store, "local", exact.clone()).is_err()
);
let mut forged = exact.clone();
forged.command = "arbitrary.exe".into();
assert!(
write_epiphany_cultmesh_semantic_projector_service_policy(&store, "local", forged)
.is_err()
);
assert!(
write_epiphany_cultmesh_semantic_projector_service_policy(
&store,
"local",
exact.clone(),
)
.is_ok()
);
let (_, policy_digest) = load_epiphany_cultmesh_managed_service_policy_with_digest(
&store,
"local",
EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID,
)?
.context("missing exact policy")?;
let receipt = EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
.into(),
receipt_id: "9f63fa72-a2e1-4ca5-9c1a-9292b7798891".into(),
service_id: EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID.into(),
scheduler_id: "epiphany-daemon-supervisor".into(),
runtime_id: "local".into(),
daemon_selector: "epiphany-daemon-supervisor".into(),
action: "launch".into(),
status: "launched".into(),
command: exact.command.clone(),
args: exact.args.clone(),
cwd: exact.cwd.clone(),
process_id: Some(4242),
exit_code: None,
started_at_utc: "2026-07-15T12:00:00Z".into(),
completed_at_utc: Some("2026-07-15T12:00:01Z".into()),
operator_artifact_ref: "service://semantic-projector/launch".into(),
private_state_exposed: false,
notes: vec![],
executable_sha256: "sha256-test-projector".into(),
preflight_witness_id: String::new(),
required_document_types: vec![],
schema_preflight_passed: false,
schema_catalog_sha256: String::new(),
managed_policy_id: exact.policy_id.clone(),
managed_policy_digest: policy_digest,
provider_daemon_id: "epiphany-memory-semantic-projector".into(),
startup_correlation_id: "9f63fa72-a2e1-4ca5-9c1a-9292b7798891".into(),
process_creation_token: 1,
process_created_at_rfc3339: None,
process_executable_path: "C:\\epiphany\\semantic-projector.exe".into(),
};
let written = write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"local",
receipt.clone(),
)?;
assert_eq!(
authenticate_epiphany_cultmesh_semantic_projector_launch(
&store,
"local",
&receipt.receipt_id,
)?,
written
);
assert_eq!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"local",
receipt.clone(),
)?,
receipt
);
let mut collision = receipt;
collision.process_id = Some(4343);
assert!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(&store, "local", collision,)
.unwrap_err()
.to_string()
.contains("identity collision")
);
Ok(())
}
#[test]
fn reserved_workspace_coverage_projector_contract_is_exact_and_policy_bound() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("verse.ccmp");
let binary = std::env::current_exe()?.with_file_name(if cfg!(windows) {
"epiphany-workspace-coverage-projector.exe"
} else {
"epiphany-workspace-coverage-projector"
});
let exact = EpiphanyCultMeshManagedServicePolicyEntry {
schema_version: EPIPHANY_CULTMESH_MANAGED_SERVICE_POLICY_SCHEMA_VERSION.to_string(),
policy_id: "managed-service-policy-epiphany-workspace-coverage-projector-service"
.into(),
service_id: EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID.into(),
owner_daemon_id: "epiphany-daemon-supervisor".into(),
command: binary.display().to_string(),
args: vec![
"serve",
"--runtime-store",
"runtime.ccmp",
"--local-verse-store",
"verse.ccmp",
"--runtime-id",
"local",
"--interval-seconds",
"60",
"--heartbeat-interval-seconds",
"10",
"--qdrant-url",
"http://127.0.0.1:6333",
"--ollama-base-url",
"http://127.0.0.1:11434",
"--ollama-model",
"qwen3-embedding:0.6b",
]
.into_iter()
.map(str::to_string)
.collect(),
cwd: None,
enabled: true,
restart_mode: "always".into(),
cooldown_seconds: 0,
backoff_multiplier: 1,
stdout_artifact: "workspace-projector.stdout.log".into(),
stderr_artifact: "workspace-projector.stderr.log".into(),
updated_at_utc: "2026-07-15T12:00:00Z".into(),
private_state_exposed: false,
notes: vec![],
};
assert!(
write_epiphany_cultmesh_managed_service_policy(&store, "local", exact.clone()).is_err()
);
let mut arbitrary_binary = exact.clone();
arbitrary_binary.command = "arbitrary-projector.exe".into();
assert!(
write_epiphany_cultmesh_workspace_coverage_projector_service_policy(
&store,
"local",
arbitrary_binary,
)
.is_err()
);
let mut injected_workspace = exact.clone();
injected_workspace.args.insert(3, "--workspace".into());
injected_workspace.args.insert(4, "stolen".into());
assert!(
write_epiphany_cultmesh_workspace_coverage_projector_service_policy(
&store,
"local",
injected_workspace,
)
.is_err()
);
write_epiphany_cultmesh_workspace_coverage_projector_service_policy(
&store,
"local",
exact.clone(),
)?;
let receipt_id = "fd3b7be9-02b0-4ac7-a47e-2d25097ff1f5";
let receipt = EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
.into(),
receipt_id: receipt_id.into(),
service_id: EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_SERVICE_ID.into(),
scheduler_id: "epiphany-daemon-supervisor".into(),
runtime_id: "local".into(),
daemon_selector: "epiphany-daemon-supervisor".into(),
action: "launch".into(),
status: "launched".into(),
command: exact.command.clone(),
args: exact.args.clone(),
cwd: exact.cwd.clone(),
process_id: Some(4242),
exit_code: None,
started_at_utc: "2026-07-15T12:00:00Z".into(),
completed_at_utc: Some("2026-07-15T12:00:01Z".into()),
operator_artifact_ref: "service://workspace-coverage-projector/launch".into(),
private_state_exposed: false,
notes: vec![],
executable_sha256: "sha256-test-workspace-projector".into(),
preflight_witness_id: String::new(),
required_document_types: vec![],
schema_preflight_passed: false,
schema_catalog_sha256: String::new(),
managed_policy_id: exact.policy_id.clone(),
managed_policy_digest: "sha256-dead-authority".into(),
provider_daemon_id: EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID.into(),
startup_correlation_id: receipt_id.into(),
process_creation_token: 1,
process_created_at_rfc3339: None,
process_executable_path: "C:\\epiphany\\semantic-projector.exe".into(),
};
let mut wrong_provider = receipt.clone();
wrong_provider.receipt_id = "f6d454dd-3765-44cb-930a-bae0d47487aa".into();
wrong_provider.startup_correlation_id = wrong_provider.receipt_id.clone();
wrong_provider.provider_daemon_id = "epiphany-memory-semantic-projector".into();
assert!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"local",
wrong_provider,
)
.is_err()
);
let mut stale = receipt.clone();
stale.receipt_id = "a0ea76d1-9a9a-4dc7-a8bc-a56ab1d8079a".into();
stale.startup_correlation_id = stale.receipt_id.clone();
stale.managed_policy_digest = "sha256-stale".into();
assert!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(&store, "local", stale)
.is_err()
);
assert!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"local",
receipt.clone(),
)
.unwrap_err()
.to_string()
.contains("specialized managed process documents")
);
let mut advanced = exact;
advanced.updated_at_utc = "2026-07-15T12:00:02Z".into();
write_epiphany_cultmesh_workspace_coverage_projector_service_policy(
&store, "local", advanced,
)?;
assert!(
load_epiphany_cultmesh_daemon_service_lifecycle_receipt(&store, "local", receipt_id,)?
.is_none()
);
let generic_heartbeat = EpiphanyCultMeshDaemonHeartbeatEventEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION.to_string(),
heartbeat_id: Uuid::new_v4().to_string(),
daemon_id: EPIPHANY_WORKSPACE_COVERAGE_PROJECTOR_DAEMON_ID.to_string(),
cluster_id: "local".to_string(),
provider_incarnation: Uuid::new_v4().to_string(),
sequence: 1,
status: "ready".to_string(),
heartbeat_at: "2026-07-15T12:00:03Z".to_string(),
private_state_exposed: false,
startup_lifecycle_receipt_id: receipt_id.to_string(),
};
assert!(
write_epiphany_cultmesh_daemon_heartbeat_event(&store, "local", generic_heartbeat,)
.unwrap_err()
.to_string()
.contains("specialized signed heartbeat")
);
Ok(())
}
fn semantic_health_input(
store: &Path,
swarm_id: &str,
partition: &str,
generation: u64,
) -> Result<crate::MemorySemanticProjectionInput> {
let graph_id = format!("{partition}-graph");
let obligation = crate::MemorySemanticProjectionObligation {
schema_version: crate::MEMORY_SEMANTIC_PROJECTION_OBLIGATION_SCHEMA_VERSION.to_string(),
obligation_id: format!("obligation-{partition}-{generation}"),
swarm_id: swarm_id.to_string(),
partition: partition.to_string(),
canonical_source_id: format!("canonical/{partition}"),
source_commit_id: format!("commit-{generation}"),
graph_id: graph_id.clone(),
source_generation: generation,
source_model_hash: format!("model-{generation}"),
canonical_content_set_hash: format!("content-{generation}"),
projection_schema_version: crate::SEMANTIC_PROJECTION_SCHEMA_VERSION.to_string(),
created_at: "2026-07-15T12:00:00Z".to_string(),
};
let head = crate::MemorySemanticProjectionSourceHead {
swarm_id: swarm_id.to_string(),
partition: partition.to_string(),
canonical_source_id: format!("canonical/{partition}"),
source_commit_id: format!("commit-{generation}"),
graph_id: graph_id.clone(),
source_generation: generation,
source_model_hash: format!("model-{generation}"),
canonical_content_set_hash: format!("content-{generation}"),
};
let mut cache = crate::memory_graph::semantic_projector::semantic_projector_cache(store)?;
cache.put(&obligation.obligation_id, &obligation)?;
let envelopes = SingleFileMessagePackBackingStore::new(store).pull_all()?;
let authority = envelopes
.into_iter()
.find(|row| {
row.r#type == "gamecult.epiphany.memory_semantic_projection_obligation"
&& row.key == obligation.obligation_id
})
.expect("persisted obligation envelope");
Ok(crate::MemorySemanticProjectionInput {
snapshot: crate::EpiphanyMemoryGraphSnapshot {
schema_version: Some("v0".to_string()),
graph_id,
model_revision: generation,
..Default::default()
},
obligation,
authority:
crate::memory_graph::semantic_projector::MemorySemanticProjectionAuthoritySnapshot {
head,
envelopes: vec![authority],
},
})
}
#[test]
fn semantic_health_publication_is_monotonic_partitioned_sight_only() -> Result<()> {
let temp = tempfile::tempdir()?;
let canonical = temp.path().join("canonical.msgpack");
let verse = temp.path().join("verse.ccmp");
let modeling_1 = semantic_health_input(&canonical, "swarm-a", "modeling", 1)?;
let modeling_2 = semantic_health_input(&canonical, "swarm-a", "modeling", 2)?;
let mind_1 = semantic_health_input(&canonical, "swarm-a", "mind", 1)?;
let before = SingleFileMessagePackBackingStore::new(&canonical).pull_all()?;
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&modeling_1,
"incarnation-a",
)?;
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&modeling_2,
"incarnation-a",
)?;
let delayed = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&modeling_1,
"incarnation-a",
)?;
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&mind_1,
"incarnation-a",
)?;
assert_eq!(delayed.source_generation, 2);
let rows = load_epiphany_cultmesh_semantic_projection_health(&verse, "runtime")?;
assert_eq!(rows.len(), 2);
assert_eq!(rows[0].partition, "mind");
assert_eq!(rows[1].partition, "modeling");
assert_eq!(rows[1].source_generation, 2);
assert!(rows.iter().all(|row| !row.private_state_exposed));
assert_eq!(
SingleFileMessagePackBackingStore::new(&canonical).pull_all()?,
before,
"publishing sight must not create canonical projection work"
);
Ok(())
}
#[test]
fn semantic_health_rejects_older_conflicting_obligation_for_same_generation() -> Result<()> {
let temp = tempfile::tempdir()?;
let canonical = temp.path().join("canonical.msgpack");
let verse = temp.path().join("verse.ccmp");
let mut latest = semantic_health_input(&canonical, "swarm-a", "modeling", 2)?;
latest.obligation.created_at = "2026-07-15T12:02:00Z".to_string();
let mut cache =
crate::memory_graph::semantic_projector::semantic_projector_cache(&canonical)?;
cache.put(&latest.obligation.obligation_id, &latest.obligation)?;
latest.authority.envelopes = SingleFileMessagePackBackingStore::new(&canonical)
.pull_all()?
.into_iter()
.filter(|row| {
row.r#type == "gamecult.epiphany.memory_semantic_projection_obligation"
&& row.key == latest.obligation.obligation_id
})
.collect();
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&latest,
"incarnation-a",
)?;
let mut older_conflict = latest.clone();
older_conflict.obligation.obligation_id = "conflicting-obligation-modeling-2".to_string();
older_conflict.obligation.created_at = "2026-07-15T12:01:00Z".to_string();
cache.put(
&older_conflict.obligation.obligation_id,
&older_conflict.obligation,
)?;
older_conflict.authority.envelopes = SingleFileMessagePackBackingStore::new(&canonical)
.pull_all()?
.into_iter()
.filter(|row| {
row.r#type == "gamecult.epiphany.memory_semantic_projection_obligation"
&& row.key == older_conflict.obligation.obligation_id
})
.collect();
let error = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&older_conflict,
"incarnation-a",
)
.expect_err("chronology must not hide a same-generation obligation conflict");
assert!(
error
.to_string()
.contains("conflicting canonical obligations")
);
Ok(())
}
#[test]
fn semantic_health_loader_rejects_latest_outside_declared_scope() -> Result<()> {
let temp = tempfile::tempdir()?;
let canonical = temp.path().join("canonical.msgpack");
let verse = temp.path().join("verse.ccmp");
let input = semantic_health_input(&canonical, "swarm-a", "mind", 1)?;
let row = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&input,
"incarnation-a",
)?;
let hostile_key = format!(
"{}/latest",
semantic_projection_health_scope_key("other-swarm", "mind")
);
let mut node = open_epiphany_cultmesh_node(&verse, "hostile")?;
node.put(hostile_key, &row)?;
node.flush()?;
let error = load_epiphany_cultmesh_semantic_projection_health(&verse, "runtime")
.expect_err("a latest row must authenticate its key scope");
assert!(
error
.to_string()
.contains("does not match its declared scope")
);
Ok(())
}
#[test]
fn forged_ready_health_cannot_mint_canonical_readiness() -> Result<()> {
let temp = tempfile::tempdir()?;
let canonical = temp.path().join("canonical.msgpack");
let verse = temp.path().join("verse.ccmp");
let input = semantic_health_input(&canonical, "swarm-a", "mind", 1)?;
let mut empty_authority = input.clone();
empty_authority.authority.envelopes.clear();
assert!(
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&empty_authority,
"incarnation-a"
)
.is_err()
);
let other_store = temp.path().join("other.msgpack");
assert!(
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&other_store,
&input,
"incarnation-a"
)
.is_err()
);
let mut forged = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"runtime",
&canonical,
&input,
"incarnation-a",
)?;
forged.status = "ready".to_string();
forged.receipt_id = Some("forged-receipt".to_string());
forged.indexed_document_count = Some(999);
forged.vector_dimensions = Some(999);
let mut node = open_epiphany_cultmesh_node(&verse, "hostile")?;
node.put("gamecult-local/hostile/forged-ready", &forged)?;
node.flush()?;
assert!(
crate::load_memory_semantic_projection_readiness(&canonical, &input)?.is_none(),
"CultMesh mirrors are not an import edge into canonical readiness"
);
let mut config = crate::MemorySemanticIndexConfig::from_env();
config.qdrant_url = "http://127.0.0.1:1".to_string();
let packet = crate::semantic_memory_context(
input.snapshot(),
"swarm-a",
crate::SemanticPartition::Mind,
&crate::EpiphanyMemoryContextQuery {
id: "hostile-query".to_string(),
text: Some("test".to_string()),
..Default::default()
},
None,
&config,
);
assert!(
packet
.warnings
.iter()
.any(|warning| warning.contains("canonical BM25"))
);
Ok(())
}
#[test]
fn semantic_health_preserves_projection_states_and_later_repair_failure() -> Result<()> {
let temp = tempfile::tempdir()?;
let canonical = temp.path().join("canonical.msgpack");
let verse = temp.path().join("verse.ccmp");
let input = semantic_health_input(&canonical, "swarm-four", "modeling", 7)?;
let pending = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"provider",
&canonical,
&input,
"incarnation-a",
)?;
assert_eq!(pending.status, "pending");
let claim =
crate::memory_graph::semantic_projector::idunn_acquire_memory_semantic_projection(
&canonical,
&input,
"executor-a",
"executor-a-incarnation",
"execute",
"idunn-test-incarnation",
"2026-07-15T12:01:00Z",
)?
.claim;
let raw_receipt = crate::MemorySemanticIndexReceipt {
schema_version: crate::MEMORY_SEMANTIC_INDEX_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: "receipt-four-state".to_string(),
swarm_id: input.obligation().swarm_id.clone(),
partition: input.obligation().partition.clone(),
collection_name: "projection".to_string(),
graph_id: input.obligation().graph_id.clone(),
model_revision: input.obligation().source_generation,
model_hash: input.obligation().source_model_hash.clone(),
embedding_provider_id: "embedder".to_string(),
embedding_model: "model".to_string(),
vector_dimensions: 3,
indexed_document_count: 2,
deleted_document_count: 0,
canonical_content_set_hash: input.obligation().canonical_content_set_hash.clone(),
indexed_at: "2026-07-15T12:02:00Z".to_string(),
status: "ready".to_string(),
obligation_id: claim.obligation_id.clone(),
canonical_source_id: String::new(),
source_commit_id: String::new(),
source_generation: input.obligation().source_generation,
projection_schema_version: crate::SEMANTIC_PROJECTION_SCHEMA_VERSION.to_string(),
claim_id: claim.claim_id.clone(),
claim_epoch: claim.epoch,
observed_vector_binding_root_sha256: "0".repeat(64),
};
crate::memory_graph::semantic_projector::succeed_memory_semantic_projection_claim(
&canonical,
&claim.claim_id,
&input.authority,
raw_receipt,
"2026-07-15T12:02:01Z",
)?;
let ready = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"provider",
&canonical,
&input,
"incarnation-a",
)?;
assert_eq!(ready.status, "ready");
assert!(ready.query_eligible_display_only);
let repair =
crate::memory_graph::semantic_projector::idunn_acquire_memory_semantic_projection(
&canonical,
&input,
"executor-b",
"executor-b-incarnation",
"repair",
"idunn-test-incarnation",
"2026-07-15T12:03:00Z",
)?
.claim;
crate::memory_graph::semantic_projector::fail_memory_semantic_projection_claim(
&canonical,
&repair.claim_id,
"2026-07-15T12:04:00Z",
"private backend failure /secret/path",
)?;
let failed = publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"provider",
&canonical,
&input,
"incarnation-a",
)?;
assert_eq!(failed.status, "failed");
assert!(!failed.query_eligible_display_only);
assert!(failed.receipt_id.is_none());
let encoded = format!("{failed:?}");
assert!(!encoded.contains("private backend failure"));
assert!(!encoded.contains("/secret/path"));
let mut stale_input = input.clone();
stale_input.authority.head.source_generation += 1;
assert!(crate::observe_memory_semantic_projection(&canonical, &stale_input).is_err());
assert!(
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"provider",
&canonical,
&stale_input,
"incarnation-a"
)
.is_err()
);
assert!(
publish_epiphany_cultmesh_semantic_projection_health(
&verse,
"provider",
&canonical,
&input,
"C:\\secret\\token"
)
.is_err()
);
Ok(())
}
fn publish_all_test_provider_state(store: &Path) -> Result<()> {
for cluster in epiphany_cultmesh_cluster_topology() {
write_legacy_provider_fixture(store, "epiphany-test", &cluster.daemon_id)?;
}
Ok(())
}
#[test]
fn epiphany_status_round_trips_through_cultmesh() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-local.ccmp");
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_snapshot_distills_status_json_into_typed_cultmesh_document() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-operator-snapshot.ccmp");
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"
},
"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"]);
write_epiphany_cultmesh_operator_snapshot(&store, snapshot.clone())?;
assert_eq!(
load_epiphany_cultmesh_operator_snapshot(&store, "epiphany-test", "snapshot-test")?,
Some(snapshot.clone())
);
let mut newer = snapshot.clone();
newer.snapshot_id = "snapshot-newer".to_string();
newer.generated_at_utc = "2026-05-27T01:00:00Z".to_string();
newer.coordinator_action = "continue".to_string();
write_epiphany_cultmesh_operator_snapshot(&store, newer.clone())?;
let mut delayed = snapshot.clone();
delayed.snapshot_id = "snapshot-delayed".to_string();
delayed.generated_at_utc = "2026-05-26T23:00:00Z".to_string();
write_epiphany_cultmesh_operator_snapshot(&store, delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_operator_snapshot(&store, "epiphany-test")?,
Some(newer)
);
let mut invalid_time = snapshot.clone();
invalid_time.snapshot_id = "snapshot-invalid-time".to_string();
invalid_time.generated_at_utc = "not-a-time".to_string();
assert!(
write_epiphany_cultmesh_operator_snapshot(&store, invalid_time)
.unwrap_err()
.to_string()
.contains("invalid generated_at_utc")
);
let mut wrong_verse = snapshot;
wrong_verse.snapshot_id = "snapshot-wrong-verse".to_string();
wrong_verse.verse_id = EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string();
assert!(
write_epiphany_cultmesh_operator_snapshot(&store, wrong_verse)
.unwrap_err()
.to_string()
.contains("internal Verse")
);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_OPERATOR_SNAPSHOT_TYPE)
.is_some()
);
Ok(())
}
#[test]
fn service_lifecycle_receipt_history_excludes_latest_mirror() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-service-lifecycle.ccmp");
let first = EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: "service-lifecycle-first".to_string(),
service_id: "epiphany-daemon-supervisor-service".to_string(),
scheduler_id: "epiphany-daemon-supervisor".to_string(),
runtime_id: "epiphany-test".to_string(),
daemon_selector: "epiphany-daemon-supervisor".to_string(),
action: "windows-service-execution-audit".to_string(),
status: "incomplete".to_string(),
command: "epiphany-daemon-supervisor".to_string(),
args: vec!["windows-service-execution-audit".to_string()],
cwd: Some("E:/Projects/EpiphanyAgent".to_string()),
process_id: None,
exit_code: Some(0),
started_at_utc: "2026-06-18T00:00:00Z".to_string(),
completed_at_utc: Some("2026-06-18T00:00:01Z".to_string()),
operator_artifact_ref: "artifact://service-lifecycle/first".to_string(),
private_state_exposed: false,
notes: Vec::new(),
executable_sha256: "sha256-test-projector".into(),
preflight_witness_id: String::new(),
required_document_types: Vec::new(),
schema_preflight_passed: false,
schema_catalog_sha256: String::new(),
managed_policy_id: String::new(),
managed_policy_digest: String::new(),
provider_daemon_id: String::new(),
startup_correlation_id: String::new(),
process_creation_token: 0,
process_created_at_rfc3339: None,
process_executable_path: String::new(),
};
let mut second = first.clone();
second.receipt_id = "service-lifecycle-second".to_string();
second.status = "written".to_string();
second.action = "windows-service-execution-runbook".to_string();
second.started_at_utc = "2026-06-18T00:01:00Z".to_string();
second.completed_at_utc = Some("2026-06-18T00:01:01Z".to_string());
second.operator_artifact_ref = "artifact://service-lifecycle/second".to_string();
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test",
first.clone(),
)?;
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test",
second.clone(),
)?;
let receipts =
load_epiphany_cultmesh_daemon_service_lifecycle_receipts(&store, "epiphany-test")?;
let mut ids = receipts
.iter()
.map(|receipt| receipt.receipt_id.as_str())
.collect::<Vec<_>>();
ids.sort_unstable();
assert_eq!(
ids,
vec!["service-lifecycle-first", "service-lifecycle-second"]
);
assert_eq!(
load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test"
)?,
Some(second.clone())
);
let mut delayed_first = first.clone();
delayed_first.receipt_id = "service-lifecycle-delayed-first".to_string();
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test",
delayed_first,
)?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test"
)?,
Some(second)
);
Ok(())
}
#[test]
fn scheduler_latest_mirror_refuses_delayed_replay() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-scheduler-order.ccmp");
let older = EpiphanyCultMeshDaemonSchedulerReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: "scheduler-older".to_string(),
scheduler_id: "epiphany-daemon-supervisor".to_string(),
runtime_id: "epiphany-test".to_string(),
daemon_selector: "*".to_string(),
iteration: 1,
status: "completed".to_string(),
tick_started_utc: "2026-07-13T01:00:00Z".to_string(),
tick_completed_utc: "2026-07-13T01:00:01Z".to_string(),
next_wake_utc: Some("2026-07-13T01:01:01Z".to_string()),
outcome_count: 1,
restarted_count: 0,
refused_count: 0,
skipped_count: 1,
private_state_exposed: false,
notes: Vec::new(),
};
let mut newer = older.clone();
newer.receipt_id = "scheduler-newer".to_string();
newer.iteration = 2;
newer.tick_started_utc = "2026-07-13T02:00:00Z".to_string();
newer.tick_completed_utc = "2026-07-13T02:00:01Z".to_string();
newer.next_wake_utc = Some("2026-07-13T02:01:01Z".to_string());
write_epiphany_cultmesh_daemon_scheduler_receipt(&store, "epiphany-test", newer.clone())?;
write_epiphany_cultmesh_daemon_scheduler_receipt(&store, "epiphany-test", older)?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_scheduler_receipt(&store, "epiphany-test")?,
Some(newer)
);
Ok(())
}
#[test]
fn scheduler_receipt_refuses_impossible_time_order() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-scheduler-invalid-time.ccmp");
let receipt = EpiphanyCultMeshDaemonSchedulerReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SCHEDULER_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: "scheduler-invalid".to_string(),
scheduler_id: "epiphany-daemon-supervisor".to_string(),
runtime_id: "epiphany-test".to_string(),
daemon_selector: "*".to_string(),
iteration: 1,
status: "completed".to_string(),
tick_started_utc: "2026-07-13T02:00:00Z".to_string(),
tick_completed_utc: "2026-07-13T01:00:00Z".to_string(),
next_wake_utc: Some("2026-07-13T00:00:00Z".to_string()),
outcome_count: 0,
restarted_count: 0,
refused_count: 0,
skipped_count: 0,
private_state_exposed: false,
notes: Vec::new(),
};
assert!(
write_epiphany_cultmesh_daemon_scheduler_receipt(&store, "epiphany-test", receipt,)
.is_err()
);
assert!(
load_latest_epiphany_cultmesh_daemon_scheduler_receipt(&store, "epiphany-test")?
.is_none()
);
Ok(())
}
#[test]
fn service_lifecycle_receipt_refuses_invalid_or_reversed_time() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-service-lifecycle-invalid-time.ccmp");
let mut receipt = EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: "service-lifecycle-invalid-time".to_string(),
service_id: "epiphany-daemon-supervisor-service".to_string(),
scheduler_id: "epiphany-daemon-supervisor".to_string(),
runtime_id: "epiphany-test".to_string(),
daemon_selector: "epiphany-daemon-supervisor".to_string(),
action: "windows-service-status".to_string(),
status: "running".to_string(),
command: "powershell.exe".to_string(),
args: Vec::new(),
cwd: None,
process_id: None,
exit_code: Some(0),
started_at_utc: "not-a-time".to_string(),
completed_at_utc: None,
operator_artifact_ref: "test://invalid-time".to_string(),
private_state_exposed: false,
notes: Vec::new(),
executable_sha256: String::new(),
preflight_witness_id: String::new(),
required_document_types: Vec::new(),
schema_preflight_passed: false,
schema_catalog_sha256: String::new(),
managed_policy_id: String::new(),
managed_policy_digest: String::new(),
provider_daemon_id: String::new(),
startup_correlation_id: String::new(),
process_creation_token: 0,
process_created_at_rfc3339: None,
process_executable_path: String::new(),
};
assert!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test",
receipt.clone(),
)
.is_err()
);
receipt.started_at_utc = "2026-07-13T02:00:00Z".to_string();
receipt.completed_at_utc = Some("2026-07-13T01:00:00Z".to_string());
assert!(
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test",
receipt,
)
.is_err()
);
assert!(
load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&store,
"epiphany-test"
)?
.is_none()
);
Ok(())
}
#[test]
fn service_execution_audit_checks_expose_operator_artifact_refs() -> Result<()> {
let report = epiphany_service_execution_audit_report(&[
EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
.to_string(),
receipt_id: "service-execution-runbook-receipt".to_string(),
service_id: "epiphany-daemon-supervisor-service".to_string(),
scheduler_id: "epiphany-daemon-supervisor".to_string(),
runtime_id: "epiphany-test".to_string(),
daemon_selector: "epiphany-daemon-supervisor".to_string(),
action: "windows-service-execution-runbook".to_string(),
status: "written".to_string(),
command: "epiphany-daemon-supervisor".to_string(),
args: vec!["windows-service-execution-runbook".to_string()],
cwd: Some("E:/Projects/EpiphanyAgent".to_string()),
process_id: None,
exit_code: Some(0),
started_at_utc: "2026-06-18T00:00:00Z".to_string(),
completed_at_utc: Some("2026-06-18T00:00:01Z".to_string()),
operator_artifact_ref: "E:/Projects/EpiphanyAgent/.epiphany-run/runbook.ps1"
.to_string(),
private_state_exposed: false,
notes: Vec::new(),
executable_sha256: String::new(),
preflight_witness_id: String::new(),
required_document_types: Vec::new(),
schema_preflight_passed: false,
schema_catalog_sha256: String::new(),
managed_policy_id: String::new(),
managed_policy_digest: String::new(),
provider_daemon_id: String::new(),
startup_correlation_id: String::new(),
process_creation_token: 0,
process_created_at_rfc3339: None,
process_executable_path: String::new(),
},
]);
let runbook_check = report
.checks
.iter()
.find(|check| check.action == "windows-service-execution-runbook")
.context("missing runbook audit check")?;
assert!(runbook_check.ok);
assert_eq!(
runbook_check.operator_artifact_ref.as_deref(),
Some("E:/Projects/EpiphanyAgent/.epiphany-run/runbook.ps1")
);
Ok(())
}
#[test]
fn daemon_tool_invocation_mirrors_status_tools_into_local_verse() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-tools.ccmp");
let status_json = serde_json::json!({
"tools": {
"runtimeStore": "state/runtime-spine.msgpack",
"summary": {
"intentCount": 1,
"pendingCount": 0,
"receiptCount": 1
},
"invocations": [
{
"intentId": "tool-intent-test",
"adapter": "epiphany-tools",
"server": "epiphany_source",
"toolName": "read_file",
"callId": "call-test",
"modelRequestId": "model-request-test",
"caller": "verification",
"reason": "Inspect source for Soul verdict.",
"createdAt": "2026-06-18T00:00:00Z",
"status": "ok",
"receiptId": "tool-receipt-test",
"completedAt": "2026-06-18T00:00:01Z"
}
]
}
});
let (intent, receipt) = epiphany_cultmesh_daemon_tool_invocation_from_status_json(
"epiphany-test",
".epiphany-run/status.json",
&status_json,
)?
.expect("status should contain a tool invocation");
let receipt = receipt.expect("completed invocation should mirror a receipt");
assert_eq!(intent.intent_id, "tool-intent-test");
assert_eq!(intent.tool_name, "read_file");
assert_eq!(
intent.payload_ref,
".epiphany-run/status.json#/tools/invocations/0"
);
assert_eq!(receipt.receipt_id, "tool-receipt-test");
assert!(!intent.private_state_requested);
assert!(!receipt.private_state_exposed);
write_epiphany_cultmesh_daemon_tool_invocation_intent(
&store,
"epiphany-test",
intent.clone(),
)?;
write_epiphany_cultmesh_daemon_tool_invocation_receipt(
&store,
"epiphany-test",
receipt.clone(),
)?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_tool_invocation_intent(&store, "epiphany-test")?,
Some(intent.clone())
);
assert_eq!(
load_latest_epiphany_cultmesh_daemon_tool_invocation_receipt(&store, "epiphany-test")?,
Some(receipt)
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(context.latest_daemon_tool_invocation_intent, Some(intent));
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.ccmp");
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.ccmp".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.clone())
);
assert_eq!(
load_latest_epiphany_cultmesh_operator_run_receipt(&store, "epiphany-test")?,
Some(receipt.clone())
);
let mut newer_intent = intent.clone();
newer_intent.run_id = "run-newer".to_string();
newer_intent.requested_at_utc = "2026-05-27T01:00:00Z".to_string();
write_epiphany_cultmesh_operator_run_intent(&store, newer_intent.clone())?;
let mut delayed_intent = intent.clone();
delayed_intent.run_id = "run-delayed".to_string();
delayed_intent.requested_at_utc = "2026-05-26T23:00:00Z".to_string();
write_epiphany_cultmesh_operator_run_intent(&store, delayed_intent.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_operator_run_intent(&store, "epiphany-test")?,
Some(newer_intent)
);
assert_eq!(
load_epiphany_cultmesh_operator_run_intent(&store, "epiphany-test", "run-delayed")?,
Some(delayed_intent)
);
let mut newer_receipt = receipt.clone();
newer_receipt.run_id = "run-newer".to_string();
newer_receipt.completed_at_utc = "2026-05-27T01:00:01Z".to_string();
write_epiphany_cultmesh_operator_run_receipt(&store, newer_receipt.clone())?;
let mut delayed_receipt = receipt.clone();
delayed_receipt.run_id = "run-delayed".to_string();
delayed_receipt.completed_at_utc = "2026-05-26T23:00:01Z".to_string();
write_epiphany_cultmesh_operator_run_receipt(&store, delayed_receipt)?;
assert_eq!(
load_latest_epiphany_cultmesh_operator_run_receipt(&store, "epiphany-test")?,
Some(newer_receipt)
);
let mut invalid_intent = intent.clone();
invalid_intent.run_id = "run-invalid".to_string();
invalid_intent.requested_at_utc = "not-a-time".to_string();
assert!(
write_epiphany_cultmesh_operator_run_intent(&store, invalid_intent)
.unwrap_err()
.to_string()
.contains("invalid requested_at_utc")
);
let mut wrong_verse_receipt = receipt;
wrong_verse_receipt.run_id = "run-wrong-verse".to_string();
wrong_verse_receipt.verse_id = EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string();
assert!(
write_epiphany_cultmesh_operator_run_receipt(&store, wrong_verse_receipt)
.unwrap_err()
.to_string()
.contains("internal Verse")
);
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 coordinator_run_receipt_mirrors_summary_into_local_verse() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-coordinator-run.ccmp");
let summary_json = serde_json::json!({
"threadId": "thread-test",
"mode": "run",
"steps": [{"index": 0}, {"index": 1}],
"finalAction": {
"action": "launchModeling",
"reason": "continue bounded work"
},
"coordinatorRunReceipt": {
"documentType": "epiphany.coordinator_run_receipt.v0",
"receiptId": "runtime-coordinator-receipt-test",
"store": "state/runtime-spine.msgpack"
},
"artifactManifest": [
"coordinator-summary.json",
"coordinator-steps.jsonl"
],
"sealedArtifactManifest": [
{
"path": "epiphany-transcript.jsonl",
"reason": "sealed"
}
]
});
let receipt = epiphany_cultmesh_coordinator_run_receipt_from_summary_json(
"epiphany-test",
"coordinator-cultmesh-test",
"2026-06-18T00:00:00Z",
".epiphany-dogfood/coordinator",
&summary_json,
)?;
assert_eq!(
receipt.source_receipt_id,
"runtime-coordinator-receipt-test"
);
assert_eq!(receipt.final_action, "launchModeling");
assert_eq!(receipt.step_count, 2);
assert_eq!(
receipt.sealed_artifact_refs,
vec!["epiphany-transcript.jsonl"]
);
assert!(!receipt.private_state_exposed);
write_epiphany_cultmesh_coordinator_run_receipt(&store, receipt.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_coordinator_run_receipt(&store, "epiphany-test")?,
Some(receipt.clone())
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(
context.latest_coordinator_run_receipt,
Some(receipt.clone())
);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_COORDINATOR_RUN_RECEIPT_TYPE)
.is_some()
);
let mut newer = receipt.clone();
newer.receipt_id = "coordinator-cultmesh-newer".to_string();
newer.source_receipt_id = "runtime-coordinator-receipt-newer".to_string();
newer.final_action = "continueImplementation".to_string();
newer.status = "continueImplementation".to_string();
newer.created_at_utc = "2026-06-18T01:00:00Z".to_string();
write_epiphany_cultmesh_coordinator_run_receipt(&store, newer.clone())?;
let mut delayed = receipt.clone();
delayed.receipt_id = "coordinator-cultmesh-delayed".to_string();
delayed.source_receipt_id = "runtime-coordinator-receipt-delayed".to_string();
delayed.final_action = "launchResearch".to_string();
delayed.status = "launchResearch".to_string();
delayed.created_at_utc = "2026-06-17T23:00:00Z".to_string();
write_epiphany_cultmesh_coordinator_run_receipt(&store, delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_coordinator_run_receipt(&store, "epiphany-test")?,
Some(newer)
);
let mut invalid_time = receipt.clone();
invalid_time.receipt_id = "coordinator-cultmesh-invalid".to_string();
invalid_time.source_receipt_id = "runtime-coordinator-receipt-invalid".to_string();
invalid_time.created_at_utc = "not-a-time".to_string();
let err = write_epiphany_cultmesh_coordinator_run_receipt(&store, invalid_time)
.expect_err("invalid coordinator run time must be refused");
assert!(err.to_string().contains("invalid created at"));
let mut leaked = receipt;
leaked.private_state_exposed = true;
let err = write_epiphany_cultmesh_coordinator_run_receipt(&store, leaked)
.expect_err("private coordinator receipt mirror must be refused");
assert!(err.to_string().contains("must not expose private state"));
Ok(())
}
#[test]
fn hands_action_gate_mirrors_summary_into_local_verse() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-hands-gate.ccmp");
let summary_json = serde_json::json!({
"threadId": "thread-test",
"mode": "run",
"coordinatorRunReceipt": {
"receiptId": "runtime-coordinator-receipt-test"
},
"finalAction": {
"action": "continueImplementation",
"handsActionGate": {
"status": "ready",
"runtimeJobId": "hands-job-test",
"substrateGateGrantReceiptId": "substrate-grant-test",
"intentId": "hands-intent-test",
"reviewId": "hands-review-test",
"requestedPaths": ["epiphany-core/src/cultmesh_integration.rs"],
"requiredReceipts": [
"epiphany.hands.patch_receipt.v0",
"epiphany.hands.command_receipt.v0",
"epiphany.hands.commit_receipt.v0"
],
"recordPassCommand": {
"executable": "epiphany-hands-action",
"args": [
"--store",
"state/runtime-spine.msgpack",
"record-pass",
"--gate-summary",
".epiphany-dogfood/coordinator/coordinator-summary.json"
]
}
}
}
});
let gate = epiphany_cultmesh_hands_action_gate_from_summary_json(
"epiphany-test",
"2026-06-18T00:00:00Z",
".epiphany-dogfood/coordinator/coordinator-summary.json",
&summary_json,
)?
.expect("summary should contain a Hands action gate");
assert_eq!(gate.gate_id, "hands-intent-test:hands-review-test");
assert_eq!(
gate.source_coordinator_receipt_id,
"runtime-coordinator-receipt-test"
);
assert_eq!(gate.record_pass_executable, "epiphany-hands-action");
assert!(!gate.private_state_exposed);
write_epiphany_cultmesh_hands_action_gate(&store, gate.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_hands_action_gate(&store, "epiphany-test")?,
Some(gate.clone())
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(context.latest_hands_action_gate, Some(gate.clone()));
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_HANDS_ACTION_GATE_TYPE)
.is_some()
);
let mut newer = gate.clone();
newer.gate_id = "hands-intent-newer:hands-review-newer".to_string();
newer.hands_intent_id = "hands-intent-newer".to_string();
newer.hands_review_id = "hands-review-newer".to_string();
newer.created_at_utc = "2026-06-18T01:00:00Z".to_string();
write_epiphany_cultmesh_hands_action_gate(&store, newer.clone())?;
let mut delayed = gate.clone();
delayed.gate_id = "hands-intent-delayed:hands-review-delayed".to_string();
delayed.hands_intent_id = "hands-intent-delayed".to_string();
delayed.hands_review_id = "hands-review-delayed".to_string();
delayed.created_at_utc = "2026-06-17T23:00:00Z".to_string();
write_epiphany_cultmesh_hands_action_gate(&store, delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_hands_action_gate(&store, "epiphany-test")?,
Some(newer)
);
let mut invalid_time = gate.clone();
invalid_time.gate_id = "hands-intent-invalid:hands-review-invalid".to_string();
invalid_time.hands_intent_id = "hands-intent-invalid".to_string();
invalid_time.hands_review_id = "hands-review-invalid".to_string();
invalid_time.created_at_utc = "not-a-time".to_string();
let err = write_epiphany_cultmesh_hands_action_gate(&store, invalid_time)
.expect_err("invalid Hands gate time must be refused");
assert!(err.to_string().contains("invalid created at"));
let mut leaked = gate;
leaked.private_state_exposed = true;
let err = write_epiphany_cultmesh_hands_action_gate(&store, leaked)
.expect_err("private Hands action gate mirror must be refused");
assert!(err.to_string().contains("must not expose private state"));
Ok(())
}
#[test]
fn role_review_event_mirrors_summary_into_local_verse() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-role-review.ccmp");
let summary_json = serde_json::json!({
"threadId": "thread-test",
"mode": "run",
"coordinatorRunReceipt": {
"receiptId": "runtime-coordinator-receipt-test"
},
"steps": [
{
"events": [
{
"type": "roleFailureReview",
"roleId": "verification",
"superseded": {
"patch": {
"acceptanceReceipts": [
{
"id": "role-failure-review-test",
"result_id": "result-verification-test",
"job_id": "job-verification-test",
"binding_id": "verification-review-worker",
"surface": "roleFailureReview",
"role_id": "verification",
"status": "superseded",
"accepted_at": "2026-06-18T00:00:00Z",
"summary": "Old failed Soul result reviewed before relaunch."
}
]
}
}
}
]
}
]
});
let event = epiphany_cultmesh_role_review_event_from_summary_json(
"epiphany-test",
"2026-06-18T00:00:01Z",
".epiphany-dogfood/coordinator/coordinator-summary.json",
&summary_json,
)?
.expect("summary should contain a role review event");
assert_eq!(event.surface, "roleFailureReview");
assert_eq!(event.role_id, "verification");
assert_eq!(event.review_status, "superseded");
assert_eq!(event.acceptance_receipt_id, "role-failure-review-test");
assert_eq!(event.runtime_result_id, "result-verification-test");
assert!(!event.private_state_exposed);
write_epiphany_cultmesh_role_review_event(&store, event.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_role_review_event(&store, "epiphany-test")?,
Some(event.clone())
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(context.latest_role_review_event, Some(event.clone()));
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_ROLE_REVIEW_EVENT_TYPE)
.is_some()
);
let mut newer = event.clone();
newer.event_id = "roleAccept:modeling:accepted".to_string();
newer.surface = "roleAccept".to_string();
newer.role_id = "modeling".to_string();
newer.review_status = "accepted".to_string();
newer.created_at_utc = "2026-06-18T01:00:00Z".to_string();
write_epiphany_cultmesh_role_review_event(&store, newer.clone())?;
let mut delayed = event.clone();
delayed.event_id = "roleAccept:research:accepted".to_string();
delayed.surface = "roleAccept".to_string();
delayed.role_id = "research".to_string();
delayed.review_status = "accepted".to_string();
delayed.created_at_utc = "2026-06-17T23:00:00Z".to_string();
write_epiphany_cultmesh_role_review_event(&store, delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_role_review_event(&store, "epiphany-test")?,
Some(newer)
);
let mut invalid_time = event.clone();
invalid_time.event_id = "roleAccept:invalid:accepted".to_string();
invalid_time.surface = "roleAccept".to_string();
invalid_time.role_id = "invalid".to_string();
invalid_time.review_status = "accepted".to_string();
invalid_time.created_at_utc = "not-a-time".to_string();
let err = write_epiphany_cultmesh_role_review_event(&store, invalid_time)
.expect_err("invalid role review time must be refused");
assert!(err.to_string().contains("invalid created at"));
let mut leaked = event;
leaked.private_state_exposed = true;
let err = write_epiphany_cultmesh_role_review_event(&store, leaked)
.expect_err("private role review mirror must be refused");
assert!(err.to_string().contains("must not expose private state"));
Ok(())
}
#[test]
fn work_loop_telemetry_round_trips_as_internal_cultmesh_document() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-local-verse.ccmp");
let telemetry = EpiphanyCultMeshWorkLoopTelemetryEntry {
schema_version: EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_SCHEMA_VERSION.to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string(),
telemetry_id: "work-loop-telemetry-test".to_string(),
thread_id: "thread-test".to_string(),
produced_at_utc: "2026-06-12T00:00:00Z".to_string(),
source_stage: "hands".to_string(),
target_stages: vec!["soul".to_string(), "Modeling".to_string()],
lower_bound_receipt_at: "2026-06-11T23:59:59Z".to_string(),
hands_intent_id: "hands-intent-test".to_string(),
hands_review_id: "hands-review-test".to_string(),
hands_runtime_job_id: "hands-job-test".to_string(),
substrate_gate_grant_receipt_id: "substrate-grant-test".to_string(),
hands_patch_receipt_id: "hands-patch-test".to_string(),
hands_command_receipt_id: "hands-command-test".to_string(),
hands_commit_receipt_id: "hands-commit-test".to_string(),
command: "cargo test".to_string(),
exit_code: "0".to_string(),
stdout_artifact: "stdout.log".to_string(),
stderr_artifact: "stderr.log".to_string(),
commit_sha: "abc123".to_string(),
branch: "codex/test".to_string(),
changed_paths: vec!["epiphany-core/src/runtime_spine.rs".to_string()],
artifact_previews: vec!["stdout: ok".to_string()],
source_refs: vec!["epiphany-core/src/runtime_spine.rs".to_string()],
source_path_proof: vec!["runtime-spine persisted Hands receipts".to_string()],
soul_receipt_ids: vec!["accept-verification-test".to_string()],
summary: "Hands consequence telemetry for the work loop.".to_string(),
receipt_payload_previews: vec!["patch receipt body".to_string()],
commit_diff_preview: "diff --git a/file b/file".to_string(),
verification_assertions: vec!["test asserts CultMesh round trip".to_string()],
};
write_epiphany_cultmesh_work_loop_telemetry(&store, telemetry.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_work_loop_telemetry(&store, "epiphany-test")?,
Some(telemetry.clone())
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
let summary = context
.latest_work_loop_summary
.expect("local Verse context should expose a sealed work-loop digest");
assert_eq!(summary.telemetry_id, telemetry.telemetry_id);
assert_eq!(summary.hands_patch_receipt_id, "hands-patch-test");
assert_eq!(summary.hands_command_receipt_id, "hands-command-test");
assert_eq!(summary.hands_commit_receipt_id, "hands-commit-test");
assert_eq!(summary.changed_path_count, 1);
assert_eq!(summary.source_ref_count, 1);
assert_eq!(summary.verification_assertion_count, 1);
let serialized_summary = serde_json::to_string(&summary)?;
assert!(!serialized_summary.contains("patch receipt body"));
assert!(!serialized_summary.contains("diff --git"));
assert!(!serialized_summary.contains("stdout: ok"));
assert!(serialized_summary.contains("exposes only this digest"));
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_WORK_LOOP_TELEMETRY_TYPE)
.is_some()
);
let mut newer = telemetry.clone();
newer.telemetry_id = "work-loop-telemetry-newer".to_string();
newer.produced_at_utc = "2026-06-12T01:00:00Z".to_string();
write_epiphany_cultmesh_work_loop_telemetry(&store, newer.clone())?;
let mut delayed = telemetry.clone();
delayed.telemetry_id = "work-loop-telemetry-delayed".to_string();
delayed.produced_at_utc = "2026-06-11T23:30:00Z".to_string();
delayed.lower_bound_receipt_at = "2026-06-11T23:00:00Z".to_string();
write_epiphany_cultmesh_work_loop_telemetry(&store, delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_work_loop_telemetry(&store, "epiphany-test")?,
Some(newer)
);
let mut future_bound = telemetry.clone();
future_bound.telemetry_id = "work-loop-telemetry-future-bound".to_string();
future_bound.lower_bound_receipt_at = "2026-06-12T00:00:01Z".to_string();
let err = write_epiphany_cultmesh_work_loop_telemetry(&store, future_bound)
.expect_err("future receipt lower bound must be refused");
assert!(err.to_string().contains("after packet production"));
let mut wrong_verse = telemetry;
wrong_verse.telemetry_id = "work-loop-telemetry-wrong-verse".to_string();
wrong_verse.verse_id = EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string();
let err = write_epiphany_cultmesh_work_loop_telemetry(&store, wrong_verse)
.expect_err("work-loop evidence outside internal Verse must be refused");
assert!(err.to_string().contains("internal Verse"));
Ok(())
}
#[test]
fn agent_state_soa_summary_mirrors_agent_store_shape_without_memory_text() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-local-verse.ccmp");
let soa = EpiphanyAgentStateSoaEntry {
schema_version: "epiphany.agent_state_soa.v0".to_string(),
generated_at: "2026-06-18T00:00:00Z".to_string(),
source_store: "state/agents.msgpack".to_string(),
role_ids: vec!["Persona".to_string(), "implementation".to_string()],
agent_ids: vec!["epiphany.Persona".to_string(), "epiphany.hands".to_string()],
display_names: vec!["Persona".to_string(), "Hands".to_string()],
profile_kinds: vec!["Persona".to_string(), "WorkOrgan".to_string()],
portable_contracts: vec![
"gamecult.persona_state.v0".to_string(),
"epiphany.work_organ_state.v0".to_string(),
],
semantic_memory_counts: vec![3, 2],
episodic_memory_counts: vec![1, 0],
relationship_memory_counts: vec![2, 0],
goal_counts: vec![1, 1],
value_counts: vec![4, 3],
};
let summary = epiphany_cultmesh_agent_state_soa_summary_from_entry(
"epiphany-test",
"agent-state-soa-summary-test",
&soa,
);
write_epiphany_cultmesh_agent_state_soa_summary(&store, summary.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_agent_state_soa_summary(&store, "epiphany-test")?,
Some(summary.clone())
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(
context.latest_agent_state_soa_summary,
Some(summary.clone())
);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
assert!(
node.documents()
.binding(EPIPHANY_CULTMESH_AGENT_STATE_SOA_SUMMARY_TYPE)
.is_some()
);
let summary_table = node.soa::<EpiphanyCultMeshAgentStateSoaSummaryEntry>()?;
assert_eq!(summary_table.len(), 2);
assert!(
summary_table
.column::<String>("summaryId")?
.values()
.contains(&"agent-state-soa-summary-test".to_string())
);
assert!(
summary_table
.column::<u32>("rowCount")?
.values()
.contains(&2)
);
assert!(
summary_table
.column::<bool>("privateStateExposed")?
.values()
.iter()
.all(|exposed| !exposed)
);
assert!(
summary_table
.column::<Vec<String>>("portableContracts")?
.values()
.iter()
.any(|contracts| contracts.contains(&"gamecult.persona_state.v0".to_string()))
);
let serialized = serde_json::to_string(&summary)?;
assert!(serialized.contains("gamecult.persona_state.v0"));
assert!(!serialized.contains("privateNotes"));
assert!(!summary.private_state_exposed);
let mut newer = summary.clone();
newer.summary_id = "agent-state-soa-summary-newer".to_string();
newer.generated_at = "2026-06-18T01:00:00Z".to_string();
write_epiphany_cultmesh_agent_state_soa_summary(&store, newer.clone())?;
let mut delayed = summary.clone();
delayed.summary_id = "agent-state-soa-summary-delayed".to_string();
delayed.generated_at = "2026-06-17T23:00:00Z".to_string();
write_epiphany_cultmesh_agent_state_soa_summary(&store, delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_agent_state_soa_summary(&store, "epiphany-test")?,
Some(newer)
);
let mut invalid_time = summary.clone();
invalid_time.summary_id = "agent-state-soa-summary-invalid".to_string();
invalid_time.generated_at = "not-a-time".to_string();
let err = write_epiphany_cultmesh_agent_state_soa_summary(&store, invalid_time)
.expect_err("invalid agent summary time must be refused");
assert!(err.to_string().contains("invalid generated_at"));
let mut wrong_verse = summary.clone();
wrong_verse.summary_id = "agent-state-soa-summary-wrong-verse".to_string();
wrong_verse.verse_id = EPIPHANY_CULTMESH_INTERNAL_VERSE_ID.to_string();
let err = write_epiphany_cultmesh_agent_state_soa_summary(&store, wrong_verse)
.expect_err("agent summary outside local-area Verse must be refused");
assert!(err.to_string().contains("local-area Verse"));
let mut leaked = summary.clone();
leaked.private_state_exposed = true;
let err = write_epiphany_cultmesh_agent_state_soa_summary(&store, leaked)
.expect_err("private-state agent summaries must be refused");
assert!(err.to_string().contains("must not expose private state"));
let mut drifted = summary;
drifted.agent_ids.pop();
let err = write_epiphany_cultmesh_agent_state_soa_summary(&store, drifted)
.expect_err("column length drift must be refused");
assert!(err.to_string().contains("column agentIds has length"));
Ok(())
}
#[test]
fn builtin_verse_policies_keep_public_and_private_boundaries_apart() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-verses.ccmp");
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.ccmp");
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 cluster_topology_names_private_verses_body_daemons_and_eve_surfaces() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-cluster-topology.ccmp");
let written = write_epiphany_cultmesh_cluster_topology(
&store,
"epiphany-test",
"repo:C:/fixture/Epiphany",
)?;
assert_eq!(written.len(), 7);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let persona =
node.get_required::<EpiphanyCultMeshClusterTopologyEntry>("epiphany.cluster.persona")?;
let hands =
node.get_required::<EpiphanyCultMeshClusterTopologyEntry>("epiphany.cluster.hands")?;
assert_eq!(persona.private_verse_id, "epiphany.cluster.persona.private");
assert_eq!(persona.body_domain, "repo:C:/fixture/Epiphany");
assert_eq!(persona.daemon_id, "epiphany-daemon-persona");
assert_eq!(persona.eve_surface_id, "eve://epiphany/persona");
assert!(persona.public_persona_discussion_allowed);
assert!(!hands.public_persona_discussion_allowed);
assert!(
hands
.notes
.iter()
.any(|note| note.contains("Odin may advertise compact metadata"))
);
Ok(())
}
#[test]
fn odin_advertisements_expose_eve_metadata_without_private_state() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-odin-advertisements.ccmp");
publish_all_test_provider_state(&store)?;
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let persona = node.get_required::<EpiphanyCultMeshOdinAdvertisementEntry>(
"odin.advertisement.epiphany.cluster.persona",
)?;
assert_eq!(persona.cluster_id, "epiphany.cluster.persona");
assert_eq!(
persona.advertised_verse_id,
"epiphany.cluster.persona.private"
);
assert_eq!(persona.eve_surface_id, "eve://epiphany/persona");
assert!(!persona.private_state_exposed);
assert!(
persona
.advertised_document_types
.iter()
.any(|document_type| document_type == EPIPHANY_CULTMESH_ODIN_ADVERTISEMENT_TYPE)
);
assert!(
persona
.notes
.iter()
.any(|note| note.contains("discovery metadata"))
);
Ok(())
}
#[test]
fn legacy_provider_rows_are_not_live_discovery_state() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-eve-surface-states.ccmp");
write_epiphany_cultmesh_cluster_topology(
&store,
"epiphany-test",
"repo:C:/fixture/Epiphany",
)?;
publish_all_test_provider_state(&store)?;
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert!(context.odin_advertisements.is_empty());
assert!(context.eve_surface_states.is_empty());
assert!(context.daemon_tool_capabilities.is_empty());
assert!(load_epiphany_cultmesh_eve_surface_directory(&store, "epiphany-test")?.is_empty());
assert!(load_epiphany_cultmesh_daemon_tool_directory(&store, "epiphany-test")?.is_empty());
Ok(())
}
#[test]
fn eve_surface_state_refuses_private_state_exposure() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-eve-surface-private.ccmp");
let mut surface = epiphany_cultmesh_eve_surface_templates()
.into_iter()
.find(|surface| surface.surface_id == "eve://epiphany/persona")
.expect("persona surface exists");
surface.private_state_exposed = true;
let mut node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let error = validate_eve_surface_state(&surface)
.expect_err("private Eve surface states must be refused");
assert!(error.to_string().contains("private state"));
surface.private_state_exposed = false;
node.put(surface.surface_id.clone(), &surface)?;
node.flush()?;
Ok(())
}
#[test]
fn daemon_statuses_cover_every_cluster_without_private_state() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-daemon-statuses.ccmp");
write_epiphany_cultmesh_cluster_topology(
&store,
"epiphany-test",
"repo:C:/fixture/Epiphany",
)?;
let statuses = write_epiphany_cultmesh_daemon_statuses(
&store,
"epiphany-test",
"2026-06-17T00:00:00Z",
)?;
assert_eq!(statuses.len(), epiphany_cultmesh_cluster_topology().len());
let hands = statuses
.iter()
.find(|status| status.daemon_id == "epiphany-daemon-hands")
.expect("Hands daemon status exists");
assert_eq!(hands.cluster_id, "epiphany.cluster.hands");
assert_eq!(hands.status, "ready");
assert!(!hands.private_state_exposed);
assert!(
hands
.supported_actions
.iter()
.any(|action| action == "pokeDaemon")
);
assert!(
hands
.supported_actions
.iter()
.any(|action| action == "watchHeartbeat")
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(
context.daemon_statuses.len(),
context.cluster_topology.len()
);
assert!(context.daemon_statuses.iter().all(|status| {
!status.private_state_exposed && !status.last_heartbeat_utc.is_empty()
}));
Ok(())
}
#[test]
fn declared_daemon_targets_do_not_materialize_observed_liveness() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-declared-versus-observed.ccmp");
let topology = write_epiphany_cultmesh_cluster_topology(
&store,
"epiphany-test",
"repo:C:/fixture/Epiphany",
)?;
assert_eq!(topology.len(), 7);
assert!(load_epiphany_cultmesh_daemon_liveness(&store, "epiphany-test")?.is_empty());
let observed = epiphany_cultmesh_daemon_statuses("2026-07-15T00:00:00Z")
.into_iter()
.next()
.expect("declared topology has a matching daemon status fixture");
let observed_daemon_id = observed.daemon_id.clone();
write_epiphany_cultmesh_daemon_status(&store, "epiphany-test", observed)?;
let liveness = load_epiphany_cultmesh_daemon_liveness(&store, "epiphany-test")?;
assert_eq!(liveness.len(), 1);
assert_eq!(liveness[0].1.daemon_id, observed_daemon_id);
Ok(())
}
#[test]
fn diagnostic_loaders_do_not_materialize_missing_body_state() -> Result<()> {
let temp = tempfile::tempdir()?;
let missing_parent = temp.path().join("missing-body");
let store = missing_parent.join("missing-local-verse.ccmp");
assert_eq!(
load_epiphany_cultmesh_status(&store, "epiphany-test")?,
None
);
assert!(load_epiphany_cultmesh_cluster_topology(&store, "epiphany-test")?.is_empty());
assert!(load_epiphany_cultmesh_daemon_liveness(&store, "epiphany-test")?.is_empty());
assert!(
load_epiphany_cultmesh_daemon_restart_policy_directory(&store, "epiphany-test")?
.is_empty()
);
assert!(load_epiphany_cultmesh_eve_surface_directory(&store, "epiphany-test")?.is_empty());
assert!(load_epiphany_cultmesh_daemon_tool_directory(&store, "epiphany-test")?.is_empty());
assert!(
!store.exists(),
"read-only diagnostic loaders must not create a CultCache store"
);
assert!(
!missing_parent.exists(),
"read-only diagnostic loaders must not create the store parent"
);
let error = query_epiphany_local_verse_context(&store, "epiphany-test")
.expect_err("a missing Verse cannot project a context");
assert!(error.to_string().contains("store does not exist"));
assert!(!missing_parent.exists());
Ok(())
}
#[test]
fn daemon_status_refuses_private_state_exposure() -> Result<()> {
let mut status = epiphany_cultmesh_daemon_statuses("2026-06-17T00:00:00Z")
.into_iter()
.find(|status| status.daemon_id == "epiphany-daemon-persona")
.expect("Persona daemon status exists");
status.private_state_exposed = true;
let error =
validate_daemon_status(&status).expect_err("private daemon status must be refused");
assert!(error.to_string().contains("private state"));
Ok(())
}
#[test]
fn daemon_poke_intent_and_receipt_round_trip() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-daemon-poke.ccmp");
write_epiphany_cultmesh_daemon_statuses(&store, "epiphany-test", "2026-06-17T00:00:00Z")?;
let hands = epiphany_cultmesh_daemon_statuses("2026-06-17T00:00:00Z")
.into_iter()
.find(|status| status.daemon_id == "epiphany-daemon-hands")
.expect("Hands daemon status exists");
let intent = epiphany_cultmesh_daemon_poke_intent_from_status(
"daemon-poke-intent-test",
"epiphany.Self",
&hands,
"Hands daemon missed a heartbeat and needs operator-safe poke.",
);
let receipt = epiphany_cultmesh_daemon_poke_receipt_for_intent(
"daemon-poke-receipt-test",
&intent,
"completed",
"ready",
"cultmesh://epiphany-local/daemon-poke/test",
);
write_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test", intent.clone())?;
write_epiphany_cultmesh_daemon_poke_receipt(&store, "epiphany-test", receipt.clone())?;
assert_eq!(
write_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test", intent.clone())?,
intent
);
assert_eq!(
write_epiphany_cultmesh_daemon_poke_receipt(&store, "epiphany-test", receipt.clone())?,
receipt
);
let mut colliding_intent = intent.clone();
colliding_intent.reason = "counterfeit replacement".to_string();
let error =
write_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test", colliding_intent)
.expect_err("non-identical intent identity collision must be refused");
assert!(error.to_string().contains("identity collision"));
let mut colliding_receipt = receipt.clone();
colliding_receipt.resulting_status = "counterfeit-ready".to_string();
let error =
write_epiphany_cultmesh_daemon_poke_receipt(&store, "epiphany-test", colliding_receipt)
.expect_err("non-identical receipt identity collision must be refused");
assert!(error.to_string().contains("identity collision"));
let mut newer_intent = intent.clone();
newer_intent.intent_id = "daemon-poke-intent-newer".to_string();
newer_intent.requested_at_utc = "2099-06-17T00:02:00Z".to_string();
let mut newer_receipt = receipt.clone();
newer_receipt.receipt_id = "daemon-poke-receipt-newer".to_string();
newer_receipt.intent_id = newer_intent.intent_id.clone();
newer_receipt.attempted_at_utc = "2099-06-17T00:02:00Z".to_string();
newer_receipt.completed_at_utc = "2099-06-17T00:03:00Z".to_string();
write_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test", newer_intent.clone())?;
write_epiphany_cultmesh_daemon_poke_receipt(
&store,
"epiphany-test",
newer_receipt.clone(),
)?;
write_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test", intent.clone())?;
write_epiphany_cultmesh_daemon_poke_receipt(&store, "epiphany-test", receipt.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test")?,
Some(newer_intent)
);
assert_eq!(
load_latest_epiphany_cultmesh_daemon_poke_receipt(&store, "epiphany-test")?,
Some(newer_receipt)
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(
context
.latest_daemon_poke_intent
.as_ref()
.map(|intent| intent.requested_action.as_str()),
Some("pokeDaemon")
);
assert_eq!(
context
.latest_daemon_poke_receipt
.as_ref()
.map(|receipt| receipt.resulting_status.as_str()),
Some("ready")
);
Ok(())
}
#[test]
fn daemon_poke_refuses_private_state_and_wrong_action() -> Result<()> {
let hands = epiphany_cultmesh_daemon_statuses("2026-06-17T00:00:00Z")
.into_iter()
.find(|status| status.daemon_id == "epiphany-daemon-hands")
.expect("Hands daemon status exists");
let mut intent = epiphany_cultmesh_daemon_poke_intent_from_status(
"daemon-poke-intent-private-test",
"epiphany.Self",
&hands,
"Attempt forbidden private daemon poke.",
);
intent.private_state_requested = true;
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-daemon-poke-refusal.ccmp");
let error = write_epiphany_cultmesh_daemon_poke_intent(&store, "epiphany-test", intent)
.expect_err("private daemon poke intents must be refused");
assert!(error.to_string().contains("private state"));
let intent = epiphany_cultmesh_daemon_poke_intent_from_status(
"daemon-poke-intent-test",
"epiphany.Self",
&hands,
"Attempt malformed receipt.",
);
let mut receipt = epiphany_cultmesh_daemon_poke_receipt_for_intent(
"daemon-poke-receipt-wrong-action-test",
&intent,
"completed",
"ready",
"cultmesh://epiphany-local/daemon-poke/test",
);
receipt.action_taken = "inspectStatus".to_string();
let error = write_epiphany_cultmesh_daemon_poke_receipt(&store, "epiphany-test", receipt)
.expect_err("wrong daemon poke receipt action must be refused");
assert!(error.to_string().contains("pokeDaemon"));
Ok(())
}
#[test]
fn swarm_brake_round_trips_and_projects_status() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-swarm-brake.ccmp");
seed_epiphany_local_verse_context(
&store,
"epiphany-test",
"2026-06-17T00:00:00Z",
"repo:C:/fixture/Epiphany",
)?;
let brake = load_epiphany_cultmesh_swarm_brake(&store, "epiphany-test")?
.expect("seeded swarm brake exists");
assert_eq!(brake.status, "released");
assert_eq!(brake.scope, "swarm");
assert!(!brake.private_state_exposed);
assert!(
brake
.affected_clusters
.iter()
.any(|cluster| cluster == "epiphany.cluster.persona")
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert_eq!(
context
.swarm_brake
.as_ref()
.map(|brake| brake.status.as_str()),
Some("released")
);
Ok(())
}
#[test]
fn swarm_brake_refuses_private_state_or_unreasoned_engagement() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-swarm-brake-refusal.ccmp");
let mut brake = default_epiphany_cultmesh_swarm_brake("2026-06-17T00:00:00Z");
brake.private_state_exposed = true;
let error = write_epiphany_cultmesh_swarm_brake(&store, "epiphany-test", brake)
.expect_err("private swarm brake must be refused");
assert!(error.to_string().contains("private state"));
let mut brake = default_epiphany_cultmesh_swarm_brake("2026-06-17T00:00:00Z");
brake.status = "engaged".to_string();
brake.reason.clear();
let error = write_epiphany_cultmesh_swarm_brake(&store, "epiphany-test", brake)
.expect_err("unreasoned engaged swarm brake must be refused");
assert!(error.to_string().contains("operator id and reason"));
Ok(())
}
#[test]
fn persona_speech_audit_round_trips_and_projects_without_private_content() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-persona-speech-audit.ccmp");
seed_epiphany_local_verse_context(
&store,
"epiphany-test",
"2026-06-17T00:00:00Z",
"repo:C:/fixture/Epiphany",
)?;
let audit = EpiphanyCultMeshPersonaSpeechAuditEntry {
schema_version: EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_SCHEMA_VERSION.to_string(),
audit_id: "persona-speech-audit-test".to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
persona_agent_id: "epiphany.Persona".to_string(),
action_kind: "post".to_string(),
decision: "blocked".to_string(),
content_fingerprint: "topic::normalized-opening".to_string(),
opening_key: "rite noted modeling".to_string(),
topic_key: "modeling|soul|evidence".to_string(),
requested_channel_id: "123".to_string(),
recent_window_count: 6,
repeated_opening_count: 2,
repeated_topic_count: 2,
same_channel_post_count: 2,
reasons: vec!["repeated-opening".to_string()],
artifact_ref: "artifact://persona/speech-audit.json".to_string(),
created_at_utc: "2026-06-17T00:00:00Z".to_string(),
private_state_exposed: false,
notes: vec![
"CultMesh audit stores policy facts and fingerprints, not raw Persona prose."
.to_string(),
],
};
write_epiphany_cultmesh_persona_speech_audit(&store, audit.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_persona_speech_audit(&store, "epiphany-test")?,
Some(audit)
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
let projected = context
.latest_persona_speech_audit
.expect("speech audit should project into local Verse context");
assert_eq!(projected.decision, "blocked");
assert_eq!(projected.reasons, vec!["repeated-opening"]);
assert!(!projected.private_state_exposed);
Ok(())
}
#[test]
fn persona_speech_audit_refuses_private_state_and_unreasoned_blocks() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-persona-speech-audit-refusal.ccmp");
let mut audit = EpiphanyCultMeshPersonaSpeechAuditEntry {
schema_version: EPIPHANY_CULTMESH_PERSONA_SPEECH_AUDIT_SCHEMA_VERSION.to_string(),
audit_id: "persona-speech-audit-test".to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
persona_agent_id: "epiphany.Persona".to_string(),
action_kind: "post".to_string(),
decision: "eligible".to_string(),
content_fingerprint: "topic::normalized-opening".to_string(),
opening_key: "rite noted modeling".to_string(),
topic_key: "modeling|soul|evidence".to_string(),
requested_channel_id: "123".to_string(),
recent_window_count: 1,
repeated_opening_count: 0,
repeated_topic_count: 0,
same_channel_post_count: 0,
reasons: Vec::new(),
artifact_ref: "artifact://persona/speech-audit.json".to_string(),
created_at_utc: "2026-06-17T00:00:00Z".to_string(),
private_state_exposed: true,
notes: Vec::new(),
};
let error = write_epiphany_cultmesh_persona_speech_audit(&store, audit.clone())
.expect_err("private speech audit must be refused");
assert!(error.to_string().contains("private state"));
audit.private_state_exposed = false;
audit.decision = "blocked".to_string();
let error = write_epiphany_cultmesh_persona_speech_audit(&store, audit)
.expect_err("blocked speech audit without reasons must be refused");
assert!(error.to_string().contains("requires reasons"));
Ok(())
}
#[test]
fn weksa_lowering_receipt_round_trips_and_projects_without_publication_authority() -> Result<()>
{
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-weksa-lowering.ccmp");
seed_epiphany_local_verse_context(
&store,
"epiphany-test",
"2026-06-21T00:00:00Z",
"repo:C:/fixture/Epiphany",
)?;
let receipt = EpiphanyCultMeshWeksaLoweringReceiptEntry {
schema_version: EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: "weksa-lowering-receipt-test".to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
packet_id: "weksa-packet-test".to_string(),
request_id: "weksa-request-test".to_string(),
persona_agent_id: "epiphany.Persona".to_string(),
target_language: "es".to_string(),
target_register: "warm-technical".to_string(),
delivery_surface: "eve-public-room".to_string(),
lowering_method: "deterministic-test".to_string(),
transport_authority: "none; Bifrost or a configured mouth transport must publish"
.to_string(),
publication_authorized: false,
lowered_text_ref: "artifact://weksa/lowered-text/es".to_string(),
lowered_text_preview: "Epiphany puede seguir trabajando.".to_string(),
created_at_utc: "2026-06-21T00:00:00Z".to_string(),
private_state_exposed: false,
notes: vec!["CultMesh Weksa receipt is sight, not publication authority.".to_string()],
};
write_epiphany_cultmesh_weksa_lowering_receipt(&store, receipt.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_weksa_lowering_receipt(&store, "epiphany-test")?,
Some(receipt)
);
let context = query_epiphany_local_verse_context(&store, "epiphany-test")?;
let projected = context
.latest_weksa_lowering_receipt
.expect("Weksa lowering receipt should project into local Verse context");
assert_eq!(projected.target_language, "es");
assert!(!projected.publication_authorized);
assert!(!projected.private_state_exposed);
Ok(())
}
#[test]
fn weksa_lowering_receipt_refuses_private_state_and_publication_authority() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-weksa-lowering-refusal.ccmp");
let mut receipt = EpiphanyCultMeshWeksaLoweringReceiptEntry {
schema_version: EPIPHANY_CULTMESH_WEKSA_LOWERING_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: "weksa-lowering-receipt-test".to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
packet_id: "weksa-packet-test".to_string(),
request_id: "weksa-request-test".to_string(),
persona_agent_id: "epiphany.Persona".to_string(),
target_language: "es".to_string(),
target_register: "warm-technical".to_string(),
delivery_surface: "eve-public-room".to_string(),
lowering_method: "deterministic-test".to_string(),
transport_authority: "none".to_string(),
publication_authorized: false,
lowered_text_ref: "artifact://weksa/lowered-text/es".to_string(),
lowered_text_preview: "Epiphany puede seguir trabajando.".to_string(),
created_at_utc: "2026-06-21T00:00:00Z".to_string(),
private_state_exposed: true,
notes: Vec::new(),
};
let error = write_epiphany_cultmesh_weksa_lowering_receipt(&store, receipt.clone())
.expect_err("private Weksa receipt must be refused");
assert!(error.to_string().contains("private state"));
receipt.private_state_exposed = false;
receipt.publication_authorized = true;
let error = write_epiphany_cultmesh_weksa_lowering_receipt(&store, receipt)
.expect_err("publication-authorizing Weksa receipt must be refused");
assert!(error.to_string().contains("publication authority"));
Ok(())
}
#[test]
fn daemon_tool_capabilities_make_every_local_tool_available_to_all_agents() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-daemon-tools.ccmp");
publish_all_test_provider_state(&store)?;
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let persona_status = node.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.persona.tool.status",
)?;
let self_service_health = node.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.self.tool.service-health",
)?;
let self_service_policy_directory = node
.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.self.tool.service-policy-directory",
)?;
let self_swarm_online_runbook = node
.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.self.tool.swarm-online-runbook",
)?;
let hands_action = node.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.hands.tool.repo-action",
)?;
let soul_verify = node.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.soul.tool.verify",
)?;
for capability in [
persona_status.clone(),
self_service_health.clone(),
self_service_policy_directory.clone(),
self_swarm_online_runbook.clone(),
hands_action.clone(),
soul_verify.clone(),
] {
assert!(capability.available_to_all_agents);
assert!(capability.requires_receipt);
assert!(!capability.private_state_exposed);
assert!(capability.eve_surface_id.starts_with("eve://epiphany/"));
}
assert_eq!(hands_action.authority_gate, "hands");
assert_eq!(soul_verify.authority_gate, "soul");
assert_eq!(persona_status.authority_gate, "none");
assert_eq!(
self_service_health.authority_gate,
"daemon.service_lifecycle"
);
assert_eq!(
self_service_health.input_contract_type,
"epiphany.cultmesh.daemon_service_lifecycle_query"
);
assert_eq!(
self_service_health.receipt_contract_type,
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE
);
assert_eq!(
self_service_policy_directory.authority_gate,
"daemon.service_lifecycle"
);
assert_eq!(
self_service_policy_directory.operation,
"readServicePolicyDirectory"
);
assert_eq!(
self_service_policy_directory.input_contract_type,
"epiphany.cultmesh.daemon_restart_policy_directory_query"
);
assert_eq!(
self_service_policy_directory.receipt_contract_type,
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE
);
assert_eq!(
self_swarm_online_runbook.authority_gate,
"daemon.service_lifecycle"
);
assert_eq!(
self_swarm_online_runbook.operation,
"prepareSwarmOnlineRunbook"
);
assert_eq!(
self_swarm_online_runbook.input_contract_type,
"epiphany.cultmesh.daemon_service_online_runbook_request"
);
assert_eq!(
self_swarm_online_runbook.receipt_contract_type,
EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_TYPE
);
assert!(
hands_action
.notes
.iter()
.any(|note| note.contains("Every agent in the local CultMesh network"))
);
Ok(())
}
#[test]
fn daemon_tool_invocation_intent_and_receipt_round_trip_for_any_agent() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-daemon-tool-invocation.ccmp");
write_legacy_provider_fixture(&store, "epiphany-test", "epiphany-daemon-hands")?;
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let hands_action = node.get_required::<EpiphanyCultMeshDaemonToolCapabilityEntry>(
"epiphany.cluster.hands.tool.repo-action",
)?;
let intent = epiphany_cultmesh_daemon_tool_invocation_intent_from_capability(
"daemon-tool-intent-test",
"epiphany.Persona",
"epiphany.cluster.persona",
&hands_action,
"cultmesh://epiphany-local/hands-action-intent/test",
"Persona asks Hands to review a repo action through a globally advertised daemon tool.",
);
let receipt = epiphany_cultmesh_daemon_tool_invocation_receipt_for_intent(
"daemon-tool-receipt-test",
&intent,
"accepted-for-hands-review",
hands_action.receipt_contract_type.clone(),
"cultmesh://epiphany-local/hands-action-review/test",
"Hands accepted the daemon tool invocation for typed review.",
);
write_epiphany_cultmesh_daemon_tool_invocation_intent(
&store,
"epiphany-test",
intent.clone(),
)?;
write_epiphany_cultmesh_daemon_tool_invocation_receipt(
&store,
"epiphany-test",
receipt.clone(),
)?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_tool_invocation_intent(&store, "epiphany-test")?,
Some(intent.clone())
);
assert_eq!(
load_latest_epiphany_cultmesh_daemon_tool_invocation_receipt(&store, "epiphany-test")?,
Some(receipt.clone())
);
assert_eq!(intent.requesting_cluster_id, "epiphany.cluster.persona");
assert_eq!(intent.host_cluster_id, "epiphany.cluster.hands");
assert_eq!(intent.authority_gate, "hands");
assert!(intent.requires_receipt);
assert!(!intent.private_state_requested);
assert_eq!(
receipt.receipt_contract_type,
"epiphany.hands.action_review"
);
assert!(!receipt.private_state_exposed);
Ok(())
}
#[test]
fn daemon_tool_invocation_refuses_private_state_requests() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-daemon-tool-private-refusal.ccmp");
let capability = epiphany_cultmesh_daemon_tool_capability_templates()
.into_iter()
.find(|capability| capability.capability_id == "epiphany.cluster.persona.tool.status")
.expect("persona status capability exists");
let mut intent = epiphany_cultmesh_daemon_tool_invocation_intent_from_capability(
"daemon-tool-private-test",
"epiphany.Self",
"epiphany.cluster.self",
&capability,
"cultmesh://epiphany-local/private-state/test",
"Attempt forbidden private state through a globally visible daemon tool.",
);
intent.private_state_requested = true;
let error =
write_epiphany_cultmesh_daemon_tool_invocation_intent(&store, "epiphany-test", intent)
.expect_err("private state requests must be refused");
assert!(
error
.to_string()
.contains("must not request private Verse state")
);
Ok(())
}
#[test]
fn bifrost_body_change_publication_intent_and_receipt_round_trip() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-bifrost-body-change-publication.ccmp");
let intent = epiphany_cultmesh_bifrost_body_change_publication_intent(
"bifrost-publication-intent-test",
"epiphany.cluster.hands",
"epiphany.Hands",
"repo:E:/Projects/EpiphanyAgent",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"Route typed CultMesh publication proof through Bifrost.",
"Publication needs Bifrost ledger, credit, review, and GitHub routing proof.",
vec!["epiphany-core/src/cultmesh_integration.rs".to_string()],
vec!["soul-verdict-test".to_string()],
vec!["maintainer-review-test".to_string()],
vec!["epiphany.Hands".to_string()],
vec!["GameCult/EpiphanyAgent".to_string()],
);
let receipt = epiphany_cultmesh_bifrost_body_change_publication_receipt_for_intent(
"bifrost-publication-receipt-test",
&intent,
"accepted-for-github-publication",
"bifrost-ledger-test",
"github-publication-test",
vec!["credit-receipt-test".to_string()],
vec!["maintainer-review-test".to_string()],
"https://github.com/GameCult/EpiphanyAgent/pull/test",
);
write_epiphany_cultmesh_bifrost_body_change_publication_intent(
&store,
"epiphany-test",
intent.clone(),
)?;
write_epiphany_cultmesh_bifrost_body_change_publication_receipt(
&store,
"epiphany-test",
receipt.clone(),
)?;
assert_eq!(
load_arrival_latest_epiphany_cultmesh_bifrost_body_change_publication_intent(
&store,
"epiphany-test"
)?,
Some(intent.clone())
);
assert_eq!(
load_arrival_latest_epiphany_cultmesh_bifrost_body_change_publication_receipt(
&store,
"epiphany-test"
)?,
Some(receipt.clone())
);
assert!(intent.github_publication_requested);
assert!(!intent.private_state_included);
assert_eq!(intent.verification_receipt_ids, vec!["soul-verdict-test"]);
assert_eq!(receipt.bifrost_ledger_entry_id, "bifrost-ledger-test");
assert_eq!(
receipt.github_publication_receipt_id,
"github-publication-test"
);
assert!(!receipt.private_state_exposed);
Ok(())
}
#[test]
fn bifrost_body_change_publication_refuses_private_or_unverified_intents() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-bifrost-publication-refusal.ccmp");
let mut intent = epiphany_cultmesh_bifrost_body_change_publication_intent(
"bifrost-publication-private-test",
"epiphany.cluster.hands",
"epiphany.Hands",
"repo:E:/Projects/EpiphanyAgent",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"Attempt invalid publication.",
"This should be refused.",
vec!["epiphany-core/src/cultmesh_integration.rs".to_string()],
vec!["soul-verdict-test".to_string()],
vec!["maintainer-review-test".to_string()],
vec!["epiphany.Hands".to_string()],
vec!["GameCult/EpiphanyAgent".to_string()],
);
intent.private_state_included = true;
let error = write_epiphany_cultmesh_bifrost_body_change_publication_intent(
&store,
"epiphany-test",
intent,
)
.expect_err("private publication payloads must be refused");
assert!(error.to_string().contains("must not include private state"));
let unverified = epiphany_cultmesh_bifrost_body_change_publication_intent(
"bifrost-publication-unverified-test",
"epiphany.cluster.hands",
"epiphany.Hands",
"repo:E:/Projects/EpiphanyAgent",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"Attempt unverified publication.",
"This should be refused.",
vec!["epiphany-core/src/cultmesh_integration.rs".to_string()],
Vec::new(),
vec!["maintainer-review-test".to_string()],
vec!["epiphany.Hands".to_string()],
vec!["GameCult/EpiphanyAgent".to_string()],
);
let error = write_epiphany_cultmesh_bifrost_body_change_publication_intent(
&store,
"epiphany-test",
unverified,
)
.expect_err("unverified publication payloads must be refused");
assert!(error.to_string().contains("require verification receipts"));
Ok(())
}
#[test]
fn bifrost_github_publication_receipt_round_trips_with_hands_pr_proof() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-bifrost-github-publication.ccmp");
let intent = epiphany_cultmesh_bifrost_body_change_publication_intent(
"bifrost-publication-intent-test",
"epiphany.cluster.hands",
"epiphany.Hands",
"repo:E:/Projects/EpiphanyAgent",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"Route typed GitHub publication proof through Bifrost.",
"Publication needs Bifrost ledger, Hands PR, credit, and review proof.",
vec!["epiphany-core/src/cultmesh_integration.rs".to_string()],
vec!["soul-verdict-test".to_string()],
vec!["maintainer-review-test".to_string()],
vec!["epiphany.Hands".to_string()],
vec!["GameCult/EpiphanyAgent".to_string()],
);
let publication = epiphany_cultmesh_bifrost_body_change_publication_receipt_for_intent(
"bifrost-publication-receipt-test",
&intent,
"accepted-for-github-publication",
"bifrost-ledger-test",
"github-publication-test",
vec!["credit-receipt-test".to_string()],
vec!["maintainer-review-test".to_string()],
"https://github.com/GameCult/EpiphanyAgent/pull/test",
);
let github = epiphany_cultmesh_bifrost_github_publication_receipt_for_publication(
"github-publication-test",
&publication,
"hands-pr-test",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"test",
"abc123",
"epiphany.Hands",
);
write_epiphany_cultmesh_bifrost_body_change_publication_intent(
&store,
"epiphany-test",
intent,
)?;
write_epiphany_cultmesh_bifrost_body_change_publication_receipt(
&store,
"epiphany-test",
publication.clone(),
)?;
write_epiphany_cultmesh_bifrost_github_publication_receipt(
&store,
"epiphany-test",
github.clone(),
)?;
assert_eq!(
load_arrival_latest_epiphany_cultmesh_bifrost_github_publication_receipt(
&store,
"epiphany-test"
)?,
Some(github.clone())
);
assert_eq!(
github.bifrost_publication_receipt_id,
"bifrost-publication-receipt-test"
);
assert_eq!(github.hands_pr_receipt_id, "hands-pr-test");
assert_eq!(github.ledger_entry_id, "bifrost-ledger-test");
assert_eq!(github.credit_receipt_ids, vec!["credit-receipt-test"]);
assert_eq!(
github.pull_request_url,
"https://github.com/GameCult/EpiphanyAgent/pull/test"
);
assert!(!github.private_state_exposed);
Ok(())
}
#[test]
fn bifrost_github_publication_refuses_private_or_unlinked_receipts() -> Result<()> {
let publication = EpiphanyCultMeshBifrostBodyChangePublicationReceiptEntry {
schema_version:
EPIPHANY_CULTMESH_BIFROST_BODY_CHANGE_PUBLICATION_RECEIPT_SCHEMA_VERSION.to_string(),
receipt_id: "bifrost-publication-receipt-test".to_string(),
intent_id: "bifrost-publication-intent-test".to_string(),
status: "accepted-for-github-publication".to_string(),
bifrost_ledger_entry_id: "bifrost-ledger-test".to_string(),
github_publication_receipt_id: "github-publication-test".to_string(),
credit_receipt_ids: vec!["credit-receipt-test".to_string()],
accepted_changed_paths: vec!["epiphany-core/src/cultmesh_integration.rs".to_string()],
reviewer_ids: vec!["maintainer-review-test".to_string()],
publication_url: "https://github.com/GameCult/EpiphanyAgent/pull/test".to_string(),
private_state_exposed: false,
notes: Vec::new(),
};
let mut github = epiphany_cultmesh_bifrost_github_publication_receipt_for_publication(
"github-publication-test",
&publication,
"hands-pr-test",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"test",
"abc123",
"epiphany.Hands",
);
github.private_state_exposed = true;
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-bifrost-github-refusal.ccmp");
let error = write_epiphany_cultmesh_bifrost_github_publication_receipt(
&store,
"epiphany-test",
github,
)
.expect_err("private GitHub publication receipts must be refused");
assert!(error.to_string().contains("must not expose private state"));
let mut unlinked = epiphany_cultmesh_bifrost_github_publication_receipt_for_publication(
"github-publication-unlinked-test",
&publication,
"hands-pr-test",
"E:/Projects/EpiphanyAgent",
"codex/perfect-machine-cultmesh",
"test",
"abc123",
"epiphany.Hands",
);
unlinked.hands_pr_receipt_id.clear();
let error = write_epiphany_cultmesh_bifrost_github_publication_receipt(
&store,
"epiphany-test",
unlinked,
)
.expect_err("GitHub publication receipts without Hands PR proof must be refused");
assert!(error.to_string().contains("require a Hands PR receipt"));
Ok(())
}
#[test]
fn bifrost_public_proof_publication_receipt_round_trips() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-bifrost-public-proof-publication.ccmp");
let proof = EpiphanyCultMeshRepoWorkPublicProofEntry {
schema_version: EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_SCHEMA_VERSION.to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
public_proof_id: "repo-work-public-proof-test".to_string(),
generated_at: "2026-06-20T12:00:00Z".to_string(),
workspace: "E:/Projects/EpiphanyAgent".to_string(),
item: "test-item".to_string(),
branch: "codex/test-item".to_string(),
current_gate: "awaiting-publication".to_string(),
blocker: "bifrost-publication-missing".to_string(),
next_safe_move: "publish-redacted-proof".to_string(),
changed_paths: vec!["notes/test.md".to_string()],
commit_sha: "abc123".to_string(),
soul_verdict: "passed".to_string(),
upstream_main_synced: true,
artifact_row_count: 3,
publication_row_count: 5,
public_proof_ref: "public-proof.json".to_string(),
public_proof_sha256: "0123456789abcdef".to_string(),
tui_rows: vec!["proof row".to_string()],
private_state_exposed: false,
notes: vec!["redacted proof".to_string()],
};
let receipt = epiphany_cultmesh_bifrost_public_proof_publication_receipt_for_proof(
"bifrost-public-proof-publication-test",
&proof,
"published-to-public-verse",
EPIPHANY_CULTMESH_GLOBAL_VERSE_ID,
"epiphany-global/repo-work/public-proofs",
"bifrost-ledger-public-proof-test",
vec!["credit-receipt-test".to_string()],
vec!["maintainer-review-test".to_string()],
"cultmesh://epiphany-global/repo-work/public-proofs/repo-work-public-proof-test",
);
write_epiphany_cultmesh_bifrost_public_proof_publication_receipt(
&store,
"epiphany-test",
receipt.clone(),
)?;
assert_eq!(
load_arrival_latest_epiphany_cultmesh_bifrost_public_proof_publication_receipt(
&store,
"epiphany-test"
)?,
Some(receipt.clone())
);
assert_eq!(receipt.public_proof_id, proof.public_proof_id);
assert_eq!(receipt.public_proof_sha256, proof.public_proof_sha256);
assert_eq!(
receipt.target_public_verse_id,
EPIPHANY_CULTMESH_GLOBAL_VERSE_ID
);
assert_eq!(receipt.credit_receipt_ids, vec!["credit-receipt-test"]);
assert_eq!(receipt.reviewer_ids, vec!["maintainer-review-test"]);
assert!(!receipt.private_state_exposed);
Ok(())
}
#[test]
fn bifrost_public_proof_publication_refuses_private_or_wrong_verse() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp
.path()
.join("epiphany-bifrost-public-proof-publication-refusal.ccmp");
let proof = EpiphanyCultMeshRepoWorkPublicProofEntry {
schema_version: EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_SCHEMA_VERSION.to_string(),
runtime_id: "epiphany-test".to_string(),
verse_id: EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID.to_string(),
public_proof_id: "repo-work-public-proof-test".to_string(),
generated_at: "2026-06-20T12:00:00Z".to_string(),
workspace: "E:/Projects/EpiphanyAgent".to_string(),
item: "test-item".to_string(),
branch: "codex/test-item".to_string(),
current_gate: "awaiting-publication".to_string(),
blocker: "bifrost-publication-missing".to_string(),
next_safe_move: "publish-redacted-proof".to_string(),
changed_paths: vec!["notes/test.md".to_string()],
commit_sha: "abc123".to_string(),
soul_verdict: "passed".to_string(),
upstream_main_synced: true,
artifact_row_count: 3,
publication_row_count: 5,
public_proof_ref: "public-proof.json".to_string(),
public_proof_sha256: "0123456789abcdef".to_string(),
tui_rows: vec!["proof row".to_string()],
private_state_exposed: false,
notes: vec!["redacted proof".to_string()],
};
let mut receipt = epiphany_cultmesh_bifrost_public_proof_publication_receipt_for_proof(
"bifrost-public-proof-publication-private-test",
&proof,
"published-to-public-verse",
EPIPHANY_CULTMESH_GLOBAL_VERSE_ID,
"epiphany-global/repo-work/public-proofs",
"bifrost-ledger-public-proof-test",
vec!["credit-receipt-test".to_string()],
vec!["maintainer-review-test".to_string()],
"cultmesh://epiphany-global/repo-work/public-proofs/repo-work-public-proof-test",
);
receipt.private_state_exposed = true;
let error = write_epiphany_cultmesh_bifrost_public_proof_publication_receipt(
&store,
"epiphany-test",
receipt,
)
.expect_err("private proof publication receipts must be refused");
assert!(error.to_string().contains("must not expose private state"));
let wrong_verse = epiphany_cultmesh_bifrost_public_proof_publication_receipt_for_proof(
"bifrost-public-proof-publication-wrong-verse-test",
&proof,
"published-to-public-verse",
EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID,
"gamecult-local/repo-work/public-proofs",
"bifrost-ledger-public-proof-test",
vec!["credit-receipt-test".to_string()],
vec!["maintainer-review-test".to_string()],
"cultmesh://gamecult-local/repo-work/public-proofs/repo-work-public-proof-test",
);
let error = write_epiphany_cultmesh_bifrost_public_proof_publication_receipt(
&store,
"epiphany-test",
wrong_verse,
)
.expect_err("non-public Verse proof publication receipts must be refused");
assert!(error.to_string().contains("global public Verse"));
Ok(())
}
#[test]
fn local_verse_bootstrap_does_not_publish_provider_owned_state() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-local-verse.ccmp");
seed_epiphany_local_verse_context(
&store,
"epiphany-test",
"2026-06-02T00:00:00Z",
"repo:C:/fixture/Epiphany",
)?;
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_eq!(context.cluster_topology.len(), 7);
assert!(context.cluster_topology.iter().any(|cluster| {
cluster.cluster_id == "epiphany.cluster.persona"
&& cluster.public_persona_discussion_allowed
&& cluster.eve_surface_id == "eve://epiphany/persona"
}));
assert!(context.odin_advertisements.is_empty());
assert!(context.eve_surface_states.is_empty());
assert!(context.daemon_tool_capabilities.is_empty());
assert!(
context
.contract_summaries
.iter()
.any(|contract| contract.authority == "mind")
);
assert!(
context
.contract_summaries
.iter()
.any(|contract| contract.authority == "substrateGate")
);
assert!(
context
.contract_summaries
.iter()
.any(|contract| contract.authority == "bifrost")
);
assert!(context.odin_scope.contains("all-seer"));
assert!(context.yggdrasil_scope.contains("Bifrost"));
assert!(context.prompt_assembly_note.contains("bounded context"));
Ok(())
}
#[test]
fn explicit_bootstrap_retires_legacy_provider_forgery() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-provider-boundary.ccmp");
seed_epiphany_local_verse_context(
&store,
"epiphany-test",
"2026-07-12T00:00:00Z",
"repo:C:/fixture/Epiphany",
)?;
let sentinel_before =
open_epiphany_cultmesh_node(&store, "epiphany-test")?
.get_required::<EpiphanyCultMeshStatusEntry>(EPIPHANY_CULTMESH_STATUS_KEY)?;
write_legacy_provider_fixture(&store, "epiphany-test", "epiphany-daemon-hands")?;
assert!(
query_epiphany_local_verse_context(&store, "epiphany-test")?
.odin_advertisements
.is_empty()
);
let mut retired = retire_epiphany_cultmesh_legacy_provider_documents(&store)?;
retired.sort();
assert_eq!(
retired,
vec![
"epiphany.cluster.hands.tool.repo-action".to_string(),
"epiphany.cluster.hands.tool.status".to_string(),
"eve://epiphany/hands".to_string(),
"odin.advertisement.epiphany.cluster.hands".to_string(),
]
);
assert_eq!(
open_epiphany_cultmesh_node(&store, "epiphany-test")?
.get_required::<EpiphanyCultMeshStatusEntry>(EPIPHANY_CULTMESH_STATUS_KEY)?,
sentinel_before
);
seed_epiphany_local_verse_context(
&store,
"epiphany-test",
"2026-07-12T00:01:00Z",
"repo:C:/fixture/Epiphany",
)?;
assert!(retire_epiphany_cultmesh_legacy_provider_documents(&store)?.is_empty());
let error =
write_legacy_provider_fixture(&store, "epiphany-test", "epiphany-daemon-counterfeit")
.expect_err("unknown daemons must not create even a legacy fixture");
assert!(
error
.to_string()
.contains("legacy fixture daemon has no topology")
);
let unchanged = query_epiphany_local_verse_context(&store, "epiphany-test")?;
assert!(unchanged.odin_advertisements.is_empty());
assert!(unchanged.eve_surface_states.is_empty());
assert!(unchanged.daemon_tool_capabilities.is_empty());
Ok(())
}
#[test]
fn mind_contracts_use_verses_to_keep_state_guarded() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-mind-contracts.ccmp");
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.ccmp");
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.ccmp");
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.ccmp");
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.ccmp");
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.ccmp");
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(())
}
#[test]
fn bifrost_contracts_expose_publication_without_feedback_admission_substitution() -> Result<()>
{
let temp = tempfile::tempdir()?;
let store = temp.path().join("epiphany-bifrost-contracts.ccmp");
let written = write_epiphany_cultmesh_bifrost_contracts(&store, "epiphany-test")?;
assert_eq!(written.len(), 2);
let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?;
let publication = node.get_required::<EpiphanyCultMeshBifrostContractEntry>(
"gamecult.bifrost.body_change.publication",
)?;
assert!(
node.get::<EpiphanyCultMeshBifrostContractEntry>(
"gamecult.bifrost.collaboration.feedback",
)?
.is_none()
);
let public_proof = node.get_required::<EpiphanyCultMeshBifrostContractEntry>(
"gamecult.bifrost.public_proof.publication",
)?;
assert_eq!(publication.verse_id, EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID);
assert_eq!(publication.authority, "bifrost");
assert!(
publication
.receipt_document_types
.iter()
.any(|receipt| receipt == "gamecult.bifrost.github_publication_receipt")
);
assert!(
publication
.receipt_document_types
.iter()
.any(|receipt| receipt == "gamecult.bifrost.credit_receipt")
);
assert!(
publication
.notes
.iter()
.any(|note| note.contains("GitHub publication"))
);
assert_eq!(public_proof.authority, "bifrost");
assert_eq!(
public_proof.document_type,
EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_TYPE
);
assert!(
public_proof
.intent_document_types
.iter()
.any(|intent| intent == EPIPHANY_CULTMESH_REPO_WORK_PUBLIC_PROOF_TYPE)
);
assert!(
public_proof
.receipt_document_types
.iter()
.any(|receipt| receipt
== EPIPHANY_CULTMESH_BIFROST_PUBLIC_PROOF_PUBLICATION_RECEIPT_TYPE)
);
Ok(())
}
fn heartbeat_event(
heartbeat_id: &str,
incarnation: &str,
sequence: u64,
heartbeat_at: &str,
) -> EpiphanyCultMeshDaemonHeartbeatEventEntry {
EpiphanyCultMeshDaemonHeartbeatEventEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION.to_string(),
heartbeat_id: heartbeat_id.to_string(),
daemon_id: "daemon-test".to_string(),
cluster_id: "cluster-test".to_string(),
provider_incarnation: incarnation.to_string(),
sequence,
status: "ready".to_string(),
heartbeat_at: heartbeat_at.to_string(),
private_state_exposed: false,
startup_lifecycle_receipt_id: String::new(),
}
}
#[test]
fn daemon_heartbeat_events_are_immutable_and_advance_latest_monotonically() -> Result<()> {
let temp = tempfile::tempdir()?;
let store = temp.path().join("daemon-heartbeats.ccmp");
let first = heartbeat_event("heartbeat-1", "incarnation-a", 1, "2026-07-15T12:00:00Z");
write_epiphany_cultmesh_daemon_heartbeat_event(&store, "runtime-test", first.clone())?;
assert_eq!(
load_epiphany_cultmesh_daemon_heartbeat_event(&store, "runtime-test", "heartbeat-1")?,
Some(first.clone())
);
let delayed = heartbeat_event(
"heartbeat-delayed",
"incarnation-a",
1,
"2026-07-15T11:59:59Z",
);
write_epiphany_cultmesh_daemon_heartbeat_event(&store, "runtime-test", delayed)?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_heartbeat(&store, "runtime-test", "daemon-test")?,
Some(first.clone())
);
let restarted = heartbeat_event("heartbeat-2", "incarnation-b", 1, "2026-07-15T12:00:01Z");
write_epiphany_cultmesh_daemon_heartbeat_event(&store, "runtime-test", restarted.clone())?;
assert_eq!(
load_latest_epiphany_cultmesh_daemon_heartbeat(&store, "runtime-test", "daemon-test")?,
Some(restarted)
);
let mut collision = first.clone();
collision.status = "degraded".to_string();
assert!(
write_epiphany_cultmesh_daemon_heartbeat_event(&store, "runtime-test", collision)
.expect_err("heartbeat identity is immutable")
.to_string()
.contains("identity collision")
);
let mut private = heartbeat_event(
"heartbeat-private",
"incarnation-b",
2,
"2026-07-15T12:00:02Z",
);
private.private_state_exposed = true;
assert!(
write_epiphany_cultmesh_daemon_heartbeat_event(&store, "runtime-test", private)
.expect_err("private heartbeat must be refused")
.to_string()
.contains("must not expose private state")
);
Ok(())
}
#[test]
fn semantic_recovery_requires_current_policy_launch_heartbeat_chain_and_is_single_use()
-> Result<()> {
let temp = tempfile::tempdir()?;
let canonical = temp.path().join("canonical.msgpack");
let verse = temp.path().join("verse.ccmp");
let input = semantic_health_input(&canonical, "swarm-recovery", "mind", 1)?;
let claim =
crate::memory_graph::semantic_projector::idunn_acquire_memory_semantic_projection(
&canonical,
&input,
"executor-old",
"provider-old",
"execute",
"idunn-test-incarnation",
"2026-07-15T12:00:00Z",
)?
.claim;
let binary = if cfg!(windows) {
"C:\\epiphany-memory-semantic-projector.exe"
} else {
"/tmp/epiphany-memory-semantic-projector"
};
let policy = EpiphanyCultMeshManagedServicePolicyEntry {
schema_version: EPIPHANY_CULTMESH_MANAGED_SERVICE_POLICY_SCHEMA_VERSION.to_string(),
policy_id: "managed-service-policy-epiphany-memory-semantic-projector-service".into(),
service_id: EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID.into(),
owner_daemon_id: "epiphany-daemon-supervisor".into(),
command: binary.into(),
args: vec![
"serve",
"--agent-store",
"mind.ccmp",
"--runtime-store",
"modeling.ccmp",
"--local-verse-store",
"verse.ccmp",
"--runtime-id",
"runtime-test",
"--interval-seconds",
"60",
"--qdrant-url",
"http://127.0.0.1:16333",
"--ollama-base-url",
"http://10.77.0.1:11435",
"--ollama-model",
"qwen3-embedding:0.6b",
]
.into_iter()
.map(str::to_string)
.collect(),
cwd: None,
enabled: true,
restart_mode: "always".into(),
cooldown_seconds: 0,
backoff_multiplier: 1,
stdout_artifact: "projector.stdout.log".into(),
stderr_artifact: "projector.stderr.log".into(),
updated_at_utc: "2026-07-15T12:01:00Z".into(),
private_state_exposed: false,
notes: vec![],
};
write_epiphany_cultmesh_semantic_projector_service_policy(
&verse,
"runtime-test",
policy.clone(),
)?;
let (_, policy_digest) = load_epiphany_cultmesh_managed_service_policy_with_digest(
&verse,
"runtime-test",
EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID,
)?
.context("semantic policy missing")?;
let receipt = EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_SCHEMA_VERSION
.into(),
receipt_id: "f32666a9-94ce-47c5-b2bd-7d18624dfe9b".into(),
service_id: EPIPHANY_SEMANTIC_PROJECTOR_SERVICE_ID.into(),
scheduler_id: "epiphany-daemon-supervisor".into(),
runtime_id: "runtime-test".into(),
daemon_selector: "epiphany-daemon-supervisor".into(),
action: "launch".into(),
status: "launched".into(),
command: policy.command.clone(),
args: policy.args.clone(),
cwd: None,
process_id: Some(4242),
exit_code: None,
started_at_utc: "2026-07-15T12:01:00Z".into(),
completed_at_utc: Some("2026-07-15T12:02:00Z".into()),
operator_artifact_ref: "service://semantic-projector/launch".into(),
private_state_exposed: false,
notes: vec![],
executable_sha256: "sha256-test-projector".into(),
preflight_witness_id: String::new(),
required_document_types: vec![],
schema_preflight_passed: false,
schema_catalog_sha256: String::new(),
managed_policy_id: policy.policy_id.clone(),
managed_policy_digest: policy_digest,
provider_daemon_id: "epiphany-memory-semantic-projector".into(),
startup_correlation_id: "f32666a9-94ce-47c5-b2bd-7d18624dfe9b".into(),
process_creation_token: 1,
process_created_at_rfc3339: None,
process_executable_path: "C:\\epiphany\\semantic-projector.exe".into(),
};
write_epiphany_cultmesh_daemon_service_lifecycle_receipt(
&verse,
"runtime-test",
receipt.clone(),
)?;
let unrelated = EpiphanyCultMeshDaemonHeartbeatEventEntry {
schema_version: EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION.to_string(),
heartbeat_id: "semantic-heartbeat-unrelated".to_string(),
daemon_id: "epiphany-memory-semantic-projector".into(),
cluster_id: "local".into(),
provider_incarnation: "provider-new".to_string(),
sequence: 1,
status: "ready".to_string(),
heartbeat_at: "2026-07-15T12:03:00Z".to_string(),
private_state_exposed: false,
startup_lifecycle_receipt_id: String::new(),
};
write_epiphany_cultmesh_daemon_heartbeat_event(&verse, "runtime-test", unrelated)?;
assert!(
idunn_recover_memory_semantic_projection_from_cultmesh(
&verse,
"runtime-test",
&canonical,
&input,
&claim.claim_id,
"executor-new",
&receipt.receipt_id,
"semantic-heartbeat-unrelated",
"2026-07-15T12:04:00Z",
)
.is_err()
);
let mut advanced_policy = policy.clone();
advanced_policy.updated_at_utc = "2026-07-15T12:02:30Z".into();
write_epiphany_cultmesh_semantic_projector_service_policy(
&verse,
"runtime-test",
advanced_policy,
)?;
assert!(
idunn_recover_memory_semantic_projection_from_cultmesh(
&verse,
"runtime-test",
&canonical,
&input,
&claim.claim_id,
"executor-new",
&receipt.receipt_id,
"semantic-heartbeat-unrelated",
"2026-07-15T12:04:00Z",
)
.expect_err("an obsolete launch receipt cannot authorize a newer policy")
.to_string()
.contains("disagrees with current managed policy")
);
write_epiphany_cultmesh_semantic_projector_service_policy(&verse, "runtime-test", policy)?;
let correlated = EpiphanyCultMeshDaemonHeartbeatEventEntry {
heartbeat_id: "semantic-heartbeat-correlated".to_string(),
sequence: 2,
startup_lifecycle_receipt_id: receipt.receipt_id.clone(),
..heartbeat_event(
"semantic-heartbeat-template",
"provider-new",
2,
"2026-07-15T12:03:00Z",
)
};
let mut correlated = correlated;
correlated.daemon_id = "epiphany-memory-semantic-projector".into();
correlated.cluster_id = "local".into();
write_epiphany_cultmesh_daemon_heartbeat_event(&verse, "runtime-test", correlated.clone())?;
let (_, recovered) = idunn_recover_memory_semantic_projection_from_cultmesh(
&verse,
"runtime-test",
&canonical,
&input,
&claim.claim_id,
"executor-new",
&receipt.receipt_id,
&correlated.heartbeat_id,
"2026-07-15T12:04:00Z",
)?;
assert_eq!(recovered.epoch, claim.epoch + 1);
assert_eq!(recovered.executor_incarnation, "provider-new");
assert!(
idunn_recover_memory_semantic_projection_from_cultmesh(
&verse,
"runtime-test",
&canonical,
&input,
&recovered.claim_id,
"executor-third",
&receipt.receipt_id,
&correlated.heartbeat_id,
"2026-07-15T12:05:00Z",
)
.is_err()
);
Ok(())
}
#[test]
fn bifrost_mirrors_name_arrival_order_without_rewriting_storage_keys() {
let source = include_str!("cultmesh_integration.rs");
let old_loader = ["load_", "latest_epiphany_cultmesh_bifrost_"].concat();
let old_field = ["pub ", "latest_bifrost_"].concat();
assert!(!source.contains(&old_loader));
assert!(!source.contains(&old_field));
assert_eq!(
source
.lines()
.filter(|line| {
line.contains("\"gamecult-local/bifrost/") && line.contains("/latest\"")
})
.count(),
6
);
}
}